From ca442edb2d98f4b61d6560df2f1915131519fade Mon Sep 17 00:00:00 2001 From: Zoltan Ratkai Date: Thu, 14 Nov 2024 15:23:16 +0100 Subject: [PATCH] HIVE-28586 Support write order for Iceberg tables at CREATE TABLE Change-Id: Ia9a0a92d19d33693887137c797e0662088a314db --- .../java/org/apache/iceberg/mr/Catalogs.java | 21 +- .../apache/iceberg/mr/InputFormatConfig.java | 1 + .../iceberg/mr/hive/HiveIcebergMetaHook.java | 23 +- .../positive/iceberg_create_sorted_table.q | 14 + .../llap/iceberg_create_sorted_table.q.out | 96 + .../hadoop/hive/ql/parse/CreateDDLParser.g | 4 + .../hadoop/hive/ql/parse/HiveLexerParent.g | 1 + .../apache/hadoop/hive/ql/parse/HiveParser.g | 11 + .../hive/ql/parse/BaseSemanticAnalyzer.java | 14 +- .../hive/ql/parse/SemanticAnalyzer.java | 37 +- .../thrift/gen-cpp/ThriftHiveMetastore.cpp | 2534 +++--- .../thrift/gen-cpp/hive_metastore_types.cpp | 8013 +++++++++-------- .../gen/thrift/gen-cpp/hive_metastore_types.h | 32 +- .../hive/metastore/api/NullOrderingType.java | 43 + .../hadoop/hive/metastore/api/Order.java | 128 +- .../gen-php/metastore/NullOrderingType.php | 30 + .../gen/thrift/gen-php/metastore/Order.php | 25 + .../thrift/gen-py/hive_metastore/ttypes.py | 29 +- .../gen/thrift/gen-rb/hive_metastore_types.rb | 14 +- .../src/main/thrift/hive_metastore.thrift | 12 +- 20 files changed, 5804 insertions(+), 5278 deletions(-) create mode 100644 iceberg/iceberg-handler/src/test/queries/positive/iceberg_create_sorted_table.q create mode 100644 iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_create_sorted_table.q.out create mode 100644 standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NullOrderingType.java create mode 100644 standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/NullOrderingType.php diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/Catalogs.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/Catalogs.java index f2bd5b5f999c..06e15845d45a 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/Catalogs.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/Catalogs.java @@ -30,6 +30,8 @@ import org.apache.iceberg.PartitionSpecParser; import org.apache.iceberg.Schema; import org.apache.iceberg.SchemaParser; +import org.apache.iceberg.SortOrder; +import org.apache.iceberg.SortOrderParser; import org.apache.iceberg.Table; import org.apache.iceberg.catalog.Catalog; import org.apache.iceberg.catalog.TableIdentifier; @@ -37,6 +39,7 @@ import org.apache.iceberg.relocated.com.google.common.base.Preconditions; import org.apache.iceberg.relocated.com.google.common.collect.ImmutableSet; import org.apache.iceberg.relocated.com.google.common.collect.Maps; +import org.apache.parquet.Strings; /** * Class for catalog resolution and accessing the common functions for {@link Catalog} API. @@ -140,15 +143,23 @@ public static Table createTable(Configuration conf, Properties props) { Map map = filterIcebergTableProperties(props); Optional catalog = loadCatalog(conf, catalogName); - + SortOrder sortOrder = getSortOrder(props, schema); if (catalog.isPresent()) { String name = props.getProperty(NAME); Preconditions.checkNotNull(name, "Table identifier not set"); - return catalog.get().createTable(TableIdentifier.parse(name), schema, spec, location, map); + return catalog.get().buildTable(TableIdentifier.parse(name), schema).withPartitionSpec(spec) + .withLocation(location).withProperties(map).withSortOrder(sortOrder).create(); } Preconditions.checkNotNull(location, "Table location not set"); - return new HadoopTables(conf).create(schema, spec, map, location); + return new HadoopTables(conf).create(schema, spec, sortOrder, map, location); + } + + private static SortOrder getSortOrder(Properties props, Schema schema) { + String sortOrderJsonString = props.getProperty(InputFormatConfig.INSERT_WRITE_ORDER); + SortOrder sortOrder = Strings.isNullOrEmpty(sortOrderJsonString) ? + SortOrder.unsorted() : SortOrderParser.fromJson(schema, sortOrderJsonString); + return sortOrder; } /** @@ -215,9 +226,9 @@ public static Table registerTable(Configuration conf, Properties props, String m Preconditions.checkNotNull(name, "Table identifier not set"); return catalog.get().registerTable(TableIdentifier.parse(name), metadataLocation); } - Preconditions.checkNotNull(location, "Table location not set"); - return new HadoopTables(conf).create(schema, spec, map, location); + SortOrder sortOrder = getSortOrder(props, schema); + return new HadoopTables(conf).create(schema, spec, sortOrder, map, location); } public static void renameTable(Configuration conf, Properties props, TableIdentifier to) { diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/InputFormatConfig.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/InputFormatConfig.java index e7778b408691..91235ae9ffcc 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/InputFormatConfig.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/InputFormatConfig.java @@ -88,6 +88,7 @@ private InputFormatConfig() { public static final String CATALOG_CLASS_TEMPLATE = "iceberg.catalog.%s.catalog-impl"; public static final String CATALOG_DEFAULT_CONFIG_PREFIX = "iceberg.catalog-default."; public static final String QUERY_FILTERS = "iceberg.query.filters"; + public static final String INSERT_WRITE_ORDER = "iceberg.write-order"; public enum InMemoryDataModel { PIG, diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java index b82143954d69..6b8cd81a400e 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java @@ -47,6 +47,7 @@ import org.apache.hadoop.hive.metastore.api.EnvironmentContext; import org.apache.hadoop.hive.metastore.api.FieldSchema; import org.apache.hadoop.hive.metastore.api.MetaException; +import org.apache.hadoop.hive.metastore.api.NullOrderingType; import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey; import org.apache.hadoop.hive.metastore.api.SerDeInfo; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; @@ -82,6 +83,7 @@ import org.apache.iceberg.FileScanTask; import org.apache.iceberg.MetadataTableType; import org.apache.iceberg.MetadataTableUtils; +import org.apache.iceberg.NullOrder; import org.apache.iceberg.PartitionData; import org.apache.iceberg.PartitionField; import org.apache.iceberg.PartitionSpec; @@ -89,6 +91,8 @@ import org.apache.iceberg.PartitionsTable; import org.apache.iceberg.Schema; import org.apache.iceberg.SchemaParser; +import org.apache.iceberg.SortOrder; +import org.apache.iceberg.SortOrderParser; import org.apache.iceberg.Table; import org.apache.iceberg.TableMetadata; import org.apache.iceberg.TableMetadataParser; @@ -271,6 +275,23 @@ public void preCreateTable(CreateTableRequest request) { setOrcOnlyFilesParam(hmsTable); // Remove hive primary key columns from table request, as iceberg doesn't support hive primary key. request.setPrimaryKeys(null); + addSortOrder(hmsTable, schema, catalogProperties); + } + + private void addSortOrder(org.apache.hadoop.hive.metastore.api.Table hmsTable, Schema schema, + Properties properties) { + SortOrder.Builder sortOderBuilder = SortOrder.builderFor(schema); + hmsTable.getSd().getSortCols().forEach(item -> { + NullOrder nullOrder = item.getNullOrdering() == NullOrderingType.NULLS_FIRST ? + NullOrder.NULLS_FIRST : NullOrder.NULLS_LAST; + if (item.getOrder() == 0) { + sortOderBuilder.desc(item.getCol(), nullOrder); + } else { + sortOderBuilder.asc(item.getCol(), nullOrder); + } + + }); + properties.put(InputFormatConfig.INSERT_WRITE_ORDER, SortOrderParser.toJson(sortOderBuilder.build())); } @Override @@ -781,7 +802,7 @@ private void setCommonHmsTablePropertiesForIceberg(org.apache.hadoop.hive.metast * @param hmsTable Table for which we are calculating the properties * @return The properties we can provide for Iceberg functions, like {@link Catalogs} */ - private static Properties getCatalogProperties(org.apache.hadoop.hive.metastore.api.Table hmsTable) { + private Properties getCatalogProperties(org.apache.hadoop.hive.metastore.api.Table hmsTable) { Properties properties = new Properties(); hmsTable.getParameters().entrySet().stream().filter(e -> e.getKey() != null && e.getValue() != null).forEach(e -> { diff --git a/iceberg/iceberg-handler/src/test/queries/positive/iceberg_create_sorted_table.q b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_create_sorted_table.q new file mode 100644 index 000000000000..f6957f396223 --- /dev/null +++ b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_create_sorted_table.q @@ -0,0 +1,14 @@ +set hive.llap.io.enabled=true; +set hive.vectorized.execution.enabled=true; +set hive.optimize.shared.work.merge.ts.schema=true; + + +create table ice_orc_sorted (id int, text string) write ordered by id desc nulls first, text asc nulls last stored by iceberg stored as orc; + +insert into ice_orc_sorted values (3, "3"),(2, "2"),(4, "4"),(5, "5"),(1, "1"),(2, "3"),(3,null),(2,null),(null,"a"); + +describe formatted ice_orc_sorted; +describe extended ice_orc_sorted; + +select * from ice_orc_sorted; + diff --git a/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_create_sorted_table.q.out b/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_create_sorted_table.q.out new file mode 100644 index 000000000000..4585912f8478 --- /dev/null +++ b/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_create_sorted_table.q.out @@ -0,0 +1,96 @@ +PREHOOK: query: create table ice_orc_sorted (id int, text string) write ordered by id desc nulls first, text asc nulls last stored by iceberg stored as orc +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@ice_orc_sorted +POSTHOOK: query: create table ice_orc_sorted (id int, text string) write ordered by id desc nulls first, text asc nulls last stored by iceberg stored as orc +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@ice_orc_sorted +PREHOOK: query: insert into ice_orc_sorted values (3, "3"),(2, "2"),(4, "4"),(5, "5"),(1, "1"),(2, "3"),(3,null),(2,null),(null,"a") +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@ice_orc_sorted +POSTHOOK: query: insert into ice_orc_sorted values (3, "3"),(2, "2"),(4, "4"),(5, "5"),(1, "1"),(2, "3"),(3,null),(2,null),(null,"a") +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@ice_orc_sorted +PREHOOK: query: describe formatted ice_orc_sorted +PREHOOK: type: DESCTABLE +PREHOOK: Input: default@ice_orc_sorted +POSTHOOK: query: describe formatted ice_orc_sorted +POSTHOOK: type: DESCTABLE +POSTHOOK: Input: default@ice_orc_sorted +# col_name data_type comment +id int +text string + +# Detailed Table Information +Database: default +#### A masked pattern was here #### +Retention: 0 +#### A masked pattern was here #### +Table Type: EXTERNAL_TABLE +Table Parameters: + COLUMN_STATS_ACCURATE {\"BASIC_STATS\":\"true\",\"COLUMN_STATS\":{\"id\":\"true\",\"text\":\"true\"}} + EXTERNAL TRUE + SORTBUCKETCOLSPREFIX TRUE + bucketing_version 2 + current-schema {\"type\":\"struct\",\"schema-id\":0,\"fields\":[{\"id\":1,\"name\":\"id\",\"required\":false,\"type\":\"int\"},{\"id\":2,\"name\":\"text\",\"required\":false,\"type\":\"string\"}]} + current-snapshot-id 7320236589871429354 + current-snapshot-summary {\"added-data-files\":\"1\",\"added-records\":\"9\",\"added-files-size\":\"373\",\"changed-partition-count\":\"1\",\"total-records\":\"9\",\"total-files-size\":\"373\",\"total-data-files\":\"1\",\"total-delete-files\":\"0\",\"total-position-deletes\":\"0\",\"total-equality-deletes\":\"0\",\"iceberg-version\":\"Apache Iceberg 1.6.1 (commit 8e9d59d299be42b0bca9461457cd1e95dbaad086)\"} + current-snapshot-timestamp-ms 1731506391808 + default-sort-order {\"order-id\":1,\"fields\":[{\"transform\":\"identity\",\"source-id\":1,\"direction\":\"desc\",\"null-order\":\"nulls-first\"},{\"transform\":\"identity\",\"source-id\":2,\"direction\":\"asc\",\"null-order\":\"nulls-last\"}]} + format-version 2 + iceberg.orc.files.only true + iceberg.write-order {\"order-id\":1,\"fields\":[{\"transform\":\"identity\",\"source-id\":1,\"direction\":\"desc\",\"null-order\":\"nulls-first\"},{\"transform\":\"identity\",\"source-id\":2,\"direction\":\"asc\",\"null-order\":\"nulls-last\"}]} +#### A masked pattern was here #### + numFiles 1 + numRows 9 + parquet.compression zstd +#### A masked pattern was here #### + rawDataSize 0 + serialization.format 1 + snapshot-count 1 + storage_handler org.apache.iceberg.mr.hive.HiveIcebergStorageHandler + table_type ICEBERG + totalSize #Masked# +#### A masked pattern was here #### + uuid fb098a98-2597-4f22-b933-27b71f674f08 + write.delete.mode merge-on-read + write.format.default orc + write.merge.mode merge-on-read + write.update.mode merge-on-read + +# Storage Information +SerDe Library: org.apache.iceberg.mr.hive.HiveIcebergSerDe +InputFormat: org.apache.iceberg.mr.hive.HiveIcebergInputFormat +OutputFormat: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat +Compressed: No +Sort Columns: [FieldSchema(name:id, type:int, comment:Transform: identity, Sort direction: DESC, Null sort order: NULLS_FIRST), FieldSchema(name:text, type:string, comment:Transform: identity, Sort direction: ASC, Null sort order: NULLS_LAST)] +PREHOOK: query: describe extended ice_orc_sorted +PREHOOK: type: DESCTABLE +PREHOOK: Input: default@ice_orc_sorted +POSTHOOK: query: describe extended ice_orc_sorted +POSTHOOK: type: DESCTABLE +POSTHOOK: Input: default@ice_orc_sorted +id int +text string + +#### A masked pattern was here #### +PREHOOK: query: select * from ice_orc_sorted +PREHOOK: type: QUERY +PREHOOK: Input: default@ice_orc_sorted +#### A masked pattern was here #### +POSTHOOK: query: select * from ice_orc_sorted +POSTHOOK: type: QUERY +POSTHOOK: Input: default@ice_orc_sorted +#### A masked pattern was here #### +NULL a +5 5 +4 4 +3 3 +3 NULL +2 2 +2 3 +2 NULL +1 1 diff --git a/parser/src/java/org/apache/hadoop/hive/ql/parse/CreateDDLParser.g b/parser/src/java/org/apache/hadoop/hive/ql/parse/CreateDDLParser.g index 97f04f8dc1f5..c3b9b89ecd5c 100644 --- a/parser/src/java/org/apache/hadoop/hive/ql/parse/CreateDDLParser.g +++ b/parser/src/java/org/apache/hadoop/hive/ql/parse/CreateDDLParser.g @@ -64,6 +64,7 @@ createTableStatement tableComment? createTablePartitionSpec? tableBuckets? + tableWriteOrdered? tableSkewed? tableRowFormat? tableFileFormat? @@ -77,6 +78,7 @@ createTableStatement tableComment? createTablePartitionSpec? tableBuckets? + tableWriteOrdered? tableSkewed? tableRowFormat? tableFileFormat? @@ -94,6 +96,7 @@ createTableStatement tableComment? createTablePartitionSpec? tableBuckets? + tableWriteOrdered? tableSkewed? tableRowFormat? tableFileFormat? @@ -107,6 +110,7 @@ createTableStatement tableComment? createTablePartitionSpec? tableBuckets? + tableWriteOrdered? tableSkewed? tableRowFormat? tableFileFormat? diff --git a/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g b/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g index 078cd561b1b4..37ff29e75ce8 100644 --- a/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g +++ b/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g @@ -37,6 +37,7 @@ KW_DESC : 'DESC'; KW_NULLS : 'NULLS'; KW_LAST : 'LAST'; KW_ORDER : 'ORDER'; +KW_ORDERED : 'ORDERED'; KW_GROUP : 'GROUP'; KW_BY : 'BY'; KW_HAVING : 'HAVING'; diff --git a/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g b/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g index f05aa897f3af..fe2b6e2ba996 100644 --- a/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ b/parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -558,6 +558,7 @@ import org.apache.hadoop.hive.conf.HiveConf; xlateMap.put("KW_NULLS", "NULLS"); xlateMap.put("KW_LAST", "LAST"); xlateMap.put("KW_ORDER", "ORDER"); + xlateMap.put("KW_ORDERED", "ORDERED"); xlateMap.put("KW_BY", "BY"); xlateMap.put("KW_GROUP", "GROUP"); xlateMap.put("KW_WHERE", "WHERE"); @@ -1840,6 +1841,14 @@ tableImplBuckets -> ^(TOK_ALTERTABLE_BUCKETS $num) ; +tableWriteOrdered +@init { pushMsg("table sorted specification", state); } +@after { popMsg(state); } + : + KW_WRITE KW_ORDERED KW_BY sortCols=columnNameOrderList + -> ^(TOK_ALTERTABLE_BUCKETS $sortCols?) + ; + tableSkewed @init { pushMsg("table skewed specification", state); } @after { popMsg(state); } @@ -2201,6 +2210,8 @@ columnNameOrder ^(TOK_TABSORTCOLNAMEDESC ^(TOK_NULLS_LAST identifier)) -> {$orderSpec.tree.getType()==HiveParser.KW_ASC}? ^(TOK_TABSORTCOLNAMEASC ^($nullSpec identifier)) + -> {$orderSpec.tree.getType()==HiveParser.KW_DESC}? + ^(TOK_TABSORTCOLNAMEDESC ^($nullSpec identifier)) -> ^(TOK_TABSORTCOLNAMEDESC ^($nullSpec identifier)) ; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java index f528d67716a5..1cb6dd1acc91 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java @@ -49,6 +49,7 @@ import org.apache.hadoop.hive.metastore.api.DataConnector; import org.apache.hadoop.hive.metastore.api.Database; import org.apache.hadoop.hive.metastore.api.FieldSchema; +import org.apache.hadoop.hive.metastore.api.NullOrderingType; import org.apache.hadoop.hive.metastore.api.Order; import org.apache.hadoop.hive.metastore.api.SQLCheckConstraint; import org.apache.hadoop.hive.metastore.api.SQLDefaultConstraint; @@ -966,15 +967,10 @@ protected List getColumnNamesOrder(ASTNode ast) throws SemanticException ASTNode child = (ASTNode) ast.getChild(i); int directionCode = DirectionUtils.tokenToCode(child.getToken().getType()); child = (ASTNode) child.getChild(0); - if (child.getToken().getType() != HiveParser.TOK_NULLS_FIRST && directionCode == DirectionUtils.ASCENDING_CODE) { - throw new SemanticException( - "create/alter bucketed table: not supported NULLS LAST for SORTED BY in ASC order"); - } - if (child.getToken().getType() != HiveParser.TOK_NULLS_LAST && directionCode == DirectionUtils.DESCENDING_CODE) { - throw new SemanticException( - "create/alter bucketed table: not supported NULLS FIRST for SORTED BY in DESC order"); - } - colList.add(new Order(unescapeIdentifier(child.getChild(0).getText()).toLowerCase(), directionCode)); + Order order = new Order(unescapeIdentifier(child.getChild(0).getText()).toLowerCase(), directionCode); + order.setNullOrdering(child.getToken().getType()== HiveParser.TOK_NULLS_FIRST? + NullOrderingType.NULLS_FIRST : NullOrderingType.NULLS_LAST); + colList.add(order); } return colList; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java index 0c668b93f6f0..443b8a01769e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java @@ -101,6 +101,7 @@ import org.apache.hadoop.hive.metastore.api.Database; import org.apache.hadoop.hive.metastore.api.FieldSchema; import org.apache.hadoop.hive.metastore.api.MetaException; +import org.apache.hadoop.hive.metastore.api.NullOrderingType; import org.apache.hadoop.hive.metastore.api.Order; import org.apache.hadoop.hive.metastore.api.SQLCheckConstraint; import org.apache.hadoop.hive.metastore.api.SQLDefaultConstraint; @@ -14119,12 +14120,19 @@ ASTNode analyzeCreateTable( partColNames = getColumnNames(child); break; case HiveParser.TOK_ALTERTABLE_BUCKETS: - bucketCols = getColumnNames((ASTNode) child.getChild(0)); - if (child.getChildCount() == 2) { - numBuckets = Integer.parseInt(child.getChild(1).getText()); - } else { - sortCols = getColumnNamesOrder((ASTNode) child.getChild(1)); - numBuckets = Integer.parseInt(child.getChild(2).getText()); + switch(child.getChildCount()){ + case 1: + sortCols = getColumnNamesOrder((ASTNode) child.getChild(0)); + break; + case 2: + bucketCols = getColumnNames((ASTNode) child.getChild(0)); + numBuckets = Integer.parseInt(child.getChild(1).getText()); + break; + case 3: + bucketCols = getColumnNames((ASTNode) child.getChild(0)); + sortCols = getColumnNamesOrder((ASTNode) child.getChild(1)); + numBuckets = Integer.parseInt(child.getChild(2).getText()); + break; } break; case HiveParser.TOK_TABLEROWFORMAT: @@ -14249,6 +14257,7 @@ ASTNode analyzeCreateTable( throw new SemanticException( "Partition columns can only declared using their name and types in regular CREATE TABLE statements"); } + checkSortCols(sortCols, storageFormat); tblProps = validateAndAddDefaultProperties( tblProps, isExt, storageFormat, dbDotTab, sortCols, isMaterialization, isTemporary, isTransactional, isManaged, new String[] {qualifiedTabName.getDb(), qualifiedTabName.getTable()}, isDefaultTableTypeChanged); @@ -14444,6 +14453,22 @@ ASTNode analyzeCreateTable( return null; } + private void checkSortCols(List sortCols, StorageFormat storageFormat) throws SemanticException{ + if("org.apache.iceberg.mr.hive.HiveIcebergStorageHandler".equalsIgnoreCase(storageFormat.getStorageHandler())){ + return; + } + for (Order sortCol : sortCols) { + if (sortCol.getNullOrdering() != NullOrderingType.NULLS_FIRST && sortCol.getOrder() == DirectionUtils.ASCENDING_CODE) { + throw new SemanticException( + "create/alter bucketed table: not supported NULLS LAST for SORTED BY in ASC order"); + } + if (sortCol.getNullOrdering() != NullOrderingType.NULLS_LAST && sortCol.getOrder() == DirectionUtils.DESCENDING_CODE) { + throw new SemanticException( + "create/alter bucketed table: not supported NULLS FIRST for SORTED BY in DESC order"); + } + } + } + private String getDefaultLocation(String dbName, String tableName, boolean isExt) throws SemanticException { String tblLocation; try { 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 4a8ec3631daa..0c4d1aa5a616 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 @@ -3202,14 +3202,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1903; - ::apache::thrift::protocol::TType _etype1906; - xfer += iprot->readListBegin(_etype1906, _size1903); - this->success.resize(_size1903); - uint32_t _i1907; - for (_i1907 = 0; _i1907 < _size1903; ++_i1907) + uint32_t _size1904; + ::apache::thrift::protocol::TType _etype1907; + xfer += iprot->readListBegin(_etype1907, _size1904); + this->success.resize(_size1904); + uint32_t _i1908; + for (_i1908 = 0; _i1908 < _size1904; ++_i1908) { - xfer += iprot->readString(this->success[_i1907]); + xfer += iprot->readString(this->success[_i1908]); } xfer += iprot->readListEnd(); } @@ -3248,10 +3248,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 _iter1908; - for (_iter1908 = this->success.begin(); _iter1908 != this->success.end(); ++_iter1908) + std::vector ::const_iterator _iter1909; + for (_iter1909 = this->success.begin(); _iter1909 != this->success.end(); ++_iter1909) { - xfer += oprot->writeString((*_iter1908)); + xfer += oprot->writeString((*_iter1909)); } xfer += oprot->writeListEnd(); } @@ -3296,14 +3296,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1909; - ::apache::thrift::protocol::TType _etype1912; - xfer += iprot->readListBegin(_etype1912, _size1909); - (*(this->success)).resize(_size1909); - uint32_t _i1913; - for (_i1913 = 0; _i1913 < _size1909; ++_i1913) + uint32_t _size1910; + ::apache::thrift::protocol::TType _etype1913; + xfer += iprot->readListBegin(_etype1913, _size1910); + (*(this->success)).resize(_size1910); + uint32_t _i1914; + for (_i1914 = 0; _i1914 < _size1910; ++_i1914) { - xfer += iprot->readString((*(this->success))[_i1913]); + xfer += iprot->readString((*(this->success))[_i1914]); } xfer += iprot->readListEnd(); } @@ -3420,14 +3420,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1914; - ::apache::thrift::protocol::TType _etype1917; - xfer += iprot->readListBegin(_etype1917, _size1914); - this->success.resize(_size1914); - uint32_t _i1918; - for (_i1918 = 0; _i1918 < _size1914; ++_i1918) + uint32_t _size1915; + ::apache::thrift::protocol::TType _etype1918; + xfer += iprot->readListBegin(_etype1918, _size1915); + this->success.resize(_size1915); + uint32_t _i1919; + for (_i1919 = 0; _i1919 < _size1915; ++_i1919) { - xfer += iprot->readString(this->success[_i1918]); + xfer += iprot->readString(this->success[_i1919]); } xfer += iprot->readListEnd(); } @@ -3466,10 +3466,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 _iter1919; - for (_iter1919 = this->success.begin(); _iter1919 != this->success.end(); ++_iter1919) + std::vector ::const_iterator _iter1920; + for (_iter1920 = this->success.begin(); _iter1920 != this->success.end(); ++_iter1920) { - xfer += oprot->writeString((*_iter1919)); + xfer += oprot->writeString((*_iter1920)); } xfer += oprot->writeListEnd(); } @@ -3514,14 +3514,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1920; - ::apache::thrift::protocol::TType _etype1923; - xfer += iprot->readListBegin(_etype1923, _size1920); - (*(this->success)).resize(_size1920); - uint32_t _i1924; - for (_i1924 = 0; _i1924 < _size1920; ++_i1924) + uint32_t _size1921; + ::apache::thrift::protocol::TType _etype1924; + xfer += iprot->readListBegin(_etype1924, _size1921); + (*(this->success)).resize(_size1921); + uint32_t _i1925; + for (_i1925 = 0; _i1925 < _size1921; ++_i1925) { - xfer += iprot->readString((*(this->success))[_i1924]); + xfer += iprot->readString((*(this->success))[_i1925]); } xfer += iprot->readListEnd(); } @@ -4749,14 +4749,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1925; - ::apache::thrift::protocol::TType _etype1928; - xfer += iprot->readListBegin(_etype1928, _size1925); - this->success.resize(_size1925); - uint32_t _i1929; - for (_i1929 = 0; _i1929 < _size1925; ++_i1929) + uint32_t _size1926; + ::apache::thrift::protocol::TType _etype1929; + xfer += iprot->readListBegin(_etype1929, _size1926); + this->success.resize(_size1926); + uint32_t _i1930; + for (_i1930 = 0; _i1930 < _size1926; ++_i1930) { - xfer += iprot->readString(this->success[_i1929]); + xfer += iprot->readString(this->success[_i1930]); } xfer += iprot->readListEnd(); } @@ -4795,10 +4795,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 _iter1930; - for (_iter1930 = this->success.begin(); _iter1930 != this->success.end(); ++_iter1930) + std::vector ::const_iterator _iter1931; + for (_iter1931 = this->success.begin(); _iter1931 != this->success.end(); ++_iter1931) { - xfer += oprot->writeString((*_iter1930)); + xfer += oprot->writeString((*_iter1931)); } xfer += oprot->writeListEnd(); } @@ -4843,14 +4843,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1931; - ::apache::thrift::protocol::TType _etype1934; - xfer += iprot->readListBegin(_etype1934, _size1931); - (*(this->success)).resize(_size1931); - uint32_t _i1935; - for (_i1935 = 0; _i1935 < _size1931; ++_i1935) + uint32_t _size1932; + ::apache::thrift::protocol::TType _etype1935; + xfer += iprot->readListBegin(_etype1935, _size1932); + (*(this->success)).resize(_size1932); + uint32_t _i1936; + for (_i1936 = 0; _i1936 < _size1932; ++_i1936) { - xfer += iprot->readString((*(this->success))[_i1935]); + xfer += iprot->readString((*(this->success))[_i1936]); } xfer += iprot->readListEnd(); } @@ -5896,17 +5896,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1936; - ::apache::thrift::protocol::TType _ktype1937; - ::apache::thrift::protocol::TType _vtype1938; - xfer += iprot->readMapBegin(_ktype1937, _vtype1938, _size1936); - uint32_t _i1940; - for (_i1940 = 0; _i1940 < _size1936; ++_i1940) + uint32_t _size1937; + ::apache::thrift::protocol::TType _ktype1938; + ::apache::thrift::protocol::TType _vtype1939; + xfer += iprot->readMapBegin(_ktype1938, _vtype1939, _size1937); + uint32_t _i1941; + for (_i1941 = 0; _i1941 < _size1937; ++_i1941) { - std::string _key1941; - xfer += iprot->readString(_key1941); - Type& _val1942 = this->success[_key1941]; - xfer += _val1942.read(iprot); + std::string _key1942; + xfer += iprot->readString(_key1942); + Type& _val1943 = this->success[_key1942]; + xfer += _val1943.read(iprot); } xfer += iprot->readMapEnd(); } @@ -5945,11 +5945,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 _iter1943; - for (_iter1943 = this->success.begin(); _iter1943 != this->success.end(); ++_iter1943) + std::map ::const_iterator _iter1944; + for (_iter1944 = this->success.begin(); _iter1944 != this->success.end(); ++_iter1944) { - xfer += oprot->writeString(_iter1943->first); - xfer += _iter1943->second.write(oprot); + xfer += oprot->writeString(_iter1944->first); + xfer += _iter1944->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -5994,17 +5994,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1944; - ::apache::thrift::protocol::TType _ktype1945; - ::apache::thrift::protocol::TType _vtype1946; - xfer += iprot->readMapBegin(_ktype1945, _vtype1946, _size1944); - uint32_t _i1948; - for (_i1948 = 0; _i1948 < _size1944; ++_i1948) + uint32_t _size1945; + ::apache::thrift::protocol::TType _ktype1946; + ::apache::thrift::protocol::TType _vtype1947; + xfer += iprot->readMapBegin(_ktype1946, _vtype1947, _size1945); + uint32_t _i1949; + for (_i1949 = 0; _i1949 < _size1945; ++_i1949) { - std::string _key1949; - xfer += iprot->readString(_key1949); - Type& _val1950 = (*(this->success))[_key1949]; - xfer += _val1950.read(iprot); + std::string _key1950; + xfer += iprot->readString(_key1950); + Type& _val1951 = (*(this->success))[_key1950]; + xfer += _val1951.read(iprot); } xfer += iprot->readMapEnd(); } @@ -6158,14 +6158,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1952; + ::apache::thrift::protocol::TType _etype1955; + xfer += iprot->readListBegin(_etype1955, _size1952); + this->success.resize(_size1952); + uint32_t _i1956; + for (_i1956 = 0; _i1956 < _size1952; ++_i1956) { - xfer += this->success[_i1955].read(iprot); + xfer += this->success[_i1956].read(iprot); } xfer += iprot->readListEnd(); } @@ -6220,10 +6220,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 _iter1956; - for (_iter1956 = this->success.begin(); _iter1956 != this->success.end(); ++_iter1956) + std::vector ::const_iterator _iter1957; + for (_iter1957 = this->success.begin(); _iter1957 != this->success.end(); ++_iter1957) { - xfer += (*_iter1956).write(oprot); + xfer += (*_iter1957).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6276,14 +6276,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1958; + ::apache::thrift::protocol::TType _etype1961; + xfer += iprot->readListBegin(_etype1961, _size1958); + (*(this->success)).resize(_size1958); + uint32_t _i1962; + for (_i1962 = 0; _i1962 < _size1958; ++_i1962) { - xfer += (*(this->success))[_i1961].read(iprot); + xfer += (*(this->success))[_i1962].read(iprot); } xfer += iprot->readListEnd(); } @@ -6469,14 +6469,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1963; + ::apache::thrift::protocol::TType _etype1966; + xfer += iprot->readListBegin(_etype1966, _size1963); + this->success.resize(_size1963); + uint32_t _i1967; + for (_i1967 = 0; _i1967 < _size1963; ++_i1967) { - xfer += this->success[_i1966].read(iprot); + xfer += this->success[_i1967].read(iprot); } xfer += iprot->readListEnd(); } @@ -6531,10 +6531,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 _iter1967; - for (_iter1967 = this->success.begin(); _iter1967 != this->success.end(); ++_iter1967) + std::vector ::const_iterator _iter1968; + for (_iter1968 = this->success.begin(); _iter1968 != this->success.end(); ++_iter1968) { - xfer += (*_iter1967).write(oprot); + xfer += (*_iter1968).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6587,14 +6587,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1969; + ::apache::thrift::protocol::TType _etype1972; + xfer += iprot->readListBegin(_etype1972, _size1969); + (*(this->success)).resize(_size1969); + uint32_t _i1973; + for (_i1973 = 0; _i1973 < _size1969; ++_i1973) { - xfer += (*(this->success))[_i1972].read(iprot); + xfer += (*(this->success))[_i1973].read(iprot); } xfer += iprot->readListEnd(); } @@ -7011,14 +7011,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1973; - ::apache::thrift::protocol::TType _etype1976; - xfer += iprot->readListBegin(_etype1976, _size1973); - this->success.resize(_size1973); - uint32_t _i1977; - for (_i1977 = 0; _i1977 < _size1973; ++_i1977) + uint32_t _size1974; + ::apache::thrift::protocol::TType _etype1977; + xfer += iprot->readListBegin(_etype1977, _size1974); + this->success.resize(_size1974); + uint32_t _i1978; + for (_i1978 = 0; _i1978 < _size1974; ++_i1978) { - xfer += this->success[_i1977].read(iprot); + xfer += this->success[_i1978].read(iprot); } xfer += iprot->readListEnd(); } @@ -7073,10 +7073,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 _iter1978; - for (_iter1978 = this->success.begin(); _iter1978 != this->success.end(); ++_iter1978) + std::vector ::const_iterator _iter1979; + for (_iter1979 = this->success.begin(); _iter1979 != this->success.end(); ++_iter1979) { - xfer += (*_iter1978).write(oprot); + xfer += (*_iter1979).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7129,14 +7129,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol 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(); } @@ -7322,14 +7322,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1984; - ::apache::thrift::protocol::TType _etype1987; - xfer += iprot->readListBegin(_etype1987, _size1984); - this->success.resize(_size1984); - uint32_t _i1988; - for (_i1988 = 0; _i1988 < _size1984; ++_i1988) + 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) { - xfer += this->success[_i1988].read(iprot); + xfer += this->success[_i1989].read(iprot); } xfer += iprot->readListEnd(); } @@ -7384,10 +7384,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 _iter1989; - for (_iter1989 = this->success.begin(); _iter1989 != this->success.end(); ++_iter1989) + std::vector ::const_iterator _iter1990; + for (_iter1990 = this->success.begin(); _iter1990 != this->success.end(); ++_iter1990) { - xfer += (*_iter1989).write(oprot); + xfer += (*_iter1990).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7440,14 +7440,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: 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 += (*(this->success))[_i1994].read(iprot); + xfer += (*(this->success))[_i1995].read(iprot); } xfer += iprot->readListEnd(); } @@ -8287,14 +8287,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1995; - ::apache::thrift::protocol::TType _etype1998; - xfer += iprot->readListBegin(_etype1998, _size1995); - this->primaryKeys.resize(_size1995); - uint32_t _i1999; - for (_i1999 = 0; _i1999 < _size1995; ++_i1999) + uint32_t _size1996; + ::apache::thrift::protocol::TType _etype1999; + xfer += iprot->readListBegin(_etype1999, _size1996); + this->primaryKeys.resize(_size1996); + uint32_t _i2000; + for (_i2000 = 0; _i2000 < _size1996; ++_i2000) { - xfer += this->primaryKeys[_i1999].read(iprot); + xfer += this->primaryKeys[_i2000].read(iprot); } xfer += iprot->readListEnd(); } @@ -8307,14 +8307,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size2000; - ::apache::thrift::protocol::TType _etype2003; - xfer += iprot->readListBegin(_etype2003, _size2000); - this->foreignKeys.resize(_size2000); - uint32_t _i2004; - for (_i2004 = 0; _i2004 < _size2000; ++_i2004) + uint32_t _size2001; + ::apache::thrift::protocol::TType _etype2004; + xfer += iprot->readListBegin(_etype2004, _size2001); + this->foreignKeys.resize(_size2001); + uint32_t _i2005; + for (_i2005 = 0; _i2005 < _size2001; ++_i2005) { - xfer += this->foreignKeys[_i2004].read(iprot); + xfer += this->foreignKeys[_i2005].read(iprot); } xfer += iprot->readListEnd(); } @@ -8327,14 +8327,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size2005; - ::apache::thrift::protocol::TType _etype2008; - xfer += iprot->readListBegin(_etype2008, _size2005); - this->uniqueConstraints.resize(_size2005); - uint32_t _i2009; - for (_i2009 = 0; _i2009 < _size2005; ++_i2009) + uint32_t _size2006; + ::apache::thrift::protocol::TType _etype2009; + xfer += iprot->readListBegin(_etype2009, _size2006); + this->uniqueConstraints.resize(_size2006); + uint32_t _i2010; + for (_i2010 = 0; _i2010 < _size2006; ++_i2010) { - xfer += this->uniqueConstraints[_i2009].read(iprot); + xfer += this->uniqueConstraints[_i2010].read(iprot); } xfer += iprot->readListEnd(); } @@ -8347,14 +8347,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size2010; - ::apache::thrift::protocol::TType _etype2013; - xfer += iprot->readListBegin(_etype2013, _size2010); - this->notNullConstraints.resize(_size2010); - uint32_t _i2014; - for (_i2014 = 0; _i2014 < _size2010; ++_i2014) + uint32_t _size2011; + ::apache::thrift::protocol::TType _etype2014; + xfer += iprot->readListBegin(_etype2014, _size2011); + this->notNullConstraints.resize(_size2011); + uint32_t _i2015; + for (_i2015 = 0; _i2015 < _size2011; ++_i2015) { - xfer += this->notNullConstraints[_i2014].read(iprot); + xfer += this->notNullConstraints[_i2015].read(iprot); } xfer += iprot->readListEnd(); } @@ -8367,14 +8367,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size2015; - ::apache::thrift::protocol::TType _etype2018; - xfer += iprot->readListBegin(_etype2018, _size2015); - this->defaultConstraints.resize(_size2015); - uint32_t _i2019; - for (_i2019 = 0; _i2019 < _size2015; ++_i2019) + uint32_t _size2016; + ::apache::thrift::protocol::TType _etype2019; + xfer += iprot->readListBegin(_etype2019, _size2016); + this->defaultConstraints.resize(_size2016); + uint32_t _i2020; + for (_i2020 = 0; _i2020 < _size2016; ++_i2020) { - xfer += this->defaultConstraints[_i2019].read(iprot); + xfer += this->defaultConstraints[_i2020].read(iprot); } xfer += iprot->readListEnd(); } @@ -8387,14 +8387,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size2020; - ::apache::thrift::protocol::TType _etype2023; - xfer += iprot->readListBegin(_etype2023, _size2020); - this->checkConstraints.resize(_size2020); - uint32_t _i2024; - for (_i2024 = 0; _i2024 < _size2020; ++_i2024) + uint32_t _size2021; + ::apache::thrift::protocol::TType _etype2024; + xfer += iprot->readListBegin(_etype2024, _size2021); + this->checkConstraints.resize(_size2021); + uint32_t _i2025; + for (_i2025 = 0; _i2025 < _size2021; ++_i2025) { - xfer += this->checkConstraints[_i2024].read(iprot); + xfer += this->checkConstraints[_i2025].read(iprot); } xfer += iprot->readListEnd(); } @@ -8427,10 +8427,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 _iter2025; - for (_iter2025 = this->primaryKeys.begin(); _iter2025 != this->primaryKeys.end(); ++_iter2025) + std::vector ::const_iterator _iter2026; + for (_iter2026 = this->primaryKeys.begin(); _iter2026 != this->primaryKeys.end(); ++_iter2026) { - xfer += (*_iter2025).write(oprot); + xfer += (*_iter2026).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8439,10 +8439,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 _iter2026; - for (_iter2026 = this->foreignKeys.begin(); _iter2026 != this->foreignKeys.end(); ++_iter2026) + std::vector ::const_iterator _iter2027; + for (_iter2027 = this->foreignKeys.begin(); _iter2027 != this->foreignKeys.end(); ++_iter2027) { - xfer += (*_iter2026).write(oprot); + xfer += (*_iter2027).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8451,10 +8451,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 _iter2027; - for (_iter2027 = this->uniqueConstraints.begin(); _iter2027 != this->uniqueConstraints.end(); ++_iter2027) + std::vector ::const_iterator _iter2028; + for (_iter2028 = this->uniqueConstraints.begin(); _iter2028 != this->uniqueConstraints.end(); ++_iter2028) { - xfer += (*_iter2027).write(oprot); + xfer += (*_iter2028).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8463,10 +8463,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 _iter2028; - for (_iter2028 = this->notNullConstraints.begin(); _iter2028 != this->notNullConstraints.end(); ++_iter2028) + std::vector ::const_iterator _iter2029; + for (_iter2029 = this->notNullConstraints.begin(); _iter2029 != this->notNullConstraints.end(); ++_iter2029) { - xfer += (*_iter2028).write(oprot); + xfer += (*_iter2029).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8475,10 +8475,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 _iter2029; - for (_iter2029 = this->defaultConstraints.begin(); _iter2029 != this->defaultConstraints.end(); ++_iter2029) + std::vector ::const_iterator _iter2030; + for (_iter2030 = this->defaultConstraints.begin(); _iter2030 != this->defaultConstraints.end(); ++_iter2030) { - xfer += (*_iter2029).write(oprot); + xfer += (*_iter2030).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8487,10 +8487,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 _iter2030; - for (_iter2030 = this->checkConstraints.begin(); _iter2030 != this->checkConstraints.end(); ++_iter2030) + std::vector ::const_iterator _iter2031; + for (_iter2031 = this->checkConstraints.begin(); _iter2031 != this->checkConstraints.end(); ++_iter2031) { - xfer += (*_iter2030).write(oprot); + xfer += (*_iter2031).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8518,10 +8518,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 _iter2031; - for (_iter2031 = (*(this->primaryKeys)).begin(); _iter2031 != (*(this->primaryKeys)).end(); ++_iter2031) + std::vector ::const_iterator _iter2032; + for (_iter2032 = (*(this->primaryKeys)).begin(); _iter2032 != (*(this->primaryKeys)).end(); ++_iter2032) { - xfer += (*_iter2031).write(oprot); + xfer += (*_iter2032).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8530,10 +8530,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 _iter2032; - for (_iter2032 = (*(this->foreignKeys)).begin(); _iter2032 != (*(this->foreignKeys)).end(); ++_iter2032) + std::vector ::const_iterator _iter2033; + for (_iter2033 = (*(this->foreignKeys)).begin(); _iter2033 != (*(this->foreignKeys)).end(); ++_iter2033) { - xfer += (*_iter2032).write(oprot); + xfer += (*_iter2033).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8542,10 +8542,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 _iter2033; - for (_iter2033 = (*(this->uniqueConstraints)).begin(); _iter2033 != (*(this->uniqueConstraints)).end(); ++_iter2033) + std::vector ::const_iterator _iter2034; + for (_iter2034 = (*(this->uniqueConstraints)).begin(); _iter2034 != (*(this->uniqueConstraints)).end(); ++_iter2034) { - xfer += (*_iter2033).write(oprot); + xfer += (*_iter2034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8554,10 +8554,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 _iter2034; - for (_iter2034 = (*(this->notNullConstraints)).begin(); _iter2034 != (*(this->notNullConstraints)).end(); ++_iter2034) + std::vector ::const_iterator _iter2035; + for (_iter2035 = (*(this->notNullConstraints)).begin(); _iter2035 != (*(this->notNullConstraints)).end(); ++_iter2035) { - xfer += (*_iter2034).write(oprot); + xfer += (*_iter2035).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8566,10 +8566,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 _iter2035; - for (_iter2035 = (*(this->defaultConstraints)).begin(); _iter2035 != (*(this->defaultConstraints)).end(); ++_iter2035) + std::vector ::const_iterator _iter2036; + for (_iter2036 = (*(this->defaultConstraints)).begin(); _iter2036 != (*(this->defaultConstraints)).end(); ++_iter2036) { - xfer += (*_iter2035).write(oprot); + xfer += (*_iter2036).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8578,10 +8578,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 _iter2036; - for (_iter2036 = (*(this->checkConstraints)).begin(); _iter2036 != (*(this->checkConstraints)).end(); ++_iter2036) + std::vector ::const_iterator _iter2037; + for (_iter2037 = (*(this->checkConstraints)).begin(); _iter2037 != (*(this->checkConstraints)).end(); ++_iter2037) { - xfer += (*_iter2036).write(oprot); + xfer += (*_iter2037).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11470,14 +11470,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size2037; - ::apache::thrift::protocol::TType _etype2040; - xfer += iprot->readListBegin(_etype2040, _size2037); - this->partNames.resize(_size2037); - uint32_t _i2041; - for (_i2041 = 0; _i2041 < _size2037; ++_i2041) + uint32_t _size2038; + ::apache::thrift::protocol::TType _etype2041; + xfer += iprot->readListBegin(_etype2041, _size2038); + this->partNames.resize(_size2038); + uint32_t _i2042; + for (_i2042 = 0; _i2042 < _size2038; ++_i2042) { - xfer += iprot->readString(this->partNames[_i2041]); + xfer += iprot->readString(this->partNames[_i2042]); } xfer += iprot->readListEnd(); } @@ -11514,10 +11514,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 _iter2042; - for (_iter2042 = this->partNames.begin(); _iter2042 != this->partNames.end(); ++_iter2042) + std::vector ::const_iterator _iter2043; + for (_iter2043 = this->partNames.begin(); _iter2043 != this->partNames.end(); ++_iter2043) { - xfer += oprot->writeString((*_iter2042)); + xfer += oprot->writeString((*_iter2043)); } xfer += oprot->writeListEnd(); } @@ -11549,10 +11549,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 _iter2043; - for (_iter2043 = (*(this->partNames)).begin(); _iter2043 != (*(this->partNames)).end(); ++_iter2043) + std::vector ::const_iterator _iter2044; + for (_iter2044 = (*(this->partNames)).begin(); _iter2044 != (*(this->partNames)).end(); ++_iter2044) { - xfer += oprot->writeString((*_iter2043)); + xfer += oprot->writeString((*_iter2044)); } xfer += oprot->writeListEnd(); } @@ -12003,14 +12003,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2044; - ::apache::thrift::protocol::TType _etype2047; - xfer += iprot->readListBegin(_etype2047, _size2044); - this->success.resize(_size2044); - uint32_t _i2048; - for (_i2048 = 0; _i2048 < _size2044; ++_i2048) + uint32_t _size2045; + ::apache::thrift::protocol::TType _etype2048; + xfer += iprot->readListBegin(_etype2048, _size2045); + this->success.resize(_size2045); + uint32_t _i2049; + for (_i2049 = 0; _i2049 < _size2045; ++_i2049) { - xfer += iprot->readString(this->success[_i2048]); + xfer += iprot->readString(this->success[_i2049]); } xfer += iprot->readListEnd(); } @@ -12049,10 +12049,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 _iter2049; - for (_iter2049 = this->success.begin(); _iter2049 != this->success.end(); ++_iter2049) + std::vector ::const_iterator _iter2050; + for (_iter2050 = this->success.begin(); _iter2050 != this->success.end(); ++_iter2050) { - xfer += oprot->writeString((*_iter2049)); + xfer += oprot->writeString((*_iter2050)); } xfer += oprot->writeListEnd(); } @@ -12097,14 +12097,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2050; - ::apache::thrift::protocol::TType _etype2053; - xfer += iprot->readListBegin(_etype2053, _size2050); - (*(this->success)).resize(_size2050); - uint32_t _i2054; - for (_i2054 = 0; _i2054 < _size2050; ++_i2054) + uint32_t _size2051; + ::apache::thrift::protocol::TType _etype2054; + xfer += iprot->readListBegin(_etype2054, _size2051); + (*(this->success)).resize(_size2051); + uint32_t _i2055; + for (_i2055 = 0; _i2055 < _size2051; ++_i2055) { - xfer += iprot->readString((*(this->success))[_i2054]); + xfer += iprot->readString((*(this->success))[_i2055]); } xfer += iprot->readListEnd(); } @@ -12274,14 +12274,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 _size2055; - ::apache::thrift::protocol::TType _etype2058; - xfer += iprot->readListBegin(_etype2058, _size2055); - this->success.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->success.resize(_size2056); + uint32_t _i2060; + for (_i2060 = 0; _i2060 < _size2056; ++_i2060) { - xfer += iprot->readString(this->success[_i2059]); + xfer += iprot->readString(this->success[_i2060]); } xfer += iprot->readListEnd(); } @@ -12320,10 +12320,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 _iter2060; - for (_iter2060 = this->success.begin(); _iter2060 != this->success.end(); ++_iter2060) + std::vector ::const_iterator _iter2061; + for (_iter2061 = this->success.begin(); _iter2061 != this->success.end(); ++_iter2061) { - xfer += oprot->writeString((*_iter2060)); + xfer += oprot->writeString((*_iter2061)); } xfer += oprot->writeListEnd(); } @@ -12368,14 +12368,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2061; - ::apache::thrift::protocol::TType _etype2064; - xfer += iprot->readListBegin(_etype2064, _size2061); - (*(this->success)).resize(_size2061); - uint32_t _i2065; - for (_i2065 = 0; _i2065 < _size2061; ++_i2065) + uint32_t _size2062; + ::apache::thrift::protocol::TType _etype2065; + xfer += iprot->readListBegin(_etype2065, _size2062); + (*(this->success)).resize(_size2062); + uint32_t _i2066; + for (_i2066 = 0; _i2066 < _size2062; ++_i2066) { - xfer += iprot->readString((*(this->success))[_i2065]); + xfer += iprot->readString((*(this->success))[_i2066]); } xfer += iprot->readListEnd(); } @@ -12492,14 +12492,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_res if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2066; - ::apache::thrift::protocol::TType _etype2069; - xfer += iprot->readListBegin(_etype2069, _size2066); - this->success.resize(_size2066); - uint32_t _i2070; - for (_i2070 = 0; _i2070 < _size2066; ++_i2070) + uint32_t _size2067; + ::apache::thrift::protocol::TType _etype2070; + xfer += iprot->readListBegin(_etype2070, _size2067); + this->success.resize(_size2067); + uint32_t _i2071; + for (_i2071 = 0; _i2071 < _size2067; ++_i2071) { - xfer += this->success[_i2070].read(iprot); + xfer += this->success[_i2071].read(iprot); } xfer += iprot->readListEnd(); } @@ -12538,10 +12538,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 _iter2071; - for (_iter2071 = this->success.begin(); _iter2071 != this->success.end(); ++_iter2071) + std::vector
::const_iterator _iter2072; + for (_iter2072 = this->success.begin(); _iter2072 != this->success.end(); ++_iter2072) { - xfer += (*_iter2071).write(oprot); + xfer += (*_iter2072).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12586,14 +12586,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pre if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2072; - ::apache::thrift::protocol::TType _etype2075; - xfer += iprot->readListBegin(_etype2075, _size2072); - (*(this->success)).resize(_size2072); - uint32_t _i2076; - for (_i2076 = 0; _i2076 < _size2072; ++_i2076) + uint32_t _size2073; + ::apache::thrift::protocol::TType _etype2076; + xfer += iprot->readListBegin(_etype2076, _size2073); + (*(this->success)).resize(_size2073); + uint32_t _i2077; + for (_i2077 = 0; _i2077 < _size2073; ++_i2077) { - xfer += (*(this->success))[_i2076].read(iprot); + xfer += (*(this->success))[_i2077].read(iprot); } xfer += iprot->readListEnd(); } @@ -12731,14 +12731,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2077; - ::apache::thrift::protocol::TType _etype2080; - xfer += iprot->readListBegin(_etype2080, _size2077); - this->success.resize(_size2077); - uint32_t _i2081; - for (_i2081 = 0; _i2081 < _size2077; ++_i2081) + uint32_t _size2078; + ::apache::thrift::protocol::TType _etype2081; + xfer += iprot->readListBegin(_etype2081, _size2078); + this->success.resize(_size2078); + uint32_t _i2082; + for (_i2082 = 0; _i2082 < _size2078; ++_i2082) { - xfer += iprot->readString(this->success[_i2081]); + xfer += iprot->readString(this->success[_i2082]); } xfer += iprot->readListEnd(); } @@ -12777,10 +12777,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 _iter2082; - for (_iter2082 = this->success.begin(); _iter2082 != this->success.end(); ++_iter2082) + std::vector ::const_iterator _iter2083; + for (_iter2083 = this->success.begin(); _iter2083 != this->success.end(); ++_iter2083) { - xfer += oprot->writeString((*_iter2082)); + xfer += oprot->writeString((*_iter2083)); } xfer += oprot->writeListEnd(); } @@ -12825,14 +12825,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2083; - ::apache::thrift::protocol::TType _etype2086; - xfer += iprot->readListBegin(_etype2086, _size2083); - (*(this->success)).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->success)).resize(_size2084); + uint32_t _i2088; + for (_i2088 = 0; _i2088 < _size2084; ++_i2088) { - xfer += iprot->readString((*(this->success))[_i2087]); + xfer += iprot->readString((*(this->success))[_i2088]); } xfer += iprot->readListEnd(); } @@ -12907,14 +12907,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 _size2088; - ::apache::thrift::protocol::TType _etype2091; - xfer += iprot->readListBegin(_etype2091, _size2088); - this->tbl_types.resize(_size2088); - uint32_t _i2092; - for (_i2092 = 0; _i2092 < _size2088; ++_i2092) + uint32_t _size2089; + ::apache::thrift::protocol::TType _etype2092; + xfer += iprot->readListBegin(_etype2092, _size2089); + this->tbl_types.resize(_size2089); + uint32_t _i2093; + for (_i2093 = 0; _i2093 < _size2089; ++_i2093) { - xfer += iprot->readString(this->tbl_types[_i2092]); + xfer += iprot->readString(this->tbl_types[_i2093]); } xfer += iprot->readListEnd(); } @@ -12951,10 +12951,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 _iter2093; - for (_iter2093 = this->tbl_types.begin(); _iter2093 != this->tbl_types.end(); ++_iter2093) + std::vector ::const_iterator _iter2094; + for (_iter2094 = this->tbl_types.begin(); _iter2094 != this->tbl_types.end(); ++_iter2094) { - xfer += oprot->writeString((*_iter2093)); + xfer += oprot->writeString((*_iter2094)); } xfer += oprot->writeListEnd(); } @@ -12986,10 +12986,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 _iter2094; - for (_iter2094 = (*(this->tbl_types)).begin(); _iter2094 != (*(this->tbl_types)).end(); ++_iter2094) + std::vector ::const_iterator _iter2095; + for (_iter2095 = (*(this->tbl_types)).begin(); _iter2095 != (*(this->tbl_types)).end(); ++_iter2095) { - xfer += oprot->writeString((*_iter2094)); + xfer += oprot->writeString((*_iter2095)); } xfer += oprot->writeListEnd(); } @@ -13030,14 +13030,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2095; - ::apache::thrift::protocol::TType _etype2098; - xfer += iprot->readListBegin(_etype2098, _size2095); - this->success.resize(_size2095); - uint32_t _i2099; - for (_i2099 = 0; _i2099 < _size2095; ++_i2099) + uint32_t _size2096; + ::apache::thrift::protocol::TType _etype2099; + xfer += iprot->readListBegin(_etype2099, _size2096); + this->success.resize(_size2096); + uint32_t _i2100; + for (_i2100 = 0; _i2100 < _size2096; ++_i2100) { - xfer += this->success[_i2099].read(iprot); + xfer += this->success[_i2100].read(iprot); } xfer += iprot->readListEnd(); } @@ -13076,10 +13076,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 _iter2100; - for (_iter2100 = this->success.begin(); _iter2100 != this->success.end(); ++_iter2100) + std::vector ::const_iterator _iter2101; + for (_iter2101 = this->success.begin(); _iter2101 != this->success.end(); ++_iter2101) { - xfer += (*_iter2100).write(oprot); + xfer += (*_iter2101).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13124,14 +13124,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2101; - ::apache::thrift::protocol::TType _etype2104; - xfer += iprot->readListBegin(_etype2104, _size2101); - (*(this->success)).resize(_size2101); - uint32_t _i2105; - for (_i2105 = 0; _i2105 < _size2101; ++_i2105) + uint32_t _size2102; + ::apache::thrift::protocol::TType _etype2105; + xfer += iprot->readListBegin(_etype2105, _size2102); + (*(this->success)).resize(_size2102); + uint32_t _i2106; + for (_i2106 = 0; _i2106 < _size2102; ++_i2106) { - xfer += (*(this->success))[_i2105].read(iprot); + xfer += (*(this->success))[_i2106].read(iprot); } xfer += iprot->readListEnd(); } @@ -13269,14 +13269,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2106; - ::apache::thrift::protocol::TType _etype2109; - xfer += iprot->readListBegin(_etype2109, _size2106); - this->success.resize(_size2106); - uint32_t _i2110; - for (_i2110 = 0; _i2110 < _size2106; ++_i2110) + uint32_t _size2107; + ::apache::thrift::protocol::TType _etype2110; + xfer += iprot->readListBegin(_etype2110, _size2107); + this->success.resize(_size2107); + uint32_t _i2111; + for (_i2111 = 0; _i2111 < _size2107; ++_i2111) { - xfer += iprot->readString(this->success[_i2110]); + xfer += iprot->readString(this->success[_i2111]); } xfer += iprot->readListEnd(); } @@ -13315,10 +13315,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 _iter2111; - for (_iter2111 = this->success.begin(); _iter2111 != this->success.end(); ++_iter2111) + std::vector ::const_iterator _iter2112; + for (_iter2112 = this->success.begin(); _iter2112 != this->success.end(); ++_iter2112) { - xfer += oprot->writeString((*_iter2111)); + xfer += oprot->writeString((*_iter2112)); } xfer += oprot->writeListEnd(); } @@ -13363,14 +13363,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2112; - ::apache::thrift::protocol::TType _etype2115; - xfer += iprot->readListBegin(_etype2115, _size2112); - (*(this->success)).resize(_size2112); - uint32_t _i2116; - for (_i2116 = 0; _i2116 < _size2112; ++_i2116) + uint32_t _size2113; + ::apache::thrift::protocol::TType _etype2116; + xfer += iprot->readListBegin(_etype2116, _size2113); + (*(this->success)).resize(_size2113); + uint32_t _i2117; + for (_i2117 = 0; _i2117 < _size2113; ++_i2117) { - xfer += iprot->readString((*(this->success))[_i2116]); + xfer += iprot->readString((*(this->success))[_i2117]); } xfer += iprot->readListEnd(); } @@ -13508,14 +13508,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2117; - ::apache::thrift::protocol::TType _etype2120; - xfer += iprot->readListBegin(_etype2120, _size2117); - this->success.resize(_size2117); - uint32_t _i2121; - for (_i2121 = 0; _i2121 < _size2117; ++_i2121) + uint32_t _size2118; + ::apache::thrift::protocol::TType _etype2121; + xfer += iprot->readListBegin(_etype2121, _size2118); + this->success.resize(_size2118); + uint32_t _i2122; + for (_i2122 = 0; _i2122 < _size2118; ++_i2122) { - xfer += this->success[_i2121].read(iprot); + xfer += this->success[_i2122].read(iprot); } xfer += iprot->readListEnd(); } @@ -13554,10 +13554,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 _iter2122; - for (_iter2122 = this->success.begin(); _iter2122 != this->success.end(); ++_iter2122) + std::vector ::const_iterator _iter2123; + for (_iter2123 = this->success.begin(); _iter2123 != this->success.end(); ++_iter2123) { - xfer += (*_iter2122).write(oprot); + xfer += (*_iter2123).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13602,14 +13602,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2123; - ::apache::thrift::protocol::TType _etype2126; - xfer += iprot->readListBegin(_etype2126, _size2123); - (*(this->success)).resize(_size2123); - uint32_t _i2127; - for (_i2127 = 0; _i2127 < _size2123; ++_i2127) + uint32_t _size2124; + ::apache::thrift::protocol::TType _etype2127; + xfer += iprot->readListBegin(_etype2127, _size2124); + (*(this->success)).resize(_size2124); + uint32_t _i2128; + for (_i2128 = 0; _i2128 < _size2124; ++_i2128) { - xfer += (*(this->success))[_i2127].read(iprot); + xfer += (*(this->success))[_i2128].read(iprot); } xfer += iprot->readListEnd(); } @@ -14791,14 +14791,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 _size2128; - ::apache::thrift::protocol::TType _etype2131; - xfer += iprot->readListBegin(_etype2131, _size2128); - this->success.resize(_size2128); - uint32_t _i2132; - for (_i2132 = 0; _i2132 < _size2128; ++_i2132) + uint32_t _size2129; + ::apache::thrift::protocol::TType _etype2132; + xfer += iprot->readListBegin(_etype2132, _size2129); + this->success.resize(_size2129); + uint32_t _i2133; + for (_i2133 = 0; _i2133 < _size2129; ++_i2133) { - xfer += iprot->readString(this->success[_i2132]); + xfer += iprot->readString(this->success[_i2133]); } xfer += iprot->readListEnd(); } @@ -14853,10 +14853,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 _iter2133; - for (_iter2133 = this->success.begin(); _iter2133 != this->success.end(); ++_iter2133) + std::vector ::const_iterator _iter2134; + for (_iter2134 = this->success.begin(); _iter2134 != this->success.end(); ++_iter2134) { - xfer += oprot->writeString((*_iter2133)); + xfer += oprot->writeString((*_iter2134)); } xfer += oprot->writeListEnd(); } @@ -14909,14 +14909,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 _size2134; - ::apache::thrift::protocol::TType _etype2137; - xfer += iprot->readListBegin(_etype2137, _size2134); - (*(this->success)).resize(_size2134); - uint32_t _i2138; - for (_i2138 = 0; _i2138 < _size2134; ++_i2138) + uint32_t _size2135; + ::apache::thrift::protocol::TType _etype2138; + xfer += iprot->readListBegin(_etype2138, _size2135); + (*(this->success)).resize(_size2135); + uint32_t _i2139; + for (_i2139 = 0; _i2139 < _size2135; ++_i2139) { - xfer += iprot->readString((*(this->success))[_i2138]); + xfer += iprot->readString((*(this->success))[_i2139]); } xfer += iprot->readListEnd(); } @@ -16477,14 +16477,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2139; - ::apache::thrift::protocol::TType _etype2142; - xfer += iprot->readListBegin(_etype2142, _size2139); - this->new_parts.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->new_parts.resize(_size2140); + uint32_t _i2144; + for (_i2144 = 0; _i2144 < _size2140; ++_i2144) { - xfer += this->new_parts[_i2143].read(iprot); + xfer += this->new_parts[_i2144].read(iprot); } xfer += iprot->readListEnd(); } @@ -16513,10 +16513,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 _iter2144; - for (_iter2144 = this->new_parts.begin(); _iter2144 != this->new_parts.end(); ++_iter2144) + std::vector ::const_iterator _iter2145; + for (_iter2145 = this->new_parts.begin(); _iter2145 != this->new_parts.end(); ++_iter2145) { - xfer += (*_iter2144).write(oprot); + xfer += (*_iter2145).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16540,10 +16540,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 _iter2145; - for (_iter2145 = (*(this->new_parts)).begin(); _iter2145 != (*(this->new_parts)).end(); ++_iter2145) + std::vector ::const_iterator _iter2146; + for (_iter2146 = (*(this->new_parts)).begin(); _iter2146 != (*(this->new_parts)).end(); ++_iter2146) { - xfer += (*_iter2145).write(oprot); + xfer += (*_iter2146).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16752,14 +16752,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 _size2146; - ::apache::thrift::protocol::TType _etype2149; - xfer += iprot->readListBegin(_etype2149, _size2146); - this->new_parts.resize(_size2146); - uint32_t _i2150; - for (_i2150 = 0; _i2150 < _size2146; ++_i2150) + uint32_t _size2147; + ::apache::thrift::protocol::TType _etype2150; + xfer += iprot->readListBegin(_etype2150, _size2147); + this->new_parts.resize(_size2147); + uint32_t _i2151; + for (_i2151 = 0; _i2151 < _size2147; ++_i2151) { - xfer += this->new_parts[_i2150].read(iprot); + xfer += this->new_parts[_i2151].read(iprot); } xfer += iprot->readListEnd(); } @@ -16788,10 +16788,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 _iter2151; - for (_iter2151 = this->new_parts.begin(); _iter2151 != this->new_parts.end(); ++_iter2151) + std::vector ::const_iterator _iter2152; + for (_iter2152 = this->new_parts.begin(); _iter2152 != this->new_parts.end(); ++_iter2152) { - xfer += (*_iter2151).write(oprot); + xfer += (*_iter2152).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16815,10 +16815,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 _iter2152; - for (_iter2152 = (*(this->new_parts)).begin(); _iter2152 != (*(this->new_parts)).end(); ++_iter2152) + std::vector ::const_iterator _iter2153; + for (_iter2153 = (*(this->new_parts)).begin(); _iter2153 != (*(this->new_parts)).end(); ++_iter2153) { - xfer += (*_iter2152).write(oprot); + xfer += (*_iter2153).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17043,14 +17043,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2153; - ::apache::thrift::protocol::TType _etype2156; - xfer += iprot->readListBegin(_etype2156, _size2153); - this->part_vals.resize(_size2153); - uint32_t _i2157; - for (_i2157 = 0; _i2157 < _size2153; ++_i2157) + uint32_t _size2154; + ::apache::thrift::protocol::TType _etype2157; + xfer += iprot->readListBegin(_etype2157, _size2154); + this->part_vals.resize(_size2154); + uint32_t _i2158; + for (_i2158 = 0; _i2158 < _size2154; ++_i2158) { - xfer += iprot->readString(this->part_vals[_i2157]); + xfer += iprot->readString(this->part_vals[_i2158]); } xfer += iprot->readListEnd(); } @@ -17087,10 +17087,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 _iter2158; - for (_iter2158 = this->part_vals.begin(); _iter2158 != this->part_vals.end(); ++_iter2158) + std::vector ::const_iterator _iter2159; + for (_iter2159 = this->part_vals.begin(); _iter2159 != this->part_vals.end(); ++_iter2159) { - xfer += oprot->writeString((*_iter2158)); + xfer += oprot->writeString((*_iter2159)); } xfer += oprot->writeListEnd(); } @@ -17122,10 +17122,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 _iter2159; - for (_iter2159 = (*(this->part_vals)).begin(); _iter2159 != (*(this->part_vals)).end(); ++_iter2159) + std::vector ::const_iterator _iter2160; + for (_iter2160 = (*(this->part_vals)).begin(); _iter2160 != (*(this->part_vals)).end(); ++_iter2160) { - xfer += oprot->writeString((*_iter2159)); + xfer += oprot->writeString((*_iter2160)); } xfer += oprot->writeListEnd(); } @@ -17597,14 +17597,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2160; - ::apache::thrift::protocol::TType _etype2163; - xfer += iprot->readListBegin(_etype2163, _size2160); - this->part_vals.resize(_size2160); - uint32_t _i2164; - for (_i2164 = 0; _i2164 < _size2160; ++_i2164) + uint32_t _size2161; + ::apache::thrift::protocol::TType _etype2164; + xfer += iprot->readListBegin(_etype2164, _size2161); + this->part_vals.resize(_size2161); + uint32_t _i2165; + for (_i2165 = 0; _i2165 < _size2161; ++_i2165) { - xfer += iprot->readString(this->part_vals[_i2164]); + xfer += iprot->readString(this->part_vals[_i2165]); } xfer += iprot->readListEnd(); } @@ -17649,10 +17649,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 _iter2165; - for (_iter2165 = this->part_vals.begin(); _iter2165 != this->part_vals.end(); ++_iter2165) + std::vector ::const_iterator _iter2166; + for (_iter2166 = this->part_vals.begin(); _iter2166 != this->part_vals.end(); ++_iter2166) { - xfer += oprot->writeString((*_iter2165)); + xfer += oprot->writeString((*_iter2166)); } xfer += oprot->writeListEnd(); } @@ -17688,10 +17688,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 _iter2166; - for (_iter2166 = (*(this->part_vals)).begin(); _iter2166 != (*(this->part_vals)).end(); ++_iter2166) + std::vector ::const_iterator _iter2167; + for (_iter2167 = (*(this->part_vals)).begin(); _iter2167 != (*(this->part_vals)).end(); ++_iter2167) { - xfer += oprot->writeString((*_iter2166)); + xfer += oprot->writeString((*_iter2167)); } xfer += oprot->writeListEnd(); } @@ -18741,14 +18741,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2167; - ::apache::thrift::protocol::TType _etype2170; - xfer += iprot->readListBegin(_etype2170, _size2167); - this->part_vals.resize(_size2167); - uint32_t _i2171; - for (_i2171 = 0; _i2171 < _size2167; ++_i2171) + uint32_t _size2168; + ::apache::thrift::protocol::TType _etype2171; + xfer += iprot->readListBegin(_etype2171, _size2168); + this->part_vals.resize(_size2168); + uint32_t _i2172; + for (_i2172 = 0; _i2172 < _size2168; ++_i2172) { - xfer += iprot->readString(this->part_vals[_i2171]); + xfer += iprot->readString(this->part_vals[_i2172]); } xfer += iprot->readListEnd(); } @@ -18793,10 +18793,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 _iter2172; - for (_iter2172 = this->part_vals.begin(); _iter2172 != this->part_vals.end(); ++_iter2172) + std::vector ::const_iterator _iter2173; + for (_iter2173 = this->part_vals.begin(); _iter2173 != this->part_vals.end(); ++_iter2173) { - xfer += oprot->writeString((*_iter2172)); + xfer += oprot->writeString((*_iter2173)); } xfer += oprot->writeListEnd(); } @@ -18832,10 +18832,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 _iter2173; - for (_iter2173 = (*(this->part_vals)).begin(); _iter2173 != (*(this->part_vals)).end(); ++_iter2173) + std::vector ::const_iterator _iter2174; + for (_iter2174 = (*(this->part_vals)).begin(); _iter2174 != (*(this->part_vals)).end(); ++_iter2174) { - xfer += oprot->writeString((*_iter2173)); + xfer += oprot->writeString((*_iter2174)); } xfer += oprot->writeListEnd(); } @@ -19044,14 +19044,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2174; - ::apache::thrift::protocol::TType _etype2177; - xfer += iprot->readListBegin(_etype2177, _size2174); - this->part_vals.resize(_size2174); - uint32_t _i2178; - for (_i2178 = 0; _i2178 < _size2174; ++_i2178) + uint32_t _size2175; + ::apache::thrift::protocol::TType _etype2178; + xfer += iprot->readListBegin(_etype2178, _size2175); + this->part_vals.resize(_size2175); + uint32_t _i2179; + for (_i2179 = 0; _i2179 < _size2175; ++_i2179) { - xfer += iprot->readString(this->part_vals[_i2178]); + xfer += iprot->readString(this->part_vals[_i2179]); } xfer += iprot->readListEnd(); } @@ -19104,10 +19104,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 _iter2179; - for (_iter2179 = this->part_vals.begin(); _iter2179 != this->part_vals.end(); ++_iter2179) + std::vector ::const_iterator _iter2180; + for (_iter2180 = this->part_vals.begin(); _iter2180 != this->part_vals.end(); ++_iter2180) { - xfer += oprot->writeString((*_iter2179)); + xfer += oprot->writeString((*_iter2180)); } xfer += oprot->writeListEnd(); } @@ -19147,10 +19147,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 _iter2180; - for (_iter2180 = (*(this->part_vals)).begin(); _iter2180 != (*(this->part_vals)).end(); ++_iter2180) + std::vector ::const_iterator _iter2181; + for (_iter2181 = (*(this->part_vals)).begin(); _iter2181 != (*(this->part_vals)).end(); ++_iter2181) { - xfer += oprot->writeString((*_iter2180)); + xfer += oprot->writeString((*_iter2181)); } xfer += oprot->writeListEnd(); } @@ -20383,14 +20383,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2181; - ::apache::thrift::protocol::TType _etype2184; - xfer += iprot->readListBegin(_etype2184, _size2181); - this->part_vals.resize(_size2181); - uint32_t _i2185; - for (_i2185 = 0; _i2185 < _size2181; ++_i2185) + uint32_t _size2182; + ::apache::thrift::protocol::TType _etype2185; + xfer += iprot->readListBegin(_etype2185, _size2182); + this->part_vals.resize(_size2182); + uint32_t _i2186; + for (_i2186 = 0; _i2186 < _size2182; ++_i2186) { - xfer += iprot->readString(this->part_vals[_i2185]); + xfer += iprot->readString(this->part_vals[_i2186]); } xfer += iprot->readListEnd(); } @@ -20427,10 +20427,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 _iter2186; - for (_iter2186 = this->part_vals.begin(); _iter2186 != this->part_vals.end(); ++_iter2186) + std::vector ::const_iterator _iter2187; + for (_iter2187 = this->part_vals.begin(); _iter2187 != this->part_vals.end(); ++_iter2187) { - xfer += oprot->writeString((*_iter2186)); + xfer += oprot->writeString((*_iter2187)); } xfer += oprot->writeListEnd(); } @@ -20462,10 +20462,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 _iter2187; - for (_iter2187 = (*(this->part_vals)).begin(); _iter2187 != (*(this->part_vals)).end(); ++_iter2187) + std::vector ::const_iterator _iter2188; + for (_iter2188 = (*(this->part_vals)).begin(); _iter2188 != (*(this->part_vals)).end(); ++_iter2188) { - xfer += oprot->writeString((*_iter2187)); + xfer += oprot->writeString((*_iter2188)); } xfer += oprot->writeListEnd(); } @@ -20881,17 +20881,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2188; - ::apache::thrift::protocol::TType _ktype2189; - ::apache::thrift::protocol::TType _vtype2190; - xfer += iprot->readMapBegin(_ktype2189, _vtype2190, _size2188); - uint32_t _i2192; - for (_i2192 = 0; _i2192 < _size2188; ++_i2192) + uint32_t _size2189; + ::apache::thrift::protocol::TType _ktype2190; + ::apache::thrift::protocol::TType _vtype2191; + xfer += iprot->readMapBegin(_ktype2190, _vtype2191, _size2189); + uint32_t _i2193; + for (_i2193 = 0; _i2193 < _size2189; ++_i2193) { - std::string _key2193; - xfer += iprot->readString(_key2193); - std::string& _val2194 = this->partitionSpecs[_key2193]; - xfer += iprot->readString(_val2194); + std::string _key2194; + xfer += iprot->readString(_key2194); + std::string& _val2195 = this->partitionSpecs[_key2194]; + xfer += iprot->readString(_val2195); } xfer += iprot->readMapEnd(); } @@ -20952,11 +20952,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 _iter2195; - for (_iter2195 = this->partitionSpecs.begin(); _iter2195 != this->partitionSpecs.end(); ++_iter2195) + std::map ::const_iterator _iter2196; + for (_iter2196 = this->partitionSpecs.begin(); _iter2196 != this->partitionSpecs.end(); ++_iter2196) { - xfer += oprot->writeString(_iter2195->first); - xfer += oprot->writeString(_iter2195->second); + xfer += oprot->writeString(_iter2196->first); + xfer += oprot->writeString(_iter2196->second); } xfer += oprot->writeMapEnd(); } @@ -20996,11 +20996,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 _iter2196; - for (_iter2196 = (*(this->partitionSpecs)).begin(); _iter2196 != (*(this->partitionSpecs)).end(); ++_iter2196) + std::map ::const_iterator _iter2197; + for (_iter2197 = (*(this->partitionSpecs)).begin(); _iter2197 != (*(this->partitionSpecs)).end(); ++_iter2197) { - xfer += oprot->writeString(_iter2196->first); - xfer += oprot->writeString(_iter2196->second); + xfer += oprot->writeString(_iter2197->first); + xfer += oprot->writeString(_iter2197->second); } xfer += oprot->writeMapEnd(); } @@ -21245,17 +21245,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2197; - ::apache::thrift::protocol::TType _ktype2198; - ::apache::thrift::protocol::TType _vtype2199; - xfer += iprot->readMapBegin(_ktype2198, _vtype2199, _size2197); - uint32_t _i2201; - for (_i2201 = 0; _i2201 < _size2197; ++_i2201) + uint32_t _size2198; + ::apache::thrift::protocol::TType _ktype2199; + ::apache::thrift::protocol::TType _vtype2200; + xfer += iprot->readMapBegin(_ktype2199, _vtype2200, _size2198); + uint32_t _i2202; + for (_i2202 = 0; _i2202 < _size2198; ++_i2202) { - std::string _key2202; - xfer += iprot->readString(_key2202); - std::string& _val2203 = this->partitionSpecs[_key2202]; - xfer += iprot->readString(_val2203); + std::string _key2203; + xfer += iprot->readString(_key2203); + std::string& _val2204 = this->partitionSpecs[_key2203]; + xfer += iprot->readString(_val2204); } xfer += iprot->readMapEnd(); } @@ -21316,11 +21316,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 _iter2204; - for (_iter2204 = this->partitionSpecs.begin(); _iter2204 != this->partitionSpecs.end(); ++_iter2204) + std::map ::const_iterator _iter2205; + for (_iter2205 = this->partitionSpecs.begin(); _iter2205 != this->partitionSpecs.end(); ++_iter2205) { - xfer += oprot->writeString(_iter2204->first); - xfer += oprot->writeString(_iter2204->second); + xfer += oprot->writeString(_iter2205->first); + xfer += oprot->writeString(_iter2205->second); } xfer += oprot->writeMapEnd(); } @@ -21360,11 +21360,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 _iter2205; - for (_iter2205 = (*(this->partitionSpecs)).begin(); _iter2205 != (*(this->partitionSpecs)).end(); ++_iter2205) + std::map ::const_iterator _iter2206; + for (_iter2206 = (*(this->partitionSpecs)).begin(); _iter2206 != (*(this->partitionSpecs)).end(); ++_iter2206) { - xfer += oprot->writeString(_iter2205->first); - xfer += oprot->writeString(_iter2205->second); + xfer += oprot->writeString(_iter2206->first); + xfer += oprot->writeString(_iter2206->second); } xfer += oprot->writeMapEnd(); } @@ -21421,14 +21421,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2206; - ::apache::thrift::protocol::TType _etype2209; - xfer += iprot->readListBegin(_etype2209, _size2206); - this->success.resize(_size2206); - uint32_t _i2210; - for (_i2210 = 0; _i2210 < _size2206; ++_i2210) + uint32_t _size2207; + ::apache::thrift::protocol::TType _etype2210; + xfer += iprot->readListBegin(_etype2210, _size2207); + this->success.resize(_size2207); + uint32_t _i2211; + for (_i2211 = 0; _i2211 < _size2207; ++_i2211) { - xfer += this->success[_i2210].read(iprot); + xfer += this->success[_i2211].read(iprot); } xfer += iprot->readListEnd(); } @@ -21491,10 +21491,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 _iter2211; - for (_iter2211 = this->success.begin(); _iter2211 != this->success.end(); ++_iter2211) + std::vector ::const_iterator _iter2212; + for (_iter2212 = this->success.begin(); _iter2212 != this->success.end(); ++_iter2212) { - xfer += (*_iter2211).write(oprot); + xfer += (*_iter2212).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21551,14 +21551,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2212; - ::apache::thrift::protocol::TType _etype2215; - xfer += iprot->readListBegin(_etype2215, _size2212); - (*(this->success)).resize(_size2212); - uint32_t _i2216; - for (_i2216 = 0; _i2216 < _size2212; ++_i2216) + uint32_t _size2213; + ::apache::thrift::protocol::TType _etype2216; + xfer += iprot->readListBegin(_etype2216, _size2213); + (*(this->success)).resize(_size2213); + uint32_t _i2217; + for (_i2217 = 0; _i2217 < _size2213; ++_i2217) { - xfer += (*(this->success))[_i2216].read(iprot); + xfer += (*(this->success))[_i2217].read(iprot); } xfer += iprot->readListEnd(); } @@ -21657,14 +21657,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 _size2217; - ::apache::thrift::protocol::TType _etype2220; - xfer += iprot->readListBegin(_etype2220, _size2217); - this->part_vals.resize(_size2217); - uint32_t _i2221; - for (_i2221 = 0; _i2221 < _size2217; ++_i2221) + uint32_t _size2218; + ::apache::thrift::protocol::TType _etype2221; + xfer += iprot->readListBegin(_etype2221, _size2218); + this->part_vals.resize(_size2218); + uint32_t _i2222; + for (_i2222 = 0; _i2222 < _size2218; ++_i2222) { - xfer += iprot->readString(this->part_vals[_i2221]); + xfer += iprot->readString(this->part_vals[_i2222]); } xfer += iprot->readListEnd(); } @@ -21685,14 +21685,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 _size2222; - ::apache::thrift::protocol::TType _etype2225; - xfer += iprot->readListBegin(_etype2225, _size2222); - this->group_names.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->group_names.resize(_size2223); + uint32_t _i2227; + for (_i2227 = 0; _i2227 < _size2223; ++_i2227) { - xfer += iprot->readString(this->group_names[_i2226]); + xfer += iprot->readString(this->group_names[_i2227]); } xfer += iprot->readListEnd(); } @@ -21729,10 +21729,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 _iter2227; - for (_iter2227 = this->part_vals.begin(); _iter2227 != this->part_vals.end(); ++_iter2227) + std::vector ::const_iterator _iter2228; + for (_iter2228 = this->part_vals.begin(); _iter2228 != this->part_vals.end(); ++_iter2228) { - xfer += oprot->writeString((*_iter2227)); + xfer += oprot->writeString((*_iter2228)); } xfer += oprot->writeListEnd(); } @@ -21745,10 +21745,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 _iter2228; - for (_iter2228 = this->group_names.begin(); _iter2228 != this->group_names.end(); ++_iter2228) + std::vector ::const_iterator _iter2229; + for (_iter2229 = this->group_names.begin(); _iter2229 != this->group_names.end(); ++_iter2229) { - xfer += oprot->writeString((*_iter2228)); + xfer += oprot->writeString((*_iter2229)); } xfer += oprot->writeListEnd(); } @@ -21780,10 +21780,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 _iter2229; - for (_iter2229 = (*(this->part_vals)).begin(); _iter2229 != (*(this->part_vals)).end(); ++_iter2229) + std::vector ::const_iterator _iter2230; + for (_iter2230 = (*(this->part_vals)).begin(); _iter2230 != (*(this->part_vals)).end(); ++_iter2230) { - xfer += oprot->writeString((*_iter2229)); + xfer += oprot->writeString((*_iter2230)); } xfer += oprot->writeListEnd(); } @@ -21796,10 +21796,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 _iter2230; - for (_iter2230 = (*(this->group_names)).begin(); _iter2230 != (*(this->group_names)).end(); ++_iter2230) + std::vector ::const_iterator _iter2231; + for (_iter2231 = (*(this->group_names)).begin(); _iter2231 != (*(this->group_names)).end(); ++_iter2231) { - xfer += oprot->writeString((*_iter2230)); + xfer += oprot->writeString((*_iter2231)); } xfer += oprot->writeListEnd(); } @@ -22358,14 +22358,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2231; - ::apache::thrift::protocol::TType _etype2234; - xfer += iprot->readListBegin(_etype2234, _size2231); - this->success.resize(_size2231); - uint32_t _i2235; - for (_i2235 = 0; _i2235 < _size2231; ++_i2235) + uint32_t _size2232; + ::apache::thrift::protocol::TType _etype2235; + xfer += iprot->readListBegin(_etype2235, _size2232); + this->success.resize(_size2232); + uint32_t _i2236; + for (_i2236 = 0; _i2236 < _size2232; ++_i2236) { - xfer += this->success[_i2235].read(iprot); + xfer += this->success[_i2236].read(iprot); } xfer += iprot->readListEnd(); } @@ -22412,10 +22412,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 _iter2236; - for (_iter2236 = this->success.begin(); _iter2236 != this->success.end(); ++_iter2236) + std::vector ::const_iterator _iter2237; + for (_iter2237 = this->success.begin(); _iter2237 != this->success.end(); ++_iter2237) { - xfer += (*_iter2236).write(oprot); + xfer += (*_iter2237).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22464,14 +22464,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2237; - ::apache::thrift::protocol::TType _etype2240; - xfer += iprot->readListBegin(_etype2240, _size2237); - (*(this->success)).resize(_size2237); - uint32_t _i2241; - for (_i2241 = 0; _i2241 < _size2237; ++_i2241) + uint32_t _size2238; + ::apache::thrift::protocol::TType _etype2241; + xfer += iprot->readListBegin(_etype2241, _size2238); + (*(this->success)).resize(_size2238); + uint32_t _i2242; + for (_i2242 = 0; _i2242 < _size2238; ++_i2242) { - xfer += (*(this->success))[_i2241].read(iprot); + xfer += (*(this->success))[_i2242].read(iprot); } xfer += iprot->readListEnd(); } @@ -22797,14 +22797,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 _size2242; - ::apache::thrift::protocol::TType _etype2245; - xfer += iprot->readListBegin(_etype2245, _size2242); - this->group_names.resize(_size2242); - uint32_t _i2246; - for (_i2246 = 0; _i2246 < _size2242; ++_i2246) + uint32_t _size2243; + ::apache::thrift::protocol::TType _etype2246; + xfer += iprot->readListBegin(_etype2246, _size2243); + this->group_names.resize(_size2243); + uint32_t _i2247; + for (_i2247 = 0; _i2247 < _size2243; ++_i2247) { - xfer += iprot->readString(this->group_names[_i2246]); + xfer += iprot->readString(this->group_names[_i2247]); } xfer += iprot->readListEnd(); } @@ -22849,10 +22849,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 _iter2247; - for (_iter2247 = this->group_names.begin(); _iter2247 != this->group_names.end(); ++_iter2247) + std::vector ::const_iterator _iter2248; + for (_iter2248 = this->group_names.begin(); _iter2248 != this->group_names.end(); ++_iter2248) { - xfer += oprot->writeString((*_iter2247)); + xfer += oprot->writeString((*_iter2248)); } xfer += oprot->writeListEnd(); } @@ -22892,10 +22892,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 _iter2248; - for (_iter2248 = (*(this->group_names)).begin(); _iter2248 != (*(this->group_names)).end(); ++_iter2248) + std::vector ::const_iterator _iter2249; + for (_iter2249 = (*(this->group_names)).begin(); _iter2249 != (*(this->group_names)).end(); ++_iter2249) { - xfer += oprot->writeString((*_iter2248)); + xfer += oprot->writeString((*_iter2249)); } xfer += oprot->writeListEnd(); } @@ -22936,14 +22936,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2249; - ::apache::thrift::protocol::TType _etype2252; - xfer += iprot->readListBegin(_etype2252, _size2249); - this->success.resize(_size2249); - uint32_t _i2253; - for (_i2253 = 0; _i2253 < _size2249; ++_i2253) + uint32_t _size2250; + ::apache::thrift::protocol::TType _etype2253; + xfer += iprot->readListBegin(_etype2253, _size2250); + this->success.resize(_size2250); + uint32_t _i2254; + for (_i2254 = 0; _i2254 < _size2250; ++_i2254) { - xfer += this->success[_i2253].read(iprot); + xfer += this->success[_i2254].read(iprot); } xfer += iprot->readListEnd(); } @@ -22990,10 +22990,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 _iter2254; - for (_iter2254 = this->success.begin(); _iter2254 != this->success.end(); ++_iter2254) + std::vector ::const_iterator _iter2255; + for (_iter2255 = this->success.begin(); _iter2255 != this->success.end(); ++_iter2255) { - xfer += (*_iter2254).write(oprot); + xfer += (*_iter2255).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23042,14 +23042,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2255; - ::apache::thrift::protocol::TType _etype2258; - xfer += iprot->readListBegin(_etype2258, _size2255); - (*(this->success)).resize(_size2255); - uint32_t _i2259; - for (_i2259 = 0; _i2259 < _size2255; ++_i2259) + 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) { - xfer += (*(this->success))[_i2259].read(iprot); + xfer += (*(this->success))[_i2260].read(iprot); } xfer += iprot->readListEnd(); } @@ -23227,14 +23227,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2260; - ::apache::thrift::protocol::TType _etype2263; - xfer += iprot->readListBegin(_etype2263, _size2260); - this->success.resize(_size2260); - uint32_t _i2264; - for (_i2264 = 0; _i2264 < _size2260; ++_i2264) + uint32_t _size2261; + ::apache::thrift::protocol::TType _etype2264; + xfer += iprot->readListBegin(_etype2264, _size2261); + this->success.resize(_size2261); + uint32_t _i2265; + for (_i2265 = 0; _i2265 < _size2261; ++_i2265) { - xfer += this->success[_i2264].read(iprot); + xfer += this->success[_i2265].read(iprot); } xfer += iprot->readListEnd(); } @@ -23281,10 +23281,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 _iter2265; - for (_iter2265 = this->success.begin(); _iter2265 != this->success.end(); ++_iter2265) + std::vector ::const_iterator _iter2266; + for (_iter2266 = this->success.begin(); _iter2266 != this->success.end(); ++_iter2266) { - xfer += (*_iter2265).write(oprot); + xfer += (*_iter2266).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23333,14 +23333,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2266; - ::apache::thrift::protocol::TType _etype2269; - xfer += iprot->readListBegin(_etype2269, _size2266); - (*(this->success)).resize(_size2266); - uint32_t _i2270; - for (_i2270 = 0; _i2270 < _size2266; ++_i2270) + 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) { - xfer += (*(this->success))[_i2270].read(iprot); + xfer += (*(this->success))[_i2271].read(iprot); } xfer += iprot->readListEnd(); } @@ -23518,14 +23518,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2271; - ::apache::thrift::protocol::TType _etype2274; - xfer += iprot->readListBegin(_etype2274, _size2271); - this->success.resize(_size2271); - uint32_t _i2275; - for (_i2275 = 0; _i2275 < _size2271; ++_i2275) + uint32_t _size2272; + ::apache::thrift::protocol::TType _etype2275; + xfer += iprot->readListBegin(_etype2275, _size2272); + this->success.resize(_size2272); + uint32_t _i2276; + for (_i2276 = 0; _i2276 < _size2272; ++_i2276) { - xfer += iprot->readString(this->success[_i2275]); + xfer += iprot->readString(this->success[_i2276]); } xfer += iprot->readListEnd(); } @@ -23572,10 +23572,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 _iter2276; - for (_iter2276 = this->success.begin(); _iter2276 != this->success.end(); ++_iter2276) + std::vector ::const_iterator _iter2277; + for (_iter2277 = this->success.begin(); _iter2277 != this->success.end(); ++_iter2277) { - xfer += oprot->writeString((*_iter2276)); + xfer += oprot->writeString((*_iter2277)); } xfer += oprot->writeListEnd(); } @@ -23624,14 +23624,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2277; - ::apache::thrift::protocol::TType _etype2280; - xfer += iprot->readListBegin(_etype2280, _size2277); - (*(this->success)).resize(_size2277); - uint32_t _i2281; - for (_i2281 = 0; _i2281 < _size2277; ++_i2281) + uint32_t _size2278; + ::apache::thrift::protocol::TType _etype2281; + xfer += iprot->readListBegin(_etype2281, _size2278); + (*(this->success)).resize(_size2278); + uint32_t _i2282; + for (_i2282 = 0; _i2282 < _size2278; ++_i2282) { - xfer += iprot->readString((*(this->success))[_i2281]); + xfer += iprot->readString((*(this->success))[_i2282]); } xfer += iprot->readListEnd(); } @@ -23777,14 +23777,14 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2282; - ::apache::thrift::protocol::TType _etype2285; - xfer += iprot->readListBegin(_etype2285, _size2282); - this->success.resize(_size2282); - uint32_t _i2286; - for (_i2286 = 0; _i2286 < _size2282; ++_i2286) + uint32_t _size2283; + ::apache::thrift::protocol::TType _etype2286; + xfer += iprot->readListBegin(_etype2286, _size2283); + this->success.resize(_size2283); + uint32_t _i2287; + for (_i2287 = 0; _i2287 < _size2283; ++_i2287) { - xfer += iprot->readString(this->success[_i2286]); + xfer += iprot->readString(this->success[_i2287]); } xfer += iprot->readListEnd(); } @@ -23831,10 +23831,10 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_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 _iter2287; - for (_iter2287 = this->success.begin(); _iter2287 != this->success.end(); ++_iter2287) + std::vector ::const_iterator _iter2288; + for (_iter2288 = this->success.begin(); _iter2288 != this->success.end(); ++_iter2288) { - xfer += oprot->writeString((*_iter2287)); + xfer += oprot->writeString((*_iter2288)); } xfer += oprot->writeListEnd(); } @@ -23883,14 +23883,14 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2288; - ::apache::thrift::protocol::TType _etype2291; - xfer += iprot->readListBegin(_etype2291, _size2288); - (*(this->success)).resize(_size2288); - uint32_t _i2292; - for (_i2292 = 0; _i2292 < _size2288; ++_i2292) + uint32_t _size2289; + ::apache::thrift::protocol::TType _etype2292; + xfer += iprot->readListBegin(_etype2292, _size2289); + (*(this->success)).resize(_size2289); + uint32_t _i2293; + for (_i2293 = 0; _i2293 < _size2289; ++_i2293) { - xfer += iprot->readString((*(this->success))[_i2292]); + xfer += iprot->readString((*(this->success))[_i2293]); } xfer += iprot->readListEnd(); } @@ -24200,14 +24200,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 _size2293; - ::apache::thrift::protocol::TType _etype2296; - xfer += iprot->readListBegin(_etype2296, _size2293); - this->part_vals.resize(_size2293); - uint32_t _i2297; - for (_i2297 = 0; _i2297 < _size2293; ++_i2297) + uint32_t _size2294; + ::apache::thrift::protocol::TType _etype2297; + xfer += iprot->readListBegin(_etype2297, _size2294); + this->part_vals.resize(_size2294); + uint32_t _i2298; + for (_i2298 = 0; _i2298 < _size2294; ++_i2298) { - xfer += iprot->readString(this->part_vals[_i2297]); + xfer += iprot->readString(this->part_vals[_i2298]); } xfer += iprot->readListEnd(); } @@ -24252,10 +24252,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 _iter2298; - for (_iter2298 = this->part_vals.begin(); _iter2298 != this->part_vals.end(); ++_iter2298) + std::vector ::const_iterator _iter2299; + for (_iter2299 = this->part_vals.begin(); _iter2299 != this->part_vals.end(); ++_iter2299) { - xfer += oprot->writeString((*_iter2298)); + xfer += oprot->writeString((*_iter2299)); } xfer += oprot->writeListEnd(); } @@ -24291,10 +24291,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 _iter2299; - for (_iter2299 = (*(this->part_vals)).begin(); _iter2299 != (*(this->part_vals)).end(); ++_iter2299) + std::vector ::const_iterator _iter2300; + for (_iter2300 = (*(this->part_vals)).begin(); _iter2300 != (*(this->part_vals)).end(); ++_iter2300) { - xfer += oprot->writeString((*_iter2299)); + xfer += oprot->writeString((*_iter2300)); } xfer += oprot->writeListEnd(); } @@ -24339,14 +24339,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2300; - ::apache::thrift::protocol::TType _etype2303; - xfer += iprot->readListBegin(_etype2303, _size2300); - this->success.resize(_size2300); - uint32_t _i2304; - for (_i2304 = 0; _i2304 < _size2300; ++_i2304) + uint32_t _size2301; + ::apache::thrift::protocol::TType _etype2304; + xfer += iprot->readListBegin(_etype2304, _size2301); + this->success.resize(_size2301); + uint32_t _i2305; + for (_i2305 = 0; _i2305 < _size2301; ++_i2305) { - xfer += this->success[_i2304].read(iprot); + xfer += this->success[_i2305].read(iprot); } xfer += iprot->readListEnd(); } @@ -24393,10 +24393,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 _iter2305; - for (_iter2305 = this->success.begin(); _iter2305 != this->success.end(); ++_iter2305) + std::vector ::const_iterator _iter2306; + for (_iter2306 = this->success.begin(); _iter2306 != this->success.end(); ++_iter2306) { - xfer += (*_iter2305).write(oprot); + xfer += (*_iter2306).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24445,14 +24445,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2306; - ::apache::thrift::protocol::TType _etype2309; - xfer += iprot->readListBegin(_etype2309, _size2306); - (*(this->success)).resize(_size2306); - uint32_t _i2310; - for (_i2310 = 0; _i2310 < _size2306; ++_i2310) + uint32_t _size2307; + ::apache::thrift::protocol::TType _etype2310; + xfer += iprot->readListBegin(_etype2310, _size2307); + (*(this->success)).resize(_size2307); + uint32_t _i2311; + for (_i2311 = 0; _i2311 < _size2307; ++_i2311) { - xfer += (*(this->success))[_i2310].read(iprot); + xfer += (*(this->success))[_i2311].read(iprot); } xfer += iprot->readListEnd(); } @@ -24535,14 +24535,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 _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) + uint32_t _size2312; + ::apache::thrift::protocol::TType _etype2315; + xfer += iprot->readListBegin(_etype2315, _size2312); + this->part_vals.resize(_size2312); + uint32_t _i2316; + for (_i2316 = 0; _i2316 < _size2312; ++_i2316) { - xfer += iprot->readString(this->part_vals[_i2315]); + xfer += iprot->readString(this->part_vals[_i2316]); } xfer += iprot->readListEnd(); } @@ -24571,14 +24571,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 _size2316; - ::apache::thrift::protocol::TType _etype2319; - xfer += iprot->readListBegin(_etype2319, _size2316); - this->group_names.resize(_size2316); - uint32_t _i2320; - for (_i2320 = 0; _i2320 < _size2316; ++_i2320) + uint32_t _size2317; + ::apache::thrift::protocol::TType _etype2320; + xfer += iprot->readListBegin(_etype2320, _size2317); + this->group_names.resize(_size2317); + uint32_t _i2321; + for (_i2321 = 0; _i2321 < _size2317; ++_i2321) { - xfer += iprot->readString(this->group_names[_i2320]); + xfer += iprot->readString(this->group_names[_i2321]); } xfer += iprot->readListEnd(); } @@ -24615,10 +24615,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 _iter2321; - for (_iter2321 = this->part_vals.begin(); _iter2321 != this->part_vals.end(); ++_iter2321) + std::vector ::const_iterator _iter2322; + for (_iter2322 = this->part_vals.begin(); _iter2322 != this->part_vals.end(); ++_iter2322) { - xfer += oprot->writeString((*_iter2321)); + xfer += oprot->writeString((*_iter2322)); } xfer += oprot->writeListEnd(); } @@ -24635,10 +24635,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 _iter2322; - for (_iter2322 = this->group_names.begin(); _iter2322 != this->group_names.end(); ++_iter2322) + std::vector ::const_iterator _iter2323; + for (_iter2323 = this->group_names.begin(); _iter2323 != this->group_names.end(); ++_iter2323) { - xfer += oprot->writeString((*_iter2322)); + xfer += oprot->writeString((*_iter2323)); } xfer += oprot->writeListEnd(); } @@ -24670,10 +24670,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 _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(); } @@ -24690,10 +24690,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 _iter2324; - for (_iter2324 = (*(this->group_names)).begin(); _iter2324 != (*(this->group_names)).end(); ++_iter2324) + std::vector ::const_iterator _iter2325; + for (_iter2325 = (*(this->group_names)).begin(); _iter2325 != (*(this->group_names)).end(); ++_iter2325) { - xfer += oprot->writeString((*_iter2324)); + xfer += oprot->writeString((*_iter2325)); } xfer += oprot->writeListEnd(); } @@ -24734,14 +24734,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size2326; + ::apache::thrift::protocol::TType _etype2329; + xfer += iprot->readListBegin(_etype2329, _size2326); + this->success.resize(_size2326); + uint32_t _i2330; + for (_i2330 = 0; _i2330 < _size2326; ++_i2330) { - xfer += this->success[_i2329].read(iprot); + xfer += this->success[_i2330].read(iprot); } xfer += iprot->readListEnd(); } @@ -24788,10 +24788,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 _iter2330; - for (_iter2330 = this->success.begin(); _iter2330 != this->success.end(); ++_iter2330) + std::vector ::const_iterator _iter2331; + for (_iter2331 = this->success.begin(); _iter2331 != this->success.end(); ++_iter2331) { - xfer += (*_iter2330).write(oprot); + xfer += (*_iter2331).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24840,14 +24840,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size2332; + ::apache::thrift::protocol::TType _etype2335; + xfer += iprot->readListBegin(_etype2335, _size2332); + (*(this->success)).resize(_size2332); + uint32_t _i2336; + for (_i2336 = 0; _i2336 < _size2332; ++_i2336) { - xfer += (*(this->success))[_i2335].read(iprot); + xfer += (*(this->success))[_i2336].read(iprot); } xfer += iprot->readListEnd(); } @@ -25157,14 +25157,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 _size2336; - ::apache::thrift::protocol::TType _etype2339; - xfer += iprot->readListBegin(_etype2339, _size2336); - this->part_vals.resize(_size2336); - uint32_t _i2340; - for (_i2340 = 0; _i2340 < _size2336; ++_i2340) + uint32_t _size2337; + ::apache::thrift::protocol::TType _etype2340; + xfer += iprot->readListBegin(_etype2340, _size2337); + this->part_vals.resize(_size2337); + uint32_t _i2341; + for (_i2341 = 0; _i2341 < _size2337; ++_i2341) { - xfer += iprot->readString(this->part_vals[_i2340]); + xfer += iprot->readString(this->part_vals[_i2341]); } xfer += iprot->readListEnd(); } @@ -25209,10 +25209,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 _iter2341; - for (_iter2341 = this->part_vals.begin(); _iter2341 != this->part_vals.end(); ++_iter2341) + std::vector ::const_iterator _iter2342; + for (_iter2342 = this->part_vals.begin(); _iter2342 != this->part_vals.end(); ++_iter2342) { - xfer += oprot->writeString((*_iter2341)); + xfer += oprot->writeString((*_iter2342)); } xfer += oprot->writeListEnd(); } @@ -25248,10 +25248,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 _iter2342; - for (_iter2342 = (*(this->part_vals)).begin(); _iter2342 != (*(this->part_vals)).end(); ++_iter2342) + std::vector ::const_iterator _iter2343; + for (_iter2343 = (*(this->part_vals)).begin(); _iter2343 != (*(this->part_vals)).end(); ++_iter2343) { - xfer += oprot->writeString((*_iter2342)); + xfer += oprot->writeString((*_iter2343)); } xfer += oprot->writeListEnd(); } @@ -25296,14 +25296,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2343; - ::apache::thrift::protocol::TType _etype2346; - xfer += iprot->readListBegin(_etype2346, _size2343); - this->success.resize(_size2343); - uint32_t _i2347; - for (_i2347 = 0; _i2347 < _size2343; ++_i2347) + uint32_t _size2344; + ::apache::thrift::protocol::TType _etype2347; + xfer += iprot->readListBegin(_etype2347, _size2344); + this->success.resize(_size2344); + uint32_t _i2348; + for (_i2348 = 0; _i2348 < _size2344; ++_i2348) { - xfer += iprot->readString(this->success[_i2347]); + xfer += iprot->readString(this->success[_i2348]); } xfer += iprot->readListEnd(); } @@ -25350,10 +25350,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 _iter2348; - for (_iter2348 = this->success.begin(); _iter2348 != this->success.end(); ++_iter2348) + std::vector ::const_iterator _iter2349; + for (_iter2349 = this->success.begin(); _iter2349 != this->success.end(); ++_iter2349) { - xfer += oprot->writeString((*_iter2348)); + xfer += oprot->writeString((*_iter2349)); } xfer += oprot->writeListEnd(); } @@ -25402,14 +25402,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2349; - ::apache::thrift::protocol::TType _etype2352; - xfer += iprot->readListBegin(_etype2352, _size2349); - (*(this->success)).resize(_size2349); - uint32_t _i2353; - for (_i2353 = 0; _i2353 < _size2349; ++_i2353) + uint32_t _size2350; + ::apache::thrift::protocol::TType _etype2353; + xfer += iprot->readListBegin(_etype2353, _size2350); + (*(this->success)).resize(_size2350); + uint32_t _i2354; + for (_i2354 = 0; _i2354 < _size2350; ++_i2354) { - xfer += iprot->readString((*(this->success))[_i2353]); + xfer += iprot->readString((*(this->success))[_i2354]); } xfer += iprot->readListEnd(); } @@ -25782,14 +25782,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2354; - ::apache::thrift::protocol::TType _etype2357; - xfer += iprot->readListBegin(_etype2357, _size2354); - this->success.resize(_size2354); - uint32_t _i2358; - for (_i2358 = 0; _i2358 < _size2354; ++_i2358) + uint32_t _size2355; + ::apache::thrift::protocol::TType _etype2358; + xfer += iprot->readListBegin(_etype2358, _size2355); + this->success.resize(_size2355); + uint32_t _i2359; + for (_i2359 = 0; _i2359 < _size2355; ++_i2359) { - xfer += iprot->readString(this->success[_i2358]); + xfer += iprot->readString(this->success[_i2359]); } xfer += iprot->readListEnd(); } @@ -25836,10 +25836,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 _iter2359; - for (_iter2359 = this->success.begin(); _iter2359 != this->success.end(); ++_iter2359) + std::vector ::const_iterator _iter2360; + for (_iter2360 = this->success.begin(); _iter2360 != this->success.end(); ++_iter2360) { - xfer += oprot->writeString((*_iter2359)); + xfer += oprot->writeString((*_iter2360)); } xfer += oprot->writeListEnd(); } @@ -25888,14 +25888,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2360; - ::apache::thrift::protocol::TType _etype2363; - xfer += iprot->readListBegin(_etype2363, _size2360); - (*(this->success)).resize(_size2360); - uint32_t _i2364; - for (_i2364 = 0; _i2364 < _size2360; ++_i2364) + uint32_t _size2361; + ::apache::thrift::protocol::TType _etype2364; + xfer += iprot->readListBegin(_etype2364, _size2361); + (*(this->success)).resize(_size2361); + uint32_t _i2365; + for (_i2365 = 0; _i2365 < _size2361; ++_i2365) { - xfer += iprot->readString((*(this->success))[_i2364]); + xfer += iprot->readString((*(this->success))[_i2365]); } xfer += iprot->readListEnd(); } @@ -26089,14 +26089,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2365; - ::apache::thrift::protocol::TType _etype2368; - xfer += iprot->readListBegin(_etype2368, _size2365); - this->success.resize(_size2365); - uint32_t _i2369; - for (_i2369 = 0; _i2369 < _size2365; ++_i2369) + uint32_t _size2366; + ::apache::thrift::protocol::TType _etype2369; + xfer += iprot->readListBegin(_etype2369, _size2366); + this->success.resize(_size2366); + uint32_t _i2370; + for (_i2370 = 0; _i2370 < _size2366; ++_i2370) { - xfer += this->success[_i2369].read(iprot); + xfer += this->success[_i2370].read(iprot); } xfer += iprot->readListEnd(); } @@ -26143,10 +26143,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 _iter2370; - for (_iter2370 = this->success.begin(); _iter2370 != this->success.end(); ++_iter2370) + std::vector ::const_iterator _iter2371; + for (_iter2371 = this->success.begin(); _iter2371 != this->success.end(); ++_iter2371) { - xfer += (*_iter2370).write(oprot); + xfer += (*_iter2371).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26195,14 +26195,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size2372; + ::apache::thrift::protocol::TType _etype2375; + xfer += iprot->readListBegin(_etype2375, _size2372); + (*(this->success)).resize(_size2372); + uint32_t _i2376; + for (_i2376 = 0; _i2376 < _size2372; ++_i2376) { - xfer += (*(this->success))[_i2375].read(iprot); + xfer += (*(this->success))[_i2376].read(iprot); } xfer += iprot->readListEnd(); } @@ -26348,14 +26348,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_result::read(::apache: 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 += this->success[_i2380].read(iprot); + xfer += this->success[_i2381].read(iprot); } xfer += iprot->readListEnd(); } @@ -26402,10 +26402,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_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 _iter2381; - for (_iter2381 = this->success.begin(); _iter2381 != this->success.end(); ++_iter2381) + std::vector ::const_iterator _iter2382; + for (_iter2382 = this->success.begin(); _iter2382 != this->success.end(); ++_iter2382) { - xfer += (*_iter2381).write(oprot); + xfer += (*_iter2382).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26454,14 +26454,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_presult::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size2383; + ::apache::thrift::protocol::TType _etype2386; + xfer += iprot->readListBegin(_etype2386, _size2383); + (*(this->success)).resize(_size2383); + uint32_t _i2387; + for (_i2387 = 0; _i2387 < _size2383; ++_i2387) { - xfer += (*(this->success))[_i2386].read(iprot); + xfer += (*(this->success))[_i2387].read(iprot); } xfer += iprot->readListEnd(); } @@ -26655,14 +26655,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 _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 += this->success[_i2391].read(iprot); + xfer += this->success[_i2392].read(iprot); } xfer += iprot->readListEnd(); } @@ -26709,10 +26709,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 _iter2392; - for (_iter2392 = this->success.begin(); _iter2392 != this->success.end(); ++_iter2392) + std::vector ::const_iterator _iter2393; + for (_iter2393 = this->success.begin(); _iter2393 != this->success.end(); ++_iter2393) { - xfer += (*_iter2392).write(oprot); + xfer += (*_iter2393).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26761,14 +26761,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 _size2393; - ::apache::thrift::protocol::TType _etype2396; - xfer += iprot->readListBegin(_etype2396, _size2393); - (*(this->success)).resize(_size2393); - uint32_t _i2397; - for (_i2397 = 0; _i2397 < _size2393; ++_i2397) + uint32_t _size2394; + ::apache::thrift::protocol::TType _etype2397; + xfer += iprot->readListBegin(_etype2397, _size2394); + (*(this->success)).resize(_size2394); + uint32_t _i2398; + for (_i2398 = 0; _i2398 < _size2394; ++_i2398) { - xfer += (*(this->success))[_i2397].read(iprot); + xfer += (*(this->success))[_i2398].read(iprot); } xfer += iprot->readListEnd(); } @@ -27564,14 +27564,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size2398; - ::apache::thrift::protocol::TType _etype2401; - xfer += iprot->readListBegin(_etype2401, _size2398); - this->names.resize(_size2398); - uint32_t _i2402; - for (_i2402 = 0; _i2402 < _size2398; ++_i2402) + uint32_t _size2399; + ::apache::thrift::protocol::TType _etype2402; + xfer += iprot->readListBegin(_etype2402, _size2399); + this->names.resize(_size2399); + uint32_t _i2403; + for (_i2403 = 0; _i2403 < _size2399; ++_i2403) { - xfer += iprot->readString(this->names[_i2402]); + xfer += iprot->readString(this->names[_i2403]); } xfer += iprot->readListEnd(); } @@ -27608,10 +27608,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 _iter2403; - for (_iter2403 = this->names.begin(); _iter2403 != this->names.end(); ++_iter2403) + std::vector ::const_iterator _iter2404; + for (_iter2404 = this->names.begin(); _iter2404 != this->names.end(); ++_iter2404) { - xfer += oprot->writeString((*_iter2403)); + xfer += oprot->writeString((*_iter2404)); } xfer += oprot->writeListEnd(); } @@ -27643,10 +27643,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 _iter2404; - for (_iter2404 = (*(this->names)).begin(); _iter2404 != (*(this->names)).end(); ++_iter2404) + std::vector ::const_iterator _iter2405; + for (_iter2405 = (*(this->names)).begin(); _iter2405 != (*(this->names)).end(); ++_iter2405) { - xfer += oprot->writeString((*_iter2404)); + xfer += oprot->writeString((*_iter2405)); } xfer += oprot->writeListEnd(); } @@ -27687,14 +27687,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2405; - ::apache::thrift::protocol::TType _etype2408; - xfer += iprot->readListBegin(_etype2408, _size2405); - this->success.resize(_size2405); - uint32_t _i2409; - for (_i2409 = 0; _i2409 < _size2405; ++_i2409) + uint32_t _size2406; + ::apache::thrift::protocol::TType _etype2409; + xfer += iprot->readListBegin(_etype2409, _size2406); + this->success.resize(_size2406); + uint32_t _i2410; + for (_i2410 = 0; _i2410 < _size2406; ++_i2410) { - xfer += this->success[_i2409].read(iprot); + xfer += this->success[_i2410].read(iprot); } xfer += iprot->readListEnd(); } @@ -27749,10 +27749,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 _iter2410; - for (_iter2410 = this->success.begin(); _iter2410 != this->success.end(); ++_iter2410) + std::vector ::const_iterator _iter2411; + for (_iter2411 = this->success.begin(); _iter2411 != this->success.end(); ++_iter2411) { - xfer += (*_iter2410).write(oprot); + xfer += (*_iter2411).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27805,14 +27805,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2411; - ::apache::thrift::protocol::TType _etype2414; - xfer += iprot->readListBegin(_etype2414, _size2411); - (*(this->success)).resize(_size2411); - uint32_t _i2415; - for (_i2415 = 0; _i2415 < _size2411; ++_i2415) + uint32_t _size2412; + ::apache::thrift::protocol::TType _etype2415; + xfer += iprot->readListBegin(_etype2415, _size2412); + (*(this->success)).resize(_size2412); + uint32_t _i2416; + for (_i2416 = 0; _i2416 < _size2412; ++_i2416) { - xfer += (*(this->success))[_i2415].read(iprot); + xfer += (*(this->success))[_i2416].read(iprot); } xfer += iprot->readListEnd(); } @@ -28843,14 +28843,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2416; - ::apache::thrift::protocol::TType _etype2419; - xfer += iprot->readListBegin(_etype2419, _size2416); - this->new_parts.resize(_size2416); - uint32_t _i2420; - for (_i2420 = 0; _i2420 < _size2416; ++_i2420) + uint32_t _size2417; + ::apache::thrift::protocol::TType _etype2420; + xfer += iprot->readListBegin(_etype2420, _size2417); + this->new_parts.resize(_size2417); + uint32_t _i2421; + for (_i2421 = 0; _i2421 < _size2417; ++_i2421) { - xfer += this->new_parts[_i2420].read(iprot); + xfer += this->new_parts[_i2421].read(iprot); } xfer += iprot->readListEnd(); } @@ -28887,10 +28887,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 _iter2421; - for (_iter2421 = this->new_parts.begin(); _iter2421 != this->new_parts.end(); ++_iter2421) + std::vector ::const_iterator _iter2422; + for (_iter2422 = this->new_parts.begin(); _iter2422 != this->new_parts.end(); ++_iter2422) { - xfer += (*_iter2421).write(oprot); + xfer += (*_iter2422).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28922,10 +28922,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 _iter2422; - for (_iter2422 = (*(this->new_parts)).begin(); _iter2422 != (*(this->new_parts)).end(); ++_iter2422) + std::vector ::const_iterator _iter2423; + for (_iter2423 = (*(this->new_parts)).begin(); _iter2423 != (*(this->new_parts)).end(); ++_iter2423) { - xfer += (*_iter2422).write(oprot); + xfer += (*_iter2423).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29110,14 +29110,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2423; - ::apache::thrift::protocol::TType _etype2426; - xfer += iprot->readListBegin(_etype2426, _size2423); - this->new_parts.resize(_size2423); - uint32_t _i2427; - for (_i2427 = 0; _i2427 < _size2423; ++_i2427) + uint32_t _size2424; + ::apache::thrift::protocol::TType _etype2427; + xfer += iprot->readListBegin(_etype2427, _size2424); + this->new_parts.resize(_size2424); + uint32_t _i2428; + for (_i2428 = 0; _i2428 < _size2424; ++_i2428) { - xfer += this->new_parts[_i2427].read(iprot); + xfer += this->new_parts[_i2428].read(iprot); } xfer += iprot->readListEnd(); } @@ -29162,10 +29162,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 _iter2428; - for (_iter2428 = this->new_parts.begin(); _iter2428 != this->new_parts.end(); ++_iter2428) + std::vector ::const_iterator _iter2429; + for (_iter2429 = this->new_parts.begin(); _iter2429 != this->new_parts.end(); ++_iter2429) { - xfer += (*_iter2428).write(oprot); + xfer += (*_iter2429).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29201,10 +29201,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 _iter2429; - for (_iter2429 = (*(this->new_parts)).begin(); _iter2429 != (*(this->new_parts)).end(); ++_iter2429) + std::vector ::const_iterator _iter2430; + for (_iter2430 = (*(this->new_parts)).begin(); _iter2430 != (*(this->new_parts)).end(); ++_iter2430) { - xfer += (*_iter2429).write(oprot); + xfer += (*_iter2430).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29875,14 +29875,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2430; - ::apache::thrift::protocol::TType _etype2433; - xfer += iprot->readListBegin(_etype2433, _size2430); - this->part_vals.resize(_size2430); - uint32_t _i2434; - for (_i2434 = 0; _i2434 < _size2430; ++_i2434) + uint32_t _size2431; + ::apache::thrift::protocol::TType _etype2434; + xfer += iprot->readListBegin(_etype2434, _size2431); + this->part_vals.resize(_size2431); + uint32_t _i2435; + for (_i2435 = 0; _i2435 < _size2431; ++_i2435) { - xfer += iprot->readString(this->part_vals[_i2434]); + xfer += iprot->readString(this->part_vals[_i2435]); } xfer += iprot->readListEnd(); } @@ -29927,10 +29927,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 _iter2435; - for (_iter2435 = this->part_vals.begin(); _iter2435 != this->part_vals.end(); ++_iter2435) + std::vector ::const_iterator _iter2436; + for (_iter2436 = this->part_vals.begin(); _iter2436 != this->part_vals.end(); ++_iter2436) { - xfer += oprot->writeString((*_iter2435)); + xfer += oprot->writeString((*_iter2436)); } xfer += oprot->writeListEnd(); } @@ -29966,10 +29966,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 _iter2436; - for (_iter2436 = (*(this->part_vals)).begin(); _iter2436 != (*(this->part_vals)).end(); ++_iter2436) + std::vector ::const_iterator _iter2437; + for (_iter2437 = (*(this->part_vals)).begin(); _iter2437 != (*(this->part_vals)).end(); ++_iter2437) { - xfer += oprot->writeString((*_iter2436)); + xfer += oprot->writeString((*_iter2437)); } xfer += oprot->writeListEnd(); } @@ -30369,14 +30369,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 _size2437; - ::apache::thrift::protocol::TType _etype2440; - xfer += iprot->readListBegin(_etype2440, _size2437); - this->part_vals.resize(_size2437); - uint32_t _i2441; - for (_i2441 = 0; _i2441 < _size2437; ++_i2441) + uint32_t _size2438; + ::apache::thrift::protocol::TType _etype2441; + xfer += iprot->readListBegin(_etype2441, _size2438); + this->part_vals.resize(_size2438); + uint32_t _i2442; + for (_i2442 = 0; _i2442 < _size2438; ++_i2442) { - xfer += iprot->readString(this->part_vals[_i2441]); + xfer += iprot->readString(this->part_vals[_i2442]); } xfer += iprot->readListEnd(); } @@ -30413,10 +30413,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 _iter2442; - for (_iter2442 = this->part_vals.begin(); _iter2442 != this->part_vals.end(); ++_iter2442) + std::vector ::const_iterator _iter2443; + for (_iter2443 = this->part_vals.begin(); _iter2443 != this->part_vals.end(); ++_iter2443) { - xfer += oprot->writeString((*_iter2442)); + xfer += oprot->writeString((*_iter2443)); } xfer += oprot->writeListEnd(); } @@ -30444,10 +30444,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 _iter2443; - for (_iter2443 = (*(this->part_vals)).begin(); _iter2443 != (*(this->part_vals)).end(); ++_iter2443) + std::vector ::const_iterator _iter2444; + for (_iter2444 = (*(this->part_vals)).begin(); _iter2444 != (*(this->part_vals)).end(); ++_iter2444) { - xfer += oprot->writeString((*_iter2443)); + xfer += oprot->writeString((*_iter2444)); } xfer += oprot->writeListEnd(); } @@ -30922,14 +30922,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif 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(); } @@ -30968,10 +30968,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 _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(); } @@ -31016,14 +31016,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri 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(); } @@ -31161,17 +31161,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size2455; - ::apache::thrift::protocol::TType _ktype2456; - ::apache::thrift::protocol::TType _vtype2457; - xfer += iprot->readMapBegin(_ktype2456, _vtype2457, _size2455); - uint32_t _i2459; - for (_i2459 = 0; _i2459 < _size2455; ++_i2459) + uint32_t _size2456; + ::apache::thrift::protocol::TType _ktype2457; + ::apache::thrift::protocol::TType _vtype2458; + xfer += iprot->readMapBegin(_ktype2457, _vtype2458, _size2456); + uint32_t _i2460; + for (_i2460 = 0; _i2460 < _size2456; ++_i2460) { - std::string _key2460; - xfer += iprot->readString(_key2460); - std::string& _val2461 = this->success[_key2460]; - xfer += iprot->readString(_val2461); + std::string _key2461; + xfer += iprot->readString(_key2461); + std::string& _val2462 = this->success[_key2461]; + xfer += iprot->readString(_val2462); } xfer += iprot->readMapEnd(); } @@ -31210,11 +31210,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 _iter2462; - for (_iter2462 = this->success.begin(); _iter2462 != this->success.end(); ++_iter2462) + std::map ::const_iterator _iter2463; + for (_iter2463 = this->success.begin(); _iter2463 != this->success.end(); ++_iter2463) { - xfer += oprot->writeString(_iter2462->first); - xfer += oprot->writeString(_iter2462->second); + xfer += oprot->writeString(_iter2463->first); + xfer += oprot->writeString(_iter2463->second); } xfer += oprot->writeMapEnd(); } @@ -31259,17 +31259,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size2463; - ::apache::thrift::protocol::TType _ktype2464; - ::apache::thrift::protocol::TType _vtype2465; - xfer += iprot->readMapBegin(_ktype2464, _vtype2465, _size2463); - uint32_t _i2467; - for (_i2467 = 0; _i2467 < _size2463; ++_i2467) + uint32_t _size2464; + ::apache::thrift::protocol::TType _ktype2465; + ::apache::thrift::protocol::TType _vtype2466; + xfer += iprot->readMapBegin(_ktype2465, _vtype2466, _size2464); + uint32_t _i2468; + for (_i2468 = 0; _i2468 < _size2464; ++_i2468) { - std::string _key2468; - xfer += iprot->readString(_key2468); - std::string& _val2469 = (*(this->success))[_key2468]; - xfer += iprot->readString(_val2469); + std::string _key2469; + xfer += iprot->readString(_key2469); + std::string& _val2470 = (*(this->success))[_key2469]; + xfer += iprot->readString(_val2470); } xfer += iprot->readMapEnd(); } @@ -31344,17 +31344,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2470; - ::apache::thrift::protocol::TType _ktype2471; - ::apache::thrift::protocol::TType _vtype2472; - xfer += iprot->readMapBegin(_ktype2471, _vtype2472, _size2470); - uint32_t _i2474; - for (_i2474 = 0; _i2474 < _size2470; ++_i2474) + uint32_t _size2471; + ::apache::thrift::protocol::TType _ktype2472; + ::apache::thrift::protocol::TType _vtype2473; + xfer += iprot->readMapBegin(_ktype2472, _vtype2473, _size2471); + uint32_t _i2475; + for (_i2475 = 0; _i2475 < _size2471; ++_i2475) { - std::string _key2475; - xfer += iprot->readString(_key2475); - std::string& _val2476 = this->part_vals[_key2475]; - xfer += iprot->readString(_val2476); + std::string _key2476; + xfer += iprot->readString(_key2476); + std::string& _val2477 = this->part_vals[_key2476]; + xfer += iprot->readString(_val2477); } xfer += iprot->readMapEnd(); } @@ -31365,9 +31365,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2477; - xfer += iprot->readI32(ecast2477); - this->eventType = static_cast(ecast2477); + int32_t ecast2478; + xfer += iprot->readI32(ecast2478); + this->eventType = static_cast(ecast2478); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -31401,11 +31401,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 _iter2478; - for (_iter2478 = this->part_vals.begin(); _iter2478 != this->part_vals.end(); ++_iter2478) + std::map ::const_iterator _iter2479; + for (_iter2479 = this->part_vals.begin(); _iter2479 != this->part_vals.end(); ++_iter2479) { - xfer += oprot->writeString(_iter2478->first); - xfer += oprot->writeString(_iter2478->second); + xfer += oprot->writeString(_iter2479->first); + xfer += oprot->writeString(_iter2479->second); } xfer += oprot->writeMapEnd(); } @@ -31441,11 +31441,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 _iter2479; - for (_iter2479 = (*(this->part_vals)).begin(); _iter2479 != (*(this->part_vals)).end(); ++_iter2479) + std::map ::const_iterator _iter2480; + for (_iter2480 = (*(this->part_vals)).begin(); _iter2480 != (*(this->part_vals)).end(); ++_iter2480) { - xfer += oprot->writeString(_iter2479->first); - xfer += oprot->writeString(_iter2479->second); + xfer += oprot->writeString(_iter2480->first); + xfer += oprot->writeString(_iter2480->second); } xfer += oprot->writeMapEnd(); } @@ -31714,17 +31714,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2480; - ::apache::thrift::protocol::TType _ktype2481; - ::apache::thrift::protocol::TType _vtype2482; - xfer += iprot->readMapBegin(_ktype2481, _vtype2482, _size2480); - uint32_t _i2484; - for (_i2484 = 0; _i2484 < _size2480; ++_i2484) + uint32_t _size2481; + ::apache::thrift::protocol::TType _ktype2482; + ::apache::thrift::protocol::TType _vtype2483; + xfer += iprot->readMapBegin(_ktype2482, _vtype2483, _size2481); + uint32_t _i2485; + for (_i2485 = 0; _i2485 < _size2481; ++_i2485) { - std::string _key2485; - xfer += iprot->readString(_key2485); - std::string& _val2486 = this->part_vals[_key2485]; - xfer += iprot->readString(_val2486); + std::string _key2486; + xfer += iprot->readString(_key2486); + std::string& _val2487 = this->part_vals[_key2486]; + xfer += iprot->readString(_val2487); } xfer += iprot->readMapEnd(); } @@ -31735,9 +31735,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2487; - xfer += iprot->readI32(ecast2487); - this->eventType = static_cast(ecast2487); + int32_t ecast2488; + xfer += iprot->readI32(ecast2488); + this->eventType = static_cast(ecast2488); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -31771,11 +31771,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 _iter2488; - for (_iter2488 = this->part_vals.begin(); _iter2488 != this->part_vals.end(); ++_iter2488) + std::map ::const_iterator _iter2489; + for (_iter2489 = this->part_vals.begin(); _iter2489 != this->part_vals.end(); ++_iter2489) { - xfer += oprot->writeString(_iter2488->first); - xfer += oprot->writeString(_iter2488->second); + xfer += oprot->writeString(_iter2489->first); + xfer += oprot->writeString(_iter2489->second); } xfer += oprot->writeMapEnd(); } @@ -31811,11 +31811,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 _iter2489; - for (_iter2489 = (*(this->part_vals)).begin(); _iter2489 != (*(this->part_vals)).end(); ++_iter2489) + std::map ::const_iterator _iter2490; + for (_iter2490 = (*(this->part_vals)).begin(); _iter2490 != (*(this->part_vals)).end(); ++_iter2490) { - xfer += oprot->writeString(_iter2489->first); - xfer += oprot->writeString(_iter2489->second); + xfer += oprot->writeString(_iter2490->first); + xfer += oprot->writeString(_iter2490->second); } xfer += oprot->writeMapEnd(); } @@ -37944,14 +37944,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2490; - ::apache::thrift::protocol::TType _etype2493; - xfer += iprot->readListBegin(_etype2493, _size2490); - this->success.resize(_size2490); - uint32_t _i2494; - for (_i2494 = 0; _i2494 < _size2490; ++_i2494) + uint32_t _size2491; + ::apache::thrift::protocol::TType _etype2494; + xfer += iprot->readListBegin(_etype2494, _size2491); + this->success.resize(_size2491); + uint32_t _i2495; + for (_i2495 = 0; _i2495 < _size2491; ++_i2495) { - xfer += iprot->readString(this->success[_i2494]); + xfer += iprot->readString(this->success[_i2495]); } xfer += iprot->readListEnd(); } @@ -37990,10 +37990,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 _iter2495; - for (_iter2495 = this->success.begin(); _iter2495 != this->success.end(); ++_iter2495) + std::vector ::const_iterator _iter2496; + for (_iter2496 = this->success.begin(); _iter2496 != this->success.end(); ++_iter2496) { - xfer += oprot->writeString((*_iter2495)); + xfer += oprot->writeString((*_iter2496)); } xfer += oprot->writeListEnd(); } @@ -38038,14 +38038,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2496; - ::apache::thrift::protocol::TType _etype2499; - xfer += iprot->readListBegin(_etype2499, _size2496); - (*(this->success)).resize(_size2496); - uint32_t _i2500; - for (_i2500 = 0; _i2500 < _size2496; ++_i2500) + 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) { - xfer += iprot->readString((*(this->success))[_i2500]); + xfer += iprot->readString((*(this->success))[_i2501]); } xfer += iprot->readListEnd(); } @@ -39212,14 +39212,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2501; - ::apache::thrift::protocol::TType _etype2504; - xfer += iprot->readListBegin(_etype2504, _size2501); - this->success.resize(_size2501); - uint32_t _i2505; - for (_i2505 = 0; _i2505 < _size2501; ++_i2505) + uint32_t _size2502; + ::apache::thrift::protocol::TType _etype2505; + xfer += iprot->readListBegin(_etype2505, _size2502); + this->success.resize(_size2502); + uint32_t _i2506; + for (_i2506 = 0; _i2506 < _size2502; ++_i2506) { - xfer += iprot->readString(this->success[_i2505]); + xfer += iprot->readString(this->success[_i2506]); } xfer += iprot->readListEnd(); } @@ -39258,10 +39258,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 _iter2506; - for (_iter2506 = this->success.begin(); _iter2506 != this->success.end(); ++_iter2506) + std::vector ::const_iterator _iter2507; + for (_iter2507 = this->success.begin(); _iter2507 != this->success.end(); ++_iter2507) { - xfer += oprot->writeString((*_iter2506)); + xfer += oprot->writeString((*_iter2507)); } xfer += oprot->writeListEnd(); } @@ -39306,14 +39306,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2507; - ::apache::thrift::protocol::TType _etype2510; - xfer += iprot->readListBegin(_etype2510, _size2507); - (*(this->success)).resize(_size2507); - uint32_t _i2511; - for (_i2511 = 0; _i2511 < _size2507; ++_i2511) + 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) { - xfer += iprot->readString((*(this->success))[_i2511]); + xfer += iprot->readString((*(this->success))[_i2512]); } xfer += iprot->readListEnd(); } @@ -39386,9 +39386,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2512; - xfer += iprot->readI32(ecast2512); - this->principal_type = static_cast(ecast2512); + int32_t ecast2513; + xfer += iprot->readI32(ecast2513); + this->principal_type = static_cast(ecast2513); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -39404,9 +39404,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2513; - xfer += iprot->readI32(ecast2513); - this->grantorType = static_cast(ecast2513); + int32_t ecast2514; + xfer += iprot->readI32(ecast2514); + this->grantorType = static_cast(ecast2514); this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -39677,9 +39677,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2514; - xfer += iprot->readI32(ecast2514); - this->principal_type = static_cast(ecast2514); + int32_t ecast2515; + xfer += iprot->readI32(ecast2515); + this->principal_type = static_cast(ecast2515); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -39910,9 +39910,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2515; - xfer += iprot->readI32(ecast2515); - this->principal_type = static_cast(ecast2515); + int32_t ecast2516; + xfer += iprot->readI32(ecast2516); + this->principal_type = static_cast(ecast2516); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -40001,14 +40001,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2516; - ::apache::thrift::protocol::TType _etype2519; - xfer += iprot->readListBegin(_etype2519, _size2516); - this->success.resize(_size2516); - uint32_t _i2520; - for (_i2520 = 0; _i2520 < _size2516; ++_i2520) + uint32_t _size2517; + ::apache::thrift::protocol::TType _etype2520; + xfer += iprot->readListBegin(_etype2520, _size2517); + this->success.resize(_size2517); + uint32_t _i2521; + for (_i2521 = 0; _i2521 < _size2517; ++_i2521) { - xfer += this->success[_i2520].read(iprot); + xfer += this->success[_i2521].read(iprot); } xfer += iprot->readListEnd(); } @@ -40047,10 +40047,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 _iter2521; - for (_iter2521 = this->success.begin(); _iter2521 != this->success.end(); ++_iter2521) + std::vector ::const_iterator _iter2522; + for (_iter2522 = this->success.begin(); _iter2522 != this->success.end(); ++_iter2522) { - xfer += (*_iter2521).write(oprot); + xfer += (*_iter2522).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40095,14 +40095,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2522; - ::apache::thrift::protocol::TType _etype2525; - xfer += iprot->readListBegin(_etype2525, _size2522); - (*(this->success)).resize(_size2522); - uint32_t _i2526; - for (_i2526 = 0; _i2526 < _size2522; ++_i2526) + uint32_t _size2523; + ::apache::thrift::protocol::TType _etype2526; + xfer += iprot->readListBegin(_etype2526, _size2523); + (*(this->success)).resize(_size2523); + uint32_t _i2527; + for (_i2527 = 0; _i2527 < _size2523; ++_i2527) { - xfer += (*(this->success))[_i2526].read(iprot); + xfer += (*(this->success))[_i2527].read(iprot); } xfer += iprot->readListEnd(); } @@ -40798,14 +40798,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 _size2527; - ::apache::thrift::protocol::TType _etype2530; - xfer += iprot->readListBegin(_etype2530, _size2527); - this->group_names.resize(_size2527); - uint32_t _i2531; - for (_i2531 = 0; _i2531 < _size2527; ++_i2531) + uint32_t _size2528; + ::apache::thrift::protocol::TType _etype2531; + xfer += iprot->readListBegin(_etype2531, _size2528); + this->group_names.resize(_size2528); + uint32_t _i2532; + for (_i2532 = 0; _i2532 < _size2528; ++_i2532) { - xfer += iprot->readString(this->group_names[_i2531]); + xfer += iprot->readString(this->group_names[_i2532]); } xfer += iprot->readListEnd(); } @@ -40842,10 +40842,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 _iter2532; - for (_iter2532 = this->group_names.begin(); _iter2532 != this->group_names.end(); ++_iter2532) + std::vector ::const_iterator _iter2533; + for (_iter2533 = this->group_names.begin(); _iter2533 != this->group_names.end(); ++_iter2533) { - xfer += oprot->writeString((*_iter2532)); + xfer += oprot->writeString((*_iter2533)); } xfer += oprot->writeListEnd(); } @@ -40877,10 +40877,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 _iter2533; - for (_iter2533 = (*(this->group_names)).begin(); _iter2533 != (*(this->group_names)).end(); ++_iter2533) + std::vector ::const_iterator _iter2534; + for (_iter2534 = (*(this->group_names)).begin(); _iter2534 != (*(this->group_names)).end(); ++_iter2534) { - xfer += oprot->writeString((*_iter2533)); + xfer += oprot->writeString((*_iter2534)); } xfer += oprot->writeListEnd(); } @@ -41055,9 +41055,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2534; - xfer += iprot->readI32(ecast2534); - this->principal_type = static_cast(ecast2534); + int32_t ecast2535; + xfer += iprot->readI32(ecast2535); + this->principal_type = static_cast(ecast2535); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -41162,14 +41162,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2535; - ::apache::thrift::protocol::TType _etype2538; - xfer += iprot->readListBegin(_etype2538, _size2535); - this->success.resize(_size2535); - uint32_t _i2539; - for (_i2539 = 0; _i2539 < _size2535; ++_i2539) + 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) { - xfer += this->success[_i2539].read(iprot); + xfer += this->success[_i2540].read(iprot); } xfer += iprot->readListEnd(); } @@ -41208,10 +41208,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 _iter2540; - for (_iter2540 = this->success.begin(); _iter2540 != this->success.end(); ++_iter2540) + std::vector ::const_iterator _iter2541; + for (_iter2541 = this->success.begin(); _iter2541 != this->success.end(); ++_iter2541) { - xfer += (*_iter2540).write(oprot); + xfer += (*_iter2541).write(oprot); } xfer += oprot->writeListEnd(); } @@ -41256,14 +41256,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2541; - ::apache::thrift::protocol::TType _etype2544; - xfer += iprot->readListBegin(_etype2544, _size2541); - (*(this->success)).resize(_size2541); - uint32_t _i2545; - for (_i2545 = 0; _i2545 < _size2541; ++_i2545) + uint32_t _size2542; + ::apache::thrift::protocol::TType _etype2545; + xfer += iprot->readListBegin(_etype2545, _size2542); + (*(this->success)).resize(_size2542); + uint32_t _i2546; + for (_i2546 = 0; _i2546 < _size2542; ++_i2546) { - xfer += (*(this->success))[_i2545].read(iprot); + xfer += (*(this->success))[_i2546].read(iprot); } xfer += iprot->readListEnd(); } @@ -42190,14 +42190,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 _size2546; - ::apache::thrift::protocol::TType _etype2549; - xfer += iprot->readListBegin(_etype2549, _size2546); - this->group_names.resize(_size2546); - uint32_t _i2550; - for (_i2550 = 0; _i2550 < _size2546; ++_i2550) + uint32_t _size2547; + ::apache::thrift::protocol::TType _etype2550; + xfer += iprot->readListBegin(_etype2550, _size2547); + this->group_names.resize(_size2547); + uint32_t _i2551; + for (_i2551 = 0; _i2551 < _size2547; ++_i2551) { - xfer += iprot->readString(this->group_names[_i2550]); + xfer += iprot->readString(this->group_names[_i2551]); } xfer += iprot->readListEnd(); } @@ -42230,10 +42230,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 _iter2551; - for (_iter2551 = this->group_names.begin(); _iter2551 != this->group_names.end(); ++_iter2551) + std::vector ::const_iterator _iter2552; + for (_iter2552 = this->group_names.begin(); _iter2552 != this->group_names.end(); ++_iter2552) { - xfer += oprot->writeString((*_iter2551)); + xfer += oprot->writeString((*_iter2552)); } xfer += oprot->writeListEnd(); } @@ -42261,10 +42261,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 _iter2552; - for (_iter2552 = (*(this->group_names)).begin(); _iter2552 != (*(this->group_names)).end(); ++_iter2552) + std::vector ::const_iterator _iter2553; + for (_iter2553 = (*(this->group_names)).begin(); _iter2553 != (*(this->group_names)).end(); ++_iter2553) { - xfer += oprot->writeString((*_iter2552)); + xfer += oprot->writeString((*_iter2553)); } xfer += oprot->writeListEnd(); } @@ -42305,14 +42305,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2553; - ::apache::thrift::protocol::TType _etype2556; - xfer += iprot->readListBegin(_etype2556, _size2553); - this->success.resize(_size2553); - uint32_t _i2557; - for (_i2557 = 0; _i2557 < _size2553; ++_i2557) + uint32_t _size2554; + ::apache::thrift::protocol::TType _etype2557; + xfer += iprot->readListBegin(_etype2557, _size2554); + this->success.resize(_size2554); + uint32_t _i2558; + for (_i2558 = 0; _i2558 < _size2554; ++_i2558) { - xfer += iprot->readString(this->success[_i2557]); + xfer += iprot->readString(this->success[_i2558]); } xfer += iprot->readListEnd(); } @@ -42351,10 +42351,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 _iter2558; - for (_iter2558 = this->success.begin(); _iter2558 != this->success.end(); ++_iter2558) + std::vector ::const_iterator _iter2559; + for (_iter2559 = this->success.begin(); _iter2559 != this->success.end(); ++_iter2559) { - xfer += oprot->writeString((*_iter2558)); + xfer += oprot->writeString((*_iter2559)); } xfer += oprot->writeListEnd(); } @@ -42399,14 +42399,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2559; - ::apache::thrift::protocol::TType _etype2562; - xfer += iprot->readListBegin(_etype2562, _size2559); - (*(this->success)).resize(_size2559); - uint32_t _i2563; - for (_i2563 = 0; _i2563 < _size2559; ++_i2563) + uint32_t _size2560; + ::apache::thrift::protocol::TType _etype2563; + xfer += iprot->readListBegin(_etype2563, _size2560); + (*(this->success)).resize(_size2560); + uint32_t _i2564; + for (_i2564 = 0; _i2564 < _size2560; ++_i2564) { - xfer += iprot->readString((*(this->success))[_i2563]); + xfer += iprot->readString((*(this->success))[_i2564]); } xfer += iprot->readListEnd(); } @@ -43717,14 +43717,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2564; - ::apache::thrift::protocol::TType _etype2567; - xfer += iprot->readListBegin(_etype2567, _size2564); - this->success.resize(_size2564); - uint32_t _i2568; - for (_i2568 = 0; _i2568 < _size2564; ++_i2568) + uint32_t _size2565; + ::apache::thrift::protocol::TType _etype2568; + xfer += iprot->readListBegin(_etype2568, _size2565); + this->success.resize(_size2565); + uint32_t _i2569; + for (_i2569 = 0; _i2569 < _size2565; ++_i2569) { - xfer += iprot->readString(this->success[_i2568]); + xfer += iprot->readString(this->success[_i2569]); } xfer += iprot->readListEnd(); } @@ -43755,10 +43755,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 _iter2569; - for (_iter2569 = this->success.begin(); _iter2569 != this->success.end(); ++_iter2569) + std::vector ::const_iterator _iter2570; + for (_iter2570 = this->success.begin(); _iter2570 != this->success.end(); ++_iter2570) { - xfer += oprot->writeString((*_iter2569)); + xfer += oprot->writeString((*_iter2570)); } xfer += oprot->writeListEnd(); } @@ -43799,14 +43799,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2570; - ::apache::thrift::protocol::TType _etype2573; - xfer += iprot->readListBegin(_etype2573, _size2570); - (*(this->success)).resize(_size2570); - uint32_t _i2574; - for (_i2574 = 0; _i2574 < _size2570; ++_i2574) + uint32_t _size2571; + ::apache::thrift::protocol::TType _etype2574; + xfer += iprot->readListBegin(_etype2574, _size2571); + (*(this->success)).resize(_size2571); + uint32_t _i2575; + for (_i2575 = 0; _i2575 < _size2571; ++_i2575) { - xfer += iprot->readString((*(this->success))[_i2574]); + xfer += iprot->readString((*(this->success))[_i2575]); } xfer += iprot->readListEnd(); } @@ -44532,14 +44532,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2575; - ::apache::thrift::protocol::TType _etype2578; - xfer += iprot->readListBegin(_etype2578, _size2575); - this->success.resize(_size2575); - uint32_t _i2579; - for (_i2579 = 0; _i2579 < _size2575; ++_i2579) + uint32_t _size2576; + ::apache::thrift::protocol::TType _etype2579; + xfer += iprot->readListBegin(_etype2579, _size2576); + this->success.resize(_size2576); + uint32_t _i2580; + for (_i2580 = 0; _i2580 < _size2576; ++_i2580) { - xfer += iprot->readString(this->success[_i2579]); + xfer += iprot->readString(this->success[_i2580]); } xfer += iprot->readListEnd(); } @@ -44570,10 +44570,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 _iter2580; - for (_iter2580 = this->success.begin(); _iter2580 != this->success.end(); ++_iter2580) + std::vector ::const_iterator _iter2581; + for (_iter2581 = this->success.begin(); _iter2581 != this->success.end(); ++_iter2581) { - xfer += oprot->writeString((*_iter2580)); + xfer += oprot->writeString((*_iter2581)); } xfer += oprot->writeListEnd(); } @@ -44614,14 +44614,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2581; - ::apache::thrift::protocol::TType _etype2584; - xfer += iprot->readListBegin(_etype2584, _size2581); - (*(this->success)).resize(_size2581); - uint32_t _i2585; - for (_i2585 = 0; _i2585 < _size2581; ++_i2585) + uint32_t _size2582; + ::apache::thrift::protocol::TType _etype2585; + xfer += iprot->readListBegin(_etype2585, _size2582); + (*(this->success)).resize(_size2582); + uint32_t _i2586; + for (_i2586 = 0; _i2586 < _size2582; ++_i2586) { - xfer += iprot->readString((*(this->success))[_i2585]); + xfer += iprot->readString((*(this->success))[_i2586]); } xfer += iprot->readListEnd(); } @@ -46370,17 +46370,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 _size2586; - ::apache::thrift::protocol::TType _ktype2587; - ::apache::thrift::protocol::TType _vtype2588; - xfer += iprot->readMapBegin(_ktype2587, _vtype2588, _size2586); - uint32_t _i2590; - for (_i2590 = 0; _i2590 < _size2586; ++_i2590) + uint32_t _size2587; + ::apache::thrift::protocol::TType _ktype2588; + ::apache::thrift::protocol::TType _vtype2589; + xfer += iprot->readMapBegin(_ktype2588, _vtype2589, _size2587); + uint32_t _i2591; + for (_i2591 = 0; _i2591 < _size2587; ++_i2591) { - std::string _key2591; - xfer += iprot->readString(_key2591); - int64_t& _val2592 = this->writeIds[_key2591]; - xfer += iprot->readI64(_val2592); + std::string _key2592; + xfer += iprot->readString(_key2592); + int64_t& _val2593 = this->writeIds[_key2592]; + xfer += iprot->readI64(_val2593); } xfer += iprot->readMapEnd(); } @@ -46413,11 +46413,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 _iter2593; - for (_iter2593 = this->writeIds.begin(); _iter2593 != this->writeIds.end(); ++_iter2593) + std::map ::const_iterator _iter2594; + for (_iter2594 = this->writeIds.begin(); _iter2594 != this->writeIds.end(); ++_iter2594) { - xfer += oprot->writeString(_iter2593->first); - xfer += oprot->writeI64(_iter2593->second); + xfer += oprot->writeString(_iter2594->first); + xfer += oprot->writeI64(_iter2594->second); } xfer += oprot->writeMapEnd(); } @@ -46445,11 +46445,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 _iter2594; - for (_iter2594 = (*(this->writeIds)).begin(); _iter2594 != (*(this->writeIds)).end(); ++_iter2594) + std::map ::const_iterator _iter2595; + for (_iter2595 = (*(this->writeIds)).begin(); _iter2595 != (*(this->writeIds)).end(); ++_iter2595) { - xfer += oprot->writeString(_iter2594->first); - xfer += oprot->writeI64(_iter2594->second); + xfer += oprot->writeString(_iter2595->first); + xfer += oprot->writeI64(_iter2595->second); } xfer += oprot->writeMapEnd(); } @@ -50349,14 +50349,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2595; - ::apache::thrift::protocol::TType _etype2598; - xfer += iprot->readListBegin(_etype2598, _size2595); - this->success.resize(_size2595); - uint32_t _i2599; - for (_i2599 = 0; _i2599 < _size2595; ++_i2599) + uint32_t _size2596; + ::apache::thrift::protocol::TType _etype2599; + xfer += iprot->readListBegin(_etype2599, _size2596); + this->success.resize(_size2596); + uint32_t _i2600; + for (_i2600 = 0; _i2600 < _size2596; ++_i2600) { - xfer += iprot->readString(this->success[_i2599]); + xfer += iprot->readString(this->success[_i2600]); } xfer += iprot->readListEnd(); } @@ -50387,10 +50387,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 _iter2600; - for (_iter2600 = this->success.begin(); _iter2600 != this->success.end(); ++_iter2600) + std::vector ::const_iterator _iter2601; + for (_iter2601 = this->success.begin(); _iter2601 != this->success.end(); ++_iter2601) { - xfer += oprot->writeString((*_iter2600)); + xfer += oprot->writeString((*_iter2601)); } xfer += oprot->writeListEnd(); } @@ -50431,14 +50431,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2601; - ::apache::thrift::protocol::TType _etype2604; - xfer += iprot->readListBegin(_etype2604, _size2601); - (*(this->success)).resize(_size2601); - uint32_t _i2605; - for (_i2605 = 0; _i2605 < _size2601; ++_i2605) + uint32_t _size2602; + ::apache::thrift::protocol::TType _etype2605; + xfer += iprot->readListBegin(_etype2605, _size2602); + (*(this->success)).resize(_size2602); + uint32_t _i2606; + for (_i2606 = 0; _i2606 < _size2602; ++_i2606) { - xfer += iprot->readString((*(this->success))[_i2605]); + xfer += iprot->readString((*(this->success))[_i2606]); } xfer += iprot->readListEnd(); } @@ -60361,14 +60361,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2606; - ::apache::thrift::protocol::TType _etype2609; - xfer += iprot->readListBegin(_etype2609, _size2606); - this->success.resize(_size2606); - uint32_t _i2610; - for (_i2610 = 0; _i2610 < _size2606; ++_i2610) + uint32_t _size2607; + ::apache::thrift::protocol::TType _etype2610; + xfer += iprot->readListBegin(_etype2610, _size2607); + this->success.resize(_size2607); + uint32_t _i2611; + for (_i2611 = 0; _i2611 < _size2607; ++_i2611) { - xfer += this->success[_i2610].read(iprot); + xfer += this->success[_i2611].read(iprot); } xfer += iprot->readListEnd(); } @@ -60415,10 +60415,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 _iter2611; - for (_iter2611 = this->success.begin(); _iter2611 != this->success.end(); ++_iter2611) + std::vector ::const_iterator _iter2612; + for (_iter2612 = this->success.begin(); _iter2612 != this->success.end(); ++_iter2612) { - xfer += (*_iter2611).write(oprot); + xfer += (*_iter2612).write(oprot); } xfer += oprot->writeListEnd(); } @@ -60467,14 +60467,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2612; - ::apache::thrift::protocol::TType _etype2615; - xfer += iprot->readListBegin(_etype2615, _size2612); - (*(this->success)).resize(_size2612); - uint32_t _i2616; - for (_i2616 = 0; _i2616 < _size2612; ++_i2616) + uint32_t _size2613; + ::apache::thrift::protocol::TType _etype2616; + xfer += iprot->readListBegin(_etype2616, _size2613); + (*(this->success)).resize(_size2613); + uint32_t _i2617; + for (_i2617 = 0; _i2617 < _size2613; ++_i2617) { - xfer += (*(this->success))[_i2616].read(iprot); + xfer += (*(this->success))[_i2617].read(iprot); } xfer += iprot->readListEnd(); } @@ -62527,14 +62527,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2617; - ::apache::thrift::protocol::TType _etype2620; - xfer += iprot->readListBegin(_etype2620, _size2617); - this->success.resize(_size2617); - uint32_t _i2621; - for (_i2621 = 0; _i2621 < _size2617; ++_i2621) + uint32_t _size2618; + ::apache::thrift::protocol::TType _etype2621; + xfer += iprot->readListBegin(_etype2621, _size2618); + this->success.resize(_size2618); + uint32_t _i2622; + for (_i2622 = 0; _i2622 < _size2618; ++_i2622) { - xfer += this->success[_i2621].read(iprot); + xfer += this->success[_i2622].read(iprot); } xfer += iprot->readListEnd(); } @@ -62573,10 +62573,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 _iter2622; - for (_iter2622 = this->success.begin(); _iter2622 != this->success.end(); ++_iter2622) + std::vector ::const_iterator _iter2623; + for (_iter2623 = this->success.begin(); _iter2623 != this->success.end(); ++_iter2623) { - xfer += (*_iter2622).write(oprot); + xfer += (*_iter2623).write(oprot); } xfer += oprot->writeListEnd(); } @@ -62621,14 +62621,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2623; - ::apache::thrift::protocol::TType _etype2626; - xfer += iprot->readListBegin(_etype2626, _size2623); - (*(this->success)).resize(_size2623); - uint32_t _i2627; - for (_i2627 = 0; _i2627 < _size2623; ++_i2627) + uint32_t _size2624; + ::apache::thrift::protocol::TType _etype2627; + xfer += iprot->readListBegin(_etype2627, _size2624); + (*(this->success)).resize(_size2624); + uint32_t _i2628; + for (_i2628 = 0; _i2628 < _size2624; ++_i2628) { - xfer += (*(this->success))[_i2627].read(iprot); + xfer += (*(this->success))[_i2628].read(iprot); } xfer += iprot->readListEnd(); } @@ -65063,14 +65063,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2628; - ::apache::thrift::protocol::TType _etype2631; - xfer += iprot->readListBegin(_etype2631, _size2628); - this->success.resize(_size2628); - uint32_t _i2632; - for (_i2632 = 0; _i2632 < _size2628; ++_i2632) + uint32_t _size2629; + ::apache::thrift::protocol::TType _etype2632; + xfer += iprot->readListBegin(_etype2632, _size2629); + this->success.resize(_size2629); + uint32_t _i2633; + for (_i2633 = 0; _i2633 < _size2629; ++_i2633) { - xfer += iprot->readString(this->success[_i2632]); + xfer += iprot->readString(this->success[_i2633]); } xfer += iprot->readListEnd(); } @@ -65109,10 +65109,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 _iter2633; - for (_iter2633 = this->success.begin(); _iter2633 != this->success.end(); ++_iter2633) + std::vector ::const_iterator _iter2634; + for (_iter2634 = this->success.begin(); _iter2634 != this->success.end(); ++_iter2634) { - xfer += oprot->writeString((*_iter2633)); + xfer += oprot->writeString((*_iter2634)); } xfer += oprot->writeListEnd(); } @@ -65157,14 +65157,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2634; - ::apache::thrift::protocol::TType _etype2637; - xfer += iprot->readListBegin(_etype2637, _size2634); - (*(this->success)).resize(_size2634); - uint32_t _i2638; - for (_i2638 = 0; _i2638 < _size2634; ++_i2638) + uint32_t _size2635; + ::apache::thrift::protocol::TType _etype2638; + xfer += iprot->readListBegin(_etype2638, _size2635); + (*(this->success)).resize(_size2635); + uint32_t _i2639; + for (_i2639 = 0; _i2639 < _size2635; ++_i2639) { - xfer += iprot->readString((*(this->success))[_i2638]); + xfer += iprot->readString((*(this->success))[_i2639]); } xfer += iprot->readListEnd(); } @@ -65716,14 +65716,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_result::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2639; - ::apache::thrift::protocol::TType _etype2642; - xfer += iprot->readListBegin(_etype2642, _size2639); - this->success.resize(_size2639); - uint32_t _i2643; - for (_i2643 = 0; _i2643 < _size2639; ++_i2643) + uint32_t _size2640; + ::apache::thrift::protocol::TType _etype2643; + xfer += iprot->readListBegin(_etype2643, _size2640); + this->success.resize(_size2640); + uint32_t _i2644; + for (_i2644 = 0; _i2644 < _size2640; ++_i2644) { - xfer += iprot->readString(this->success[_i2643]); + xfer += iprot->readString(this->success[_i2644]); } xfer += iprot->readListEnd(); } @@ -65762,10 +65762,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 _iter2644; - for (_iter2644 = this->success.begin(); _iter2644 != this->success.end(); ++_iter2644) + std::vector ::const_iterator _iter2645; + for (_iter2645 = this->success.begin(); _iter2645 != this->success.end(); ++_iter2645) { - xfer += oprot->writeString((*_iter2644)); + xfer += oprot->writeString((*_iter2645)); } xfer += oprot->writeListEnd(); } @@ -65810,14 +65810,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_presult::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2645; - ::apache::thrift::protocol::TType _etype2648; - xfer += iprot->readListBegin(_etype2648, _size2645); - (*(this->success)).resize(_size2645); - uint32_t _i2649; - for (_i2649 = 0; _i2649 < _size2645; ++_i2649) + uint32_t _size2646; + ::apache::thrift::protocol::TType _etype2649; + xfer += iprot->readListBegin(_etype2649, _size2646); + (*(this->success)).resize(_size2646); + uint32_t _i2650; + for (_i2650 = 0; _i2650 < _size2646; ++_i2650) { - xfer += iprot->readString((*(this->success))[_i2649]); + xfer += iprot->readString((*(this->success))[_i2650]); } xfer += iprot->readListEnd(); } @@ -66142,14 +66142,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 _size2650; - ::apache::thrift::protocol::TType _etype2653; - xfer += iprot->readListBegin(_etype2653, _size2650); - this->success.resize(_size2650); - uint32_t _i2654; - for (_i2654 = 0; _i2654 < _size2650; ++_i2654) + uint32_t _size2651; + ::apache::thrift::protocol::TType _etype2654; + xfer += iprot->readListBegin(_etype2654, _size2651); + this->success.resize(_size2651); + uint32_t _i2655; + for (_i2655 = 0; _i2655 < _size2651; ++_i2655) { - xfer += this->success[_i2654].read(iprot); + xfer += this->success[_i2655].read(iprot); } xfer += iprot->readListEnd(); } @@ -66188,10 +66188,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 _iter2655; - for (_iter2655 = this->success.begin(); _iter2655 != this->success.end(); ++_iter2655) + std::vector ::const_iterator _iter2656; + for (_iter2656 = this->success.begin(); _iter2656 != this->success.end(); ++_iter2656) { - xfer += (*_iter2655).write(oprot); + xfer += (*_iter2656).write(oprot); } xfer += oprot->writeListEnd(); } @@ -66236,14 +66236,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 _size2656; - ::apache::thrift::protocol::TType _etype2659; - xfer += iprot->readListBegin(_etype2659, _size2656); - (*(this->success)).resize(_size2656); - uint32_t _i2660; - for (_i2660 = 0; _i2660 < _size2656; ++_i2660) + uint32_t _size2657; + ::apache::thrift::protocol::TType _etype2660; + xfer += iprot->readListBegin(_etype2660, _size2657); + (*(this->success)).resize(_size2657); + uint32_t _i2661; + for (_i2661 = 0; _i2661 < _size2657; ++_i2661) { - xfer += (*(this->success))[_i2660].read(iprot); + xfer += (*(this->success))[_i2661].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 70a78fc27021..5942cc7f314f 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 @@ -556,6 +556,35 @@ std::string to_string(const DatabaseType::type& val) { } } +int _kNullOrderingTypeValues[] = { + NullOrderingType::NULLS_FIRST, + NullOrderingType::NULLS_LAST +}; +const char* _kNullOrderingTypeNames[] = { + "NULLS_FIRST", + "NULLS_LAST" +}; +const std::map _NullOrderingType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kNullOrderingTypeValues, _kNullOrderingTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const NullOrderingType::type& val) { + std::map::const_iterator it = _NullOrderingType_VALUES_TO_NAMES.find(val); + if (it != _NullOrderingType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const NullOrderingType::type& val) { + std::map::const_iterator it = _NullOrderingType_VALUES_TO_NAMES.find(val); + if (it != _NullOrderingType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + int _kFunctionTypeValues[] = { FunctionType::JAVA }; @@ -7835,6 +7864,11 @@ void Order::__set_col(const std::string& val) { void Order::__set_order(const int32_t val) { this->order = val; } + +void Order::__set_nullOrdering(const NullOrderingType::type val) { + this->nullOrdering = val; +__isset.nullOrdering = true; +} std::ostream& operator<<(std::ostream& out, const Order& obj) { obj.printTo(out); @@ -7879,6 +7913,16 @@ uint32_t Order::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast267; + xfer += iprot->readI32(ecast267); + this->nullOrdering = static_cast(ecast267); + this->__isset.nullOrdering = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -7904,6 +7948,11 @@ uint32_t Order::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeI32(this->order); xfer += oprot->writeFieldEnd(); + if (this->__isset.nullOrdering) { + xfer += oprot->writeFieldBegin("nullOrdering", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->nullOrdering)); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -7913,18 +7962,21 @@ void swap(Order &a, Order &b) { using ::std::swap; swap(a.col, b.col); swap(a.order, b.order); + swap(a.nullOrdering, b.nullOrdering); swap(a.__isset, b.__isset); } -Order::Order(const Order& other267) { - col = other267.col; - order = other267.order; - __isset = other267.__isset; -} -Order& Order::operator=(const Order& other268) { +Order::Order(const Order& other268) { col = other268.col; order = other268.order; + nullOrdering = other268.nullOrdering; __isset = other268.__isset; +} +Order& Order::operator=(const Order& other269) { + col = other269.col; + order = other269.order; + nullOrdering = other269.nullOrdering; + __isset = other269.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -7932,6 +7984,7 @@ void Order::printTo(std::ostream& out) const { out << "Order("; out << "col=" << to_string(col); out << ", " << "order=" << to_string(order); + out << ", " << "nullOrdering="; (__isset.nullOrdering ? (out << to_string(nullOrdering)) : (out << "")); out << ")"; } @@ -7983,14 +8036,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size269; - ::apache::thrift::protocol::TType _etype272; - xfer += iprot->readListBegin(_etype272, _size269); - this->skewedColNames.resize(_size269); - uint32_t _i273; - for (_i273 = 0; _i273 < _size269; ++_i273) + uint32_t _size270; + ::apache::thrift::protocol::TType _etype273; + xfer += iprot->readListBegin(_etype273, _size270); + this->skewedColNames.resize(_size270); + uint32_t _i274; + for (_i274 = 0; _i274 < _size270; ++_i274) { - xfer += iprot->readString(this->skewedColNames[_i273]); + xfer += iprot->readString(this->skewedColNames[_i274]); } xfer += iprot->readListEnd(); } @@ -8003,23 +8056,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size274; - ::apache::thrift::protocol::TType _etype277; - xfer += iprot->readListBegin(_etype277, _size274); - this->skewedColValues.resize(_size274); - uint32_t _i278; - for (_i278 = 0; _i278 < _size274; ++_i278) + uint32_t _size275; + ::apache::thrift::protocol::TType _etype278; + xfer += iprot->readListBegin(_etype278, _size275); + this->skewedColValues.resize(_size275); + uint32_t _i279; + for (_i279 = 0; _i279 < _size275; ++_i279) { { - this->skewedColValues[_i278].clear(); - uint32_t _size279; - ::apache::thrift::protocol::TType _etype282; - xfer += iprot->readListBegin(_etype282, _size279); - this->skewedColValues[_i278].resize(_size279); - uint32_t _i283; - for (_i283 = 0; _i283 < _size279; ++_i283) + this->skewedColValues[_i279].clear(); + uint32_t _size280; + ::apache::thrift::protocol::TType _etype283; + xfer += iprot->readListBegin(_etype283, _size280); + this->skewedColValues[_i279].resize(_size280); + uint32_t _i284; + for (_i284 = 0; _i284 < _size280; ++_i284) { - xfer += iprot->readString(this->skewedColValues[_i278][_i283]); + xfer += iprot->readString(this->skewedColValues[_i279][_i284]); } xfer += iprot->readListEnd(); } @@ -8035,29 +8088,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size284; - ::apache::thrift::protocol::TType _ktype285; - ::apache::thrift::protocol::TType _vtype286; - xfer += iprot->readMapBegin(_ktype285, _vtype286, _size284); - uint32_t _i288; - for (_i288 = 0; _i288 < _size284; ++_i288) + uint32_t _size285; + ::apache::thrift::protocol::TType _ktype286; + ::apache::thrift::protocol::TType _vtype287; + xfer += iprot->readMapBegin(_ktype286, _vtype287, _size285); + uint32_t _i289; + for (_i289 = 0; _i289 < _size285; ++_i289) { - std::vector _key289; + std::vector _key290; { - _key289.clear(); - uint32_t _size291; - ::apache::thrift::protocol::TType _etype294; - xfer += iprot->readListBegin(_etype294, _size291); - _key289.resize(_size291); - uint32_t _i295; - for (_i295 = 0; _i295 < _size291; ++_i295) + _key290.clear(); + uint32_t _size292; + ::apache::thrift::protocol::TType _etype295; + xfer += iprot->readListBegin(_etype295, _size292); + _key290.resize(_size292); + uint32_t _i296; + for (_i296 = 0; _i296 < _size292; ++_i296) { - xfer += iprot->readString(_key289[_i295]); + xfer += iprot->readString(_key290[_i296]); } xfer += iprot->readListEnd(); } - std::string& _val290 = this->skewedColValueLocationMaps[_key289]; - xfer += iprot->readString(_val290); + std::string& _val291 = this->skewedColValueLocationMaps[_key290]; + xfer += iprot->readString(_val291); } xfer += iprot->readMapEnd(); } @@ -8086,10 +8139,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->skewedColNames.size())); - std::vector ::const_iterator _iter296; - for (_iter296 = this->skewedColNames.begin(); _iter296 != this->skewedColNames.end(); ++_iter296) + std::vector ::const_iterator _iter297; + for (_iter297 = this->skewedColNames.begin(); _iter297 != this->skewedColNames.end(); ++_iter297) { - xfer += oprot->writeString((*_iter296)); + xfer += oprot->writeString((*_iter297)); } xfer += oprot->writeListEnd(); } @@ -8098,15 +8151,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->skewedColValues.size())); - std::vector > ::const_iterator _iter297; - for (_iter297 = this->skewedColValues.begin(); _iter297 != this->skewedColValues.end(); ++_iter297) + std::vector > ::const_iterator _iter298; + for (_iter298 = this->skewedColValues.begin(); _iter298 != this->skewedColValues.end(); ++_iter298) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter297).size())); - std::vector ::const_iterator _iter298; - for (_iter298 = (*_iter297).begin(); _iter298 != (*_iter297).end(); ++_iter298) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter298).size())); + std::vector ::const_iterator _iter299; + for (_iter299 = (*_iter298).begin(); _iter299 != (*_iter298).end(); ++_iter299) { - xfer += oprot->writeString((*_iter298)); + xfer += oprot->writeString((*_iter299)); } xfer += oprot->writeListEnd(); } @@ -8118,19 +8171,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast(this->skewedColValueLocationMaps.size())); - std::map , std::string> ::const_iterator _iter299; - for (_iter299 = this->skewedColValueLocationMaps.begin(); _iter299 != this->skewedColValueLocationMaps.end(); ++_iter299) + std::map , std::string> ::const_iterator _iter300; + for (_iter300 = this->skewedColValueLocationMaps.begin(); _iter300 != this->skewedColValueLocationMaps.end(); ++_iter300) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter299->first.size())); - std::vector ::const_iterator _iter300; - for (_iter300 = _iter299->first.begin(); _iter300 != _iter299->first.end(); ++_iter300) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter300->first.size())); + std::vector ::const_iterator _iter301; + for (_iter301 = _iter300->first.begin(); _iter301 != _iter300->first.end(); ++_iter301) { - xfer += oprot->writeString((*_iter300)); + xfer += oprot->writeString((*_iter301)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter299->second); + xfer += oprot->writeString(_iter300->second); } xfer += oprot->writeMapEnd(); } @@ -8149,17 +8202,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other301) { - skewedColNames = other301.skewedColNames; - skewedColValues = other301.skewedColValues; - skewedColValueLocationMaps = other301.skewedColValueLocationMaps; - __isset = other301.__isset; -} -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other302) { +SkewedInfo::SkewedInfo(const SkewedInfo& other302) { skewedColNames = other302.skewedColNames; skewedColValues = other302.skewedColValues; skewedColValueLocationMaps = other302.skewedColValueLocationMaps; __isset = other302.__isset; +} +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other303) { + skewedColNames = other303.skewedColNames; + skewedColValues = other303.skewedColValues; + skewedColValueLocationMaps = other303.skewedColValueLocationMaps; + __isset = other303.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -8257,14 +8310,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size303; - ::apache::thrift::protocol::TType _etype306; - xfer += iprot->readListBegin(_etype306, _size303); - this->cols.resize(_size303); - uint32_t _i307; - for (_i307 = 0; _i307 < _size303; ++_i307) + uint32_t _size304; + ::apache::thrift::protocol::TType _etype307; + xfer += iprot->readListBegin(_etype307, _size304); + this->cols.resize(_size304); + uint32_t _i308; + for (_i308 = 0; _i308 < _size304; ++_i308) { - xfer += this->cols[_i307].read(iprot); + xfer += this->cols[_i308].read(iprot); } xfer += iprot->readListEnd(); } @@ -8325,14 +8378,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size308; - ::apache::thrift::protocol::TType _etype311; - xfer += iprot->readListBegin(_etype311, _size308); - this->bucketCols.resize(_size308); - uint32_t _i312; - for (_i312 = 0; _i312 < _size308; ++_i312) + uint32_t _size309; + ::apache::thrift::protocol::TType _etype312; + xfer += iprot->readListBegin(_etype312, _size309); + this->bucketCols.resize(_size309); + uint32_t _i313; + for (_i313 = 0; _i313 < _size309; ++_i313) { - xfer += iprot->readString(this->bucketCols[_i312]); + xfer += iprot->readString(this->bucketCols[_i313]); } xfer += iprot->readListEnd(); } @@ -8345,14 +8398,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size313; - ::apache::thrift::protocol::TType _etype316; - xfer += iprot->readListBegin(_etype316, _size313); - this->sortCols.resize(_size313); - uint32_t _i317; - for (_i317 = 0; _i317 < _size313; ++_i317) + uint32_t _size314; + ::apache::thrift::protocol::TType _etype317; + xfer += iprot->readListBegin(_etype317, _size314); + this->sortCols.resize(_size314); + uint32_t _i318; + for (_i318 = 0; _i318 < _size314; ++_i318) { - xfer += this->sortCols[_i317].read(iprot); + xfer += this->sortCols[_i318].read(iprot); } xfer += iprot->readListEnd(); } @@ -8365,17 +8418,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size318; - ::apache::thrift::protocol::TType _ktype319; - ::apache::thrift::protocol::TType _vtype320; - xfer += iprot->readMapBegin(_ktype319, _vtype320, _size318); - uint32_t _i322; - for (_i322 = 0; _i322 < _size318; ++_i322) + uint32_t _size319; + ::apache::thrift::protocol::TType _ktype320; + ::apache::thrift::protocol::TType _vtype321; + xfer += iprot->readMapBegin(_ktype320, _vtype321, _size319); + uint32_t _i323; + for (_i323 = 0; _i323 < _size319; ++_i323) { - std::string _key323; - xfer += iprot->readString(_key323); - std::string& _val324 = this->parameters[_key323]; - xfer += iprot->readString(_val324); + std::string _key324; + xfer += iprot->readString(_key324); + std::string& _val325 = this->parameters[_key324]; + xfer += iprot->readString(_val325); } xfer += iprot->readMapEnd(); } @@ -8420,10 +8473,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); - std::vector ::const_iterator _iter325; - for (_iter325 = this->cols.begin(); _iter325 != this->cols.end(); ++_iter325) + std::vector ::const_iterator _iter326; + for (_iter326 = this->cols.begin(); _iter326 != this->cols.end(); ++_iter326) { - xfer += (*_iter325).write(oprot); + xfer += (*_iter326).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8456,10 +8509,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->bucketCols.size())); - std::vector ::const_iterator _iter326; - for (_iter326 = this->bucketCols.begin(); _iter326 != this->bucketCols.end(); ++_iter326) + std::vector ::const_iterator _iter327; + for (_iter327 = this->bucketCols.begin(); _iter327 != this->bucketCols.end(); ++_iter327) { - xfer += oprot->writeString((*_iter326)); + xfer += oprot->writeString((*_iter327)); } xfer += oprot->writeListEnd(); } @@ -8468,10 +8521,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sortCols.size())); - std::vector ::const_iterator _iter327; - for (_iter327 = this->sortCols.begin(); _iter327 != this->sortCols.end(); ++_iter327) + std::vector ::const_iterator _iter328; + for (_iter328 = this->sortCols.begin(); _iter328 != this->sortCols.end(); ++_iter328) { - xfer += (*_iter327).write(oprot); + xfer += (*_iter328).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8480,11 +8533,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter328; - for (_iter328 = this->parameters.begin(); _iter328 != this->parameters.end(); ++_iter328) + std::map ::const_iterator _iter329; + for (_iter329 = this->parameters.begin(); _iter329 != this->parameters.end(); ++_iter329) { - xfer += oprot->writeString(_iter328->first); - xfer += oprot->writeString(_iter328->second); + xfer += oprot->writeString(_iter329->first); + xfer += oprot->writeString(_iter329->second); } xfer += oprot->writeMapEnd(); } @@ -8522,22 +8575,7 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(const StorageDescriptor& other329) { - cols = other329.cols; - location = other329.location; - inputFormat = other329.inputFormat; - outputFormat = other329.outputFormat; - compressed = other329.compressed; - numBuckets = other329.numBuckets; - serdeInfo = other329.serdeInfo; - bucketCols = other329.bucketCols; - sortCols = other329.sortCols; - parameters = other329.parameters; - skewedInfo = other329.skewedInfo; - storedAsSubDirectories = other329.storedAsSubDirectories; - __isset = other329.__isset; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other330) { +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other330) { cols = other330.cols; location = other330.location; inputFormat = other330.inputFormat; @@ -8551,6 +8589,21 @@ StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other33 skewedInfo = other330.skewedInfo; storedAsSubDirectories = other330.storedAsSubDirectories; __isset = other330.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other331) { + cols = other331.cols; + location = other331.location; + inputFormat = other331.inputFormat; + outputFormat = other331.outputFormat; + compressed = other331.compressed; + numBuckets = other331.numBuckets; + serdeInfo = other331.serdeInfo; + bucketCols = other331.bucketCols; + sortCols = other331.sortCols; + parameters = other331.parameters; + skewedInfo = other331.skewedInfo; + storedAsSubDirectories = other331.storedAsSubDirectories; + __isset = other331.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -8666,15 +8719,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size331; - ::apache::thrift::protocol::TType _etype334; - xfer += iprot->readSetBegin(_etype334, _size331); - uint32_t _i335; - for (_i335 = 0; _i335 < _size331; ++_i335) + uint32_t _size332; + ::apache::thrift::protocol::TType _etype335; + xfer += iprot->readSetBegin(_etype335, _size332); + uint32_t _i336; + for (_i336 = 0; _i336 < _size332; ++_i336) { - std::string _elem336; - xfer += iprot->readString(_elem336); - this->tablesUsed.insert(_elem336); + std::string _elem337; + xfer += iprot->readString(_elem337); + this->tablesUsed.insert(_elem337); } xfer += iprot->readSetEnd(); } @@ -8703,14 +8756,14 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sourceTables.clear(); - uint32_t _size337; - ::apache::thrift::protocol::TType _etype340; - xfer += iprot->readListBegin(_etype340, _size337); - this->sourceTables.resize(_size337); - uint32_t _i341; - for (_i341 = 0; _i341 < _size337; ++_i341) + uint32_t _size338; + ::apache::thrift::protocol::TType _etype341; + xfer += iprot->readListBegin(_etype341, _size338); + this->sourceTables.resize(_size338); + uint32_t _i342; + for (_i342 = 0; _i342 < _size338; ++_i342) { - xfer += this->sourceTables[_i341].read(iprot); + xfer += this->sourceTables[_i342].read(iprot); } xfer += iprot->readListEnd(); } @@ -8759,10 +8812,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 4); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); - std::set ::const_iterator _iter342; - for (_iter342 = this->tablesUsed.begin(); _iter342 != this->tablesUsed.end(); ++_iter342) + std::set ::const_iterator _iter343; + for (_iter343 = this->tablesUsed.begin(); _iter343 != this->tablesUsed.end(); ++_iter343) { - xfer += oprot->writeString((*_iter342)); + xfer += oprot->writeString((*_iter343)); } xfer += oprot->writeSetEnd(); } @@ -8782,10 +8835,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("sourceTables", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sourceTables.size())); - std::vector ::const_iterator _iter343; - for (_iter343 = this->sourceTables.begin(); _iter343 != this->sourceTables.end(); ++_iter343) + std::vector ::const_iterator _iter344; + for (_iter344 = this->sourceTables.begin(); _iter344 != this->sourceTables.end(); ++_iter344) { - xfer += (*_iter343).write(oprot); + xfer += (*_iter344).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8808,17 +8861,7 @@ void swap(CreationMetadata &a, CreationMetadata &b) { swap(a.__isset, b.__isset); } -CreationMetadata::CreationMetadata(const CreationMetadata& other344) { - catName = other344.catName; - dbName = other344.dbName; - tblName = other344.tblName; - tablesUsed = other344.tablesUsed; - validTxnList = other344.validTxnList; - materializationTime = other344.materializationTime; - sourceTables = other344.sourceTables; - __isset = other344.__isset; -} -CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other345) { +CreationMetadata::CreationMetadata(const CreationMetadata& other345) { catName = other345.catName; dbName = other345.dbName; tblName = other345.tblName; @@ -8827,6 +8870,16 @@ CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other345) materializationTime = other345.materializationTime; sourceTables = other345.sourceTables; __isset = other345.__isset; +} +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other346) { + catName = other346.catName; + dbName = other346.dbName; + tblName = other346.tblName; + tablesUsed = other346.tablesUsed; + validTxnList = other346.validTxnList; + materializationTime = other346.materializationTime; + sourceTables = other346.sourceTables; + __isset = other346.__isset; return *this; } void CreationMetadata::printTo(std::ostream& out) const { @@ -8980,19 +9033,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other346) { - numTrues = other346.numTrues; - numFalses = other346.numFalses; - numNulls = other346.numNulls; - bitVectors = other346.bitVectors; - __isset = other346.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other347) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other347) { numTrues = other347.numTrues; numFalses = other347.numFalses; numNulls = other347.numNulls; bitVectors = other347.bitVectors; __isset = other347.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other348) { + numTrues = other348.numTrues; + numFalses = other348.numFalses; + numNulls = other348.numNulls; + bitVectors = other348.bitVectors; + __isset = other348.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -9180,16 +9233,7 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other348) { - lowValue = other348.lowValue; - highValue = other348.highValue; - numNulls = other348.numNulls; - numDVs = other348.numDVs; - bitVectors = other348.bitVectors; - histogram = other348.histogram; - __isset = other348.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other349) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other349) { lowValue = other349.lowValue; highValue = other349.highValue; numNulls = other349.numNulls; @@ -9197,6 +9241,15 @@ DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsD bitVectors = other349.bitVectors; histogram = other349.histogram; __isset = other349.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other350) { + lowValue = other350.lowValue; + highValue = other350.highValue; + numNulls = other350.numNulls; + numDVs = other350.numDVs; + bitVectors = other350.bitVectors; + histogram = other350.histogram; + __isset = other350.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -9386,16 +9439,7 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other350) { - lowValue = other350.lowValue; - highValue = other350.highValue; - numNulls = other350.numNulls; - numDVs = other350.numDVs; - bitVectors = other350.bitVectors; - histogram = other350.histogram; - __isset = other350.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other351) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other351) { lowValue = other351.lowValue; highValue = other351.highValue; numNulls = other351.numNulls; @@ -9403,6 +9447,15 @@ LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& o bitVectors = other351.bitVectors; histogram = other351.histogram; __isset = other351.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other352) { + lowValue = other352.lowValue; + highValue = other352.highValue; + numNulls = other352.numNulls; + numDVs = other352.numDVs; + bitVectors = other352.bitVectors; + histogram = other352.histogram; + __isset = other352.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -9575,21 +9628,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other352) { - maxColLen = other352.maxColLen; - avgColLen = other352.avgColLen; - numNulls = other352.numNulls; - numDVs = other352.numDVs; - bitVectors = other352.bitVectors; - __isset = other352.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other353) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other353) { maxColLen = other353.maxColLen; avgColLen = other353.avgColLen; numNulls = other353.numNulls; numDVs = other353.numDVs; bitVectors = other353.bitVectors; __isset = other353.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other354) { + maxColLen = other354.maxColLen; + avgColLen = other354.avgColLen; + numNulls = other354.numNulls; + numDVs = other354.numDVs; + bitVectors = other354.bitVectors; + __isset = other354.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -9741,19 +9794,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other354) { - maxColLen = other354.maxColLen; - avgColLen = other354.avgColLen; - numNulls = other354.numNulls; - bitVectors = other354.bitVectors; - __isset = other354.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other355) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other355) { maxColLen = other355.maxColLen; avgColLen = other355.avgColLen; numNulls = other355.numNulls; bitVectors = other355.bitVectors; __isset = other355.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other356) { + maxColLen = other356.maxColLen; + avgColLen = other356.avgColLen; + numNulls = other356.numNulls; + bitVectors = other356.bitVectors; + __isset = other356.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -9864,13 +9917,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.unscaled, b.unscaled); } -Decimal::Decimal(const Decimal& other356) { - scale = other356.scale; - unscaled = other356.unscaled; -} -Decimal& Decimal::operator=(const Decimal& other357) { +Decimal::Decimal(const Decimal& other357) { scale = other357.scale; unscaled = other357.unscaled; +} +Decimal& Decimal::operator=(const Decimal& other358) { + scale = other358.scale; + unscaled = other358.unscaled; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -10056,16 +10109,7 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other358) { - lowValue = other358.lowValue; - highValue = other358.highValue; - numNulls = other358.numNulls; - numDVs = other358.numDVs; - bitVectors = other358.bitVectors; - histogram = other358.histogram; - __isset = other358.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other359) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other359) { lowValue = other359.lowValue; highValue = other359.highValue; numNulls = other359.numNulls; @@ -10073,6 +10117,15 @@ DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnSta bitVectors = other359.bitVectors; histogram = other359.histogram; __isset = other359.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other360) { + lowValue = other360.lowValue; + highValue = other360.highValue; + numNulls = other360.numNulls; + numDVs = other360.numDVs; + bitVectors = other360.bitVectors; + histogram = other360.histogram; + __isset = other360.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -10165,11 +10218,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other360) noexcept { - daysSinceEpoch = other360.daysSinceEpoch; -} -Date& Date::operator=(const Date& other361) noexcept { +Date::Date(const Date& other361) noexcept { daysSinceEpoch = other361.daysSinceEpoch; +} +Date& Date::operator=(const Date& other362) noexcept { + daysSinceEpoch = other362.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -10354,16 +10407,7 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other362) { - lowValue = other362.lowValue; - highValue = other362.highValue; - numNulls = other362.numNulls; - numDVs = other362.numDVs; - bitVectors = other362.bitVectors; - histogram = other362.histogram; - __isset = other362.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other363) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other363) { lowValue = other363.lowValue; highValue = other363.highValue; numNulls = other363.numNulls; @@ -10371,6 +10415,15 @@ DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& o bitVectors = other363.bitVectors; histogram = other363.histogram; __isset = other363.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other364) { + lowValue = other364.lowValue; + highValue = other364.highValue; + numNulls = other364.numNulls; + numDVs = other364.numDVs; + bitVectors = other364.bitVectors; + histogram = other364.histogram; + __isset = other364.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -10463,11 +10516,11 @@ void swap(Timestamp &a, Timestamp &b) { swap(a.secondsSinceEpoch, b.secondsSinceEpoch); } -Timestamp::Timestamp(const Timestamp& other364) noexcept { - secondsSinceEpoch = other364.secondsSinceEpoch; -} -Timestamp& Timestamp::operator=(const Timestamp& other365) noexcept { +Timestamp::Timestamp(const Timestamp& other365) noexcept { secondsSinceEpoch = other365.secondsSinceEpoch; +} +Timestamp& Timestamp::operator=(const Timestamp& other366) noexcept { + secondsSinceEpoch = other366.secondsSinceEpoch; return *this; } void Timestamp::printTo(std::ostream& out) const { @@ -10652,16 +10705,7 @@ void swap(TimestampColumnStatsData &a, TimestampColumnStatsData &b) { swap(a.__isset, b.__isset); } -TimestampColumnStatsData::TimestampColumnStatsData(const TimestampColumnStatsData& other366) { - lowValue = other366.lowValue; - highValue = other366.highValue; - numNulls = other366.numNulls; - numDVs = other366.numDVs; - bitVectors = other366.bitVectors; - histogram = other366.histogram; - __isset = other366.__isset; -} -TimestampColumnStatsData& TimestampColumnStatsData::operator=(const TimestampColumnStatsData& other367) { +TimestampColumnStatsData::TimestampColumnStatsData(const TimestampColumnStatsData& other367) { lowValue = other367.lowValue; highValue = other367.highValue; numNulls = other367.numNulls; @@ -10669,6 +10713,15 @@ TimestampColumnStatsData& TimestampColumnStatsData::operator=(const TimestampCol bitVectors = other367.bitVectors; histogram = other367.histogram; __isset = other367.__isset; +} +TimestampColumnStatsData& TimestampColumnStatsData::operator=(const TimestampColumnStatsData& other368) { + lowValue = other368.lowValue; + highValue = other368.highValue; + numNulls = other368.numNulls; + numDVs = other368.numDVs; + bitVectors = other368.bitVectors; + histogram = other368.histogram; + __isset = other368.__isset; return *this; } void TimestampColumnStatsData::printTo(std::ostream& out) const { @@ -10894,18 +10947,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other368) { - booleanStats = other368.booleanStats; - longStats = other368.longStats; - doubleStats = other368.doubleStats; - stringStats = other368.stringStats; - binaryStats = other368.binaryStats; - decimalStats = other368.decimalStats; - dateStats = other368.dateStats; - timestampStats = other368.timestampStats; - __isset = other368.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other369) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other369) { booleanStats = other369.booleanStats; longStats = other369.longStats; doubleStats = other369.doubleStats; @@ -10915,6 +10957,17 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData dateStats = other369.dateStats; timestampStats = other369.timestampStats; __isset = other369.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other370) { + booleanStats = other370.booleanStats; + longStats = other370.longStats; + doubleStats = other370.doubleStats; + stringStats = other370.stringStats; + binaryStats = other370.binaryStats; + decimalStats = other370.decimalStats; + dateStats = other370.dateStats; + timestampStats = other370.timestampStats; + __isset = other370.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -11049,15 +11102,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other370) { - colName = other370.colName; - colType = other370.colType; - statsData = other370.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other371) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other371) { colName = other371.colName; colType = other371.colType; statsData = other371.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other372) { + colName = other372.colName; + colType = other372.colType; + statsData = other372.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -11245,16 +11298,7 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other372) { - isTblLevel = other372.isTblLevel; - dbName = other372.dbName; - tableName = other372.tableName; - partName = other372.partName; - lastAnalyzed = other372.lastAnalyzed; - catName = other372.catName; - __isset = other372.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other373) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other373) { isTblLevel = other373.isTblLevel; dbName = other373.dbName; tableName = other373.tableName; @@ -11262,6 +11306,15 @@ ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc lastAnalyzed = other373.lastAnalyzed; catName = other373.catName; __isset = other373.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other374) { + isTblLevel = other374.isTblLevel; + dbName = other374.dbName; + tableName = other374.tableName; + partName = other374.partName; + lastAnalyzed = other374.lastAnalyzed; + catName = other374.catName; + __isset = other374.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -11340,14 +11393,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size374; - ::apache::thrift::protocol::TType _etype377; - xfer += iprot->readListBegin(_etype377, _size374); - this->statsObj.resize(_size374); - uint32_t _i378; - for (_i378 = 0; _i378 < _size374; ++_i378) + uint32_t _size375; + ::apache::thrift::protocol::TType _etype378; + xfer += iprot->readListBegin(_etype378, _size375); + this->statsObj.resize(_size375); + uint32_t _i379; + for (_i379 = 0; _i379 < _size375; ++_i379) { - xfer += this->statsObj[_i378].read(iprot); + xfer += this->statsObj[_i379].read(iprot); } xfer += iprot->readListEnd(); } @@ -11400,10 +11453,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->statsObj.size())); - std::vector ::const_iterator _iter379; - for (_iter379 = this->statsObj.begin(); _iter379 != this->statsObj.end(); ++_iter379) + std::vector ::const_iterator _iter380; + for (_iter380 = this->statsObj.begin(); _iter380 != this->statsObj.end(); ++_iter380) { - xfer += (*_iter379).write(oprot); + xfer += (*_iter380).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11433,19 +11486,19 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.__isset, b.__isset); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other380) { - statsDesc = other380.statsDesc; - statsObj = other380.statsObj; - isStatsCompliant = other380.isStatsCompliant; - engine = other380.engine; - __isset = other380.__isset; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other381) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other381) { statsDesc = other381.statsDesc; statsObj = other381.statsObj; isStatsCompliant = other381.isStatsCompliant; engine = other381.engine; __isset = other381.__isset; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other382) { + statsDesc = other382.statsDesc; + statsObj = other382.statsObj; + isStatsCompliant = other382.isStatsCompliant; + engine = other382.engine; + __isset = other382.__isset; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -11522,14 +11575,14 @@ uint32_t FileMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->data.clear(); - uint32_t _size382; - ::apache::thrift::protocol::TType _etype385; - xfer += iprot->readListBegin(_etype385, _size382); - this->data.resize(_size382); - uint32_t _i386; - for (_i386 = 0; _i386 < _size382; ++_i386) + uint32_t _size383; + ::apache::thrift::protocol::TType _etype386; + xfer += iprot->readListBegin(_etype386, _size383); + this->data.resize(_size383); + uint32_t _i387; + for (_i387 = 0; _i387 < _size383; ++_i387) { - xfer += iprot->readBinary(this->data[_i386]); + xfer += iprot->readBinary(this->data[_i387]); } xfer += iprot->readListEnd(); } @@ -11566,10 +11619,10 @@ uint32_t FileMetadata::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->data.size())); - std::vector ::const_iterator _iter387; - for (_iter387 = this->data.begin(); _iter387 != this->data.end(); ++_iter387) + std::vector ::const_iterator _iter388; + for (_iter388 = this->data.begin(); _iter388 != this->data.end(); ++_iter388) { - xfer += oprot->writeBinary((*_iter387)); + xfer += oprot->writeBinary((*_iter388)); } xfer += oprot->writeListEnd(); } @@ -11588,17 +11641,17 @@ void swap(FileMetadata &a, FileMetadata &b) { swap(a.__isset, b.__isset); } -FileMetadata::FileMetadata(const FileMetadata& other388) { - type = other388.type; - version = other388.version; - data = other388.data; - __isset = other388.__isset; -} -FileMetadata& FileMetadata::operator=(const FileMetadata& other389) { +FileMetadata::FileMetadata(const FileMetadata& other389) { type = other389.type; version = other389.version; data = other389.data; __isset = other389.__isset; +} +FileMetadata& FileMetadata::operator=(const FileMetadata& other390) { + type = other390.type; + version = other390.version; + data = other390.data; + __isset = other390.__isset; return *this; } void FileMetadata::printTo(std::ostream& out) const { @@ -11651,26 +11704,26 @@ uint32_t ObjectDictionary::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->values.clear(); - uint32_t _size390; - ::apache::thrift::protocol::TType _ktype391; - ::apache::thrift::protocol::TType _vtype392; - xfer += iprot->readMapBegin(_ktype391, _vtype392, _size390); - uint32_t _i394; - for (_i394 = 0; _i394 < _size390; ++_i394) + uint32_t _size391; + ::apache::thrift::protocol::TType _ktype392; + ::apache::thrift::protocol::TType _vtype393; + xfer += iprot->readMapBegin(_ktype392, _vtype393, _size391); + uint32_t _i395; + for (_i395 = 0; _i395 < _size391; ++_i395) { - std::string _key395; - xfer += iprot->readString(_key395); - std::vector & _val396 = this->values[_key395]; + std::string _key396; + xfer += iprot->readString(_key396); + std::vector & _val397 = this->values[_key396]; { - _val396.clear(); - uint32_t _size397; - ::apache::thrift::protocol::TType _etype400; - xfer += iprot->readListBegin(_etype400, _size397); - _val396.resize(_size397); - uint32_t _i401; - for (_i401 = 0; _i401 < _size397; ++_i401) + _val397.clear(); + uint32_t _size398; + ::apache::thrift::protocol::TType _etype401; + xfer += iprot->readListBegin(_etype401, _size398); + _val397.resize(_size398); + uint32_t _i402; + for (_i402 = 0; _i402 < _size398; ++_i402) { - xfer += iprot->readBinary(_val396[_i401]); + xfer += iprot->readBinary(_val397[_i402]); } xfer += iprot->readListEnd(); } @@ -11704,16 +11757,16 @@ uint32_t ObjectDictionary::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->values.size())); - std::map > ::const_iterator _iter402; - for (_iter402 = this->values.begin(); _iter402 != this->values.end(); ++_iter402) + std::map > ::const_iterator _iter403; + for (_iter403 = this->values.begin(); _iter403 != this->values.end(); ++_iter403) { - xfer += oprot->writeString(_iter402->first); + xfer += oprot->writeString(_iter403->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter402->second.size())); - std::vector ::const_iterator _iter403; - for (_iter403 = _iter402->second.begin(); _iter403 != _iter402->second.end(); ++_iter403) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter403->second.size())); + std::vector ::const_iterator _iter404; + for (_iter404 = _iter403->second.begin(); _iter404 != _iter403->second.end(); ++_iter404) { - xfer += oprot->writeBinary((*_iter403)); + xfer += oprot->writeBinary((*_iter404)); } xfer += oprot->writeListEnd(); } @@ -11732,11 +11785,11 @@ void swap(ObjectDictionary &a, ObjectDictionary &b) { swap(a.values, b.values); } -ObjectDictionary::ObjectDictionary(const ObjectDictionary& other404) { - values = other404.values; -} -ObjectDictionary& ObjectDictionary::operator=(const ObjectDictionary& other405) { +ObjectDictionary::ObjectDictionary(const ObjectDictionary& other405) { values = other405.values; +} +ObjectDictionary& ObjectDictionary::operator=(const ObjectDictionary& other406) { + values = other406.values; return *this; } void ObjectDictionary::printTo(std::ostream& out) const { @@ -11966,14 +12019,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size406; - ::apache::thrift::protocol::TType _etype409; - xfer += iprot->readListBegin(_etype409, _size406); - this->partitionKeys.resize(_size406); - uint32_t _i410; - for (_i410 = 0; _i410 < _size406; ++_i410) + uint32_t _size407; + ::apache::thrift::protocol::TType _etype410; + xfer += iprot->readListBegin(_etype410, _size407); + this->partitionKeys.resize(_size407); + uint32_t _i411; + for (_i411 = 0; _i411 < _size407; ++_i411) { - xfer += this->partitionKeys[_i410].read(iprot); + xfer += this->partitionKeys[_i411].read(iprot); } xfer += iprot->readListEnd(); } @@ -11986,17 +12039,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size411; - ::apache::thrift::protocol::TType _ktype412; - ::apache::thrift::protocol::TType _vtype413; - xfer += iprot->readMapBegin(_ktype412, _vtype413, _size411); - uint32_t _i415; - for (_i415 = 0; _i415 < _size411; ++_i415) + uint32_t _size412; + ::apache::thrift::protocol::TType _ktype413; + ::apache::thrift::protocol::TType _vtype414; + xfer += iprot->readMapBegin(_ktype413, _vtype414, _size412); + uint32_t _i416; + for (_i416 = 0; _i416 < _size412; ++_i416) { - std::string _key416; - xfer += iprot->readString(_key416); - std::string& _val417 = this->parameters[_key416]; - xfer += iprot->readString(_val417); + std::string _key417; + xfer += iprot->readString(_key417); + std::string& _val418 = this->parameters[_key417]; + xfer += iprot->readString(_val418); } xfer += iprot->readMapEnd(); } @@ -12071,9 +12124,9 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 18: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast418; - xfer += iprot->readI32(ecast418); - this->ownerType = static_cast(ecast418); + int32_t ecast419; + xfer += iprot->readI32(ecast419); + this->ownerType = static_cast(ecast419); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -12115,14 +12168,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->requiredReadCapabilities.clear(); - uint32_t _size419; - ::apache::thrift::protocol::TType _etype422; - xfer += iprot->readListBegin(_etype422, _size419); - this->requiredReadCapabilities.resize(_size419); - uint32_t _i423; - for (_i423 = 0; _i423 < _size419; ++_i423) + uint32_t _size420; + ::apache::thrift::protocol::TType _etype423; + xfer += iprot->readListBegin(_etype423, _size420); + this->requiredReadCapabilities.resize(_size420); + uint32_t _i424; + for (_i424 = 0; _i424 < _size420; ++_i424) { - xfer += iprot->readString(this->requiredReadCapabilities[_i423]); + xfer += iprot->readString(this->requiredReadCapabilities[_i424]); } xfer += iprot->readListEnd(); } @@ -12135,14 +12188,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->requiredWriteCapabilities.clear(); - uint32_t _size424; - ::apache::thrift::protocol::TType _etype427; - xfer += iprot->readListBegin(_etype427, _size424); - this->requiredWriteCapabilities.resize(_size424); - uint32_t _i428; - for (_i428 = 0; _i428 < _size424; ++_i428) + uint32_t _size425; + ::apache::thrift::protocol::TType _etype428; + xfer += iprot->readListBegin(_etype428, _size425); + this->requiredWriteCapabilities.resize(_size425); + uint32_t _i429; + for (_i429 = 0; _i429 < _size425; ++_i429) { - xfer += iprot->readString(this->requiredWriteCapabilities[_i428]); + xfer += iprot->readString(this->requiredWriteCapabilities[_i429]); } xfer += iprot->readListEnd(); } @@ -12231,10 +12284,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); - std::vector ::const_iterator _iter429; - for (_iter429 = this->partitionKeys.begin(); _iter429 != this->partitionKeys.end(); ++_iter429) + std::vector ::const_iterator _iter430; + for (_iter430 = this->partitionKeys.begin(); _iter430 != this->partitionKeys.end(); ++_iter430) { - xfer += (*_iter429).write(oprot); + xfer += (*_iter430).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12243,11 +12296,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter430; - for (_iter430 = this->parameters.begin(); _iter430 != this->parameters.end(); ++_iter430) + std::map ::const_iterator _iter431; + for (_iter431 = this->parameters.begin(); _iter431 != this->parameters.end(); ++_iter431) { - xfer += oprot->writeString(_iter430->first); - xfer += oprot->writeString(_iter430->second); + xfer += oprot->writeString(_iter431->first); + xfer += oprot->writeString(_iter431->second); } xfer += oprot->writeMapEnd(); } @@ -12319,10 +12372,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("requiredReadCapabilities", ::apache::thrift::protocol::T_LIST, 23); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredReadCapabilities.size())); - std::vector ::const_iterator _iter431; - for (_iter431 = this->requiredReadCapabilities.begin(); _iter431 != this->requiredReadCapabilities.end(); ++_iter431) + std::vector ::const_iterator _iter432; + for (_iter432 = this->requiredReadCapabilities.begin(); _iter432 != this->requiredReadCapabilities.end(); ++_iter432) { - xfer += oprot->writeString((*_iter431)); + xfer += oprot->writeString((*_iter432)); } xfer += oprot->writeListEnd(); } @@ -12332,10 +12385,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("requiredWriteCapabilities", ::apache::thrift::protocol::T_LIST, 24); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredWriteCapabilities.size())); - std::vector ::const_iterator _iter432; - for (_iter432 = this->requiredWriteCapabilities.begin(); _iter432 != this->requiredWriteCapabilities.end(); ++_iter432) + std::vector ::const_iterator _iter433; + for (_iter433 = this->requiredWriteCapabilities.begin(); _iter433 != this->requiredWriteCapabilities.end(); ++_iter433) { - xfer += oprot->writeString((*_iter432)); + xfer += oprot->writeString((*_iter433)); } xfer += oprot->writeListEnd(); } @@ -12399,38 +12452,7 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other433) { - tableName = other433.tableName; - dbName = other433.dbName; - owner = other433.owner; - createTime = other433.createTime; - lastAccessTime = other433.lastAccessTime; - retention = other433.retention; - sd = other433.sd; - partitionKeys = other433.partitionKeys; - parameters = other433.parameters; - viewOriginalText = other433.viewOriginalText; - viewExpandedText = other433.viewExpandedText; - tableType = other433.tableType; - privileges = other433.privileges; - temporary = other433.temporary; - rewriteEnabled = other433.rewriteEnabled; - creationMetadata = other433.creationMetadata; - catName = other433.catName; - ownerType = other433.ownerType; - writeId = other433.writeId; - isStatsCompliant = other433.isStatsCompliant; - colStats = other433.colStats; - accessType = other433.accessType; - requiredReadCapabilities = other433.requiredReadCapabilities; - requiredWriteCapabilities = other433.requiredWriteCapabilities; - id = other433.id; - fileMetadata = other433.fileMetadata; - dictionary = other433.dictionary; - txnId = other433.txnId; - __isset = other433.__isset; -} -Table& Table::operator=(const Table& other434) { +Table::Table(const Table& other434) { tableName = other434.tableName; dbName = other434.dbName; owner = other434.owner; @@ -12460,6 +12482,37 @@ Table& Table::operator=(const Table& other434) { dictionary = other434.dictionary; txnId = other434.txnId; __isset = other434.__isset; +} +Table& Table::operator=(const Table& other435) { + tableName = other435.tableName; + dbName = other435.dbName; + owner = other435.owner; + createTime = other435.createTime; + lastAccessTime = other435.lastAccessTime; + retention = other435.retention; + sd = other435.sd; + partitionKeys = other435.partitionKeys; + parameters = other435.parameters; + viewOriginalText = other435.viewOriginalText; + viewExpandedText = other435.viewExpandedText; + tableType = other435.tableType; + privileges = other435.privileges; + temporary = other435.temporary; + rewriteEnabled = other435.rewriteEnabled; + creationMetadata = other435.creationMetadata; + catName = other435.catName; + ownerType = other435.ownerType; + writeId = other435.writeId; + isStatsCompliant = other435.isStatsCompliant; + colStats = other435.colStats; + accessType = other435.accessType; + requiredReadCapabilities = other435.requiredReadCapabilities; + requiredWriteCapabilities = other435.requiredWriteCapabilities; + id = other435.id; + fileMetadata = other435.fileMetadata; + dictionary = other435.dictionary; + txnId = other435.txnId; + __isset = other435.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -12634,17 +12687,17 @@ void swap(SourceTable &a, SourceTable &b) { swap(a.deletedCount, b.deletedCount); } -SourceTable::SourceTable(const SourceTable& other435) { - table = other435.table; - insertedCount = other435.insertedCount; - updatedCount = other435.updatedCount; - deletedCount = other435.deletedCount; -} -SourceTable& SourceTable::operator=(const SourceTable& other436) { +SourceTable::SourceTable(const SourceTable& other436) { table = other436.table; insertedCount = other436.insertedCount; updatedCount = other436.updatedCount; deletedCount = other436.deletedCount; +} +SourceTable& SourceTable::operator=(const SourceTable& other437) { + table = other437.table; + insertedCount = other437.insertedCount; + updatedCount = other437.updatedCount; + deletedCount = other437.deletedCount; return *this; } void SourceTable::printTo(std::ostream& out) const { @@ -12751,14 +12804,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size437; - ::apache::thrift::protocol::TType _etype440; - xfer += iprot->readListBegin(_etype440, _size437); - this->values.resize(_size437); - uint32_t _i441; - for (_i441 = 0; _i441 < _size437; ++_i441) + uint32_t _size438; + ::apache::thrift::protocol::TType _etype441; + xfer += iprot->readListBegin(_etype441, _size438); + this->values.resize(_size438); + uint32_t _i442; + for (_i442 = 0; _i442 < _size438; ++_i442) { - xfer += iprot->readString(this->values[_i441]); + xfer += iprot->readString(this->values[_i442]); } xfer += iprot->readListEnd(); } @@ -12811,17 +12864,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size442; - ::apache::thrift::protocol::TType _ktype443; - ::apache::thrift::protocol::TType _vtype444; - xfer += iprot->readMapBegin(_ktype443, _vtype444, _size442); - uint32_t _i446; - for (_i446 = 0; _i446 < _size442; ++_i446) + uint32_t _size443; + ::apache::thrift::protocol::TType _ktype444; + ::apache::thrift::protocol::TType _vtype445; + xfer += iprot->readMapBegin(_ktype444, _vtype445, _size443); + uint32_t _i447; + for (_i447 = 0; _i447 < _size443; ++_i447) { - std::string _key447; - xfer += iprot->readString(_key447); - std::string& _val448 = this->parameters[_key447]; - xfer += iprot->readString(_val448); + std::string _key448; + xfer += iprot->readString(_key448); + std::string& _val449 = this->parameters[_key448]; + xfer += iprot->readString(_val449); } xfer += iprot->readMapEnd(); } @@ -12898,10 +12951,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter449; - for (_iter449 = this->values.begin(); _iter449 != this->values.end(); ++_iter449) + std::vector ::const_iterator _iter450; + for (_iter450 = this->values.begin(); _iter450 != this->values.end(); ++_iter450) { - xfer += oprot->writeString((*_iter449)); + xfer += oprot->writeString((*_iter450)); } xfer += oprot->writeListEnd(); } @@ -12930,11 +12983,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter450; - for (_iter450 = this->parameters.begin(); _iter450 != this->parameters.end(); ++_iter450) + std::map ::const_iterator _iter451; + for (_iter451 = this->parameters.begin(); _iter451 != this->parameters.end(); ++_iter451) { - xfer += oprot->writeString(_iter450->first); - xfer += oprot->writeString(_iter450->second); + xfer += oprot->writeString(_iter451->first); + xfer += oprot->writeString(_iter451->second); } xfer += oprot->writeMapEnd(); } @@ -12993,23 +13046,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other451) { - values = other451.values; - dbName = other451.dbName; - tableName = other451.tableName; - createTime = other451.createTime; - lastAccessTime = other451.lastAccessTime; - sd = other451.sd; - parameters = other451.parameters; - privileges = other451.privileges; - catName = other451.catName; - writeId = other451.writeId; - isStatsCompliant = other451.isStatsCompliant; - colStats = other451.colStats; - fileMetadata = other451.fileMetadata; - __isset = other451.__isset; -} -Partition& Partition::operator=(const Partition& other452) { +Partition::Partition(const Partition& other452) { values = other452.values; dbName = other452.dbName; tableName = other452.tableName; @@ -13024,6 +13061,22 @@ Partition& Partition::operator=(const Partition& other452) { colStats = other452.colStats; fileMetadata = other452.fileMetadata; __isset = other452.__isset; +} +Partition& Partition::operator=(const Partition& other453) { + values = other453.values; + dbName = other453.dbName; + tableName = other453.tableName; + createTime = other453.createTime; + lastAccessTime = other453.lastAccessTime; + sd = other453.sd; + parameters = other453.parameters; + privileges = other453.privileges; + catName = other453.catName; + writeId = other453.writeId; + isStatsCompliant = other453.isStatsCompliant; + colStats = other453.colStats; + fileMetadata = other453.fileMetadata; + __isset = other453.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -13106,14 +13159,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size453; - ::apache::thrift::protocol::TType _etype456; - xfer += iprot->readListBegin(_etype456, _size453); - this->values.resize(_size453); - uint32_t _i457; - for (_i457 = 0; _i457 < _size453; ++_i457) + uint32_t _size454; + ::apache::thrift::protocol::TType _etype457; + xfer += iprot->readListBegin(_etype457, _size454); + this->values.resize(_size454); + uint32_t _i458; + for (_i458 = 0; _i458 < _size454; ++_i458) { - xfer += iprot->readString(this->values[_i457]); + xfer += iprot->readString(this->values[_i458]); } xfer += iprot->readListEnd(); } @@ -13150,17 +13203,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size458; - ::apache::thrift::protocol::TType _ktype459; - ::apache::thrift::protocol::TType _vtype460; - xfer += iprot->readMapBegin(_ktype459, _vtype460, _size458); - uint32_t _i462; - for (_i462 = 0; _i462 < _size458; ++_i462) + uint32_t _size459; + ::apache::thrift::protocol::TType _ktype460; + ::apache::thrift::protocol::TType _vtype461; + xfer += iprot->readMapBegin(_ktype460, _vtype461, _size459); + uint32_t _i463; + for (_i463 = 0; _i463 < _size459; ++_i463) { - std::string _key463; - xfer += iprot->readString(_key463); - std::string& _val464 = this->parameters[_key463]; - xfer += iprot->readString(_val464); + std::string _key464; + xfer += iprot->readString(_key464); + std::string& _val465 = this->parameters[_key464]; + xfer += iprot->readString(_val465); } xfer += iprot->readMapEnd(); } @@ -13197,10 +13250,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter465; - for (_iter465 = this->values.begin(); _iter465 != this->values.end(); ++_iter465) + std::vector ::const_iterator _iter466; + for (_iter466 = this->values.begin(); _iter466 != this->values.end(); ++_iter466) { - xfer += oprot->writeString((*_iter465)); + xfer += oprot->writeString((*_iter466)); } xfer += oprot->writeListEnd(); } @@ -13221,11 +13274,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter466; - for (_iter466 = this->parameters.begin(); _iter466 != this->parameters.end(); ++_iter466) + std::map ::const_iterator _iter467; + for (_iter467 = this->parameters.begin(); _iter467 != this->parameters.end(); ++_iter467) { - xfer += oprot->writeString(_iter466->first); - xfer += oprot->writeString(_iter466->second); + xfer += oprot->writeString(_iter467->first); + xfer += oprot->writeString(_iter467->second); } xfer += oprot->writeMapEnd(); } @@ -13252,16 +13305,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other467) { - values = other467.values; - createTime = other467.createTime; - lastAccessTime = other467.lastAccessTime; - relativePath = other467.relativePath; - parameters = other467.parameters; - privileges = other467.privileges; - __isset = other467.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other468) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other468) { values = other468.values; createTime = other468.createTime; lastAccessTime = other468.lastAccessTime; @@ -13269,6 +13313,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other468.parameters; privileges = other468.privileges; __isset = other468.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other469) { + values = other469.values; + createTime = other469.createTime; + lastAccessTime = other469.lastAccessTime; + relativePath = other469.relativePath; + parameters = other469.parameters; + privileges = other469.privileges; + __isset = other469.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -13327,14 +13380,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size469; - ::apache::thrift::protocol::TType _etype472; - xfer += iprot->readListBegin(_etype472, _size469); - this->partitions.resize(_size469); - uint32_t _i473; - for (_i473 = 0; _i473 < _size469; ++_i473) + uint32_t _size470; + ::apache::thrift::protocol::TType _etype473; + xfer += iprot->readListBegin(_etype473, _size470); + this->partitions.resize(_size470); + uint32_t _i474; + for (_i474 = 0; _i474 < _size470; ++_i474) { - xfer += this->partitions[_i473].read(iprot); + xfer += this->partitions[_i474].read(iprot); } xfer += iprot->readListEnd(); } @@ -13371,10 +13424,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter474; - for (_iter474 = this->partitions.begin(); _iter474 != this->partitions.end(); ++_iter474) + std::vector ::const_iterator _iter475; + for (_iter475 = this->partitions.begin(); _iter475 != this->partitions.end(); ++_iter475) { - xfer += (*_iter474).write(oprot); + xfer += (*_iter475).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13396,15 +13449,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other475) { - partitions = other475.partitions; - sd = other475.sd; - __isset = other475.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other476) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other476) { partitions = other476.partitions; sd = other476.sd; __isset = other476.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other477) { + partitions = other477.partitions; + sd = other477.sd; + __isset = other477.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -13455,14 +13508,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size477; - ::apache::thrift::protocol::TType _etype480; - xfer += iprot->readListBegin(_etype480, _size477); - this->partitions.resize(_size477); - uint32_t _i481; - for (_i481 = 0; _i481 < _size477; ++_i481) + uint32_t _size478; + ::apache::thrift::protocol::TType _etype481; + xfer += iprot->readListBegin(_etype481, _size478); + this->partitions.resize(_size478); + uint32_t _i482; + for (_i482 = 0; _i482 < _size478; ++_i482) { - xfer += this->partitions[_i481].read(iprot); + xfer += this->partitions[_i482].read(iprot); } xfer += iprot->readListEnd(); } @@ -13491,10 +13544,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter482; - for (_iter482 = this->partitions.begin(); _iter482 != this->partitions.end(); ++_iter482) + std::vector ::const_iterator _iter483; + for (_iter483 = this->partitions.begin(); _iter483 != this->partitions.end(); ++_iter483) { - xfer += (*_iter482).write(oprot); + xfer += (*_iter483).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13511,13 +13564,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other483) { - partitions = other483.partitions; - __isset = other483.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other484) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other484) { partitions = other484.partitions; __isset = other484.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other485) { + partitions = other485.partitions; + __isset = other485.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -13732,18 +13785,7 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other485) { - dbName = other485.dbName; - tableName = other485.tableName; - rootPath = other485.rootPath; - sharedSDPartitionSpec = other485.sharedSDPartitionSpec; - partitionList = other485.partitionList; - catName = other485.catName; - writeId = other485.writeId; - isStatsCompliant = other485.isStatsCompliant; - __isset = other485.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other486) { +PartitionSpec::PartitionSpec(const PartitionSpec& other486) { dbName = other486.dbName; tableName = other486.tableName; rootPath = other486.rootPath; @@ -13753,6 +13795,17 @@ PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other486) { writeId = other486.writeId; isStatsCompliant = other486.isStatsCompliant; __isset = other486.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other487) { + dbName = other487.dbName; + tableName = other487.tableName; + rootPath = other487.rootPath; + sharedSDPartitionSpec = other487.sharedSDPartitionSpec; + partitionList = other487.partitionList; + catName = other487.catName; + writeId = other487.writeId; + isStatsCompliant = other487.isStatsCompliant; + __isset = other487.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -13820,14 +13873,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size487; - ::apache::thrift::protocol::TType _etype490; - xfer += iprot->readListBegin(_etype490, _size487); - this->colStats.resize(_size487); - uint32_t _i491; - for (_i491 = 0; _i491 < _size487; ++_i491) + uint32_t _size488; + ::apache::thrift::protocol::TType _etype491; + xfer += iprot->readListBegin(_etype491, _size488); + this->colStats.resize(_size488); + uint32_t _i492; + for (_i492 = 0; _i492 < _size488; ++_i492) { - xfer += this->colStats[_i491].read(iprot); + xfer += this->colStats[_i492].read(iprot); } xfer += iprot->readListEnd(); } @@ -13876,10 +13929,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter492; - for (_iter492 = this->colStats.begin(); _iter492 != this->colStats.end(); ++_iter492) + std::vector ::const_iterator _iter493; + for (_iter493 = this->colStats.begin(); _iter493 != this->colStats.end(); ++_iter493) { - xfer += (*_iter492).write(oprot); + xfer += (*_iter493).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13907,17 +13960,17 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.__isset, b.__isset); } -AggrStats::AggrStats(const AggrStats& other493) { - colStats = other493.colStats; - partsFound = other493.partsFound; - isStatsCompliant = other493.isStatsCompliant; - __isset = other493.__isset; -} -AggrStats& AggrStats::operator=(const AggrStats& other494) { +AggrStats::AggrStats(const AggrStats& other494) { colStats = other494.colStats; partsFound = other494.partsFound; isStatsCompliant = other494.isStatsCompliant; __isset = other494.__isset; +} +AggrStats& AggrStats::operator=(const AggrStats& other495) { + colStats = other495.colStats; + partsFound = other495.partsFound; + isStatsCompliant = other495.isStatsCompliant; + __isset = other495.__isset; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -13990,14 +14043,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size495; - ::apache::thrift::protocol::TType _etype498; - xfer += iprot->readListBegin(_etype498, _size495); - this->colStats.resize(_size495); - uint32_t _i499; - for (_i499 = 0; _i499 < _size495; ++_i499) + uint32_t _size496; + ::apache::thrift::protocol::TType _etype499; + xfer += iprot->readListBegin(_etype499, _size496); + this->colStats.resize(_size496); + uint32_t _i500; + for (_i500 = 0; _i500 < _size496; ++_i500) { - xfer += this->colStats[_i499].read(iprot); + xfer += this->colStats[_i500].read(iprot); } xfer += iprot->readListEnd(); } @@ -14060,10 +14113,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter500; - for (_iter500 = this->colStats.begin(); _iter500 != this->colStats.end(); ++_iter500) + std::vector ::const_iterator _iter501; + for (_iter501 = this->colStats.begin(); _iter501 != this->colStats.end(); ++_iter501) { - xfer += (*_iter500).write(oprot); + xfer += (*_iter501).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14104,21 +14157,21 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other501) { - colStats = other501.colStats; - needMerge = other501.needMerge; - writeId = other501.writeId; - validWriteIdList = other501.validWriteIdList; - engine = other501.engine; - __isset = other501.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other502) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other502) { colStats = other502.colStats; needMerge = other502.needMerge; writeId = other502.writeId; validWriteIdList = other502.validWriteIdList; engine = other502.engine; __isset = other502.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other503) { + colStats = other503.colStats; + needMerge = other503.needMerge; + writeId = other503.writeId; + validWriteIdList = other503.validWriteIdList; + engine = other503.engine; + __isset = other503.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -14210,11 +14263,11 @@ void swap(SetPartitionsStatsResponse &a, SetPartitionsStatsResponse &b) { swap(a.result, b.result); } -SetPartitionsStatsResponse::SetPartitionsStatsResponse(const SetPartitionsStatsResponse& other503) noexcept { - result = other503.result; -} -SetPartitionsStatsResponse& SetPartitionsStatsResponse::operator=(const SetPartitionsStatsResponse& other504) noexcept { +SetPartitionsStatsResponse::SetPartitionsStatsResponse(const SetPartitionsStatsResponse& other504) noexcept { result = other504.result; +} +SetPartitionsStatsResponse& SetPartitionsStatsResponse::operator=(const SetPartitionsStatsResponse& other505) noexcept { + result = other505.result; return *this; } void SetPartitionsStatsResponse::printTo(std::ostream& out) const { @@ -14268,14 +14321,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size505; - ::apache::thrift::protocol::TType _etype508; - xfer += iprot->readListBegin(_etype508, _size505); - this->fieldSchemas.resize(_size505); - uint32_t _i509; - for (_i509 = 0; _i509 < _size505; ++_i509) + uint32_t _size506; + ::apache::thrift::protocol::TType _etype509; + xfer += iprot->readListBegin(_etype509, _size506); + this->fieldSchemas.resize(_size506); + uint32_t _i510; + for (_i510 = 0; _i510 < _size506; ++_i510) { - xfer += this->fieldSchemas[_i509].read(iprot); + xfer += this->fieldSchemas[_i510].read(iprot); } xfer += iprot->readListEnd(); } @@ -14288,17 +14341,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size510; - ::apache::thrift::protocol::TType _ktype511; - ::apache::thrift::protocol::TType _vtype512; - xfer += iprot->readMapBegin(_ktype511, _vtype512, _size510); - uint32_t _i514; - for (_i514 = 0; _i514 < _size510; ++_i514) + uint32_t _size511; + ::apache::thrift::protocol::TType _ktype512; + ::apache::thrift::protocol::TType _vtype513; + xfer += iprot->readMapBegin(_ktype512, _vtype513, _size511); + uint32_t _i515; + for (_i515 = 0; _i515 < _size511; ++_i515) { - std::string _key515; - xfer += iprot->readString(_key515); - std::string& _val516 = this->properties[_key515]; - xfer += iprot->readString(_val516); + std::string _key516; + xfer += iprot->readString(_key516); + std::string& _val517 = this->properties[_key516]; + xfer += iprot->readString(_val517); } xfer += iprot->readMapEnd(); } @@ -14327,10 +14380,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fieldSchemas.size())); - std::vector ::const_iterator _iter517; - for (_iter517 = this->fieldSchemas.begin(); _iter517 != this->fieldSchemas.end(); ++_iter517) + std::vector ::const_iterator _iter518; + for (_iter518 = this->fieldSchemas.begin(); _iter518 != this->fieldSchemas.end(); ++_iter518) { - xfer += (*_iter517).write(oprot); + xfer += (*_iter518).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14339,11 +14392,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter518; - for (_iter518 = this->properties.begin(); _iter518 != this->properties.end(); ++_iter518) + std::map ::const_iterator _iter519; + for (_iter519 = this->properties.begin(); _iter519 != this->properties.end(); ++_iter519) { - xfer += oprot->writeString(_iter518->first); - xfer += oprot->writeString(_iter518->second); + xfer += oprot->writeString(_iter519->first); + xfer += oprot->writeString(_iter519->second); } xfer += oprot->writeMapEnd(); } @@ -14361,15 +14414,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other519) { - fieldSchemas = other519.fieldSchemas; - properties = other519.properties; - __isset = other519.__isset; -} -Schema& Schema::operator=(const Schema& other520) { +Schema::Schema(const Schema& other520) { fieldSchemas = other520.fieldSchemas; properties = other520.properties; __isset = other520.__isset; +} +Schema& Schema::operator=(const Schema& other521) { + fieldSchemas = other521.fieldSchemas; + properties = other521.properties; + __isset = other521.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -14536,21 +14589,21 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.__isset, b.__isset); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other521) { - db_name = other521.db_name; - tbl_name = other521.tbl_name; - catName = other521.catName; - validWriteIdList = other521.validWriteIdList; - tableId = other521.tableId; - __isset = other521.__isset; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other522) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other522) { db_name = other522.db_name; tbl_name = other522.tbl_name; catName = other522.catName; validWriteIdList = other522.validWriteIdList; tableId = other522.tableId; __isset = other522.__isset; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other523) { + db_name = other523.db_name; + tbl_name = other523.tbl_name; + catName = other523.catName; + validWriteIdList = other523.validWriteIdList; + tableId = other523.tableId; + __isset = other523.__isset; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -14605,14 +14658,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size523; - ::apache::thrift::protocol::TType _etype526; - xfer += iprot->readListBegin(_etype526, _size523); - this->primaryKeys.resize(_size523); - uint32_t _i527; - for (_i527 = 0; _i527 < _size523; ++_i527) + uint32_t _size524; + ::apache::thrift::protocol::TType _etype527; + xfer += iprot->readListBegin(_etype527, _size524); + this->primaryKeys.resize(_size524); + uint32_t _i528; + for (_i528 = 0; _i528 < _size524; ++_i528) { - xfer += this->primaryKeys[_i527].read(iprot); + xfer += this->primaryKeys[_i528].read(iprot); } xfer += iprot->readListEnd(); } @@ -14643,10 +14696,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter528; - for (_iter528 = this->primaryKeys.begin(); _iter528 != this->primaryKeys.end(); ++_iter528) + std::vector ::const_iterator _iter529; + for (_iter529 = this->primaryKeys.begin(); _iter529 != this->primaryKeys.end(); ++_iter529) { - xfer += (*_iter528).write(oprot); + xfer += (*_iter529).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14662,11 +14715,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other529) { - primaryKeys = other529.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other530) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other530) { primaryKeys = other530.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other531) { + primaryKeys = other531.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -14860,17 +14913,7 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other531) { - parent_db_name = other531.parent_db_name; - parent_tbl_name = other531.parent_tbl_name; - foreign_db_name = other531.foreign_db_name; - foreign_tbl_name = other531.foreign_tbl_name; - catName = other531.catName; - validWriteIdList = other531.validWriteIdList; - tableId = other531.tableId; - __isset = other531.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other532) { +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other532) { parent_db_name = other532.parent_db_name; parent_tbl_name = other532.parent_tbl_name; foreign_db_name = other532.foreign_db_name; @@ -14879,6 +14922,16 @@ ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& othe validWriteIdList = other532.validWriteIdList; tableId = other532.tableId; __isset = other532.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other533) { + parent_db_name = other533.parent_db_name; + parent_tbl_name = other533.parent_tbl_name; + foreign_db_name = other533.foreign_db_name; + foreign_tbl_name = other533.foreign_tbl_name; + catName = other533.catName; + validWriteIdList = other533.validWriteIdList; + tableId = other533.tableId; + __isset = other533.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -14935,14 +14988,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size533; - ::apache::thrift::protocol::TType _etype536; - xfer += iprot->readListBegin(_etype536, _size533); - this->foreignKeys.resize(_size533); - uint32_t _i537; - for (_i537 = 0; _i537 < _size533; ++_i537) + uint32_t _size534; + ::apache::thrift::protocol::TType _etype537; + xfer += iprot->readListBegin(_etype537, _size534); + this->foreignKeys.resize(_size534); + uint32_t _i538; + for (_i538 = 0; _i538 < _size534; ++_i538) { - xfer += this->foreignKeys[_i537].read(iprot); + xfer += this->foreignKeys[_i538].read(iprot); } xfer += iprot->readListEnd(); } @@ -14973,10 +15026,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter538; - for (_iter538 = this->foreignKeys.begin(); _iter538 != this->foreignKeys.end(); ++_iter538) + std::vector ::const_iterator _iter539; + for (_iter539 = this->foreignKeys.begin(); _iter539 != this->foreignKeys.end(); ++_iter539) { - xfer += (*_iter538).write(oprot); + xfer += (*_iter539).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14992,11 +15045,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other539) { - foreignKeys = other539.foreignKeys; -} -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other540) { +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other540) { foreignKeys = other540.foreignKeys; +} +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other541) { + foreignKeys = other541.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -15163,21 +15216,21 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.__isset, b.__isset); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other541) { - catName = other541.catName; - db_name = other541.db_name; - tbl_name = other541.tbl_name; - validWriteIdList = other541.validWriteIdList; - tableId = other541.tableId; - __isset = other541.__isset; -} -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other542) { +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other542) { catName = other542.catName; db_name = other542.db_name; tbl_name = other542.tbl_name; validWriteIdList = other542.validWriteIdList; tableId = other542.tableId; __isset = other542.__isset; +} +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other543) { + catName = other543.catName; + db_name = other543.db_name; + tbl_name = other543.tbl_name; + validWriteIdList = other543.validWriteIdList; + tableId = other543.tableId; + __isset = other543.__isset; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -15232,14 +15285,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size543; - ::apache::thrift::protocol::TType _etype546; - xfer += iprot->readListBegin(_etype546, _size543); - this->uniqueConstraints.resize(_size543); - uint32_t _i547; - for (_i547 = 0; _i547 < _size543; ++_i547) + uint32_t _size544; + ::apache::thrift::protocol::TType _etype547; + xfer += iprot->readListBegin(_etype547, _size544); + this->uniqueConstraints.resize(_size544); + uint32_t _i548; + for (_i548 = 0; _i548 < _size544; ++_i548) { - xfer += this->uniqueConstraints[_i547].read(iprot); + xfer += this->uniqueConstraints[_i548].read(iprot); } xfer += iprot->readListEnd(); } @@ -15270,10 +15323,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter548; - for (_iter548 = this->uniqueConstraints.begin(); _iter548 != this->uniqueConstraints.end(); ++_iter548) + std::vector ::const_iterator _iter549; + for (_iter549 = this->uniqueConstraints.begin(); _iter549 != this->uniqueConstraints.end(); ++_iter549) { - xfer += (*_iter548).write(oprot); + xfer += (*_iter549).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15289,11 +15342,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other549) { - uniqueConstraints = other549.uniqueConstraints; -} -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other550) { +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other550) { uniqueConstraints = other550.uniqueConstraints; +} +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other551) { + uniqueConstraints = other551.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -15460,21 +15513,21 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.__isset, b.__isset); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other551) { - catName = other551.catName; - db_name = other551.db_name; - tbl_name = other551.tbl_name; - validWriteIdList = other551.validWriteIdList; - tableId = other551.tableId; - __isset = other551.__isset; -} -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other552) { +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other552) { catName = other552.catName; db_name = other552.db_name; tbl_name = other552.tbl_name; validWriteIdList = other552.validWriteIdList; tableId = other552.tableId; __isset = other552.__isset; +} +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other553) { + catName = other553.catName; + db_name = other553.db_name; + tbl_name = other553.tbl_name; + validWriteIdList = other553.validWriteIdList; + tableId = other553.tableId; + __isset = other553.__isset; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -15529,14 +15582,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size553; - ::apache::thrift::protocol::TType _etype556; - xfer += iprot->readListBegin(_etype556, _size553); - this->notNullConstraints.resize(_size553); - uint32_t _i557; - for (_i557 = 0; _i557 < _size553; ++_i557) + uint32_t _size554; + ::apache::thrift::protocol::TType _etype557; + xfer += iprot->readListBegin(_etype557, _size554); + this->notNullConstraints.resize(_size554); + uint32_t _i558; + for (_i558 = 0; _i558 < _size554; ++_i558) { - xfer += this->notNullConstraints[_i557].read(iprot); + xfer += this->notNullConstraints[_i558].read(iprot); } xfer += iprot->readListEnd(); } @@ -15567,10 +15620,10 @@ uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter558; - for (_iter558 = this->notNullConstraints.begin(); _iter558 != this->notNullConstraints.end(); ++_iter558) + std::vector ::const_iterator _iter559; + for (_iter559 = this->notNullConstraints.begin(); _iter559 != this->notNullConstraints.end(); ++_iter559) { - xfer += (*_iter558).write(oprot); + xfer += (*_iter559).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15586,11 +15639,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other559) { - notNullConstraints = other559.notNullConstraints; -} -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other560) { +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other560) { notNullConstraints = other560.notNullConstraints; +} +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other561) { + notNullConstraints = other561.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -15757,21 +15810,21 @@ void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) { swap(a.__isset, b.__isset); } -DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other561) { - catName = other561.catName; - db_name = other561.db_name; - tbl_name = other561.tbl_name; - validWriteIdList = other561.validWriteIdList; - tableId = other561.tableId; - __isset = other561.__isset; -} -DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other562) { +DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other562) { catName = other562.catName; db_name = other562.db_name; tbl_name = other562.tbl_name; validWriteIdList = other562.validWriteIdList; tableId = other562.tableId; __isset = other562.__isset; +} +DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other563) { + catName = other563.catName; + db_name = other563.db_name; + tbl_name = other563.tbl_name; + validWriteIdList = other563.validWriteIdList; + tableId = other563.tableId; + __isset = other563.__isset; return *this; } void DefaultConstraintsRequest::printTo(std::ostream& out) const { @@ -15826,14 +15879,14 @@ uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size563; - ::apache::thrift::protocol::TType _etype566; - xfer += iprot->readListBegin(_etype566, _size563); - this->defaultConstraints.resize(_size563); - uint32_t _i567; - for (_i567 = 0; _i567 < _size563; ++_i567) + uint32_t _size564; + ::apache::thrift::protocol::TType _etype567; + xfer += iprot->readListBegin(_etype567, _size564); + this->defaultConstraints.resize(_size564); + uint32_t _i568; + for (_i568 = 0; _i568 < _size564; ++_i568) { - xfer += this->defaultConstraints[_i567].read(iprot); + xfer += this->defaultConstraints[_i568].read(iprot); } xfer += iprot->readListEnd(); } @@ -15864,10 +15917,10 @@ uint32_t DefaultConstraintsResponse::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter568; - for (_iter568 = this->defaultConstraints.begin(); _iter568 != this->defaultConstraints.end(); ++_iter568) + std::vector ::const_iterator _iter569; + for (_iter569 = this->defaultConstraints.begin(); _iter569 != this->defaultConstraints.end(); ++_iter569) { - xfer += (*_iter568).write(oprot); + xfer += (*_iter569).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15883,11 +15936,11 @@ void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) { swap(a.defaultConstraints, b.defaultConstraints); } -DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other569) { - defaultConstraints = other569.defaultConstraints; -} -DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other570) { +DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other570) { defaultConstraints = other570.defaultConstraints; +} +DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other571) { + defaultConstraints = other571.defaultConstraints; return *this; } void DefaultConstraintsResponse::printTo(std::ostream& out) const { @@ -16054,21 +16107,21 @@ void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) { swap(a.__isset, b.__isset); } -CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other571) { - catName = other571.catName; - db_name = other571.db_name; - tbl_name = other571.tbl_name; - validWriteIdList = other571.validWriteIdList; - tableId = other571.tableId; - __isset = other571.__isset; -} -CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other572) { +CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other572) { catName = other572.catName; db_name = other572.db_name; tbl_name = other572.tbl_name; validWriteIdList = other572.validWriteIdList; tableId = other572.tableId; __isset = other572.__isset; +} +CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other573) { + catName = other573.catName; + db_name = other573.db_name; + tbl_name = other573.tbl_name; + validWriteIdList = other573.validWriteIdList; + tableId = other573.tableId; + __isset = other573.__isset; return *this; } void CheckConstraintsRequest::printTo(std::ostream& out) const { @@ -16123,14 +16176,14 @@ uint32_t CheckConstraintsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size573; - ::apache::thrift::protocol::TType _etype576; - xfer += iprot->readListBegin(_etype576, _size573); - this->checkConstraints.resize(_size573); - uint32_t _i577; - for (_i577 = 0; _i577 < _size573; ++_i577) + uint32_t _size574; + ::apache::thrift::protocol::TType _etype577; + xfer += iprot->readListBegin(_etype577, _size574); + this->checkConstraints.resize(_size574); + uint32_t _i578; + for (_i578 = 0; _i578 < _size574; ++_i578) { - xfer += this->checkConstraints[_i577].read(iprot); + xfer += this->checkConstraints[_i578].read(iprot); } xfer += iprot->readListEnd(); } @@ -16161,10 +16214,10 @@ uint32_t CheckConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter578; - for (_iter578 = this->checkConstraints.begin(); _iter578 != this->checkConstraints.end(); ++_iter578) + std::vector ::const_iterator _iter579; + for (_iter579 = this->checkConstraints.begin(); _iter579 != this->checkConstraints.end(); ++_iter579) { - xfer += (*_iter578).write(oprot); + xfer += (*_iter579).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16180,11 +16233,11 @@ void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) { swap(a.checkConstraints, b.checkConstraints); } -CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other579) { - checkConstraints = other579.checkConstraints; -} -CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other580) { +CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other580) { checkConstraints = other580.checkConstraints; +} +CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other581) { + checkConstraints = other581.checkConstraints; return *this; } void CheckConstraintsResponse::printTo(std::ostream& out) const { @@ -16351,21 +16404,21 @@ void swap(AllTableConstraintsRequest &a, AllTableConstraintsRequest &b) { swap(a.__isset, b.__isset); } -AllTableConstraintsRequest::AllTableConstraintsRequest(const AllTableConstraintsRequest& other581) { - dbName = other581.dbName; - tblName = other581.tblName; - catName = other581.catName; - validWriteIdList = other581.validWriteIdList; - tableId = other581.tableId; - __isset = other581.__isset; -} -AllTableConstraintsRequest& AllTableConstraintsRequest::operator=(const AllTableConstraintsRequest& other582) { +AllTableConstraintsRequest::AllTableConstraintsRequest(const AllTableConstraintsRequest& other582) { dbName = other582.dbName; tblName = other582.tblName; catName = other582.catName; validWriteIdList = other582.validWriteIdList; tableId = other582.tableId; __isset = other582.__isset; +} +AllTableConstraintsRequest& AllTableConstraintsRequest::operator=(const AllTableConstraintsRequest& other583) { + dbName = other583.dbName; + tblName = other583.tblName; + catName = other583.catName; + validWriteIdList = other583.validWriteIdList; + tableId = other583.tableId; + __isset = other583.__isset; return *this; } void AllTableConstraintsRequest::printTo(std::ostream& out) const { @@ -16457,11 +16510,11 @@ void swap(AllTableConstraintsResponse &a, AllTableConstraintsResponse &b) { swap(a.allTableConstraints, b.allTableConstraints); } -AllTableConstraintsResponse::AllTableConstraintsResponse(const AllTableConstraintsResponse& other583) { - allTableConstraints = other583.allTableConstraints; -} -AllTableConstraintsResponse& AllTableConstraintsResponse::operator=(const AllTableConstraintsResponse& other584) { +AllTableConstraintsResponse::AllTableConstraintsResponse(const AllTableConstraintsResponse& other584) { allTableConstraints = other584.allTableConstraints; +} +AllTableConstraintsResponse& AllTableConstraintsResponse::operator=(const AllTableConstraintsResponse& other585) { + allTableConstraints = other585.allTableConstraints; return *this; } void AllTableConstraintsResponse::printTo(std::ostream& out) const { @@ -16609,19 +16662,19 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.__isset, b.__isset); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other585) { - dbname = other585.dbname; - tablename = other585.tablename; - constraintname = other585.constraintname; - catName = other585.catName; - __isset = other585.__isset; -} -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other586) { +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other586) { dbname = other586.dbname; tablename = other586.tablename; constraintname = other586.constraintname; catName = other586.catName; __isset = other586.__isset; +} +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other587) { + dbname = other587.dbname; + tablename = other587.tablename; + constraintname = other587.constraintname; + catName = other587.catName; + __isset = other587.__isset; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -16675,14 +16728,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size587; - ::apache::thrift::protocol::TType _etype590; - xfer += iprot->readListBegin(_etype590, _size587); - this->primaryKeyCols.resize(_size587); - uint32_t _i591; - for (_i591 = 0; _i591 < _size587; ++_i591) + uint32_t _size588; + ::apache::thrift::protocol::TType _etype591; + xfer += iprot->readListBegin(_etype591, _size588); + this->primaryKeyCols.resize(_size588); + uint32_t _i592; + for (_i592 = 0; _i592 < _size588; ++_i592) { - xfer += this->primaryKeyCols[_i591].read(iprot); + xfer += this->primaryKeyCols[_i592].read(iprot); } xfer += iprot->readListEnd(); } @@ -16713,10 +16766,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeyCols.size())); - std::vector ::const_iterator _iter592; - for (_iter592 = this->primaryKeyCols.begin(); _iter592 != this->primaryKeyCols.end(); ++_iter592) + std::vector ::const_iterator _iter593; + for (_iter593 = this->primaryKeyCols.begin(); _iter593 != this->primaryKeyCols.end(); ++_iter593) { - xfer += (*_iter592).write(oprot); + xfer += (*_iter593).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16732,11 +16785,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other593) { - primaryKeyCols = other593.primaryKeyCols; -} -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other594) { +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other594) { primaryKeyCols = other594.primaryKeyCols; +} +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other595) { + primaryKeyCols = other595.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -16787,14 +16840,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size595; - ::apache::thrift::protocol::TType _etype598; - xfer += iprot->readListBegin(_etype598, _size595); - this->foreignKeyCols.resize(_size595); - uint32_t _i599; - for (_i599 = 0; _i599 < _size595; ++_i599) + uint32_t _size596; + ::apache::thrift::protocol::TType _etype599; + xfer += iprot->readListBegin(_etype599, _size596); + this->foreignKeyCols.resize(_size596); + uint32_t _i600; + for (_i600 = 0; _i600 < _size596; ++_i600) { - xfer += this->foreignKeyCols[_i599].read(iprot); + xfer += this->foreignKeyCols[_i600].read(iprot); } xfer += iprot->readListEnd(); } @@ -16825,10 +16878,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeyCols.size())); - std::vector ::const_iterator _iter600; - for (_iter600 = this->foreignKeyCols.begin(); _iter600 != this->foreignKeyCols.end(); ++_iter600) + std::vector ::const_iterator _iter601; + for (_iter601 = this->foreignKeyCols.begin(); _iter601 != this->foreignKeyCols.end(); ++_iter601) { - xfer += (*_iter600).write(oprot); + xfer += (*_iter601).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16844,11 +16897,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other601) { - foreignKeyCols = other601.foreignKeyCols; -} -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other602) { +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other602) { foreignKeyCols = other602.foreignKeyCols; +} +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other603) { + foreignKeyCols = other603.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -16899,14 +16952,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _etype606; - xfer += iprot->readListBegin(_etype606, _size603); - this->uniqueConstraintCols.resize(_size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size604; + ::apache::thrift::protocol::TType _etype607; + xfer += iprot->readListBegin(_etype607, _size604); + this->uniqueConstraintCols.resize(_size604); + uint32_t _i608; + for (_i608 = 0; _i608 < _size604; ++_i608) { - xfer += this->uniqueConstraintCols[_i607].read(iprot); + xfer += this->uniqueConstraintCols[_i608].read(iprot); } xfer += iprot->readListEnd(); } @@ -16937,10 +16990,10 @@ uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraintCols.size())); - std::vector ::const_iterator _iter608; - for (_iter608 = this->uniqueConstraintCols.begin(); _iter608 != this->uniqueConstraintCols.end(); ++_iter608) + std::vector ::const_iterator _iter609; + for (_iter609 = this->uniqueConstraintCols.begin(); _iter609 != this->uniqueConstraintCols.end(); ++_iter609) { - xfer += (*_iter608).write(oprot); + xfer += (*_iter609).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16956,11 +17009,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other609) { - uniqueConstraintCols = other609.uniqueConstraintCols; -} -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other610) { +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other610) { uniqueConstraintCols = other610.uniqueConstraintCols; +} +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other611) { + uniqueConstraintCols = other611.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -17011,14 +17064,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - uint32_t _size611; - ::apache::thrift::protocol::TType _etype614; - xfer += iprot->readListBegin(_etype614, _size611); - this->notNullConstraintCols.resize(_size611); - uint32_t _i615; - for (_i615 = 0; _i615 < _size611; ++_i615) + uint32_t _size612; + ::apache::thrift::protocol::TType _etype615; + xfer += iprot->readListBegin(_etype615, _size612); + this->notNullConstraintCols.resize(_size612); + uint32_t _i616; + for (_i616 = 0; _i616 < _size612; ++_i616) { - xfer += this->notNullConstraintCols[_i615].read(iprot); + xfer += this->notNullConstraintCols[_i616].read(iprot); } xfer += iprot->readListEnd(); } @@ -17049,10 +17102,10 @@ uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraintCols.size())); - std::vector ::const_iterator _iter616; - for (_iter616 = this->notNullConstraintCols.begin(); _iter616 != this->notNullConstraintCols.end(); ++_iter616) + std::vector ::const_iterator _iter617; + for (_iter617 = this->notNullConstraintCols.begin(); _iter617 != this->notNullConstraintCols.end(); ++_iter617) { - xfer += (*_iter616).write(oprot); + xfer += (*_iter617).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17068,11 +17121,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other617) { - notNullConstraintCols = other617.notNullConstraintCols; -} -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other618) { +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other618) { notNullConstraintCols = other618.notNullConstraintCols; +} +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other619) { + notNullConstraintCols = other619.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -17123,14 +17176,14 @@ uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraintCols.clear(); - uint32_t _size619; - ::apache::thrift::protocol::TType _etype622; - xfer += iprot->readListBegin(_etype622, _size619); - this->defaultConstraintCols.resize(_size619); - uint32_t _i623; - for (_i623 = 0; _i623 < _size619; ++_i623) + uint32_t _size620; + ::apache::thrift::protocol::TType _etype623; + xfer += iprot->readListBegin(_etype623, _size620); + this->defaultConstraintCols.resize(_size620); + uint32_t _i624; + for (_i624 = 0; _i624 < _size620; ++_i624) { - xfer += this->defaultConstraintCols[_i623].read(iprot); + xfer += this->defaultConstraintCols[_i624].read(iprot); } xfer += iprot->readListEnd(); } @@ -17161,10 +17214,10 @@ uint32_t AddDefaultConstraintRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("defaultConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraintCols.size())); - std::vector ::const_iterator _iter624; - for (_iter624 = this->defaultConstraintCols.begin(); _iter624 != this->defaultConstraintCols.end(); ++_iter624) + std::vector ::const_iterator _iter625; + for (_iter625 = this->defaultConstraintCols.begin(); _iter625 != this->defaultConstraintCols.end(); ++_iter625) { - xfer += (*_iter624).write(oprot); + xfer += (*_iter625).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17180,11 +17233,11 @@ void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) { swap(a.defaultConstraintCols, b.defaultConstraintCols); } -AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other625) { - defaultConstraintCols = other625.defaultConstraintCols; -} -AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other626) { +AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other626) { defaultConstraintCols = other626.defaultConstraintCols; +} +AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other627) { + defaultConstraintCols = other627.defaultConstraintCols; return *this; } void AddDefaultConstraintRequest::printTo(std::ostream& out) const { @@ -17235,14 +17288,14 @@ uint32_t AddCheckConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraintCols.clear(); - uint32_t _size627; - ::apache::thrift::protocol::TType _etype630; - xfer += iprot->readListBegin(_etype630, _size627); - this->checkConstraintCols.resize(_size627); - uint32_t _i631; - for (_i631 = 0; _i631 < _size627; ++_i631) + uint32_t _size628; + ::apache::thrift::protocol::TType _etype631; + xfer += iprot->readListBegin(_etype631, _size628); + this->checkConstraintCols.resize(_size628); + uint32_t _i632; + for (_i632 = 0; _i632 < _size628; ++_i632) { - xfer += this->checkConstraintCols[_i631].read(iprot); + xfer += this->checkConstraintCols[_i632].read(iprot); } xfer += iprot->readListEnd(); } @@ -17273,10 +17326,10 @@ uint32_t AddCheckConstraintRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("checkConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraintCols.size())); - std::vector ::const_iterator _iter632; - for (_iter632 = this->checkConstraintCols.begin(); _iter632 != this->checkConstraintCols.end(); ++_iter632) + std::vector ::const_iterator _iter633; + for (_iter633 = this->checkConstraintCols.begin(); _iter633 != this->checkConstraintCols.end(); ++_iter633) { - xfer += (*_iter632).write(oprot); + xfer += (*_iter633).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17292,11 +17345,11 @@ void swap(AddCheckConstraintRequest &a, AddCheckConstraintRequest &b) { swap(a.checkConstraintCols, b.checkConstraintCols); } -AddCheckConstraintRequest::AddCheckConstraintRequest(const AddCheckConstraintRequest& other633) { - checkConstraintCols = other633.checkConstraintCols; -} -AddCheckConstraintRequest& AddCheckConstraintRequest::operator=(const AddCheckConstraintRequest& other634) { +AddCheckConstraintRequest::AddCheckConstraintRequest(const AddCheckConstraintRequest& other634) { checkConstraintCols = other634.checkConstraintCols; +} +AddCheckConstraintRequest& AddCheckConstraintRequest::operator=(const AddCheckConstraintRequest& other635) { + checkConstraintCols = other635.checkConstraintCols; return *this; } void AddCheckConstraintRequest::printTo(std::ostream& out) const { @@ -17352,14 +17405,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size635; - ::apache::thrift::protocol::TType _etype638; - xfer += iprot->readListBegin(_etype638, _size635); - this->partitions.resize(_size635); - uint32_t _i639; - for (_i639 = 0; _i639 < _size635; ++_i639) + uint32_t _size636; + ::apache::thrift::protocol::TType _etype639; + xfer += iprot->readListBegin(_etype639, _size636); + this->partitions.resize(_size636); + uint32_t _i640; + for (_i640 = 0; _i640 < _size636; ++_i640) { - xfer += this->partitions[_i639].read(iprot); + xfer += this->partitions[_i640].read(iprot); } xfer += iprot->readListEnd(); } @@ -17400,10 +17453,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter640; - for (_iter640 = this->partitions.begin(); _iter640 != this->partitions.end(); ++_iter640) + std::vector ::const_iterator _iter641; + for (_iter641 = this->partitions.begin(); _iter641 != this->partitions.end(); ++_iter641) { - xfer += (*_iter640).write(oprot); + xfer += (*_iter641).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17424,13 +17477,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other641) { - partitions = other641.partitions; - hasUnknownPartitions = other641.hasUnknownPartitions; -} -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other642) { +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other642) { partitions = other642.partitions; hasUnknownPartitions = other642.hasUnknownPartitions; +} +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other643) { + partitions = other643.partitions; + hasUnknownPartitions = other643.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -17487,14 +17540,14 @@ uint32_t PartitionsSpecByExprResult::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionsSpec.clear(); - uint32_t _size643; - ::apache::thrift::protocol::TType _etype646; - xfer += iprot->readListBegin(_etype646, _size643); - this->partitionsSpec.resize(_size643); - uint32_t _i647; - for (_i647 = 0; _i647 < _size643; ++_i647) + uint32_t _size644; + ::apache::thrift::protocol::TType _etype647; + xfer += iprot->readListBegin(_etype647, _size644); + this->partitionsSpec.resize(_size644); + uint32_t _i648; + for (_i648 = 0; _i648 < _size644; ++_i648) { - xfer += this->partitionsSpec[_i647].read(iprot); + xfer += this->partitionsSpec[_i648].read(iprot); } xfer += iprot->readListEnd(); } @@ -17535,10 +17588,10 @@ uint32_t PartitionsSpecByExprResult::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partitionsSpec", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionsSpec.size())); - std::vector ::const_iterator _iter648; - for (_iter648 = this->partitionsSpec.begin(); _iter648 != this->partitionsSpec.end(); ++_iter648) + std::vector ::const_iterator _iter649; + for (_iter649 = this->partitionsSpec.begin(); _iter649 != this->partitionsSpec.end(); ++_iter649) { - xfer += (*_iter648).write(oprot); + xfer += (*_iter649).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17559,13 +17612,13 @@ void swap(PartitionsSpecByExprResult &a, PartitionsSpecByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsSpecByExprResult::PartitionsSpecByExprResult(const PartitionsSpecByExprResult& other649) { - partitionsSpec = other649.partitionsSpec; - hasUnknownPartitions = other649.hasUnknownPartitions; -} -PartitionsSpecByExprResult& PartitionsSpecByExprResult::operator=(const PartitionsSpecByExprResult& other650) { +PartitionsSpecByExprResult::PartitionsSpecByExprResult(const PartitionsSpecByExprResult& other650) { partitionsSpec = other650.partitionsSpec; hasUnknownPartitions = other650.hasUnknownPartitions; +} +PartitionsSpecByExprResult& PartitionsSpecByExprResult::operator=(const PartitionsSpecByExprResult& other651) { + partitionsSpec = other651.partitionsSpec; + hasUnknownPartitions = other651.hasUnknownPartitions; return *this; } void PartitionsSpecByExprResult::printTo(std::ostream& out) const { @@ -17866,22 +17919,7 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other651) { - dbName = other651.dbName; - tblName = other651.tblName; - expr = other651.expr; - defaultPartitionName = other651.defaultPartitionName; - maxParts = other651.maxParts; - catName = other651.catName; - order = other651.order; - validWriteIdList = other651.validWriteIdList; - id = other651.id; - skipColumnSchemaForPartition = other651.skipColumnSchemaForPartition; - includeParamKeyPattern = other651.includeParamKeyPattern; - excludeParamKeyPattern = other651.excludeParamKeyPattern; - __isset = other651.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other652) { +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other652) { dbName = other652.dbName; tblName = other652.tblName; expr = other652.expr; @@ -17895,6 +17933,21 @@ PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByEx includeParamKeyPattern = other652.includeParamKeyPattern; excludeParamKeyPattern = other652.excludeParamKeyPattern; __isset = other652.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other653) { + dbName = other653.dbName; + tblName = other653.tblName; + expr = other653.expr; + defaultPartitionName = other653.defaultPartitionName; + maxParts = other653.maxParts; + catName = other653.catName; + order = other653.order; + validWriteIdList = other653.validWriteIdList; + id = other653.id; + skipColumnSchemaForPartition = other653.skipColumnSchemaForPartition; + includeParamKeyPattern = other653.includeParamKeyPattern; + excludeParamKeyPattern = other653.excludeParamKeyPattern; + __isset = other653.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -17961,14 +18014,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size653; - ::apache::thrift::protocol::TType _etype656; - xfer += iprot->readListBegin(_etype656, _size653); - this->tableStats.resize(_size653); - uint32_t _i657; - for (_i657 = 0; _i657 < _size653; ++_i657) + uint32_t _size654; + ::apache::thrift::protocol::TType _etype657; + xfer += iprot->readListBegin(_etype657, _size654); + this->tableStats.resize(_size654); + uint32_t _i658; + for (_i658 = 0; _i658 < _size654; ++_i658) { - xfer += this->tableStats[_i657].read(iprot); + xfer += this->tableStats[_i658].read(iprot); } xfer += iprot->readListEnd(); } @@ -18007,10 +18060,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); - std::vector ::const_iterator _iter658; - for (_iter658 = this->tableStats.begin(); _iter658 != this->tableStats.end(); ++_iter658) + std::vector ::const_iterator _iter659; + for (_iter659 = this->tableStats.begin(); _iter659 != this->tableStats.end(); ++_iter659) { - xfer += (*_iter658).write(oprot); + xfer += (*_iter659).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18033,15 +18086,15 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.__isset, b.__isset); } -TableStatsResult::TableStatsResult(const TableStatsResult& other659) { - tableStats = other659.tableStats; - isStatsCompliant = other659.isStatsCompliant; - __isset = other659.__isset; -} -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other660) { +TableStatsResult::TableStatsResult(const TableStatsResult& other660) { tableStats = other660.tableStats; isStatsCompliant = other660.isStatsCompliant; __isset = other660.__isset; +} +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other661) { + tableStats = other661.tableStats; + isStatsCompliant = other661.isStatsCompliant; + __isset = other661.__isset; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -18098,26 +18151,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size661; - ::apache::thrift::protocol::TType _ktype662; - ::apache::thrift::protocol::TType _vtype663; - xfer += iprot->readMapBegin(_ktype662, _vtype663, _size661); - uint32_t _i665; - for (_i665 = 0; _i665 < _size661; ++_i665) + uint32_t _size662; + ::apache::thrift::protocol::TType _ktype663; + ::apache::thrift::protocol::TType _vtype664; + xfer += iprot->readMapBegin(_ktype663, _vtype664, _size662); + uint32_t _i666; + for (_i666 = 0; _i666 < _size662; ++_i666) { - std::string _key666; - xfer += iprot->readString(_key666); - std::vector & _val667 = this->partStats[_key666]; + std::string _key667; + xfer += iprot->readString(_key667); + std::vector & _val668 = this->partStats[_key667]; { - _val667.clear(); - uint32_t _size668; - ::apache::thrift::protocol::TType _etype671; - xfer += iprot->readListBegin(_etype671, _size668); - _val667.resize(_size668); - uint32_t _i672; - for (_i672 = 0; _i672 < _size668; ++_i672) + _val668.clear(); + uint32_t _size669; + ::apache::thrift::protocol::TType _etype672; + xfer += iprot->readListBegin(_etype672, _size669); + _val668.resize(_size669); + uint32_t _i673; + for (_i673 = 0; _i673 < _size669; ++_i673) { - xfer += _val667[_i672].read(iprot); + xfer += _val668[_i673].read(iprot); } xfer += iprot->readListEnd(); } @@ -18159,16 +18212,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); - std::map > ::const_iterator _iter673; - for (_iter673 = this->partStats.begin(); _iter673 != this->partStats.end(); ++_iter673) + std::map > ::const_iterator _iter674; + for (_iter674 = this->partStats.begin(); _iter674 != this->partStats.end(); ++_iter674) { - xfer += oprot->writeString(_iter673->first); + xfer += oprot->writeString(_iter674->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter673->second.size())); - std::vector ::const_iterator _iter674; - for (_iter674 = _iter673->second.begin(); _iter674 != _iter673->second.end(); ++_iter674) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter674->second.size())); + std::vector ::const_iterator _iter675; + for (_iter675 = _iter674->second.begin(); _iter675 != _iter674->second.end(); ++_iter675) { - xfer += (*_iter674).write(oprot); + xfer += (*_iter675).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18194,15 +18247,15 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.__isset, b.__isset); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other675) { - partStats = other675.partStats; - isStatsCompliant = other675.isStatsCompliant; - __isset = other675.__isset; -} -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other676) { +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other676) { partStats = other676.partStats; isStatsCompliant = other676.isStatsCompliant; __isset = other676.__isset; +} +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other677) { + partStats = other677.partStats; + isStatsCompliant = other677.isStatsCompliant; + __isset = other677.__isset; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -18300,14 +18353,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size677; - ::apache::thrift::protocol::TType _etype680; - xfer += iprot->readListBegin(_etype680, _size677); - this->colNames.resize(_size677); - uint32_t _i681; - for (_i681 = 0; _i681 < _size677; ++_i681) + uint32_t _size678; + ::apache::thrift::protocol::TType _etype681; + xfer += iprot->readListBegin(_etype681, _size678); + this->colNames.resize(_size678); + uint32_t _i682; + for (_i682 = 0; _i682 < _size678; ++_i682) { - xfer += iprot->readString(this->colNames[_i681]); + xfer += iprot->readString(this->colNames[_i682]); } xfer += iprot->readListEnd(); } @@ -18382,10 +18435,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter682; - for (_iter682 = this->colNames.begin(); _iter682 != this->colNames.end(); ++_iter682) + std::vector ::const_iterator _iter683; + for (_iter683 = this->colNames.begin(); _iter683 != this->colNames.end(); ++_iter683) { - xfer += oprot->writeString((*_iter682)); + xfer += oprot->writeString((*_iter683)); } xfer += oprot->writeListEnd(); } @@ -18428,17 +18481,7 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.__isset, b.__isset); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other683) { - dbName = other683.dbName; - tblName = other683.tblName; - colNames = other683.colNames; - catName = other683.catName; - validWriteIdList = other683.validWriteIdList; - engine = other683.engine; - id = other683.id; - __isset = other683.__isset; -} -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other684) { +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other684) { dbName = other684.dbName; tblName = other684.tblName; colNames = other684.colNames; @@ -18447,6 +18490,16 @@ TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other68 engine = other684.engine; id = other684.id; __isset = other684.__isset; +} +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other685) { + dbName = other685.dbName; + tblName = other685.tblName; + colNames = other685.colNames; + catName = other685.catName; + validWriteIdList = other685.validWriteIdList; + engine = other685.engine; + id = other685.id; + __isset = other685.__isset; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -18549,14 +18602,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size685; - ::apache::thrift::protocol::TType _etype688; - xfer += iprot->readListBegin(_etype688, _size685); - this->colNames.resize(_size685); - uint32_t _i689; - for (_i689 = 0; _i689 < _size685; ++_i689) + uint32_t _size686; + ::apache::thrift::protocol::TType _etype689; + xfer += iprot->readListBegin(_etype689, _size686); + this->colNames.resize(_size686); + uint32_t _i690; + for (_i690 = 0; _i690 < _size686; ++_i690) { - xfer += iprot->readString(this->colNames[_i689]); + xfer += iprot->readString(this->colNames[_i690]); } xfer += iprot->readListEnd(); } @@ -18569,14 +18622,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - this->partNames.resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size691; + ::apache::thrift::protocol::TType _etype694; + xfer += iprot->readListBegin(_etype694, _size691); + this->partNames.resize(_size691); + uint32_t _i695; + for (_i695 = 0; _i695 < _size691; ++_i695) { - xfer += iprot->readString(this->partNames[_i694]); + xfer += iprot->readString(this->partNames[_i695]); } xfer += iprot->readListEnd(); } @@ -18645,10 +18698,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter695; - for (_iter695 = this->colNames.begin(); _iter695 != this->colNames.end(); ++_iter695) + std::vector ::const_iterator _iter696; + for (_iter696 = this->colNames.begin(); _iter696 != this->colNames.end(); ++_iter696) { - xfer += oprot->writeString((*_iter695)); + xfer += oprot->writeString((*_iter696)); } xfer += oprot->writeListEnd(); } @@ -18657,10 +18710,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter696; - for (_iter696 = this->partNames.begin(); _iter696 != this->partNames.end(); ++_iter696) + std::vector ::const_iterator _iter697; + for (_iter697 = this->partNames.begin(); _iter697 != this->partNames.end(); ++_iter697) { - xfer += oprot->writeString((*_iter696)); + xfer += oprot->writeString((*_iter697)); } xfer += oprot->writeListEnd(); } @@ -18698,17 +18751,7 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other697) { - dbName = other697.dbName; - tblName = other697.tblName; - colNames = other697.colNames; - partNames = other697.partNames; - catName = other697.catName; - validWriteIdList = other697.validWriteIdList; - engine = other697.engine; - __isset = other697.__isset; -} -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other698) { +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other698) { dbName = other698.dbName; tblName = other698.tblName; colNames = other698.colNames; @@ -18717,6 +18760,16 @@ PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsR validWriteIdList = other698.validWriteIdList; engine = other698.engine; __isset = other698.__isset; +} +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other699) { + dbName = other699.dbName; + tblName = other699.tblName; + colNames = other699.colNames; + partNames = other699.partNames; + catName = other699.catName; + validWriteIdList = other699.validWriteIdList; + engine = other699.engine; + __isset = other699.__isset; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -18783,14 +18836,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size699; - ::apache::thrift::protocol::TType _etype702; - xfer += iprot->readListBegin(_etype702, _size699); - this->partitions.resize(_size699); - uint32_t _i703; - for (_i703 = 0; _i703 < _size699; ++_i703) + uint32_t _size700; + ::apache::thrift::protocol::TType _etype703; + xfer += iprot->readListBegin(_etype703, _size700); + this->partitions.resize(_size700); + uint32_t _i704; + for (_i704 = 0; _i704 < _size700; ++_i704) { - xfer += this->partitions[_i703].read(iprot); + xfer += this->partitions[_i704].read(iprot); } xfer += iprot->readListEnd(); } @@ -18811,14 +18864,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionColSchema.clear(); - uint32_t _size704; - ::apache::thrift::protocol::TType _etype707; - xfer += iprot->readListBegin(_etype707, _size704); - this->partitionColSchema.resize(_size704); - uint32_t _i708; - for (_i708 = 0; _i708 < _size704; ++_i708) + uint32_t _size705; + ::apache::thrift::protocol::TType _etype708; + xfer += iprot->readListBegin(_etype708, _size705); + this->partitionColSchema.resize(_size705); + uint32_t _i709; + for (_i709 = 0; _i709 < _size705; ++_i709) { - xfer += this->partitionColSchema[_i708].read(iprot); + xfer += this->partitionColSchema[_i709].read(iprot); } xfer += iprot->readListEnd(); } @@ -18848,10 +18901,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter709; - for (_iter709 = this->partitions.begin(); _iter709 != this->partitions.end(); ++_iter709) + std::vector ::const_iterator _iter710; + for (_iter710 = this->partitions.begin(); _iter710 != this->partitions.end(); ++_iter710) { - xfer += (*_iter709).write(oprot); + xfer += (*_iter710).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18866,10 +18919,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); - std::vector ::const_iterator _iter710; - for (_iter710 = this->partitionColSchema.begin(); _iter710 != this->partitionColSchema.end(); ++_iter710) + std::vector ::const_iterator _iter711; + for (_iter711 = this->partitionColSchema.begin(); _iter711 != this->partitionColSchema.end(); ++_iter711) { - xfer += (*_iter710).write(oprot); + xfer += (*_iter711).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18888,17 +18941,17 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other711) { - partitions = other711.partitions; - isStatsCompliant = other711.isStatsCompliant; - partitionColSchema = other711.partitionColSchema; - __isset = other711.__isset; -} -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other712) { +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other712) { partitions = other712.partitions; isStatsCompliant = other712.isStatsCompliant; partitionColSchema = other712.partitionColSchema; __isset = other712.__isset; +} +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other713) { + partitions = other713.partitions; + isStatsCompliant = other713.isStatsCompliant; + partitionColSchema = other713.partitionColSchema; + __isset = other713.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -19012,14 +19065,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size713; - ::apache::thrift::protocol::TType _etype716; - xfer += iprot->readListBegin(_etype716, _size713); - this->parts.resize(_size713); - uint32_t _i717; - for (_i717 = 0; _i717 < _size713; ++_i717) + uint32_t _size714; + ::apache::thrift::protocol::TType _etype717; + xfer += iprot->readListBegin(_etype717, _size714); + this->parts.resize(_size714); + uint32_t _i718; + for (_i718 = 0; _i718 < _size714; ++_i718) { - xfer += this->parts[_i717].read(iprot); + xfer += this->parts[_i718].read(iprot); } xfer += iprot->readListEnd(); } @@ -19072,14 +19125,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionColSchema.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _etype721; - xfer += iprot->readListBegin(_etype721, _size718); - this->partitionColSchema.resize(_size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + uint32_t _size719; + ::apache::thrift::protocol::TType _etype722; + xfer += iprot->readListBegin(_etype722, _size719); + this->partitionColSchema.resize(_size719); + uint32_t _i723; + for (_i723 = 0; _i723 < _size719; ++_i723) { - xfer += this->partitionColSchema[_i722].read(iprot); + xfer += this->partitionColSchema[_i723].read(iprot); } xfer += iprot->readListEnd(); } @@ -19132,10 +19185,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); - std::vector ::const_iterator _iter723; - for (_iter723 = this->parts.begin(); _iter723 != this->parts.end(); ++_iter723) + std::vector ::const_iterator _iter724; + for (_iter724 = this->parts.begin(); _iter724 != this->parts.end(); ++_iter724) { - xfer += (*_iter723).write(oprot); + xfer += (*_iter724).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19169,10 +19222,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); - std::vector ::const_iterator _iter724; - for (_iter724 = this->partitionColSchema.begin(); _iter724 != this->partitionColSchema.end(); ++_iter724) + std::vector ::const_iterator _iter725; + for (_iter725 = this->partitionColSchema.begin(); _iter725 != this->partitionColSchema.end(); ++_iter725) { - xfer += (*_iter724).write(oprot); + xfer += (*_iter725).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19203,20 +19256,7 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other725) { - dbName = other725.dbName; - tblName = other725.tblName; - parts = other725.parts; - ifNotExists = other725.ifNotExists; - needResult = other725.needResult; - catName = other725.catName; - validWriteIdList = other725.validWriteIdList; - skipColumnSchemaForPartition = other725.skipColumnSchemaForPartition; - partitionColSchema = other725.partitionColSchema; - environmentContext = other725.environmentContext; - __isset = other725.__isset; -} -AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other726) { +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other726) { dbName = other726.dbName; tblName = other726.tblName; parts = other726.parts; @@ -19228,6 +19268,19 @@ AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest partitionColSchema = other726.partitionColSchema; environmentContext = other726.environmentContext; __isset = other726.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other727) { + dbName = other727.dbName; + tblName = other727.tblName; + parts = other727.parts; + ifNotExists = other727.ifNotExists; + needResult = other727.needResult; + catName = other727.catName; + validWriteIdList = other727.validWriteIdList; + skipColumnSchemaForPartition = other727.skipColumnSchemaForPartition; + partitionColSchema = other727.partitionColSchema; + environmentContext = other727.environmentContext; + __isset = other727.__isset; return *this; } void AddPartitionsRequest::printTo(std::ostream& out) const { @@ -19287,14 +19340,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size727; - ::apache::thrift::protocol::TType _etype730; - xfer += iprot->readListBegin(_etype730, _size727); - this->partitions.resize(_size727); - uint32_t _i731; - for (_i731 = 0; _i731 < _size727; ++_i731) + uint32_t _size728; + ::apache::thrift::protocol::TType _etype731; + xfer += iprot->readListBegin(_etype731, _size728); + this->partitions.resize(_size728); + uint32_t _i732; + for (_i732 = 0; _i732 < _size728; ++_i732) { - xfer += this->partitions[_i731].read(iprot); + xfer += this->partitions[_i732].read(iprot); } xfer += iprot->readListEnd(); } @@ -19324,10 +19377,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter732; - for (_iter732 = this->partitions.begin(); _iter732 != this->partitions.end(); ++_iter732) + std::vector ::const_iterator _iter733; + for (_iter733 = this->partitions.begin(); _iter733 != this->partitions.end(); ++_iter733) { - xfer += (*_iter732).write(oprot); + xfer += (*_iter733).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19344,13 +19397,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { swap(a.__isset, b.__isset); } -DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other733) { - partitions = other733.partitions; - __isset = other733.__isset; -} -DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other734) { +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other734) { partitions = other734.partitions; __isset = other734.__isset; +} +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other735) { + partitions = other735.partitions; + __isset = other735.__isset; return *this; } void DropPartitionsResult::printTo(std::ostream& out) const { @@ -19458,15 +19511,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { swap(a.__isset, b.__isset); } -DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other735) { - expr = other735.expr; - partArchiveLevel = other735.partArchiveLevel; - __isset = other735.__isset; -} -DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other736) { +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other736) { expr = other736.expr; partArchiveLevel = other736.partArchiveLevel; __isset = other736.__isset; +} +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other737) { + expr = other737.expr; + partArchiveLevel = other737.partArchiveLevel; + __isset = other737.__isset; return *this; } void DropPartitionsExpr::printTo(std::ostream& out) const { @@ -19523,14 +19576,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size737; - ::apache::thrift::protocol::TType _etype740; - xfer += iprot->readListBegin(_etype740, _size737); - this->names.resize(_size737); - uint32_t _i741; - for (_i741 = 0; _i741 < _size737; ++_i741) + uint32_t _size738; + ::apache::thrift::protocol::TType _etype741; + xfer += iprot->readListBegin(_etype741, _size738); + this->names.resize(_size738); + uint32_t _i742; + for (_i742 = 0; _i742 < _size738; ++_i742) { - xfer += iprot->readString(this->names[_i741]); + xfer += iprot->readString(this->names[_i742]); } xfer += iprot->readListEnd(); } @@ -19543,14 +19596,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size742; - ::apache::thrift::protocol::TType _etype745; - xfer += iprot->readListBegin(_etype745, _size742); - this->exprs.resize(_size742); - uint32_t _i746; - for (_i746 = 0; _i746 < _size742; ++_i746) + uint32_t _size743; + ::apache::thrift::protocol::TType _etype746; + xfer += iprot->readListBegin(_etype746, _size743); + this->exprs.resize(_size743); + uint32_t _i747; + for (_i747 = 0; _i747 < _size743; ++_i747) { - xfer += this->exprs[_i746].read(iprot); + xfer += this->exprs[_i747].read(iprot); } xfer += iprot->readListEnd(); } @@ -19580,10 +19633,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter747; - for (_iter747 = this->names.begin(); _iter747 != this->names.end(); ++_iter747) + std::vector ::const_iterator _iter748; + for (_iter748 = this->names.begin(); _iter748 != this->names.end(); ++_iter748) { - xfer += oprot->writeString((*_iter747)); + xfer += oprot->writeString((*_iter748)); } xfer += oprot->writeListEnd(); } @@ -19593,10 +19646,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); - std::vector ::const_iterator _iter748; - for (_iter748 = this->exprs.begin(); _iter748 != this->exprs.end(); ++_iter748) + std::vector ::const_iterator _iter749; + for (_iter749 = this->exprs.begin(); _iter749 != this->exprs.end(); ++_iter749) { - xfer += (*_iter748).write(oprot); + xfer += (*_iter749).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19614,15 +19667,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { swap(a.__isset, b.__isset); } -RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other749) { - names = other749.names; - exprs = other749.exprs; - __isset = other749.__isset; -} -RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other750) { +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other750) { names = other750.names; exprs = other750.exprs; __isset = other750.__isset; +} +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other751) { + names = other751.names; + exprs = other751.exprs; + __isset = other751.__isset; return *this; } void RequestPartsSpec::printTo(std::ostream& out) const { @@ -19885,20 +19938,7 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other751) { - dbName = other751.dbName; - tblName = other751.tblName; - parts = other751.parts; - deleteData = other751.deleteData; - ifExists = other751.ifExists; - ignoreProtection = other751.ignoreProtection; - environmentContext = other751.environmentContext; - needResult = other751.needResult; - catName = other751.catName; - skipColumnSchemaForPartition = other751.skipColumnSchemaForPartition; - __isset = other751.__isset; -} -DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other752) { +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other752) { dbName = other752.dbName; tblName = other752.tblName; parts = other752.parts; @@ -19910,6 +19950,19 @@ DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequ catName = other752.catName; skipColumnSchemaForPartition = other752.skipColumnSchemaForPartition; __isset = other752.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other753) { + dbName = other753.dbName; + tblName = other753.tblName; + parts = other753.parts; + deleteData = other753.deleteData; + ifExists = other753.ifExists; + ignoreProtection = other753.ignoreProtection; + environmentContext = other753.environmentContext; + needResult = other753.needResult; + catName = other753.catName; + skipColumnSchemaForPartition = other753.skipColumnSchemaForPartition; + __isset = other753.__isset; return *this; } void DropPartitionsRequest::printTo(std::ostream& out) const { @@ -20031,14 +20084,14 @@ uint32_t DropPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size753; - ::apache::thrift::protocol::TType _etype756; - xfer += iprot->readListBegin(_etype756, _size753); - this->partVals.resize(_size753); - uint32_t _i757; - for (_i757 = 0; _i757 < _size753; ++_i757) + uint32_t _size754; + ::apache::thrift::protocol::TType _etype757; + xfer += iprot->readListBegin(_etype757, _size754); + this->partVals.resize(_size754); + uint32_t _i758; + for (_i758 = 0; _i758 < _size754; ++_i758) { - xfer += iprot->readString(this->partVals[_i757]); + xfer += iprot->readString(this->partVals[_i758]); } xfer += iprot->readListEnd(); } @@ -20106,10 +20159,10 @@ uint32_t DropPartitionRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter758; - for (_iter758 = this->partVals.begin(); _iter758 != this->partVals.end(); ++_iter758) + std::vector ::const_iterator _iter759; + for (_iter759 = this->partVals.begin(); _iter759 != this->partVals.end(); ++_iter759) { - xfer += oprot->writeString((*_iter758)); + xfer += oprot->writeString((*_iter759)); } xfer += oprot->writeListEnd(); } @@ -20142,17 +20195,7 @@ void swap(DropPartitionRequest &a, DropPartitionRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionRequest::DropPartitionRequest(const DropPartitionRequest& other759) { - catName = other759.catName; - dbName = other759.dbName; - tblName = other759.tblName; - partName = other759.partName; - partVals = other759.partVals; - deleteData = other759.deleteData; - environmentContext = other759.environmentContext; - __isset = other759.__isset; -} -DropPartitionRequest& DropPartitionRequest::operator=(const DropPartitionRequest& other760) { +DropPartitionRequest::DropPartitionRequest(const DropPartitionRequest& other760) { catName = other760.catName; dbName = other760.dbName; tblName = other760.tblName; @@ -20161,6 +20204,16 @@ DropPartitionRequest& DropPartitionRequest::operator=(const DropPartitionRequest deleteData = other760.deleteData; environmentContext = other760.environmentContext; __isset = other760.__isset; +} +DropPartitionRequest& DropPartitionRequest::operator=(const DropPartitionRequest& other761) { + catName = other761.catName; + dbName = other761.dbName; + tblName = other761.tblName; + partName = other761.partName; + partVals = other761.partVals; + deleteData = other761.deleteData; + environmentContext = other761.environmentContext; + __isset = other761.__isset; return *this; } void DropPartitionRequest::printTo(std::ostream& out) const { @@ -20278,14 +20331,14 @@ uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size761; - ::apache::thrift::protocol::TType _etype764; - xfer += iprot->readListBegin(_etype764, _size761); - this->partitionKeys.resize(_size761); - uint32_t _i765; - for (_i765 = 0; _i765 < _size761; ++_i765) + uint32_t _size762; + ::apache::thrift::protocol::TType _etype765; + xfer += iprot->readListBegin(_etype765, _size762); + this->partitionKeys.resize(_size762); + uint32_t _i766; + for (_i766 = 0; _i766 < _size762; ++_i766) { - xfer += this->partitionKeys[_i765].read(iprot); + xfer += this->partitionKeys[_i766].read(iprot); } xfer += iprot->readListEnd(); } @@ -20314,14 +20367,14 @@ uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionOrder.clear(); - uint32_t _size766; - ::apache::thrift::protocol::TType _etype769; - xfer += iprot->readListBegin(_etype769, _size766); - this->partitionOrder.resize(_size766); - uint32_t _i770; - for (_i770 = 0; _i770 < _size766; ++_i770) + uint32_t _size767; + ::apache::thrift::protocol::TType _etype770; + xfer += iprot->readListBegin(_etype770, _size767); + this->partitionOrder.resize(_size767); + uint32_t _i771; + for (_i771 = 0; _i771 < _size767; ++_i771) { - xfer += this->partitionOrder[_i770].read(iprot); + xfer += this->partitionOrder[_i771].read(iprot); } xfer += iprot->readListEnd(); } @@ -20396,10 +20449,10 @@ uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); - std::vector ::const_iterator _iter771; - for (_iter771 = this->partitionKeys.begin(); _iter771 != this->partitionKeys.end(); ++_iter771) + std::vector ::const_iterator _iter772; + for (_iter772 = this->partitionKeys.begin(); _iter772 != this->partitionKeys.end(); ++_iter772) { - xfer += (*_iter771).write(oprot); + xfer += (*_iter772).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20419,10 +20472,10 @@ uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionOrder", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionOrder.size())); - std::vector ::const_iterator _iter772; - for (_iter772 = this->partitionOrder.begin(); _iter772 != this->partitionOrder.end(); ++_iter772) + std::vector ::const_iterator _iter773; + for (_iter773 = this->partitionOrder.begin(); _iter773 != this->partitionOrder.end(); ++_iter773) { - xfer += (*_iter772).write(oprot); + xfer += (*_iter773).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20468,20 +20521,7 @@ void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) { swap(a.__isset, b.__isset); } -PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other773) { - dbName = other773.dbName; - tblName = other773.tblName; - partitionKeys = other773.partitionKeys; - applyDistinct = other773.applyDistinct; - filter = other773.filter; - partitionOrder = other773.partitionOrder; - ascending = other773.ascending; - maxParts = other773.maxParts; - catName = other773.catName; - validWriteIdList = other773.validWriteIdList; - __isset = other773.__isset; -} -PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other774) { +PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other774) { dbName = other774.dbName; tblName = other774.tblName; partitionKeys = other774.partitionKeys; @@ -20493,6 +20533,19 @@ PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesR catName = other774.catName; validWriteIdList = other774.validWriteIdList; __isset = other774.__isset; +} +PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other775) { + dbName = other775.dbName; + tblName = other775.tblName; + partitionKeys = other775.partitionKeys; + applyDistinct = other775.applyDistinct; + filter = other775.filter; + partitionOrder = other775.partitionOrder; + ascending = other775.ascending; + maxParts = other775.maxParts; + catName = other775.catName; + validWriteIdList = other775.validWriteIdList; + __isset = other775.__isset; return *this; } void PartitionValuesRequest::printTo(std::ostream& out) const { @@ -20552,14 +20605,14 @@ uint32_t PartitionValuesRow::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->row.clear(); - uint32_t _size775; - ::apache::thrift::protocol::TType _etype778; - xfer += iprot->readListBegin(_etype778, _size775); - this->row.resize(_size775); - uint32_t _i779; - for (_i779 = 0; _i779 < _size775; ++_i779) + uint32_t _size776; + ::apache::thrift::protocol::TType _etype779; + xfer += iprot->readListBegin(_etype779, _size776); + this->row.resize(_size776); + uint32_t _i780; + for (_i780 = 0; _i780 < _size776; ++_i780) { - xfer += iprot->readString(this->row[_i779]); + xfer += iprot->readString(this->row[_i780]); } xfer += iprot->readListEnd(); } @@ -20590,10 +20643,10 @@ uint32_t PartitionValuesRow::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->row.size())); - std::vector ::const_iterator _iter780; - for (_iter780 = this->row.begin(); _iter780 != this->row.end(); ++_iter780) + std::vector ::const_iterator _iter781; + for (_iter781 = this->row.begin(); _iter781 != this->row.end(); ++_iter781) { - xfer += oprot->writeString((*_iter780)); + xfer += oprot->writeString((*_iter781)); } xfer += oprot->writeListEnd(); } @@ -20609,11 +20662,11 @@ void swap(PartitionValuesRow &a, PartitionValuesRow &b) { swap(a.row, b.row); } -PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other781) { - row = other781.row; -} -PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other782) { +PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other782) { row = other782.row; +} +PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other783) { + row = other783.row; return *this; } void PartitionValuesRow::printTo(std::ostream& out) const { @@ -20664,14 +20717,14 @@ uint32_t PartitionValuesResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionValues.clear(); - uint32_t _size783; - ::apache::thrift::protocol::TType _etype786; - xfer += iprot->readListBegin(_etype786, _size783); - this->partitionValues.resize(_size783); - uint32_t _i787; - for (_i787 = 0; _i787 < _size783; ++_i787) + uint32_t _size784; + ::apache::thrift::protocol::TType _etype787; + xfer += iprot->readListBegin(_etype787, _size784); + this->partitionValues.resize(_size784); + uint32_t _i788; + for (_i788 = 0; _i788 < _size784; ++_i788) { - xfer += this->partitionValues[_i787].read(iprot); + xfer += this->partitionValues[_i788].read(iprot); } xfer += iprot->readListEnd(); } @@ -20702,10 +20755,10 @@ uint32_t PartitionValuesResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("partitionValues", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionValues.size())); - std::vector ::const_iterator _iter788; - for (_iter788 = this->partitionValues.begin(); _iter788 != this->partitionValues.end(); ++_iter788) + std::vector ::const_iterator _iter789; + for (_iter789 = this->partitionValues.begin(); _iter789 != this->partitionValues.end(); ++_iter789) { - xfer += (*_iter788).write(oprot); + xfer += (*_iter789).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20721,11 +20774,11 @@ void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) { swap(a.partitionValues, b.partitionValues); } -PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other789) { - partitionValues = other789.partitionValues; -} -PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other790) { +PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other790) { partitionValues = other790.partitionValues; +} +PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other791) { + partitionValues = other791.partitionValues; return *this; } void PartitionValuesResponse::printTo(std::ostream& out) const { @@ -20852,14 +20905,14 @@ uint32_t GetPartitionsByNamesRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size791; - ::apache::thrift::protocol::TType _etype794; - xfer += iprot->readListBegin(_etype794, _size791); - this->names.resize(_size791); - uint32_t _i795; - for (_i795 = 0; _i795 < _size791; ++_i795) + uint32_t _size792; + ::apache::thrift::protocol::TType _etype795; + xfer += iprot->readListBegin(_etype795, _size792); + this->names.resize(_size792); + uint32_t _i796; + for (_i796 = 0; _i796 < _size792; ++_i796) { - xfer += iprot->readString(this->names[_i795]); + xfer += iprot->readString(this->names[_i796]); } xfer += iprot->readListEnd(); } @@ -20880,14 +20933,14 @@ uint32_t GetPartitionsByNamesRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size796; - ::apache::thrift::protocol::TType _etype799; - xfer += iprot->readListBegin(_etype799, _size796); - this->processorCapabilities.resize(_size796); - uint32_t _i800; - for (_i800 = 0; _i800 < _size796; ++_i800) + uint32_t _size797; + ::apache::thrift::protocol::TType _etype800; + xfer += iprot->readListBegin(_etype800, _size797); + this->processorCapabilities.resize(_size797); + uint32_t _i801; + for (_i801 = 0; _i801 < _size797; ++_i801) { - xfer += iprot->readString(this->processorCapabilities[_i800]); + xfer += iprot->readString(this->processorCapabilities[_i801]); } xfer += iprot->readListEnd(); } @@ -20993,10 +21046,10 @@ uint32_t GetPartitionsByNamesRequest::write(::apache::thrift::protocol::TProtoco 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 _iter801; - for (_iter801 = this->names.begin(); _iter801 != this->names.end(); ++_iter801) + std::vector ::const_iterator _iter802; + for (_iter802 = this->names.begin(); _iter802 != this->names.end(); ++_iter802) { - xfer += oprot->writeString((*_iter801)); + xfer += oprot->writeString((*_iter802)); } xfer += oprot->writeListEnd(); } @@ -21011,10 +21064,10 @@ uint32_t GetPartitionsByNamesRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter802; - for (_iter802 = this->processorCapabilities.begin(); _iter802 != this->processorCapabilities.end(); ++_iter802) + std::vector ::const_iterator _iter803; + for (_iter803 = this->processorCapabilities.begin(); _iter803 != this->processorCapabilities.end(); ++_iter803) { - xfer += oprot->writeString((*_iter802)); + xfer += oprot->writeString((*_iter803)); } xfer += oprot->writeListEnd(); } @@ -21083,23 +21136,7 @@ void swap(GetPartitionsByNamesRequest &a, GetPartitionsByNamesRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsByNamesRequest::GetPartitionsByNamesRequest(const GetPartitionsByNamesRequest& other803) { - db_name = other803.db_name; - tbl_name = other803.tbl_name; - names = other803.names; - get_col_stats = other803.get_col_stats; - processorCapabilities = other803.processorCapabilities; - processorIdentifier = other803.processorIdentifier; - engine = other803.engine; - validWriteIdList = other803.validWriteIdList; - getFileMetadata = other803.getFileMetadata; - id = other803.id; - skipColumnSchemaForPartition = other803.skipColumnSchemaForPartition; - includeParamKeyPattern = other803.includeParamKeyPattern; - excludeParamKeyPattern = other803.excludeParamKeyPattern; - __isset = other803.__isset; -} -GetPartitionsByNamesRequest& GetPartitionsByNamesRequest::operator=(const GetPartitionsByNamesRequest& other804) { +GetPartitionsByNamesRequest::GetPartitionsByNamesRequest(const GetPartitionsByNamesRequest& other804) { db_name = other804.db_name; tbl_name = other804.tbl_name; names = other804.names; @@ -21114,6 +21151,22 @@ GetPartitionsByNamesRequest& GetPartitionsByNamesRequest::operator=(const GetPar includeParamKeyPattern = other804.includeParamKeyPattern; excludeParamKeyPattern = other804.excludeParamKeyPattern; __isset = other804.__isset; +} +GetPartitionsByNamesRequest& GetPartitionsByNamesRequest::operator=(const GetPartitionsByNamesRequest& other805) { + db_name = other805.db_name; + tbl_name = other805.tbl_name; + names = other805.names; + get_col_stats = other805.get_col_stats; + processorCapabilities = other805.processorCapabilities; + processorIdentifier = other805.processorIdentifier; + engine = other805.engine; + validWriteIdList = other805.validWriteIdList; + getFileMetadata = other805.getFileMetadata; + id = other805.id; + skipColumnSchemaForPartition = other805.skipColumnSchemaForPartition; + includeParamKeyPattern = other805.includeParamKeyPattern; + excludeParamKeyPattern = other805.excludeParamKeyPattern; + __isset = other805.__isset; return *this; } void GetPartitionsByNamesRequest::printTo(std::ostream& out) const { @@ -21181,14 +21234,14 @@ uint32_t GetPartitionsByNamesResult::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size805; - ::apache::thrift::protocol::TType _etype808; - xfer += iprot->readListBegin(_etype808, _size805); - this->partitions.resize(_size805); - uint32_t _i809; - for (_i809 = 0; _i809 < _size805; ++_i809) + uint32_t _size806; + ::apache::thrift::protocol::TType _etype809; + xfer += iprot->readListBegin(_etype809, _size806); + this->partitions.resize(_size806); + uint32_t _i810; + for (_i810 = 0; _i810 < _size806; ++_i810) { - xfer += this->partitions[_i809].read(iprot); + xfer += this->partitions[_i810].read(iprot); } xfer += iprot->readListEnd(); } @@ -21227,10 +21280,10 @@ uint32_t GetPartitionsByNamesResult::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter810; - for (_iter810 = this->partitions.begin(); _iter810 != this->partitions.end(); ++_iter810) + std::vector ::const_iterator _iter811; + for (_iter811 = this->partitions.begin(); _iter811 != this->partitions.end(); ++_iter811) { - xfer += (*_iter810).write(oprot); + xfer += (*_iter811).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21253,15 +21306,15 @@ void swap(GetPartitionsByNamesResult &a, GetPartitionsByNamesResult &b) { swap(a.__isset, b.__isset); } -GetPartitionsByNamesResult::GetPartitionsByNamesResult(const GetPartitionsByNamesResult& other811) { - partitions = other811.partitions; - dictionary = other811.dictionary; - __isset = other811.__isset; -} -GetPartitionsByNamesResult& GetPartitionsByNamesResult::operator=(const GetPartitionsByNamesResult& other812) { +GetPartitionsByNamesResult::GetPartitionsByNamesResult(const GetPartitionsByNamesResult& other812) { partitions = other812.partitions; dictionary = other812.dictionary; __isset = other812.__isset; +} +GetPartitionsByNamesResult& GetPartitionsByNamesResult::operator=(const GetPartitionsByNamesResult& other813) { + partitions = other813.partitions; + dictionary = other813.dictionary; + __isset = other813.__isset; return *this; } void GetPartitionsByNamesResult::printTo(std::ostream& out) const { @@ -21377,17 +21430,17 @@ uint32_t DataConnector::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size813; - ::apache::thrift::protocol::TType _ktype814; - ::apache::thrift::protocol::TType _vtype815; - xfer += iprot->readMapBegin(_ktype814, _vtype815, _size813); - uint32_t _i817; - for (_i817 = 0; _i817 < _size813; ++_i817) + uint32_t _size814; + ::apache::thrift::protocol::TType _ktype815; + ::apache::thrift::protocol::TType _vtype816; + xfer += iprot->readMapBegin(_ktype815, _vtype816, _size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - std::string _key818; - xfer += iprot->readString(_key818); - std::string& _val819 = this->parameters[_key818]; - xfer += iprot->readString(_val819); + std::string _key819; + xfer += iprot->readString(_key819); + std::string& _val820 = this->parameters[_key819]; + xfer += iprot->readString(_val820); } xfer += iprot->readMapEnd(); } @@ -21406,9 +21459,9 @@ uint32_t DataConnector::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast820; - xfer += iprot->readI32(ecast820); - this->ownerType = static_cast(ecast820); + int32_t ecast821; + xfer += iprot->readI32(ecast821); + this->ownerType = static_cast(ecast821); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -21460,11 +21513,11 @@ uint32_t DataConnector::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter821; - for (_iter821 = this->parameters.begin(); _iter821 != this->parameters.end(); ++_iter821) + std::map ::const_iterator _iter822; + for (_iter822 = this->parameters.begin(); _iter822 != this->parameters.end(); ++_iter822) { - xfer += oprot->writeString(_iter821->first); - xfer += oprot->writeString(_iter821->second); + xfer += oprot->writeString(_iter822->first); + xfer += oprot->writeString(_iter822->second); } xfer += oprot->writeMapEnd(); } @@ -21503,18 +21556,7 @@ void swap(DataConnector &a, DataConnector &b) { swap(a.__isset, b.__isset); } -DataConnector::DataConnector(const DataConnector& other822) { - name = other822.name; - type = other822.type; - url = other822.url; - description = other822.description; - parameters = other822.parameters; - ownerName = other822.ownerName; - ownerType = other822.ownerType; - createTime = other822.createTime; - __isset = other822.__isset; -} -DataConnector& DataConnector::operator=(const DataConnector& other823) { +DataConnector::DataConnector(const DataConnector& other823) { name = other823.name; type = other823.type; url = other823.url; @@ -21524,6 +21566,17 @@ DataConnector& DataConnector::operator=(const DataConnector& other823) { ownerType = other823.ownerType; createTime = other823.createTime; __isset = other823.__isset; +} +DataConnector& DataConnector::operator=(const DataConnector& other824) { + name = other824.name; + type = other824.type; + url = other824.url; + description = other824.description; + parameters = other824.parameters; + ownerName = other824.ownerName; + ownerType = other824.ownerType; + createTime = other824.createTime; + __isset = other824.__isset; return *this; } void DataConnector::printTo(std::ostream& out) const { @@ -21582,9 +21635,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast824; - xfer += iprot->readI32(ecast824); - this->resourceType = static_cast(ecast824); + int32_t ecast825; + xfer += iprot->readI32(ecast825); + this->resourceType = static_cast(ecast825); this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -21635,15 +21688,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other825) { - resourceType = other825.resourceType; - uri = other825.uri; - __isset = other825.__isset; -} -ResourceUri& ResourceUri::operator=(const ResourceUri& other826) { +ResourceUri::ResourceUri(const ResourceUri& other826) { resourceType = other826.resourceType; uri = other826.uri; __isset = other826.__isset; +} +ResourceUri& ResourceUri::operator=(const ResourceUri& other827) { + resourceType = other827.resourceType; + uri = other827.uri; + __isset = other827.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -21757,9 +21810,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast827; - xfer += iprot->readI32(ecast827); - this->ownerType = static_cast(ecast827); + int32_t ecast828; + xfer += iprot->readI32(ecast828); + this->ownerType = static_cast(ecast828); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -21775,9 +21828,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast828; - xfer += iprot->readI32(ecast828); - this->functionType = static_cast(ecast828); + int32_t ecast829; + xfer += iprot->readI32(ecast829); + this->functionType = static_cast(ecast829); this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -21787,14 +21840,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size829; - ::apache::thrift::protocol::TType _etype832; - xfer += iprot->readListBegin(_etype832, _size829); - this->resourceUris.resize(_size829); - uint32_t _i833; - for (_i833 = 0; _i833 < _size829; ++_i833) + uint32_t _size830; + ::apache::thrift::protocol::TType _etype833; + xfer += iprot->readListBegin(_etype833, _size830); + this->resourceUris.resize(_size830); + uint32_t _i834; + for (_i834 = 0; _i834 < _size830; ++_i834) { - xfer += this->resourceUris[_i833].read(iprot); + xfer += this->resourceUris[_i834].read(iprot); } xfer += iprot->readListEnd(); } @@ -21859,10 +21912,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); - std::vector ::const_iterator _iter834; - for (_iter834 = this->resourceUris.begin(); _iter834 != this->resourceUris.end(); ++_iter834) + std::vector ::const_iterator _iter835; + for (_iter835 = this->resourceUris.begin(); _iter835 != this->resourceUris.end(); ++_iter835) { - xfer += (*_iter834).write(oprot); + xfer += (*_iter835).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21892,19 +21945,7 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other835) { - functionName = other835.functionName; - dbName = other835.dbName; - className = other835.className; - ownerName = other835.ownerName; - ownerType = other835.ownerType; - createTime = other835.createTime; - functionType = other835.functionType; - resourceUris = other835.resourceUris; - catName = other835.catName; - __isset = other835.__isset; -} -Function& Function::operator=(const Function& other836) { +Function::Function(const Function& other836) { functionName = other836.functionName; dbName = other836.dbName; className = other836.className; @@ -21915,6 +21956,18 @@ Function& Function::operator=(const Function& other836) { resourceUris = other836.resourceUris; catName = other836.catName; __isset = other836.__isset; +} +Function& Function::operator=(const Function& other837) { + functionName = other837.functionName; + dbName = other837.dbName; + className = other837.className; + ownerName = other837.ownerName; + ownerType = other837.ownerType; + createTime = other837.createTime; + functionType = other837.functionType; + resourceUris = other837.resourceUris; + catName = other837.catName; + __isset = other837.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -22019,9 +22072,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast837; - xfer += iprot->readI32(ecast837); - this->state = static_cast(ecast837); + int32_t ecast838; + xfer += iprot->readI32(ecast838); + this->state = static_cast(ecast838); isset_state = true; } else { xfer += iprot->skip(ftype); @@ -22168,19 +22221,7 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other838) { - id = other838.id; - state = other838.state; - user = other838.user; - hostname = other838.hostname; - agentInfo = other838.agentInfo; - heartbeatCount = other838.heartbeatCount; - metaInfo = other838.metaInfo; - startedTime = other838.startedTime; - lastHeartbeatTime = other838.lastHeartbeatTime; - __isset = other838.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other839) { +TxnInfo::TxnInfo(const TxnInfo& other839) { id = other839.id; state = other839.state; user = other839.user; @@ -22191,6 +22232,18 @@ TxnInfo& TxnInfo::operator=(const TxnInfo& other839) { startedTime = other839.startedTime; lastHeartbeatTime = other839.lastHeartbeatTime; __isset = other839.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other840) { + id = other840.id; + state = other840.state; + user = other840.user; + hostname = other840.hostname; + agentInfo = other840.agentInfo; + heartbeatCount = other840.heartbeatCount; + metaInfo = other840.metaInfo; + startedTime = other840.startedTime; + lastHeartbeatTime = other840.lastHeartbeatTime; + __isset = other840.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -22262,14 +22315,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size840; - ::apache::thrift::protocol::TType _etype843; - xfer += iprot->readListBegin(_etype843, _size840); - this->open_txns.resize(_size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size841; + ::apache::thrift::protocol::TType _etype844; + xfer += iprot->readListBegin(_etype844, _size841); + this->open_txns.resize(_size841); + uint32_t _i845; + for (_i845 = 0; _i845 < _size841; ++_i845) { - xfer += this->open_txns[_i844].read(iprot); + xfer += this->open_txns[_i845].read(iprot); } xfer += iprot->readListEnd(); } @@ -22306,10 +22359,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter845; - for (_iter845 = this->open_txns.begin(); _iter845 != this->open_txns.end(); ++_iter845) + std::vector ::const_iterator _iter846; + for (_iter846 = this->open_txns.begin(); _iter846 != this->open_txns.end(); ++_iter846) { - xfer += (*_iter845).write(oprot); + xfer += (*_iter846).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22326,13 +22379,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other846) { - txn_high_water_mark = other846.txn_high_water_mark; - open_txns = other846.open_txns; -} -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other847) { +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other847) { txn_high_water_mark = other847.txn_high_water_mark; open_txns = other847.open_txns; +} +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other848) { + txn_high_water_mark = other848.txn_high_water_mark; + open_txns = other848.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -22407,14 +22460,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size848; - ::apache::thrift::protocol::TType _etype851; - xfer += iprot->readListBegin(_etype851, _size848); - this->open_txns.resize(_size848); - uint32_t _i852; - for (_i852 = 0; _i852 < _size848; ++_i852) + uint32_t _size849; + ::apache::thrift::protocol::TType _etype852; + xfer += iprot->readListBegin(_etype852, _size849); + this->open_txns.resize(_size849); + uint32_t _i853; + for (_i853 = 0; _i853 < _size849; ++_i853) { - xfer += iprot->readI64(this->open_txns[_i852]); + xfer += iprot->readI64(this->open_txns[_i853]); } xfer += iprot->readListEnd(); } @@ -22469,10 +22522,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter853; - for (_iter853 = this->open_txns.begin(); _iter853 != this->open_txns.end(); ++_iter853) + std::vector ::const_iterator _iter854; + for (_iter854 = this->open_txns.begin(); _iter854 != this->open_txns.end(); ++_iter854) { - xfer += oprot->writeI64((*_iter853)); + xfer += oprot->writeI64((*_iter854)); } xfer += oprot->writeListEnd(); } @@ -22501,19 +22554,19 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other854) { - txn_high_water_mark = other854.txn_high_water_mark; - open_txns = other854.open_txns; - min_open_txn = other854.min_open_txn; - abortedBits = other854.abortedBits; - __isset = other854.__isset; -} -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other855) { +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other855) { txn_high_water_mark = other855.txn_high_water_mark; open_txns = other855.open_txns; min_open_txn = other855.min_open_txn; abortedBits = other855.abortedBits; __isset = other855.__isset; +} +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other856) { + txn_high_water_mark = other856.txn_high_water_mark; + open_txns = other856.open_txns; + min_open_txn = other856.min_open_txn; + abortedBits = other856.abortedBits; + __isset = other856.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -22637,14 +22690,14 @@ uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->replSrcTxnIds.clear(); - uint32_t _size856; - ::apache::thrift::protocol::TType _etype859; - xfer += iprot->readListBegin(_etype859, _size856); - this->replSrcTxnIds.resize(_size856); - uint32_t _i860; - for (_i860 = 0; _i860 < _size856; ++_i860) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + this->replSrcTxnIds.resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += iprot->readI64(this->replSrcTxnIds[_i860]); + xfer += iprot->readI64(this->replSrcTxnIds[_i861]); } xfer += iprot->readListEnd(); } @@ -22655,9 +22708,9 @@ uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast861; - xfer += iprot->readI32(ecast861); - this->txn_type = static_cast(ecast861); + int32_t ecast862; + xfer += iprot->readI32(ecast862); + this->txn_type = static_cast(ecast862); this->__isset.txn_type = true; } else { xfer += iprot->skip(ftype); @@ -22712,10 +22765,10 @@ uint32_t OpenTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) con xfer += oprot->writeFieldBegin("replSrcTxnIds", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->replSrcTxnIds.size())); - std::vector ::const_iterator _iter862; - for (_iter862 = this->replSrcTxnIds.begin(); _iter862 != this->replSrcTxnIds.end(); ++_iter862) + std::vector ::const_iterator _iter863; + for (_iter863 = this->replSrcTxnIds.begin(); _iter863 != this->replSrcTxnIds.end(); ++_iter863) { - xfer += oprot->writeI64((*_iter862)); + xfer += oprot->writeI64((*_iter863)); } xfer += oprot->writeListEnd(); } @@ -22743,17 +22796,7 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other863) { - num_txns = other863.num_txns; - user = other863.user; - hostname = other863.hostname; - agentInfo = other863.agentInfo; - replPolicy = other863.replPolicy; - replSrcTxnIds = other863.replSrcTxnIds; - txn_type = other863.txn_type; - __isset = other863.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other864) { +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other864) { num_txns = other864.num_txns; user = other864.user; hostname = other864.hostname; @@ -22762,6 +22805,16 @@ OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other864) { replSrcTxnIds = other864.replSrcTxnIds; txn_type = other864.txn_type; __isset = other864.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other865) { + num_txns = other865.num_txns; + user = other865.user; + hostname = other865.hostname; + agentInfo = other865.agentInfo; + replPolicy = other865.replPolicy; + replSrcTxnIds = other865.replSrcTxnIds; + txn_type = other865.txn_type; + __isset = other865.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -22818,14 +22871,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size865; - ::apache::thrift::protocol::TType _etype868; - xfer += iprot->readListBegin(_etype868, _size865); - this->txn_ids.resize(_size865); - uint32_t _i869; - for (_i869 = 0; _i869 < _size865; ++_i869) + uint32_t _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + this->txn_ids.resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += iprot->readI64(this->txn_ids[_i869]); + xfer += iprot->readI64(this->txn_ids[_i870]); } xfer += iprot->readListEnd(); } @@ -22856,10 +22909,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter870; - for (_iter870 = this->txn_ids.begin(); _iter870 != this->txn_ids.end(); ++_iter870) + std::vector ::const_iterator _iter871; + for (_iter871 = this->txn_ids.begin(); _iter871 != this->txn_ids.end(); ++_iter871) { - xfer += oprot->writeI64((*_iter870)); + xfer += oprot->writeI64((*_iter871)); } xfer += oprot->writeListEnd(); } @@ -22875,11 +22928,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other871) { - txn_ids = other871.txn_ids; -} -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other872) { +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other872) { txn_ids = other872.txn_ids; +} +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other873) { + txn_ids = other873.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -22959,9 +23012,9 @@ uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast873; - xfer += iprot->readI32(ecast873); - this->txn_type = static_cast(ecast873); + int32_t ecast874; + xfer += iprot->readI32(ecast874); + this->txn_type = static_cast(ecast874); this->__isset.txn_type = true; } else { xfer += iprot->skip(ftype); @@ -23027,19 +23080,19 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.__isset, b.__isset); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other874) { - txnid = other874.txnid; - replPolicy = other874.replPolicy; - txn_type = other874.txn_type; - errorCode = other874.errorCode; - __isset = other874.__isset; -} -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other875) { +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other875) { txnid = other875.txnid; replPolicy = other875.replPolicy; txn_type = other875.txn_type; errorCode = other875.errorCode; __isset = other875.__isset; +} +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other876) { + txnid = other876.txnid; + replPolicy = other876.replPolicy; + txn_type = other876.txn_type; + errorCode = other876.errorCode; + __isset = other876.__isset; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -23098,14 +23151,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size876; - ::apache::thrift::protocol::TType _etype879; - xfer += iprot->readListBegin(_etype879, _size876); - this->txn_ids.resize(_size876); - uint32_t _i880; - for (_i880 = 0; _i880 < _size876; ++_i880) + uint32_t _size877; + ::apache::thrift::protocol::TType _etype880; + xfer += iprot->readListBegin(_etype880, _size877); + this->txn_ids.resize(_size877); + uint32_t _i881; + for (_i881 = 0; _i881 < _size877; ++_i881) { - xfer += iprot->readI64(this->txn_ids[_i880]); + xfer += iprot->readI64(this->txn_ids[_i881]); } xfer += iprot->readListEnd(); } @@ -23144,10 +23197,10 @@ uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter881; - for (_iter881 = this->txn_ids.begin(); _iter881 != this->txn_ids.end(); ++_iter881) + std::vector ::const_iterator _iter882; + for (_iter882 = this->txn_ids.begin(); _iter882 != this->txn_ids.end(); ++_iter882) { - xfer += oprot->writeI64((*_iter881)); + xfer += oprot->writeI64((*_iter882)); } xfer += oprot->writeListEnd(); } @@ -23170,15 +23223,15 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.__isset, b.__isset); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other882) { - txn_ids = other882.txn_ids; - errorCode = other882.errorCode; - __isset = other882.__isset; -} -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other883) { +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other883) { txn_ids = other883.txn_ids; errorCode = other883.errorCode; __isset = other883.__isset; +} +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other884) { + txn_ids = other884.txn_ids; + errorCode = other884.errorCode; + __isset = other884.__isset; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -23307,15 +23360,15 @@ void swap(CommitTxnKeyValue &a, CommitTxnKeyValue &b) { swap(a.value, b.value); } -CommitTxnKeyValue::CommitTxnKeyValue(const CommitTxnKeyValue& other884) { - tableId = other884.tableId; - key = other884.key; - value = other884.value; -} -CommitTxnKeyValue& CommitTxnKeyValue::operator=(const CommitTxnKeyValue& other885) { +CommitTxnKeyValue::CommitTxnKeyValue(const CommitTxnKeyValue& other885) { tableId = other885.tableId; key = other885.key; value = other885.value; +} +CommitTxnKeyValue& CommitTxnKeyValue::operator=(const CommitTxnKeyValue& other886) { + tableId = other886.tableId; + key = other886.key; + value = other886.value; return *this; } void CommitTxnKeyValue::printTo(std::ostream& out) const { @@ -23523,17 +23576,7 @@ void swap(WriteEventInfo &a, WriteEventInfo &b) { swap(a.__isset, b.__isset); } -WriteEventInfo::WriteEventInfo(const WriteEventInfo& other886) { - writeId = other886.writeId; - database = other886.database; - table = other886.table; - files = other886.files; - partition = other886.partition; - tableObj = other886.tableObj; - partitionObj = other886.partitionObj; - __isset = other886.__isset; -} -WriteEventInfo& WriteEventInfo::operator=(const WriteEventInfo& other887) { +WriteEventInfo::WriteEventInfo(const WriteEventInfo& other887) { writeId = other887.writeId; database = other887.database; table = other887.table; @@ -23542,6 +23585,16 @@ WriteEventInfo& WriteEventInfo::operator=(const WriteEventInfo& other887) { tableObj = other887.tableObj; partitionObj = other887.partitionObj; __isset = other887.__isset; +} +WriteEventInfo& WriteEventInfo::operator=(const WriteEventInfo& other888) { + writeId = other888.writeId; + database = other888.database; + table = other888.table; + files = other888.files; + partition = other888.partition; + tableObj = other888.tableObj; + partitionObj = other888.partitionObj; + __isset = other888.__isset; return *this; } void WriteEventInfo::printTo(std::ostream& out) const { @@ -23650,14 +23703,14 @@ uint32_t ReplLastIdInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionList.clear(); - uint32_t _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->partitionList.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size889; + ::apache::thrift::protocol::TType _etype892; + xfer += iprot->readListBegin(_etype892, _size889); + this->partitionList.resize(_size889); + uint32_t _i893; + for (_i893 = 0; _i893 < _size889; ++_i893) { - xfer += iprot->readString(this->partitionList[_i892]); + xfer += iprot->readString(this->partitionList[_i893]); } xfer += iprot->readListEnd(); } @@ -23709,10 +23762,10 @@ uint32_t ReplLastIdInfo::write(::apache::thrift::protocol::TProtocol* oprot) con xfer += oprot->writeFieldBegin("partitionList", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionList.size())); - std::vector ::const_iterator _iter893; - for (_iter893 = this->partitionList.begin(); _iter893 != this->partitionList.end(); ++_iter893) + std::vector ::const_iterator _iter894; + for (_iter894 = this->partitionList.begin(); _iter894 != this->partitionList.end(); ++_iter894) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter894)); } xfer += oprot->writeListEnd(); } @@ -23733,21 +23786,21 @@ void swap(ReplLastIdInfo &a, ReplLastIdInfo &b) { swap(a.__isset, b.__isset); } -ReplLastIdInfo::ReplLastIdInfo(const ReplLastIdInfo& other894) { - database = other894.database; - lastReplId = other894.lastReplId; - table = other894.table; - catalog = other894.catalog; - partitionList = other894.partitionList; - __isset = other894.__isset; -} -ReplLastIdInfo& ReplLastIdInfo::operator=(const ReplLastIdInfo& other895) { +ReplLastIdInfo::ReplLastIdInfo(const ReplLastIdInfo& other895) { database = other895.database; lastReplId = other895.lastReplId; table = other895.table; catalog = other895.catalog; partitionList = other895.partitionList; __isset = other895.__isset; +} +ReplLastIdInfo& ReplLastIdInfo::operator=(const ReplLastIdInfo& other896) { + database = other896.database; + lastReplId = other896.lastReplId; + table = other896.table; + catalog = other896.catalog; + partitionList = other896.partitionList; + __isset = other896.__isset; return *this; } void ReplLastIdInfo::printTo(std::ostream& out) const { @@ -23899,17 +23952,17 @@ void swap(UpdateTransactionalStatsRequest &a, UpdateTransactionalStatsRequest &b swap(a.deletedCount, b.deletedCount); } -UpdateTransactionalStatsRequest::UpdateTransactionalStatsRequest(const UpdateTransactionalStatsRequest& other896) noexcept { - tableId = other896.tableId; - insertCount = other896.insertCount; - updatedCount = other896.updatedCount; - deletedCount = other896.deletedCount; -} -UpdateTransactionalStatsRequest& UpdateTransactionalStatsRequest::operator=(const UpdateTransactionalStatsRequest& other897) noexcept { +UpdateTransactionalStatsRequest::UpdateTransactionalStatsRequest(const UpdateTransactionalStatsRequest& other897) noexcept { tableId = other897.tableId; insertCount = other897.insertCount; updatedCount = other897.updatedCount; deletedCount = other897.deletedCount; +} +UpdateTransactionalStatsRequest& UpdateTransactionalStatsRequest::operator=(const UpdateTransactionalStatsRequest& other898) noexcept { + tableId = other898.tableId; + insertCount = other898.insertCount; + updatedCount = other898.updatedCount; + deletedCount = other898.deletedCount; return *this; } void UpdateTransactionalStatsRequest::printTo(std::ostream& out) const { @@ -24009,14 +24062,14 @@ uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->writeEventInfos.clear(); - uint32_t _size898; - ::apache::thrift::protocol::TType _etype901; - xfer += iprot->readListBegin(_etype901, _size898); - this->writeEventInfos.resize(_size898); - uint32_t _i902; - for (_i902 = 0; _i902 < _size898; ++_i902) + uint32_t _size899; + ::apache::thrift::protocol::TType _etype902; + xfer += iprot->readListBegin(_etype902, _size899); + this->writeEventInfos.resize(_size899); + uint32_t _i903; + for (_i903 = 0; _i903 < _size899; ++_i903) { - xfer += this->writeEventInfos[_i902].read(iprot); + xfer += this->writeEventInfos[_i903].read(iprot); } xfer += iprot->readListEnd(); } @@ -24051,9 +24104,9 @@ uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast903; - xfer += iprot->readI32(ecast903); - this->txn_type = static_cast(ecast903); + int32_t ecast904; + xfer += iprot->readI32(ecast904); + this->txn_type = static_cast(ecast904); this->__isset.txn_type = true; } else { xfer += iprot->skip(ftype); @@ -24091,10 +24144,10 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("writeEventInfos", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->writeEventInfos.size())); - std::vector ::const_iterator _iter904; - for (_iter904 = this->writeEventInfos.begin(); _iter904 != this->writeEventInfos.end(); ++_iter904) + std::vector ::const_iterator _iter905; + for (_iter905 = this->writeEventInfos.begin(); _iter905 != this->writeEventInfos.end(); ++_iter905) { - xfer += (*_iter904).write(oprot); + xfer += (*_iter905).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24137,17 +24190,7 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.__isset, b.__isset); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other905) { - txnid = other905.txnid; - replPolicy = other905.replPolicy; - writeEventInfos = other905.writeEventInfos; - replLastIdInfo = other905.replLastIdInfo; - keyValue = other905.keyValue; - exclWriteEnabled = other905.exclWriteEnabled; - txn_type = other905.txn_type; - __isset = other905.__isset; -} -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other906) { +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other906) { txnid = other906.txnid; replPolicy = other906.replPolicy; writeEventInfos = other906.writeEventInfos; @@ -24156,6 +24199,16 @@ CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other906) exclWriteEnabled = other906.exclWriteEnabled; txn_type = other906.txn_type; __isset = other906.__isset; +} +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other907) { + txnid = other907.txnid; + replPolicy = other907.replPolicy; + writeEventInfos = other907.writeEventInfos; + replLastIdInfo = other907.replLastIdInfo; + keyValue = other907.keyValue; + exclWriteEnabled = other907.exclWriteEnabled; + txn_type = other907.txn_type; + __isset = other907.__isset; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -24277,14 +24330,14 @@ uint32_t ReplTblWriteIdStateRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size907; - ::apache::thrift::protocol::TType _etype910; - xfer += iprot->readListBegin(_etype910, _size907); - this->partNames.resize(_size907); - uint32_t _i911; - for (_i911 = 0; _i911 < _size907; ++_i911) + uint32_t _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + this->partNames.resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString(this->partNames[_i911]); + xfer += iprot->readString(this->partNames[_i912]); } xfer += iprot->readListEnd(); } @@ -24344,10 +24397,10 @@ uint32_t ReplTblWriteIdStateRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter912; - for (_iter912 = this->partNames.begin(); _iter912 != this->partNames.end(); ++_iter912) + std::vector ::const_iterator _iter913; + for (_iter913 = this->partNames.begin(); _iter913 != this->partNames.end(); ++_iter913) { - xfer += oprot->writeString((*_iter912)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -24369,16 +24422,7 @@ void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) { swap(a.__isset, b.__isset); } -ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other913) { - validWriteIdlist = other913.validWriteIdlist; - user = other913.user; - hostName = other913.hostName; - dbName = other913.dbName; - tableName = other913.tableName; - partNames = other913.partNames; - __isset = other913.__isset; -} -ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other914) { +ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other914) { validWriteIdlist = other914.validWriteIdlist; user = other914.user; hostName = other914.hostName; @@ -24386,6 +24430,15 @@ ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblW tableName = other914.tableName; partNames = other914.partNames; __isset = other914.__isset; +} +ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other915) { + validWriteIdlist = other915.validWriteIdlist; + user = other915.user; + hostName = other915.hostName; + dbName = other915.dbName; + tableName = other915.tableName; + partNames = other915.partNames; + __isset = other915.__isset; return *this; } void ReplTblWriteIdStateRequest::printTo(std::ostream& out) const { @@ -24451,14 +24504,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fullTableNames.clear(); - uint32_t _size915; - ::apache::thrift::protocol::TType _etype918; - xfer += iprot->readListBegin(_etype918, _size915); - this->fullTableNames.resize(_size915); - uint32_t _i919; - for (_i919 = 0; _i919 < _size915; ++_i919) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->fullTableNames.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += iprot->readString(this->fullTableNames[_i919]); + xfer += iprot->readString(this->fullTableNames[_i920]); } xfer += iprot->readListEnd(); } @@ -24505,10 +24558,10 @@ uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fullTableNames.size())); - std::vector ::const_iterator _iter920; - for (_iter920 = this->fullTableNames.begin(); _iter920 != this->fullTableNames.end(); ++_iter920) + std::vector ::const_iterator _iter921; + for (_iter921 = this->fullTableNames.begin(); _iter921 != this->fullTableNames.end(); ++_iter921) { - xfer += oprot->writeString((*_iter920)); + xfer += oprot->writeString((*_iter921)); } xfer += oprot->writeListEnd(); } @@ -24537,17 +24590,17 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) { swap(a.__isset, b.__isset); } -GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other921) { - fullTableNames = other921.fullTableNames; - validTxnList = other921.validTxnList; - writeId = other921.writeId; - __isset = other921.__isset; -} -GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other922) { +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other922) { fullTableNames = other922.fullTableNames; validTxnList = other922.validTxnList; writeId = other922.writeId; __isset = other922.__isset; +} +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other923) { + fullTableNames = other923.fullTableNames; + validTxnList = other923.validTxnList; + writeId = other923.writeId; + __isset = other923.__isset; return *this; } void GetValidWriteIdsRequest::printTo(std::ostream& out) const { @@ -24636,14 +24689,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->invalidWriteIds.clear(); - uint32_t _size923; - ::apache::thrift::protocol::TType _etype926; - xfer += iprot->readListBegin(_etype926, _size923); - this->invalidWriteIds.resize(_size923); - uint32_t _i927; - for (_i927 = 0; _i927 < _size923; ++_i927) + uint32_t _size924; + ::apache::thrift::protocol::TType _etype927; + xfer += iprot->readListBegin(_etype927, _size924); + this->invalidWriteIds.resize(_size924); + uint32_t _i928; + for (_i928 = 0; _i928 < _size924; ++_i928) { - xfer += iprot->readI64(this->invalidWriteIds[_i927]); + xfer += iprot->readI64(this->invalidWriteIds[_i928]); } xfer += iprot->readListEnd(); } @@ -24704,10 +24757,10 @@ uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->invalidWriteIds.size())); - std::vector ::const_iterator _iter928; - for (_iter928 = this->invalidWriteIds.begin(); _iter928 != this->invalidWriteIds.end(); ++_iter928) + std::vector ::const_iterator _iter929; + for (_iter929 = this->invalidWriteIds.begin(); _iter929 != this->invalidWriteIds.end(); ++_iter929) { - xfer += oprot->writeI64((*_iter928)); + xfer += oprot->writeI64((*_iter929)); } xfer += oprot->writeListEnd(); } @@ -24737,21 +24790,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) { swap(a.__isset, b.__isset); } -TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other929) { - fullTableName = other929.fullTableName; - writeIdHighWaterMark = other929.writeIdHighWaterMark; - invalidWriteIds = other929.invalidWriteIds; - minOpenWriteId = other929.minOpenWriteId; - abortedBits = other929.abortedBits; - __isset = other929.__isset; -} -TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other930) { +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other930) { fullTableName = other930.fullTableName; writeIdHighWaterMark = other930.writeIdHighWaterMark; invalidWriteIds = other930.invalidWriteIds; minOpenWriteId = other930.minOpenWriteId; abortedBits = other930.abortedBits; __isset = other930.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other931) { + fullTableName = other931.fullTableName; + writeIdHighWaterMark = other931.writeIdHighWaterMark; + invalidWriteIds = other931.invalidWriteIds; + minOpenWriteId = other931.minOpenWriteId; + abortedBits = other931.abortedBits; + __isset = other931.__isset; return *this; } void TableValidWriteIds::printTo(std::ostream& out) const { @@ -24806,14 +24859,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblValidWriteIds.clear(); - uint32_t _size931; - ::apache::thrift::protocol::TType _etype934; - xfer += iprot->readListBegin(_etype934, _size931); - this->tblValidWriteIds.resize(_size931); - uint32_t _i935; - for (_i935 = 0; _i935 < _size931; ++_i935) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + this->tblValidWriteIds.resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += this->tblValidWriteIds[_i935].read(iprot); + xfer += this->tblValidWriteIds[_i936].read(iprot); } xfer += iprot->readListEnd(); } @@ -24844,10 +24897,10 @@ uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tblValidWriteIds.size())); - std::vector ::const_iterator _iter936; - for (_iter936 = this->tblValidWriteIds.begin(); _iter936 != this->tblValidWriteIds.end(); ++_iter936) + std::vector ::const_iterator _iter937; + for (_iter937 = this->tblValidWriteIds.begin(); _iter937 != this->tblValidWriteIds.end(); ++_iter937) { - xfer += (*_iter936).write(oprot); + xfer += (*_iter937).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24863,11 +24916,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) { swap(a.tblValidWriteIds, b.tblValidWriteIds); } -GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other937) { - tblValidWriteIds = other937.tblValidWriteIds; -} -GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other938) { +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other938) { tblValidWriteIds = other938.tblValidWriteIds; +} +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other939) { + tblValidWriteIds = other939.tblValidWriteIds; return *this; } void GetValidWriteIdsResponse::printTo(std::ostream& out) const { @@ -24975,13 +25028,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) { swap(a.writeId, b.writeId); } -TxnToWriteId::TxnToWriteId(const TxnToWriteId& other939) noexcept { - txnId = other939.txnId; - writeId = other939.writeId; -} -TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other940) noexcept { +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other940) noexcept { txnId = other940.txnId; writeId = other940.writeId; +} +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other941) noexcept { + txnId = other941.txnId; + writeId = other941.writeId; return *this; } void TxnToWriteId::printTo(std::ostream& out) const { @@ -25074,14 +25127,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnIds.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->txnIds.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size942; + ::apache::thrift::protocol::TType _etype945; + xfer += iprot->readListBegin(_etype945, _size942); + this->txnIds.resize(_size942); + uint32_t _i946; + for (_i946 = 0; _i946 < _size942; ++_i946) { - xfer += iprot->readI64(this->txnIds[_i945]); + xfer += iprot->readI64(this->txnIds[_i946]); } xfer += iprot->readListEnd(); } @@ -25102,14 +25155,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->srcTxnToWriteIdList.clear(); - uint32_t _size946; - ::apache::thrift::protocol::TType _etype949; - xfer += iprot->readListBegin(_etype949, _size946); - this->srcTxnToWriteIdList.resize(_size946); - uint32_t _i950; - for (_i950 = 0; _i950 < _size946; ++_i950) + uint32_t _size947; + ::apache::thrift::protocol::TType _etype950; + xfer += iprot->readListBegin(_etype950, _size947); + this->srcTxnToWriteIdList.resize(_size947); + uint32_t _i951; + for (_i951 = 0; _i951 < _size947; ++_i951) { - xfer += this->srcTxnToWriteIdList[_i950].read(iprot); + xfer += this->srcTxnToWriteIdList[_i951].read(iprot); } xfer += iprot->readListEnd(); } @@ -25159,10 +25212,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txnIds.size())); - std::vector ::const_iterator _iter951; - for (_iter951 = this->txnIds.begin(); _iter951 != this->txnIds.end(); ++_iter951) + std::vector ::const_iterator _iter952; + for (_iter952 = this->txnIds.begin(); _iter952 != this->txnIds.end(); ++_iter952) { - xfer += oprot->writeI64((*_iter951)); + xfer += oprot->writeI64((*_iter952)); } xfer += oprot->writeListEnd(); } @@ -25177,10 +25230,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("srcTxnToWriteIdList", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->srcTxnToWriteIdList.size())); - std::vector ::const_iterator _iter952; - for (_iter952 = this->srcTxnToWriteIdList.begin(); _iter952 != this->srcTxnToWriteIdList.end(); ++_iter952) + std::vector ::const_iterator _iter953; + for (_iter953 = this->srcTxnToWriteIdList.begin(); _iter953 != this->srcTxnToWriteIdList.end(); ++_iter953) { - xfer += (*_iter952).write(oprot); + xfer += (*_iter953).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25207,16 +25260,7 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) { swap(a.__isset, b.__isset); } -AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other953) { - dbName = other953.dbName; - tableName = other953.tableName; - txnIds = other953.txnIds; - replPolicy = other953.replPolicy; - srcTxnToWriteIdList = other953.srcTxnToWriteIdList; - reallocate = other953.reallocate; - __isset = other953.__isset; -} -AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other954) { +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other954) { dbName = other954.dbName; tableName = other954.tableName; txnIds = other954.txnIds; @@ -25224,6 +25268,15 @@ AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const Allo srcTxnToWriteIdList = other954.srcTxnToWriteIdList; reallocate = other954.reallocate; __isset = other954.__isset; +} +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other955) { + dbName = other955.dbName; + tableName = other955.tableName; + txnIds = other955.txnIds; + replPolicy = other955.replPolicy; + srcTxnToWriteIdList = other955.srcTxnToWriteIdList; + reallocate = other955.reallocate; + __isset = other955.__isset; return *this; } void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { @@ -25279,14 +25332,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnToWriteIds.clear(); - uint32_t _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - this->txnToWriteIds.resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->txnToWriteIds.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += this->txnToWriteIds[_i959].read(iprot); + xfer += this->txnToWriteIds[_i960].read(iprot); } xfer += iprot->readListEnd(); } @@ -25317,10 +25370,10 @@ uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->txnToWriteIds.size())); - std::vector ::const_iterator _iter960; - for (_iter960 = this->txnToWriteIds.begin(); _iter960 != this->txnToWriteIds.end(); ++_iter960) + std::vector ::const_iterator _iter961; + for (_iter961 = this->txnToWriteIds.begin(); _iter961 != this->txnToWriteIds.end(); ++_iter961) { - xfer += (*_iter960).write(oprot); + xfer += (*_iter961).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25336,11 +25389,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) { swap(a.txnToWriteIds, b.txnToWriteIds); } -AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other961) { - txnToWriteIds = other961.txnToWriteIds; -} -AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other962) { +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other962) { txnToWriteIds = other962.txnToWriteIds; +} +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other963) { + txnToWriteIds = other963.txnToWriteIds; return *this; } void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { @@ -25448,13 +25501,13 @@ void swap(MaxAllocatedTableWriteIdRequest &a, MaxAllocatedTableWriteIdRequest &b swap(a.tableName, b.tableName); } -MaxAllocatedTableWriteIdRequest::MaxAllocatedTableWriteIdRequest(const MaxAllocatedTableWriteIdRequest& other963) { - dbName = other963.dbName; - tableName = other963.tableName; -} -MaxAllocatedTableWriteIdRequest& MaxAllocatedTableWriteIdRequest::operator=(const MaxAllocatedTableWriteIdRequest& other964) { +MaxAllocatedTableWriteIdRequest::MaxAllocatedTableWriteIdRequest(const MaxAllocatedTableWriteIdRequest& other964) { dbName = other964.dbName; tableName = other964.tableName; +} +MaxAllocatedTableWriteIdRequest& MaxAllocatedTableWriteIdRequest::operator=(const MaxAllocatedTableWriteIdRequest& other965) { + dbName = other965.dbName; + tableName = other965.tableName; return *this; } void MaxAllocatedTableWriteIdRequest::printTo(std::ostream& out) const { @@ -25543,11 +25596,11 @@ void swap(MaxAllocatedTableWriteIdResponse &a, MaxAllocatedTableWriteIdResponse swap(a.maxWriteId, b.maxWriteId); } -MaxAllocatedTableWriteIdResponse::MaxAllocatedTableWriteIdResponse(const MaxAllocatedTableWriteIdResponse& other965) noexcept { - maxWriteId = other965.maxWriteId; -} -MaxAllocatedTableWriteIdResponse& MaxAllocatedTableWriteIdResponse::operator=(const MaxAllocatedTableWriteIdResponse& other966) noexcept { +MaxAllocatedTableWriteIdResponse::MaxAllocatedTableWriteIdResponse(const MaxAllocatedTableWriteIdResponse& other966) noexcept { maxWriteId = other966.maxWriteId; +} +MaxAllocatedTableWriteIdResponse& MaxAllocatedTableWriteIdResponse::operator=(const MaxAllocatedTableWriteIdResponse& other967) noexcept { + maxWriteId = other967.maxWriteId; return *this; } void MaxAllocatedTableWriteIdResponse::printTo(std::ostream& out) const { @@ -25675,15 +25728,15 @@ void swap(SeedTableWriteIdsRequest &a, SeedTableWriteIdsRequest &b) { swap(a.seedWriteId, b.seedWriteId); } -SeedTableWriteIdsRequest::SeedTableWriteIdsRequest(const SeedTableWriteIdsRequest& other967) { - dbName = other967.dbName; - tableName = other967.tableName; - seedWriteId = other967.seedWriteId; -} -SeedTableWriteIdsRequest& SeedTableWriteIdsRequest::operator=(const SeedTableWriteIdsRequest& other968) { +SeedTableWriteIdsRequest::SeedTableWriteIdsRequest(const SeedTableWriteIdsRequest& other968) { dbName = other968.dbName; tableName = other968.tableName; seedWriteId = other968.seedWriteId; +} +SeedTableWriteIdsRequest& SeedTableWriteIdsRequest::operator=(const SeedTableWriteIdsRequest& other969) { + dbName = other969.dbName; + tableName = other969.tableName; + seedWriteId = other969.seedWriteId; return *this; } void SeedTableWriteIdsRequest::printTo(std::ostream& out) const { @@ -25773,11 +25826,11 @@ void swap(SeedTxnIdRequest &a, SeedTxnIdRequest &b) { swap(a.seedTxnId, b.seedTxnId); } -SeedTxnIdRequest::SeedTxnIdRequest(const SeedTxnIdRequest& other969) noexcept { - seedTxnId = other969.seedTxnId; -} -SeedTxnIdRequest& SeedTxnIdRequest::operator=(const SeedTxnIdRequest& other970) noexcept { +SeedTxnIdRequest::SeedTxnIdRequest(const SeedTxnIdRequest& other970) noexcept { seedTxnId = other970.seedTxnId; +} +SeedTxnIdRequest& SeedTxnIdRequest::operator=(const SeedTxnIdRequest& other971) noexcept { + seedTxnId = other971.seedTxnId; return *this; } void SeedTxnIdRequest::printTo(std::ostream& out) const { @@ -25861,9 +25914,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast971; - xfer += iprot->readI32(ecast971); - this->type = static_cast(ecast971); + int32_t ecast972; + xfer += iprot->readI32(ecast972); + this->type = static_cast(ecast972); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -25871,9 +25924,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast972; - xfer += iprot->readI32(ecast972); - this->level = static_cast(ecast972); + int32_t ecast973; + xfer += iprot->readI32(ecast973); + this->level = static_cast(ecast973); isset_level = true; } else { xfer += iprot->skip(ftype); @@ -25905,9 +25958,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast973; - xfer += iprot->readI32(ecast973); - this->operationType = static_cast(ecast973); + int32_t ecast974; + xfer += iprot->readI32(ecast974); + this->operationType = static_cast(ecast974); this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -26007,18 +26060,7 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other974) { - type = other974.type; - level = other974.level; - dbname = other974.dbname; - tablename = other974.tablename; - partitionname = other974.partitionname; - operationType = other974.operationType; - isTransactional = other974.isTransactional; - isDynamicPartitionWrite = other974.isDynamicPartitionWrite; - __isset = other974.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other975) { +LockComponent::LockComponent(const LockComponent& other975) { type = other975.type; level = other975.level; dbname = other975.dbname; @@ -26028,6 +26070,17 @@ LockComponent& LockComponent::operator=(const LockComponent& other975) { isTransactional = other975.isTransactional; isDynamicPartitionWrite = other975.isDynamicPartitionWrite; __isset = other975.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other976) { + type = other976.type; + level = other976.level; + dbname = other976.dbname; + tablename = other976.tablename; + partitionname = other976.partitionname; + operationType = other976.operationType; + isTransactional = other976.isTransactional; + isDynamicPartitionWrite = other976.isDynamicPartitionWrite; + __isset = other976.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -26120,14 +26173,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size976; - ::apache::thrift::protocol::TType _etype979; - xfer += iprot->readListBegin(_etype979, _size976); - this->component.resize(_size976); - uint32_t _i980; - for (_i980 = 0; _i980 < _size976; ++_i980) + uint32_t _size977; + ::apache::thrift::protocol::TType _etype980; + xfer += iprot->readListBegin(_etype980, _size977); + this->component.resize(_size977); + uint32_t _i981; + for (_i981 = 0; _i981 < _size977; ++_i981) { - xfer += this->component[_i980].read(iprot); + xfer += this->component[_i981].read(iprot); } xfer += iprot->readListEnd(); } @@ -26218,10 +26271,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); - std::vector ::const_iterator _iter981; - for (_iter981 = this->component.begin(); _iter981 != this->component.end(); ++_iter981) + std::vector ::const_iterator _iter982; + for (_iter982 = this->component.begin(); _iter982 != this->component.end(); ++_iter982) { - xfer += (*_iter981).write(oprot); + xfer += (*_iter982).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26278,18 +26331,7 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other982) { - component = other982.component; - txnid = other982.txnid; - user = other982.user; - hostname = other982.hostname; - agentInfo = other982.agentInfo; - zeroWaitReadEnabled = other982.zeroWaitReadEnabled; - exclusiveCTAS = other982.exclusiveCTAS; - locklessReadsEnabled = other982.locklessReadsEnabled; - __isset = other982.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other983) { +LockRequest::LockRequest(const LockRequest& other983) { component = other983.component; txnid = other983.txnid; user = other983.user; @@ -26299,6 +26341,17 @@ LockRequest& LockRequest::operator=(const LockRequest& other983) { exclusiveCTAS = other983.exclusiveCTAS; locklessReadsEnabled = other983.locklessReadsEnabled; __isset = other983.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other984) { + component = other984.component; + txnid = other984.txnid; + user = other984.user; + hostname = other984.hostname; + agentInfo = other984.agentInfo; + zeroWaitReadEnabled = other984.zeroWaitReadEnabled; + exclusiveCTAS = other984.exclusiveCTAS; + locklessReadsEnabled = other984.locklessReadsEnabled; + __isset = other984.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -26372,9 +26425,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast984; - xfer += iprot->readI32(ecast984); - this->state = static_cast(ecast984); + int32_t ecast985; + xfer += iprot->readI32(ecast985); + this->state = static_cast(ecast985); isset_state = true; } else { xfer += iprot->skip(ftype); @@ -26435,17 +26488,17 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.__isset, b.__isset); } -LockResponse::LockResponse(const LockResponse& other985) { - lockid = other985.lockid; - state = other985.state; - errorMessage = other985.errorMessage; - __isset = other985.__isset; -} -LockResponse& LockResponse::operator=(const LockResponse& other986) { +LockResponse::LockResponse(const LockResponse& other986) { lockid = other986.lockid; state = other986.state; errorMessage = other986.errorMessage; __isset = other986.__isset; +} +LockResponse& LockResponse::operator=(const LockResponse& other987) { + lockid = other987.lockid; + state = other987.state; + errorMessage = other987.errorMessage; + __isset = other987.__isset; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -26574,17 +26627,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other987) noexcept { - lockid = other987.lockid; - txnid = other987.txnid; - elapsed_ms = other987.elapsed_ms; - __isset = other987.__isset; -} -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other988) noexcept { +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other988) noexcept { lockid = other988.lockid; txnid = other988.txnid; elapsed_ms = other988.elapsed_ms; __isset = other988.__isset; +} +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other989) noexcept { + lockid = other989.lockid; + txnid = other989.txnid; + elapsed_ms = other989.elapsed_ms; + __isset = other989.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -26674,11 +26727,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other989) noexcept { - lockid = other989.lockid; -} -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other990) noexcept { +UnlockRequest::UnlockRequest(const UnlockRequest& other990) noexcept { lockid = other990.lockid; +} +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other991) noexcept { + lockid = other991.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -26842,21 +26895,21 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other991) { - dbname = other991.dbname; - tablename = other991.tablename; - partname = other991.partname; - isExtended = other991.isExtended; - txnid = other991.txnid; - __isset = other991.__isset; -} -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other992) { +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other992) { dbname = other992.dbname; tablename = other992.tablename; partname = other992.partname; isExtended = other992.isExtended; txnid = other992.txnid; __isset = other992.__isset; +} +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other993) { + dbname = other993.dbname; + tablename = other993.tablename; + partname = other993.partname; + isExtended = other993.isExtended; + txnid = other993.txnid; + __isset = other993.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -27016,9 +27069,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast993; - xfer += iprot->readI32(ecast993); - this->state = static_cast(ecast993); + int32_t ecast994; + xfer += iprot->readI32(ecast994); + this->state = static_cast(ecast994); isset_state = true; } else { xfer += iprot->skip(ftype); @@ -27026,9 +27079,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast994; - xfer += iprot->readI32(ecast994); - this->type = static_cast(ecast994); + int32_t ecast995; + xfer += iprot->readI32(ecast995); + this->type = static_cast(ecast995); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -27244,26 +27297,7 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other995) { - lockid = other995.lockid; - dbname = other995.dbname; - tablename = other995.tablename; - partname = other995.partname; - state = other995.state; - type = other995.type; - txnid = other995.txnid; - lastheartbeat = other995.lastheartbeat; - acquiredat = other995.acquiredat; - user = other995.user; - hostname = other995.hostname; - heartbeatCount = other995.heartbeatCount; - agentInfo = other995.agentInfo; - blockedByExtId = other995.blockedByExtId; - blockedByIntId = other995.blockedByIntId; - lockIdInternal = other995.lockIdInternal; - __isset = other995.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other996) { +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other996) { lockid = other996.lockid; dbname = other996.dbname; tablename = other996.tablename; @@ -27281,6 +27315,25 @@ ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksRes blockedByIntId = other996.blockedByIntId; lockIdInternal = other996.lockIdInternal; __isset = other996.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other997) { + lockid = other997.lockid; + dbname = other997.dbname; + tablename = other997.tablename; + partname = other997.partname; + state = other997.state; + type = other997.type; + txnid = other997.txnid; + lastheartbeat = other997.lastheartbeat; + acquiredat = other997.acquiredat; + user = other997.user; + hostname = other997.hostname; + heartbeatCount = other997.heartbeatCount; + agentInfo = other997.agentInfo; + blockedByExtId = other997.blockedByExtId; + blockedByIntId = other997.blockedByIntId; + lockIdInternal = other997.lockIdInternal; + __isset = other997.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -27345,14 +27398,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size997; - ::apache::thrift::protocol::TType _etype1000; - xfer += iprot->readListBegin(_etype1000, _size997); - this->locks.resize(_size997); - uint32_t _i1001; - for (_i1001 = 0; _i1001 < _size997; ++_i1001) + uint32_t _size998; + ::apache::thrift::protocol::TType _etype1001; + xfer += iprot->readListBegin(_etype1001, _size998); + this->locks.resize(_size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - xfer += this->locks[_i1001].read(iprot); + xfer += this->locks[_i1002].read(iprot); } xfer += iprot->readListEnd(); } @@ -27381,10 +27434,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); - std::vector ::const_iterator _iter1002; - for (_iter1002 = this->locks.begin(); _iter1002 != this->locks.end(); ++_iter1002) + std::vector ::const_iterator _iter1003; + for (_iter1003 = this->locks.begin(); _iter1003 != this->locks.end(); ++_iter1003) { - xfer += (*_iter1002).write(oprot); + xfer += (*_iter1003).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27401,13 +27454,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other1003) { - locks = other1003.locks; - __isset = other1003.__isset; -} -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other1004) { +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other1004) { locks = other1004.locks; __isset = other1004.__isset; +} +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other1005) { + locks = other1005.locks; + __isset = other1005.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -27514,15 +27567,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other1005) noexcept { - lockid = other1005.lockid; - txnid = other1005.txnid; - __isset = other1005.__isset; -} -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other1006) noexcept { +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other1006) noexcept { lockid = other1006.lockid; txnid = other1006.txnid; __isset = other1006.__isset; +} +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other1007) noexcept { + lockid = other1007.lockid; + txnid = other1007.txnid; + __isset = other1007.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -27631,13 +27684,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other1007) noexcept { - min = other1007.min; - max = other1007.max; -} -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other1008) noexcept { +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other1008) noexcept { min = other1008.min; max = other1008.max; +} +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other1009) noexcept { + min = other1009.min; + max = other1009.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -27694,15 +27747,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size1009; - ::apache::thrift::protocol::TType _etype1012; - xfer += iprot->readSetBegin(_etype1012, _size1009); - uint32_t _i1013; - for (_i1013 = 0; _i1013 < _size1009; ++_i1013) + uint32_t _size1010; + ::apache::thrift::protocol::TType _etype1013; + xfer += iprot->readSetBegin(_etype1013, _size1010); + uint32_t _i1014; + for (_i1014 = 0; _i1014 < _size1010; ++_i1014) { - int64_t _elem1014; - xfer += iprot->readI64(_elem1014); - this->aborted.insert(_elem1014); + int64_t _elem1015; + xfer += iprot->readI64(_elem1015); + this->aborted.insert(_elem1015); } xfer += iprot->readSetEnd(); } @@ -27715,15 +27768,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size1015; - ::apache::thrift::protocol::TType _etype1018; - xfer += iprot->readSetBegin(_etype1018, _size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1016; + ::apache::thrift::protocol::TType _etype1019; + xfer += iprot->readSetBegin(_etype1019, _size1016); + uint32_t _i1020; + for (_i1020 = 0; _i1020 < _size1016; ++_i1020) { - int64_t _elem1020; - xfer += iprot->readI64(_elem1020); - this->nosuch.insert(_elem1020); + int64_t _elem1021; + xfer += iprot->readI64(_elem1021); + this->nosuch.insert(_elem1021); } xfer += iprot->readSetEnd(); } @@ -27756,10 +27809,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); - std::set ::const_iterator _iter1021; - for (_iter1021 = this->aborted.begin(); _iter1021 != this->aborted.end(); ++_iter1021) + std::set ::const_iterator _iter1022; + for (_iter1022 = this->aborted.begin(); _iter1022 != this->aborted.end(); ++_iter1022) { - xfer += oprot->writeI64((*_iter1021)); + xfer += oprot->writeI64((*_iter1022)); } xfer += oprot->writeSetEnd(); } @@ -27768,10 +27821,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); - std::set ::const_iterator _iter1022; - for (_iter1022 = this->nosuch.begin(); _iter1022 != this->nosuch.end(); ++_iter1022) + std::set ::const_iterator _iter1023; + for (_iter1023 = this->nosuch.begin(); _iter1023 != this->nosuch.end(); ++_iter1023) { - xfer += oprot->writeI64((*_iter1022)); + xfer += oprot->writeI64((*_iter1023)); } xfer += oprot->writeSetEnd(); } @@ -27788,13 +27841,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other1023) { - aborted = other1023.aborted; - nosuch = other1023.nosuch; -} -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other1024) { +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other1024) { aborted = other1024.aborted; nosuch = other1024.nosuch; +} +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other1025) { + aborted = other1025.aborted; + nosuch = other1025.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -27918,9 +27971,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1025; - xfer += iprot->readI32(ecast1025); - this->type = static_cast(ecast1025); + int32_t ecast1026; + xfer += iprot->readI32(ecast1026); + this->type = static_cast(ecast1026); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -27938,17 +27991,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size1026; - ::apache::thrift::protocol::TType _ktype1027; - ::apache::thrift::protocol::TType _vtype1028; - xfer += iprot->readMapBegin(_ktype1027, _vtype1028, _size1026); - uint32_t _i1030; - for (_i1030 = 0; _i1030 < _size1026; ++_i1030) + uint32_t _size1027; + ::apache::thrift::protocol::TType _ktype1028; + ::apache::thrift::protocol::TType _vtype1029; + xfer += iprot->readMapBegin(_ktype1028, _vtype1029, _size1027); + uint32_t _i1031; + for (_i1031 = 0; _i1031 < _size1027; ++_i1031) { - std::string _key1031; - xfer += iprot->readString(_key1031); - std::string& _val1032 = this->properties[_key1031]; - xfer += iprot->readString(_val1032); + std::string _key1032; + xfer += iprot->readString(_key1032); + std::string& _val1033 = this->properties[_key1032]; + xfer += iprot->readString(_val1033); } xfer += iprot->readMapEnd(); } @@ -28046,11 +28099,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter1033; - for (_iter1033 = this->properties.begin(); _iter1033 != this->properties.end(); ++_iter1033) + std::map ::const_iterator _iter1034; + for (_iter1034 = this->properties.begin(); _iter1034 != this->properties.end(); ++_iter1034) { - xfer += oprot->writeString(_iter1033->first); - xfer += oprot->writeString(_iter1033->second); + xfer += oprot->writeString(_iter1034->first); + xfer += oprot->writeString(_iter1034->second); } xfer += oprot->writeMapEnd(); } @@ -28102,21 +28155,7 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other1034) { - dbname = other1034.dbname; - tablename = other1034.tablename; - partitionname = other1034.partitionname; - type = other1034.type; - runas = other1034.runas; - properties = other1034.properties; - initiatorId = other1034.initiatorId; - initiatorVersion = other1034.initiatorVersion; - poolName = other1034.poolName; - numberOfBuckets = other1034.numberOfBuckets; - orderByClause = other1034.orderByClause; - __isset = other1034.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other1035) { +CompactionRequest::CompactionRequest(const CompactionRequest& other1035) { dbname = other1035.dbname; tablename = other1035.tablename; partitionname = other1035.partitionname; @@ -28129,6 +28168,20 @@ CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other10 numberOfBuckets = other1035.numberOfBuckets; orderByClause = other1035.orderByClause; __isset = other1035.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other1036) { + dbname = other1036.dbname; + tablename = other1036.tablename; + partitionname = other1036.partitionname; + type = other1036.type; + runas = other1036.runas; + properties = other1036.properties; + initiatorId = other1036.initiatorId; + initiatorVersion = other1036.initiatorVersion; + poolName = other1036.poolName; + numberOfBuckets = other1036.numberOfBuckets; + orderByClause = other1036.orderByClause; + __isset = other1036.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -28309,9 +28362,9 @@ uint32_t CompactionInfoStruct::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1036; - xfer += iprot->readI32(ecast1036); - this->type = static_cast(ecast1036); + int32_t ecast1037; + xfer += iprot->readI32(ecast1037); + this->type = static_cast(ecast1037); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -28574,29 +28627,7 @@ void swap(CompactionInfoStruct &a, CompactionInfoStruct &b) { swap(a.__isset, b.__isset); } -CompactionInfoStruct::CompactionInfoStruct(const CompactionInfoStruct& other1037) { - id = other1037.id; - dbname = other1037.dbname; - tablename = other1037.tablename; - partitionname = other1037.partitionname; - type = other1037.type; - runas = other1037.runas; - properties = other1037.properties; - toomanyaborts = other1037.toomanyaborts; - state = other1037.state; - workerId = other1037.workerId; - start = other1037.start; - highestWriteId = other1037.highestWriteId; - errorMessage = other1037.errorMessage; - hasoldabort = other1037.hasoldabort; - enqueueTime = other1037.enqueueTime; - retryRetention = other1037.retryRetention; - poolname = other1037.poolname; - numberOfBuckets = other1037.numberOfBuckets; - orderByClause = other1037.orderByClause; - __isset = other1037.__isset; -} -CompactionInfoStruct& CompactionInfoStruct::operator=(const CompactionInfoStruct& other1038) { +CompactionInfoStruct::CompactionInfoStruct(const CompactionInfoStruct& other1038) { id = other1038.id; dbname = other1038.dbname; tablename = other1038.tablename; @@ -28617,6 +28648,28 @@ CompactionInfoStruct& CompactionInfoStruct::operator=(const CompactionInfoStruct numberOfBuckets = other1038.numberOfBuckets; orderByClause = other1038.orderByClause; __isset = other1038.__isset; +} +CompactionInfoStruct& CompactionInfoStruct::operator=(const CompactionInfoStruct& other1039) { + id = other1039.id; + dbname = other1039.dbname; + tablename = other1039.tablename; + partitionname = other1039.partitionname; + type = other1039.type; + runas = other1039.runas; + properties = other1039.properties; + toomanyaborts = other1039.toomanyaborts; + state = other1039.state; + workerId = other1039.workerId; + start = other1039.start; + highestWriteId = other1039.highestWriteId; + errorMessage = other1039.errorMessage; + hasoldabort = other1039.hasoldabort; + enqueueTime = other1039.enqueueTime; + retryRetention = other1039.retryRetention; + poolname = other1039.poolname; + numberOfBuckets = other1039.numberOfBuckets; + orderByClause = other1039.orderByClause; + __isset = other1039.__isset; return *this; } void CompactionInfoStruct::printTo(std::ostream& out) const { @@ -28722,13 +28775,13 @@ void swap(OptionalCompactionInfoStruct &a, OptionalCompactionInfoStruct &b) { swap(a.__isset, b.__isset); } -OptionalCompactionInfoStruct::OptionalCompactionInfoStruct(const OptionalCompactionInfoStruct& other1039) { - ci = other1039.ci; - __isset = other1039.__isset; -} -OptionalCompactionInfoStruct& OptionalCompactionInfoStruct::operator=(const OptionalCompactionInfoStruct& other1040) { +OptionalCompactionInfoStruct::OptionalCompactionInfoStruct(const OptionalCompactionInfoStruct& other1040) { ci = other1040.ci; __isset = other1040.__isset; +} +OptionalCompactionInfoStruct& OptionalCompactionInfoStruct::operator=(const OptionalCompactionInfoStruct& other1041) { + ci = other1041.ci; + __isset = other1041.__isset; return *this; } void OptionalCompactionInfoStruct::printTo(std::ostream& out) const { @@ -28831,9 +28884,9 @@ uint32_t CompactionMetricsDataStruct::read(::apache::thrift::protocol::TProtocol break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1041; - xfer += iprot->readI32(ecast1041); - this->type = static_cast(ecast1041); + int32_t ecast1042; + xfer += iprot->readI32(ecast1042); + this->type = static_cast(ecast1042); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -28938,17 +28991,7 @@ void swap(CompactionMetricsDataStruct &a, CompactionMetricsDataStruct &b) { swap(a.__isset, b.__isset); } -CompactionMetricsDataStruct::CompactionMetricsDataStruct(const CompactionMetricsDataStruct& other1042) { - dbname = other1042.dbname; - tblname = other1042.tblname; - partitionname = other1042.partitionname; - type = other1042.type; - metricvalue = other1042.metricvalue; - version = other1042.version; - threshold = other1042.threshold; - __isset = other1042.__isset; -} -CompactionMetricsDataStruct& CompactionMetricsDataStruct::operator=(const CompactionMetricsDataStruct& other1043) { +CompactionMetricsDataStruct::CompactionMetricsDataStruct(const CompactionMetricsDataStruct& other1043) { dbname = other1043.dbname; tblname = other1043.tblname; partitionname = other1043.partitionname; @@ -28957,6 +29000,16 @@ CompactionMetricsDataStruct& CompactionMetricsDataStruct::operator=(const Compac version = other1043.version; threshold = other1043.threshold; __isset = other1043.__isset; +} +CompactionMetricsDataStruct& CompactionMetricsDataStruct::operator=(const CompactionMetricsDataStruct& other1044) { + dbname = other1044.dbname; + tblname = other1044.tblname; + partitionname = other1044.partitionname; + type = other1044.type; + metricvalue = other1044.metricvalue; + version = other1044.version; + threshold = other1044.threshold; + __isset = other1044.__isset; return *this; } void CompactionMetricsDataStruct::printTo(std::ostream& out) const { @@ -29050,13 +29103,13 @@ void swap(CompactionMetricsDataResponse &a, CompactionMetricsDataResponse &b) { swap(a.__isset, b.__isset); } -CompactionMetricsDataResponse::CompactionMetricsDataResponse(const CompactionMetricsDataResponse& other1044) { - data = other1044.data; - __isset = other1044.__isset; -} -CompactionMetricsDataResponse& CompactionMetricsDataResponse::operator=(const CompactionMetricsDataResponse& other1045) { +CompactionMetricsDataResponse::CompactionMetricsDataResponse(const CompactionMetricsDataResponse& other1045) { data = other1045.data; __isset = other1045.__isset; +} +CompactionMetricsDataResponse& CompactionMetricsDataResponse::operator=(const CompactionMetricsDataResponse& other1046) { + data = other1046.data; + __isset = other1046.__isset; return *this; } void CompactionMetricsDataResponse::printTo(std::ostream& out) const { @@ -29144,9 +29197,9 @@ uint32_t CompactionMetricsDataRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1046; - xfer += iprot->readI32(ecast1046); - this->type = static_cast(ecast1046); + int32_t ecast1047; + xfer += iprot->readI32(ecast1047); + this->type = static_cast(ecast1047); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -29206,19 +29259,19 @@ void swap(CompactionMetricsDataRequest &a, CompactionMetricsDataRequest &b) { swap(a.__isset, b.__isset); } -CompactionMetricsDataRequest::CompactionMetricsDataRequest(const CompactionMetricsDataRequest& other1047) { - dbName = other1047.dbName; - tblName = other1047.tblName; - partitionName = other1047.partitionName; - type = other1047.type; - __isset = other1047.__isset; -} -CompactionMetricsDataRequest& CompactionMetricsDataRequest::operator=(const CompactionMetricsDataRequest& other1048) { +CompactionMetricsDataRequest::CompactionMetricsDataRequest(const CompactionMetricsDataRequest& other1048) { dbName = other1048.dbName; tblName = other1048.tblName; partitionName = other1048.partitionName; type = other1048.type; __isset = other1048.__isset; +} +CompactionMetricsDataRequest& CompactionMetricsDataRequest::operator=(const CompactionMetricsDataRequest& other1049) { + dbName = other1049.dbName; + tblName = other1049.tblName; + partitionName = other1049.partitionName; + type = other1049.type; + __isset = other1049.__isset; return *this; } void CompactionMetricsDataRequest::printTo(std::ostream& out) const { @@ -29369,19 +29422,19 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.__isset, b.__isset); } -CompactionResponse::CompactionResponse(const CompactionResponse& other1049) { - id = other1049.id; - state = other1049.state; - accepted = other1049.accepted; - errormessage = other1049.errormessage; - __isset = other1049.__isset; -} -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other1050) { +CompactionResponse::CompactionResponse(const CompactionResponse& other1050) { id = other1050.id; state = other1050.state; accepted = other1050.accepted; errormessage = other1050.errormessage; __isset = other1050.__isset; +} +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other1051) { + id = other1051.id; + state = other1051.state; + accepted = other1051.accepted; + errormessage = other1051.errormessage; + __isset = other1051.__isset; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -29513,9 +29566,9 @@ uint32_t ShowCompactRequest::read(::apache::thrift::protocol::TProtocol* iprot) break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1051; - xfer += iprot->readI32(ecast1051); - this->type = static_cast(ecast1051); + int32_t ecast1052; + xfer += iprot->readI32(ecast1052); + this->type = static_cast(ecast1052); this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -29626,19 +29679,7 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { swap(a.__isset, b.__isset); } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other1052) { - id = other1052.id; - poolName = other1052.poolName; - dbName = other1052.dbName; - tbName = other1052.tbName; - partName = other1052.partName; - type = other1052.type; - state = other1052.state; - limit = other1052.limit; - order = other1052.order; - __isset = other1052.__isset; -} -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other1053) { +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other1053) { id = other1053.id; poolName = other1053.poolName; dbName = other1053.dbName; @@ -29649,6 +29690,18 @@ ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& othe limit = other1053.limit; order = other1053.order; __isset = other1053.__isset; +} +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other1054) { + id = other1054.id; + poolName = other1054.poolName; + dbName = other1054.dbName; + tbName = other1054.tbName; + partName = other1054.partName; + type = other1054.type; + state = other1054.state; + limit = other1054.limit; + order = other1054.order; + __isset = other1054.__isset; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -29844,9 +29897,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1054; - xfer += iprot->readI32(ecast1054); - this->type = static_cast(ecast1054); + int32_t ecast1055; + xfer += iprot->readI32(ecast1055); + this->type = static_cast(ecast1055); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -30187,34 +30240,7 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other1055) { - dbname = other1055.dbname; - tablename = other1055.tablename; - partitionname = other1055.partitionname; - type = other1055.type; - state = other1055.state; - workerid = other1055.workerid; - start = other1055.start; - runAs = other1055.runAs; - hightestTxnId = other1055.hightestTxnId; - metaInfo = other1055.metaInfo; - endTime = other1055.endTime; - hadoopJobId = other1055.hadoopJobId; - id = other1055.id; - errorMessage = other1055.errorMessage; - enqueueTime = other1055.enqueueTime; - workerVersion = other1055.workerVersion; - initiatorId = other1055.initiatorId; - initiatorVersion = other1055.initiatorVersion; - cleanerStart = other1055.cleanerStart; - poolName = other1055.poolName; - nextTxnId = other1055.nextTxnId; - txnId = other1055.txnId; - commitTime = other1055.commitTime; - hightestWriteId = other1055.hightestWriteId; - __isset = other1055.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other1056) { +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other1056) { dbname = other1056.dbname; tablename = other1056.tablename; partitionname = other1056.partitionname; @@ -30240,6 +30266,33 @@ ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowComp commitTime = other1056.commitTime; hightestWriteId = other1056.hightestWriteId; __isset = other1056.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other1057) { + dbname = other1057.dbname; + tablename = other1057.tablename; + partitionname = other1057.partitionname; + type = other1057.type; + state = other1057.state; + workerid = other1057.workerid; + start = other1057.start; + runAs = other1057.runAs; + hightestTxnId = other1057.hightestTxnId; + metaInfo = other1057.metaInfo; + endTime = other1057.endTime; + hadoopJobId = other1057.hadoopJobId; + id = other1057.id; + errorMessage = other1057.errorMessage; + enqueueTime = other1057.enqueueTime; + workerVersion = other1057.workerVersion; + initiatorId = other1057.initiatorId; + initiatorVersion = other1057.initiatorVersion; + cleanerStart = other1057.cleanerStart; + poolName = other1057.poolName; + nextTxnId = other1057.nextTxnId; + txnId = other1057.txnId; + commitTime = other1057.commitTime; + hightestWriteId = other1057.hightestWriteId; + __isset = other1057.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -30313,14 +30366,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size1057; - ::apache::thrift::protocol::TType _etype1060; - xfer += iprot->readListBegin(_etype1060, _size1057); - this->compacts.resize(_size1057); - uint32_t _i1061; - for (_i1061 = 0; _i1061 < _size1057; ++_i1061) + uint32_t _size1058; + ::apache::thrift::protocol::TType _etype1061; + xfer += iprot->readListBegin(_etype1061, _size1058); + this->compacts.resize(_size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - xfer += this->compacts[_i1061].read(iprot); + xfer += this->compacts[_i1062].read(iprot); } xfer += iprot->readListEnd(); } @@ -30351,10 +30404,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); - std::vector ::const_iterator _iter1062; - for (_iter1062 = this->compacts.begin(); _iter1062 != this->compacts.end(); ++_iter1062) + std::vector ::const_iterator _iter1063; + for (_iter1063 = this->compacts.begin(); _iter1063 != this->compacts.end(); ++_iter1063) { - xfer += (*_iter1062).write(oprot); + xfer += (*_iter1063).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30370,11 +30423,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other1063) { - compacts = other1063.compacts; -} -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other1064) { +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other1064) { compacts = other1064.compacts; +} +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other1065) { + compacts = other1065.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -30435,14 +30488,14 @@ uint32_t AbortCompactionRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compactionIds.clear(); - uint32_t _size1065; - ::apache::thrift::protocol::TType _etype1068; - xfer += iprot->readListBegin(_etype1068, _size1065); - this->compactionIds.resize(_size1065); - uint32_t _i1069; - for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + uint32_t _size1066; + ::apache::thrift::protocol::TType _etype1069; + xfer += iprot->readListBegin(_etype1069, _size1066); + this->compactionIds.resize(_size1066); + uint32_t _i1070; + for (_i1070 = 0; _i1070 < _size1066; ++_i1070) { - xfer += iprot->readI64(this->compactionIds[_i1069]); + xfer += iprot->readI64(this->compactionIds[_i1070]); } xfer += iprot->readListEnd(); } @@ -30489,10 +30542,10 @@ uint32_t AbortCompactionRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("compactionIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->compactionIds.size())); - std::vector ::const_iterator _iter1070; - for (_iter1070 = this->compactionIds.begin(); _iter1070 != this->compactionIds.end(); ++_iter1070) + std::vector ::const_iterator _iter1071; + for (_iter1071 = this->compactionIds.begin(); _iter1071 != this->compactionIds.end(); ++_iter1071) { - xfer += oprot->writeI64((*_iter1070)); + xfer += oprot->writeI64((*_iter1071)); } xfer += oprot->writeListEnd(); } @@ -30521,17 +30574,17 @@ void swap(AbortCompactionRequest &a, AbortCompactionRequest &b) { swap(a.__isset, b.__isset); } -AbortCompactionRequest::AbortCompactionRequest(const AbortCompactionRequest& other1071) { - compactionIds = other1071.compactionIds; - type = other1071.type; - poolName = other1071.poolName; - __isset = other1071.__isset; -} -AbortCompactionRequest& AbortCompactionRequest::operator=(const AbortCompactionRequest& other1072) { +AbortCompactionRequest::AbortCompactionRequest(const AbortCompactionRequest& other1072) { compactionIds = other1072.compactionIds; type = other1072.type; poolName = other1072.poolName; __isset = other1072.__isset; +} +AbortCompactionRequest& AbortCompactionRequest::operator=(const AbortCompactionRequest& other1073) { + compactionIds = other1073.compactionIds; + type = other1073.type; + poolName = other1073.poolName; + __isset = other1073.__isset; return *this; } void AbortCompactionRequest::printTo(std::ostream& out) const { @@ -30660,17 +30713,17 @@ void swap(AbortCompactionResponseElement &a, AbortCompactionResponseElement &b) swap(a.__isset, b.__isset); } -AbortCompactionResponseElement::AbortCompactionResponseElement(const AbortCompactionResponseElement& other1073) { - compactionId = other1073.compactionId; - status = other1073.status; - message = other1073.message; - __isset = other1073.__isset; -} -AbortCompactionResponseElement& AbortCompactionResponseElement::operator=(const AbortCompactionResponseElement& other1074) { +AbortCompactionResponseElement::AbortCompactionResponseElement(const AbortCompactionResponseElement& other1074) { compactionId = other1074.compactionId; status = other1074.status; message = other1074.message; __isset = other1074.__isset; +} +AbortCompactionResponseElement& AbortCompactionResponseElement::operator=(const AbortCompactionResponseElement& other1075) { + compactionId = other1075.compactionId; + status = other1075.status; + message = other1075.message; + __isset = other1075.__isset; return *this; } void AbortCompactionResponseElement::printTo(std::ostream& out) const { @@ -30723,17 +30776,17 @@ uint32_t AbortCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_MAP) { { this->abortedcompacts.clear(); - uint32_t _size1075; - ::apache::thrift::protocol::TType _ktype1076; - ::apache::thrift::protocol::TType _vtype1077; - xfer += iprot->readMapBegin(_ktype1076, _vtype1077, _size1075); - uint32_t _i1079; - for (_i1079 = 0; _i1079 < _size1075; ++_i1079) + uint32_t _size1076; + ::apache::thrift::protocol::TType _ktype1077; + ::apache::thrift::protocol::TType _vtype1078; + xfer += iprot->readMapBegin(_ktype1077, _vtype1078, _size1076); + uint32_t _i1080; + for (_i1080 = 0; _i1080 < _size1076; ++_i1080) { - int64_t _key1080; - xfer += iprot->readI64(_key1080); - AbortCompactionResponseElement& _val1081 = this->abortedcompacts[_key1080]; - xfer += _val1081.read(iprot); + int64_t _key1081; + xfer += iprot->readI64(_key1081); + AbortCompactionResponseElement& _val1082 = this->abortedcompacts[_key1081]; + xfer += _val1082.read(iprot); } xfer += iprot->readMapEnd(); } @@ -30764,11 +30817,11 @@ uint32_t AbortCompactResponse::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("abortedcompacts", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->abortedcompacts.size())); - std::map ::const_iterator _iter1082; - for (_iter1082 = this->abortedcompacts.begin(); _iter1082 != this->abortedcompacts.end(); ++_iter1082) + std::map ::const_iterator _iter1083; + for (_iter1083 = this->abortedcompacts.begin(); _iter1083 != this->abortedcompacts.end(); ++_iter1083) { - xfer += oprot->writeI64(_iter1082->first); - xfer += _iter1082->second.write(oprot); + xfer += oprot->writeI64(_iter1083->first); + xfer += _iter1083->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -30784,11 +30837,11 @@ void swap(AbortCompactResponse &a, AbortCompactResponse &b) { swap(a.abortedcompacts, b.abortedcompacts); } -AbortCompactResponse::AbortCompactResponse(const AbortCompactResponse& other1083) { - abortedcompacts = other1083.abortedcompacts; -} -AbortCompactResponse& AbortCompactResponse::operator=(const AbortCompactResponse& other1084) { +AbortCompactResponse::AbortCompactResponse(const AbortCompactResponse& other1084) { abortedcompacts = other1084.abortedcompacts; +} +AbortCompactResponse& AbortCompactResponse::operator=(const AbortCompactResponse& other1085) { + abortedcompacts = other1085.abortedcompacts; return *this; } void AbortCompactResponse::printTo(std::ostream& out) const { @@ -30870,14 +30923,14 @@ uint32_t GetLatestCommittedCompactionInfoRequest::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size1085; - ::apache::thrift::protocol::TType _etype1088; - xfer += iprot->readListBegin(_etype1088, _size1085); - this->partitionnames.resize(_size1085); - uint32_t _i1089; - for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + uint32_t _size1086; + ::apache::thrift::protocol::TType _etype1089; + xfer += iprot->readListBegin(_etype1089, _size1086); + this->partitionnames.resize(_size1086); + uint32_t _i1090; + for (_i1090 = 0; _i1090 < _size1086; ++_i1090) { - xfer += iprot->readString(this->partitionnames[_i1089]); + xfer += iprot->readString(this->partitionnames[_i1090]); } xfer += iprot->readListEnd(); } @@ -30927,10 +30980,10 @@ uint32_t GetLatestCommittedCompactionInfoRequest::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter1090; - for (_iter1090 = this->partitionnames.begin(); _iter1090 != this->partitionnames.end(); ++_iter1090) + std::vector ::const_iterator _iter1091; + for (_iter1091 = this->partitionnames.begin(); _iter1091 != this->partitionnames.end(); ++_iter1091) { - xfer += oprot->writeString((*_iter1090)); + xfer += oprot->writeString((*_iter1091)); } xfer += oprot->writeListEnd(); } @@ -30955,19 +31008,19 @@ void swap(GetLatestCommittedCompactionInfoRequest &a, GetLatestCommittedCompacti swap(a.__isset, b.__isset); } -GetLatestCommittedCompactionInfoRequest::GetLatestCommittedCompactionInfoRequest(const GetLatestCommittedCompactionInfoRequest& other1091) { - dbname = other1091.dbname; - tablename = other1091.tablename; - partitionnames = other1091.partitionnames; - lastCompactionId = other1091.lastCompactionId; - __isset = other1091.__isset; -} -GetLatestCommittedCompactionInfoRequest& GetLatestCommittedCompactionInfoRequest::operator=(const GetLatestCommittedCompactionInfoRequest& other1092) { +GetLatestCommittedCompactionInfoRequest::GetLatestCommittedCompactionInfoRequest(const GetLatestCommittedCompactionInfoRequest& other1092) { dbname = other1092.dbname; tablename = other1092.tablename; partitionnames = other1092.partitionnames; lastCompactionId = other1092.lastCompactionId; __isset = other1092.__isset; +} +GetLatestCommittedCompactionInfoRequest& GetLatestCommittedCompactionInfoRequest::operator=(const GetLatestCommittedCompactionInfoRequest& other1093) { + dbname = other1093.dbname; + tablename = other1093.tablename; + partitionnames = other1093.partitionnames; + lastCompactionId = other1093.lastCompactionId; + __isset = other1093.__isset; return *this; } void GetLatestCommittedCompactionInfoRequest::printTo(std::ostream& out) const { @@ -31021,14 +31074,14 @@ uint32_t GetLatestCommittedCompactionInfoResponse::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compactions.clear(); - uint32_t _size1093; - ::apache::thrift::protocol::TType _etype1096; - xfer += iprot->readListBegin(_etype1096, _size1093); - this->compactions.resize(_size1093); - uint32_t _i1097; - for (_i1097 = 0; _i1097 < _size1093; ++_i1097) + uint32_t _size1094; + ::apache::thrift::protocol::TType _etype1097; + xfer += iprot->readListBegin(_etype1097, _size1094); + this->compactions.resize(_size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - xfer += this->compactions[_i1097].read(iprot); + xfer += this->compactions[_i1098].read(iprot); } xfer += iprot->readListEnd(); } @@ -31059,10 +31112,10 @@ uint32_t GetLatestCommittedCompactionInfoResponse::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("compactions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compactions.size())); - std::vector ::const_iterator _iter1098; - for (_iter1098 = this->compactions.begin(); _iter1098 != this->compactions.end(); ++_iter1098) + std::vector ::const_iterator _iter1099; + for (_iter1099 = this->compactions.begin(); _iter1099 != this->compactions.end(); ++_iter1099) { - xfer += (*_iter1098).write(oprot); + xfer += (*_iter1099).write(oprot); } xfer += oprot->writeListEnd(); } @@ -31078,11 +31131,11 @@ void swap(GetLatestCommittedCompactionInfoResponse &a, GetLatestCommittedCompact swap(a.compactions, b.compactions); } -GetLatestCommittedCompactionInfoResponse::GetLatestCommittedCompactionInfoResponse(const GetLatestCommittedCompactionInfoResponse& other1099) { - compactions = other1099.compactions; -} -GetLatestCommittedCompactionInfoResponse& GetLatestCommittedCompactionInfoResponse::operator=(const GetLatestCommittedCompactionInfoResponse& other1100) { +GetLatestCommittedCompactionInfoResponse::GetLatestCommittedCompactionInfoResponse(const GetLatestCommittedCompactionInfoResponse& other1100) { compactions = other1100.compactions; +} +GetLatestCommittedCompactionInfoResponse& GetLatestCommittedCompactionInfoResponse::operator=(const GetLatestCommittedCompactionInfoResponse& other1101) { + compactions = other1101.compactions; return *this; } void GetLatestCommittedCompactionInfoResponse::printTo(std::ostream& out) const { @@ -31208,17 +31261,17 @@ void swap(FindNextCompactRequest &a, FindNextCompactRequest &b) { swap(a.__isset, b.__isset); } -FindNextCompactRequest::FindNextCompactRequest(const FindNextCompactRequest& other1101) { - workerId = other1101.workerId; - workerVersion = other1101.workerVersion; - poolName = other1101.poolName; - __isset = other1101.__isset; -} -FindNextCompactRequest& FindNextCompactRequest::operator=(const FindNextCompactRequest& other1102) { +FindNextCompactRequest::FindNextCompactRequest(const FindNextCompactRequest& other1102) { workerId = other1102.workerId; workerVersion = other1102.workerVersion; poolName = other1102.poolName; __isset = other1102.__isset; +} +FindNextCompactRequest& FindNextCompactRequest::operator=(const FindNextCompactRequest& other1103) { + workerId = other1103.workerId; + workerVersion = other1103.workerVersion; + poolName = other1103.poolName; + __isset = other1103.__isset; return *this; } void FindNextCompactRequest::printTo(std::ostream& out) const { @@ -31328,14 +31381,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->partitionnames.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1104; + ::apache::thrift::protocol::TType _etype1107; + xfer += iprot->readListBegin(_etype1107, _size1104); + this->partitionnames.resize(_size1104); + uint32_t _i1108; + for (_i1108 = 0; _i1108 < _size1104; ++_i1108) { - xfer += iprot->readString(this->partitionnames[_i1107]); + xfer += iprot->readString(this->partitionnames[_i1108]); } xfer += iprot->readListEnd(); } @@ -31346,9 +31399,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1108; - xfer += iprot->readI32(ecast1108); - this->operationType = static_cast(ecast1108); + int32_t ecast1109; + xfer += iprot->readI32(ecast1109); + this->operationType = static_cast(ecast1109); this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -31400,10 +31453,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter1109; - for (_iter1109 = this->partitionnames.begin(); _iter1109 != this->partitionnames.end(); ++_iter1109) + std::vector ::const_iterator _iter1110; + for (_iter1110 = this->partitionnames.begin(); _iter1110 != this->partitionnames.end(); ++_iter1110) { - xfer += oprot->writeString((*_iter1109)); + xfer += oprot->writeString((*_iter1110)); } xfer += oprot->writeListEnd(); } @@ -31430,16 +31483,7 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other1110) { - txnid = other1110.txnid; - writeid = other1110.writeid; - dbname = other1110.dbname; - tablename = other1110.tablename; - partitionnames = other1110.partitionnames; - operationType = other1110.operationType; - __isset = other1110.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other1111) { +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other1111) { txnid = other1111.txnid; writeid = other1111.writeid; dbname = other1111.dbname; @@ -31447,6 +31491,15 @@ AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions partitionnames = other1111.partitionnames; operationType = other1111.operationType; __isset = other1111.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other1112) { + txnid = other1112.txnid; + writeid = other1112.writeid; + dbname = other1112.dbname; + tablename = other1112.tablename; + partitionnames = other1112.partitionnames; + operationType = other1112.operationType; + __isset = other1112.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -31635,16 +31688,7 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) { swap(a.__isset, b.__isset); } -BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other1112) { - isnull = other1112.isnull; - time = other1112.time; - txnid = other1112.txnid; - dbname = other1112.dbname; - tablename = other1112.tablename; - partitionname = other1112.partitionname; - __isset = other1112.__isset; -} -BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other1113) { +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other1113) { isnull = other1113.isnull; time = other1113.time; txnid = other1113.txnid; @@ -31652,6 +31696,15 @@ BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other1113) { tablename = other1113.tablename; partitionname = other1113.partitionname; __isset = other1113.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other1114) { + isnull = other1114.isnull; + time = other1114.time; + txnid = other1114.txnid; + dbname = other1114.dbname; + tablename = other1114.tablename; + partitionname = other1114.partitionname; + __isset = other1114.__isset; return *this; } void BasicTxnInfo::printTo(std::ostream& out) const { @@ -31748,14 +31801,14 @@ uint32_t NotificationEventRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->eventTypeSkipList.clear(); - uint32_t _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - this->eventTypeSkipList.resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1115; + ::apache::thrift::protocol::TType _etype1118; + xfer += iprot->readListBegin(_etype1118, _size1115); + this->eventTypeSkipList.resize(_size1115); + uint32_t _i1119; + for (_i1119 = 0; _i1119 < _size1115; ++_i1119) { - xfer += iprot->readString(this->eventTypeSkipList[_i1118]); + xfer += iprot->readString(this->eventTypeSkipList[_i1119]); } xfer += iprot->readListEnd(); } @@ -31784,14 +31837,14 @@ uint32_t NotificationEventRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableNames.clear(); - uint32_t _size1119; - ::apache::thrift::protocol::TType _etype1122; - xfer += iprot->readListBegin(_etype1122, _size1119); - this->tableNames.resize(_size1119); - uint32_t _i1123; - for (_i1123 = 0; _i1123 < _size1119; ++_i1123) + uint32_t _size1120; + ::apache::thrift::protocol::TType _etype1123; + xfer += iprot->readListBegin(_etype1123, _size1120); + this->tableNames.resize(_size1120); + uint32_t _i1124; + for (_i1124 = 0; _i1124 < _size1120; ++_i1124) { - xfer += iprot->readString(this->tableNames[_i1123]); + xfer += iprot->readString(this->tableNames[_i1124]); } xfer += iprot->readListEnd(); } @@ -31832,10 +31885,10 @@ uint32_t NotificationEventRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("eventTypeSkipList", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->eventTypeSkipList.size())); - std::vector ::const_iterator _iter1124; - for (_iter1124 = this->eventTypeSkipList.begin(); _iter1124 != this->eventTypeSkipList.end(); ++_iter1124) + std::vector ::const_iterator _iter1125; + for (_iter1125 = this->eventTypeSkipList.begin(); _iter1125 != this->eventTypeSkipList.end(); ++_iter1125) { - xfer += oprot->writeString((*_iter1124)); + xfer += oprot->writeString((*_iter1125)); } xfer += oprot->writeListEnd(); } @@ -31855,10 +31908,10 @@ uint32_t NotificationEventRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("tableNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tableNames.size())); - std::vector ::const_iterator _iter1125; - for (_iter1125 = this->tableNames.begin(); _iter1125 != this->tableNames.end(); ++_iter1125) + std::vector ::const_iterator _iter1126; + for (_iter1126 = this->tableNames.begin(); _iter1126 != this->tableNames.end(); ++_iter1126) { - xfer += oprot->writeString((*_iter1125)); + xfer += oprot->writeString((*_iter1126)); } xfer += oprot->writeListEnd(); } @@ -31880,16 +31933,7 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other1126) { - lastEvent = other1126.lastEvent; - maxEvents = other1126.maxEvents; - eventTypeSkipList = other1126.eventTypeSkipList; - catName = other1126.catName; - dbName = other1126.dbName; - tableNames = other1126.tableNames; - __isset = other1126.__isset; -} -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other1127) { +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other1127) { lastEvent = other1127.lastEvent; maxEvents = other1127.maxEvents; eventTypeSkipList = other1127.eventTypeSkipList; @@ -31897,6 +31941,15 @@ NotificationEventRequest& NotificationEventRequest::operator=(const Notification dbName = other1127.dbName; tableNames = other1127.tableNames; __isset = other1127.__isset; +} +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other1128) { + lastEvent = other1128.lastEvent; + maxEvents = other1128.maxEvents; + eventTypeSkipList = other1128.eventTypeSkipList; + catName = other1128.catName; + dbName = other1128.dbName; + tableNames = other1128.tableNames; + __isset = other1128.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -32126,18 +32179,7 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other1128) { - eventId = other1128.eventId; - eventTime = other1128.eventTime; - eventType = other1128.eventType; - dbName = other1128.dbName; - tableName = other1128.tableName; - message = other1128.message; - messageFormat = other1128.messageFormat; - catName = other1128.catName; - __isset = other1128.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other1129) { +NotificationEvent::NotificationEvent(const NotificationEvent& other1129) { eventId = other1129.eventId; eventTime = other1129.eventTime; eventType = other1129.eventType; @@ -32147,6 +32189,17 @@ NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other11 messageFormat = other1129.messageFormat; catName = other1129.catName; __isset = other1129.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other1130) { + eventId = other1130.eventId; + eventTime = other1130.eventTime; + eventType = other1130.eventType; + dbName = other1130.dbName; + tableName = other1130.tableName; + message = other1130.message; + messageFormat = other1130.messageFormat; + catName = other1130.catName; + __isset = other1130.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -32204,14 +32257,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size1130; - ::apache::thrift::protocol::TType _etype1133; - xfer += iprot->readListBegin(_etype1133, _size1130); - this->events.resize(_size1130); - uint32_t _i1134; - for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + uint32_t _size1131; + ::apache::thrift::protocol::TType _etype1134; + xfer += iprot->readListBegin(_etype1134, _size1131); + this->events.resize(_size1131); + uint32_t _i1135; + for (_i1135 = 0; _i1135 < _size1131; ++_i1135) { - xfer += this->events[_i1134].read(iprot); + xfer += this->events[_i1135].read(iprot); } xfer += iprot->readListEnd(); } @@ -32242,10 +32295,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); - std::vector ::const_iterator _iter1135; - for (_iter1135 = this->events.begin(); _iter1135 != this->events.end(); ++_iter1135) + std::vector ::const_iterator _iter1136; + for (_iter1136 = this->events.begin(); _iter1136 != this->events.end(); ++_iter1136) { - xfer += (*_iter1135).write(oprot); + xfer += (*_iter1136).write(oprot); } xfer += oprot->writeListEnd(); } @@ -32261,11 +32314,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other1136) { - events = other1136.events; -} -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other1137) { +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other1137) { events = other1137.events; +} +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other1138) { + events = other1138.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -32353,11 +32406,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other1138) noexcept { - eventId = other1138.eventId; -} -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other1139) noexcept { +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other1139) noexcept { eventId = other1139.eventId; +} +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other1140) noexcept { + eventId = other1140.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -32473,14 +32526,14 @@ uint32_t NotificationEventsCountRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableNames.clear(); - uint32_t _size1140; - ::apache::thrift::protocol::TType _etype1143; - xfer += iprot->readListBegin(_etype1143, _size1140); - this->tableNames.resize(_size1140); - uint32_t _i1144; - for (_i1144 = 0; _i1144 < _size1140; ++_i1144) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->tableNames.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += iprot->readString(this->tableNames[_i1144]); + xfer += iprot->readString(this->tableNames[_i1145]); } xfer += iprot->readListEnd(); } @@ -32537,10 +32590,10 @@ uint32_t NotificationEventsCountRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("tableNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tableNames.size())); - std::vector ::const_iterator _iter1145; - for (_iter1145 = this->tableNames.begin(); _iter1145 != this->tableNames.end(); ++_iter1145) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->tableNames.begin(); _iter1146 != this->tableNames.end(); ++_iter1146) { - xfer += oprot->writeString((*_iter1145)); + xfer += oprot->writeString((*_iter1146)); } xfer += oprot->writeListEnd(); } @@ -32562,16 +32615,7 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.__isset, b.__isset); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other1146) { - fromEventId = other1146.fromEventId; - dbName = other1146.dbName; - catName = other1146.catName; - toEventId = other1146.toEventId; - limit = other1146.limit; - tableNames = other1146.tableNames; - __isset = other1146.__isset; -} -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other1147) { +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other1147) { fromEventId = other1147.fromEventId; dbName = other1147.dbName; catName = other1147.catName; @@ -32579,6 +32623,15 @@ NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const limit = other1147.limit; tableNames = other1147.tableNames; __isset = other1147.__isset; +} +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other1148) { + fromEventId = other1148.fromEventId; + dbName = other1148.dbName; + catName = other1148.catName; + toEventId = other1148.toEventId; + limit = other1148.limit; + tableNames = other1148.tableNames; + __isset = other1148.__isset; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -32671,11 +32724,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other1148) noexcept { - eventsCount = other1148.eventsCount; -} -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other1149) noexcept { +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other1149) noexcept { eventsCount = other1149.eventsCount; +} +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other1150) noexcept { + eventsCount = other1150.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -32754,14 +32807,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size1150; - ::apache::thrift::protocol::TType _etype1153; - xfer += iprot->readListBegin(_etype1153, _size1150); - this->filesAdded.resize(_size1150); - uint32_t _i1154; - for (_i1154 = 0; _i1154 < _size1150; ++_i1154) + uint32_t _size1151; + ::apache::thrift::protocol::TType _etype1154; + xfer += iprot->readListBegin(_etype1154, _size1151); + this->filesAdded.resize(_size1151); + uint32_t _i1155; + for (_i1155 = 0; _i1155 < _size1151; ++_i1155) { - xfer += iprot->readString(this->filesAdded[_i1154]); + xfer += iprot->readString(this->filesAdded[_i1155]); } xfer += iprot->readListEnd(); } @@ -32774,14 +32827,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size1155; - ::apache::thrift::protocol::TType _etype1158; - xfer += iprot->readListBegin(_etype1158, _size1155); - this->filesAddedChecksum.resize(_size1155); - uint32_t _i1159; - for (_i1159 = 0; _i1159 < _size1155; ++_i1159) + uint32_t _size1156; + ::apache::thrift::protocol::TType _etype1159; + xfer += iprot->readListBegin(_etype1159, _size1156); + this->filesAddedChecksum.resize(_size1156); + uint32_t _i1160; + for (_i1160 = 0; _i1160 < _size1156; ++_i1160) { - xfer += iprot->readString(this->filesAddedChecksum[_i1159]); + xfer += iprot->readString(this->filesAddedChecksum[_i1160]); } xfer += iprot->readListEnd(); } @@ -32794,14 +32847,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->subDirectoryList.clear(); - uint32_t _size1160; - ::apache::thrift::protocol::TType _etype1163; - xfer += iprot->readListBegin(_etype1163, _size1160); - this->subDirectoryList.resize(_size1160); - uint32_t _i1164; - for (_i1164 = 0; _i1164 < _size1160; ++_i1164) + uint32_t _size1161; + ::apache::thrift::protocol::TType _etype1164; + xfer += iprot->readListBegin(_etype1164, _size1161); + this->subDirectoryList.resize(_size1161); + uint32_t _i1165; + for (_i1165 = 0; _i1165 < _size1161; ++_i1165) { - xfer += iprot->readString(this->subDirectoryList[_i1164]); + xfer += iprot->readString(this->subDirectoryList[_i1165]); } xfer += iprot->readListEnd(); } @@ -32814,14 +32867,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVal.clear(); - uint32_t _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - this->partitionVal.resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + this->partitionVal.resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += iprot->readString(this->partitionVal[_i1169]); + xfer += iprot->readString(this->partitionVal[_i1170]); } xfer += iprot->readListEnd(); } @@ -32857,10 +32910,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter1170; - for (_iter1170 = this->filesAdded.begin(); _iter1170 != this->filesAdded.end(); ++_iter1170) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->filesAdded.begin(); _iter1171 != this->filesAdded.end(); ++_iter1171) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1171)); } xfer += oprot->writeListEnd(); } @@ -32870,10 +32923,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAddedChecksum.size())); - std::vector ::const_iterator _iter1171; - for (_iter1171 = this->filesAddedChecksum.begin(); _iter1171 != this->filesAddedChecksum.end(); ++_iter1171) + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->filesAddedChecksum.begin(); _iter1172 != this->filesAddedChecksum.end(); ++_iter1172) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1172)); } xfer += oprot->writeListEnd(); } @@ -32883,10 +32936,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("subDirectoryList", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->subDirectoryList.size())); - std::vector ::const_iterator _iter1172; - for (_iter1172 = this->subDirectoryList.begin(); _iter1172 != this->subDirectoryList.end(); ++_iter1172) + std::vector ::const_iterator _iter1173; + for (_iter1173 = this->subDirectoryList.begin(); _iter1173 != this->subDirectoryList.end(); ++_iter1173) { - xfer += oprot->writeString((*_iter1172)); + xfer += oprot->writeString((*_iter1173)); } xfer += oprot->writeListEnd(); } @@ -32896,10 +32949,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionVal", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVal.size())); - std::vector ::const_iterator _iter1173; - for (_iter1173 = this->partitionVal.begin(); _iter1173 != this->partitionVal.end(); ++_iter1173) + std::vector ::const_iterator _iter1174; + for (_iter1174 = this->partitionVal.begin(); _iter1174 != this->partitionVal.end(); ++_iter1174) { - xfer += oprot->writeString((*_iter1173)); + xfer += oprot->writeString((*_iter1174)); } xfer += oprot->writeListEnd(); } @@ -32920,21 +32973,21 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other1174) { - replace = other1174.replace; - filesAdded = other1174.filesAdded; - filesAddedChecksum = other1174.filesAddedChecksum; - subDirectoryList = other1174.subDirectoryList; - partitionVal = other1174.partitionVal; - __isset = other1174.__isset; -} -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other1175) { +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other1175) { replace = other1175.replace; filesAdded = other1175.filesAdded; filesAddedChecksum = other1175.filesAddedChecksum; subDirectoryList = other1175.subDirectoryList; partitionVal = other1175.partitionVal; __isset = other1175.__isset; +} +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other1176) { + replace = other1176.replace; + filesAdded = other1176.filesAdded; + filesAddedChecksum = other1176.filesAddedChecksum; + subDirectoryList = other1176.subDirectoryList; + partitionVal = other1176.partitionVal; + __isset = other1176.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -33007,14 +33060,14 @@ uint32_t FireEventRequestData::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->insertDatas.clear(); - uint32_t _size1176; - ::apache::thrift::protocol::TType _etype1179; - xfer += iprot->readListBegin(_etype1179, _size1176); - this->insertDatas.resize(_size1176); - uint32_t _i1180; - for (_i1180 = 0; _i1180 < _size1176; ++_i1180) + uint32_t _size1177; + ::apache::thrift::protocol::TType _etype1180; + xfer += iprot->readListBegin(_etype1180, _size1177); + this->insertDatas.resize(_size1177); + uint32_t _i1181; + for (_i1181 = 0; _i1181 < _size1177; ++_i1181) { - xfer += this->insertDatas[_i1180].read(iprot); + xfer += this->insertDatas[_i1181].read(iprot); } xfer += iprot->readListEnd(); } @@ -33057,10 +33110,10 @@ uint32_t FireEventRequestData::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("insertDatas", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->insertDatas.size())); - std::vector ::const_iterator _iter1181; - for (_iter1181 = this->insertDatas.begin(); _iter1181 != this->insertDatas.end(); ++_iter1181) + std::vector ::const_iterator _iter1182; + for (_iter1182 = this->insertDatas.begin(); _iter1182 != this->insertDatas.end(); ++_iter1182) { - xfer += (*_iter1181).write(oprot); + xfer += (*_iter1182).write(oprot); } xfer += oprot->writeListEnd(); } @@ -33084,17 +33137,17 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other1182) { - insertData = other1182.insertData; - insertDatas = other1182.insertDatas; - refreshEvent = other1182.refreshEvent; - __isset = other1182.__isset; -} -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other1183) { +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other1183) { insertData = other1183.insertData; insertDatas = other1183.insertDatas; refreshEvent = other1183.refreshEvent; __isset = other1183.__isset; +} +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other1184) { + insertData = other1184.insertData; + insertDatas = other1184.insertDatas; + refreshEvent = other1184.refreshEvent; + __isset = other1184.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -33209,14 +33262,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size1184; - ::apache::thrift::protocol::TType _etype1187; - xfer += iprot->readListBegin(_etype1187, _size1184); - this->partitionVals.resize(_size1184); - uint32_t _i1188; - for (_i1188 = 0; _i1188 < _size1184; ++_i1188) + uint32_t _size1185; + ::apache::thrift::protocol::TType _etype1188; + xfer += iprot->readListBegin(_etype1188, _size1185); + this->partitionVals.resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += iprot->readString(this->partitionVals[_i1188]); + xfer += iprot->readString(this->partitionVals[_i1189]); } xfer += iprot->readListEnd(); } @@ -33237,17 +33290,17 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->tblParams.clear(); - uint32_t _size1189; - ::apache::thrift::protocol::TType _ktype1190; - ::apache::thrift::protocol::TType _vtype1191; - xfer += iprot->readMapBegin(_ktype1190, _vtype1191, _size1189); - uint32_t _i1193; - for (_i1193 = 0; _i1193 < _size1189; ++_i1193) + uint32_t _size1190; + ::apache::thrift::protocol::TType _ktype1191; + ::apache::thrift::protocol::TType _vtype1192; + xfer += iprot->readMapBegin(_ktype1191, _vtype1192, _size1190); + uint32_t _i1194; + for (_i1194 = 0; _i1194 < _size1190; ++_i1194) { - std::string _key1194; - xfer += iprot->readString(_key1194); - std::string& _val1195 = this->tblParams[_key1194]; - xfer += iprot->readString(_val1195); + std::string _key1195; + xfer += iprot->readString(_key1195); + std::string& _val1196 = this->tblParams[_key1195]; + xfer += iprot->readString(_val1196); } xfer += iprot->readMapEnd(); } @@ -33299,10 +33352,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter1196; - for (_iter1196 = this->partitionVals.begin(); _iter1196 != this->partitionVals.end(); ++_iter1196) + std::vector ::const_iterator _iter1197; + for (_iter1197 = this->partitionVals.begin(); _iter1197 != this->partitionVals.end(); ++_iter1197) { - xfer += oprot->writeString((*_iter1196)); + xfer += oprot->writeString((*_iter1197)); } xfer += oprot->writeListEnd(); } @@ -33317,11 +33370,11 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblParams", ::apache::thrift::protocol::T_MAP, 7); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->tblParams.size())); - std::map ::const_iterator _iter1197; - for (_iter1197 = this->tblParams.begin(); _iter1197 != this->tblParams.end(); ++_iter1197) + std::map ::const_iterator _iter1198; + for (_iter1198 = this->tblParams.begin(); _iter1198 != this->tblParams.end(); ++_iter1198) { - xfer += oprot->writeString(_iter1197->first); - xfer += oprot->writeString(_iter1197->second); + xfer += oprot->writeString(_iter1198->first); + xfer += oprot->writeString(_iter1198->second); } xfer += oprot->writeMapEnd(); } @@ -33344,17 +33397,7 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other1198) { - successful = other1198.successful; - data = other1198.data; - dbName = other1198.dbName; - tableName = other1198.tableName; - partitionVals = other1198.partitionVals; - catName = other1198.catName; - tblParams = other1198.tblParams; - __isset = other1198.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other1199) { +FireEventRequest::FireEventRequest(const FireEventRequest& other1199) { successful = other1199.successful; data = other1199.data; dbName = other1199.dbName; @@ -33363,6 +33406,16 @@ FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other1199) catName = other1199.catName; tblParams = other1199.tblParams; __isset = other1199.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other1200) { + successful = other1200.successful; + data = other1200.data; + dbName = other1200.dbName; + tableName = other1200.tableName; + partitionVals = other1200.partitionVals; + catName = other1200.catName; + tblParams = other1200.tblParams; + __isset = other1200.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -33418,14 +33471,14 @@ uint32_t FireEventResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->eventIds.clear(); - uint32_t _size1200; - ::apache::thrift::protocol::TType _etype1203; - xfer += iprot->readListBegin(_etype1203, _size1200); - this->eventIds.resize(_size1200); - uint32_t _i1204; - for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + uint32_t _size1201; + ::apache::thrift::protocol::TType _etype1204; + xfer += iprot->readListBegin(_etype1204, _size1201); + this->eventIds.resize(_size1201); + uint32_t _i1205; + for (_i1205 = 0; _i1205 < _size1201; ++_i1205) { - xfer += iprot->readI64(this->eventIds[_i1204]); + xfer += iprot->readI64(this->eventIds[_i1205]); } xfer += iprot->readListEnd(); } @@ -33454,10 +33507,10 @@ uint32_t FireEventResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("eventIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->eventIds.size())); - std::vector ::const_iterator _iter1205; - for (_iter1205 = this->eventIds.begin(); _iter1205 != this->eventIds.end(); ++_iter1205) + std::vector ::const_iterator _iter1206; + for (_iter1206 = this->eventIds.begin(); _iter1206 != this->eventIds.end(); ++_iter1206) { - xfer += oprot->writeI64((*_iter1205)); + xfer += oprot->writeI64((*_iter1206)); } xfer += oprot->writeListEnd(); } @@ -33474,13 +33527,13 @@ void swap(FireEventResponse &a, FireEventResponse &b) { swap(a.__isset, b.__isset); } -FireEventResponse::FireEventResponse(const FireEventResponse& other1206) { - eventIds = other1206.eventIds; - __isset = other1206.__isset; -} -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other1207) { +FireEventResponse::FireEventResponse(const FireEventResponse& other1207) { eventIds = other1207.eventIds; __isset = other1207.__isset; +} +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other1208) { + eventIds = other1208.eventIds; + __isset = other1208.__isset; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -33596,14 +33649,14 @@ uint32_t WriteNotificationLogRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - this->partitionVals.resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + uint32_t _size1209; + ::apache::thrift::protocol::TType _etype1212; + xfer += iprot->readListBegin(_etype1212, _size1209); + this->partitionVals.resize(_size1209); + uint32_t _i1213; + for (_i1213 = 0; _i1213 < _size1209; ++_i1213) { - xfer += iprot->readString(this->partitionVals[_i1212]); + xfer += iprot->readString(this->partitionVals[_i1213]); } xfer += iprot->readListEnd(); } @@ -33663,10 +33716,10 @@ uint32_t WriteNotificationLogRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter1213; - for (_iter1213 = this->partitionVals.begin(); _iter1213 != this->partitionVals.end(); ++_iter1213) + std::vector ::const_iterator _iter1214; + for (_iter1214 = this->partitionVals.begin(); _iter1214 != this->partitionVals.end(); ++_iter1214) { - xfer += oprot->writeString((*_iter1213)); + xfer += oprot->writeString((*_iter1214)); } xfer += oprot->writeListEnd(); } @@ -33688,16 +33741,7 @@ void swap(WriteNotificationLogRequest &a, WriteNotificationLogRequest &b) { swap(a.__isset, b.__isset); } -WriteNotificationLogRequest::WriteNotificationLogRequest(const WriteNotificationLogRequest& other1214) { - txnId = other1214.txnId; - writeId = other1214.writeId; - db = other1214.db; - table = other1214.table; - fileInfo = other1214.fileInfo; - partitionVals = other1214.partitionVals; - __isset = other1214.__isset; -} -WriteNotificationLogRequest& WriteNotificationLogRequest::operator=(const WriteNotificationLogRequest& other1215) { +WriteNotificationLogRequest::WriteNotificationLogRequest(const WriteNotificationLogRequest& other1215) { txnId = other1215.txnId; writeId = other1215.writeId; db = other1215.db; @@ -33705,6 +33749,15 @@ WriteNotificationLogRequest& WriteNotificationLogRequest::operator=(const WriteN fileInfo = other1215.fileInfo; partitionVals = other1215.partitionVals; __isset = other1215.__isset; +} +WriteNotificationLogRequest& WriteNotificationLogRequest::operator=(const WriteNotificationLogRequest& other1216) { + txnId = other1216.txnId; + writeId = other1216.writeId; + db = other1216.db; + table = other1216.table; + fileInfo = other1216.fileInfo; + partitionVals = other1216.partitionVals; + __isset = other1216.__isset; return *this; } void WriteNotificationLogRequest::printTo(std::ostream& out) const { @@ -33774,11 +33827,11 @@ void swap(WriteNotificationLogResponse &a, WriteNotificationLogResponse &b) { (void) b; } -WriteNotificationLogResponse::WriteNotificationLogResponse(const WriteNotificationLogResponse& other1216) noexcept { - (void) other1216; -} -WriteNotificationLogResponse& WriteNotificationLogResponse::operator=(const WriteNotificationLogResponse& other1217) noexcept { +WriteNotificationLogResponse::WriteNotificationLogResponse(const WriteNotificationLogResponse& other1217) noexcept { (void) other1217; +} +WriteNotificationLogResponse& WriteNotificationLogResponse::operator=(const WriteNotificationLogResponse& other1218) noexcept { + (void) other1218; return *this; } void WriteNotificationLogResponse::printTo(std::ostream& out) const { @@ -33867,14 +33920,14 @@ uint32_t WriteNotificationLogBatchRequest::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->requestList.clear(); - uint32_t _size1218; - ::apache::thrift::protocol::TType _etype1221; - xfer += iprot->readListBegin(_etype1221, _size1218); - this->requestList.resize(_size1218); - uint32_t _i1222; - for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + uint32_t _size1219; + ::apache::thrift::protocol::TType _etype1222; + xfer += iprot->readListBegin(_etype1222, _size1219); + this->requestList.resize(_size1219); + uint32_t _i1223; + for (_i1223 = 0; _i1223 < _size1219; ++_i1223) { - xfer += this->requestList[_i1222].read(iprot); + xfer += this->requestList[_i1223].read(iprot); } xfer += iprot->readListEnd(); } @@ -33923,10 +33976,10 @@ uint32_t WriteNotificationLogBatchRequest::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("requestList", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->requestList.size())); - std::vector ::const_iterator _iter1223; - for (_iter1223 = this->requestList.begin(); _iter1223 != this->requestList.end(); ++_iter1223) + std::vector ::const_iterator _iter1224; + for (_iter1224 = this->requestList.begin(); _iter1224 != this->requestList.end(); ++_iter1224) { - xfer += (*_iter1223).write(oprot); + xfer += (*_iter1224).write(oprot); } xfer += oprot->writeListEnd(); } @@ -33945,17 +33998,17 @@ void swap(WriteNotificationLogBatchRequest &a, WriteNotificationLogBatchRequest swap(a.requestList, b.requestList); } -WriteNotificationLogBatchRequest::WriteNotificationLogBatchRequest(const WriteNotificationLogBatchRequest& other1224) { - catalog = other1224.catalog; - db = other1224.db; - table = other1224.table; - requestList = other1224.requestList; -} -WriteNotificationLogBatchRequest& WriteNotificationLogBatchRequest::operator=(const WriteNotificationLogBatchRequest& other1225) { +WriteNotificationLogBatchRequest::WriteNotificationLogBatchRequest(const WriteNotificationLogBatchRequest& other1225) { catalog = other1225.catalog; db = other1225.db; table = other1225.table; requestList = other1225.requestList; +} +WriteNotificationLogBatchRequest& WriteNotificationLogBatchRequest::operator=(const WriteNotificationLogBatchRequest& other1226) { + catalog = other1226.catalog; + db = other1226.db; + table = other1226.table; + requestList = other1226.requestList; return *this; } void WriteNotificationLogBatchRequest::printTo(std::ostream& out) const { @@ -34023,11 +34076,11 @@ void swap(WriteNotificationLogBatchResponse &a, WriteNotificationLogBatchRespons (void) b; } -WriteNotificationLogBatchResponse::WriteNotificationLogBatchResponse(const WriteNotificationLogBatchResponse& other1226) noexcept { - (void) other1226; -} -WriteNotificationLogBatchResponse& WriteNotificationLogBatchResponse::operator=(const WriteNotificationLogBatchResponse& other1227) noexcept { +WriteNotificationLogBatchResponse::WriteNotificationLogBatchResponse(const WriteNotificationLogBatchResponse& other1227) noexcept { (void) other1227; +} +WriteNotificationLogBatchResponse& WriteNotificationLogBatchResponse::operator=(const WriteNotificationLogBatchResponse& other1228) noexcept { + (void) other1228; return *this; } void WriteNotificationLogBatchResponse::printTo(std::ostream& out) const { @@ -34133,15 +34186,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other1228) { - metadata = other1228.metadata; - includeBitset = other1228.includeBitset; - __isset = other1228.__isset; -} -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other1229) { +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other1229) { metadata = other1229.metadata; includeBitset = other1229.includeBitset; __isset = other1229.__isset; +} +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other1230) { + metadata = other1230.metadata; + includeBitset = other1230.includeBitset; + __isset = other1230.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -34198,17 +34251,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size1230; - ::apache::thrift::protocol::TType _ktype1231; - ::apache::thrift::protocol::TType _vtype1232; - xfer += iprot->readMapBegin(_ktype1231, _vtype1232, _size1230); - uint32_t _i1234; - for (_i1234 = 0; _i1234 < _size1230; ++_i1234) + uint32_t _size1231; + ::apache::thrift::protocol::TType _ktype1232; + ::apache::thrift::protocol::TType _vtype1233; + xfer += iprot->readMapBegin(_ktype1232, _vtype1233, _size1231); + uint32_t _i1235; + for (_i1235 = 0; _i1235 < _size1231; ++_i1235) { - int64_t _key1235; - xfer += iprot->readI64(_key1235); - MetadataPpdResult& _val1236 = this->metadata[_key1235]; - xfer += _val1236.read(iprot); + int64_t _key1236; + xfer += iprot->readI64(_key1236); + MetadataPpdResult& _val1237 = this->metadata[_key1236]; + xfer += _val1237.read(iprot); } xfer += iprot->readMapEnd(); } @@ -34249,11 +34302,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter1237; - for (_iter1237 = this->metadata.begin(); _iter1237 != this->metadata.end(); ++_iter1237) + std::map ::const_iterator _iter1238; + for (_iter1238 = this->metadata.begin(); _iter1238 != this->metadata.end(); ++_iter1238) { - xfer += oprot->writeI64(_iter1237->first); - xfer += _iter1237->second.write(oprot); + xfer += oprot->writeI64(_iter1238->first); + xfer += _iter1238->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -34274,13 +34327,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other1238) { - metadata = other1238.metadata; - isSupported = other1238.isSupported; -} -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other1239) { +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other1239) { metadata = other1239.metadata; isSupported = other1239.isSupported; +} +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other1240) { + metadata = other1240.metadata; + isSupported = other1240.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -34347,14 +34400,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size1240; - ::apache::thrift::protocol::TType _etype1243; - xfer += iprot->readListBegin(_etype1243, _size1240); - this->fileIds.resize(_size1240); - uint32_t _i1244; - for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + uint32_t _size1241; + ::apache::thrift::protocol::TType _etype1244; + xfer += iprot->readListBegin(_etype1244, _size1241); + this->fileIds.resize(_size1241); + uint32_t _i1245; + for (_i1245 = 0; _i1245 < _size1241; ++_i1245) { - xfer += iprot->readI64(this->fileIds[_i1244]); + xfer += iprot->readI64(this->fileIds[_i1245]); } xfer += iprot->readListEnd(); } @@ -34381,9 +34434,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1245; - xfer += iprot->readI32(ecast1245); - this->type = static_cast(ecast1245); + int32_t ecast1246; + xfer += iprot->readI32(ecast1246); + this->type = static_cast(ecast1246); this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -34413,10 +34466,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter1246; - for (_iter1246 = this->fileIds.begin(); _iter1246 != this->fileIds.end(); ++_iter1246) + std::vector ::const_iterator _iter1247; + for (_iter1247 = this->fileIds.begin(); _iter1247 != this->fileIds.end(); ++_iter1247) { - xfer += oprot->writeI64((*_iter1246)); + xfer += oprot->writeI64((*_iter1247)); } xfer += oprot->writeListEnd(); } @@ -34450,19 +34503,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other1247) { - fileIds = other1247.fileIds; - expr = other1247.expr; - doGetFooters = other1247.doGetFooters; - type = other1247.type; - __isset = other1247.__isset; -} -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other1248) { +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other1248) { fileIds = other1248.fileIds; expr = other1248.expr; doGetFooters = other1248.doGetFooters; type = other1248.type; __isset = other1248.__isset; +} +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other1249) { + fileIds = other1249.fileIds; + expr = other1249.expr; + doGetFooters = other1249.doGetFooters; + type = other1249.type; + __isset = other1249.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -34521,17 +34574,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size1249; - ::apache::thrift::protocol::TType _ktype1250; - ::apache::thrift::protocol::TType _vtype1251; - xfer += iprot->readMapBegin(_ktype1250, _vtype1251, _size1249); - uint32_t _i1253; - for (_i1253 = 0; _i1253 < _size1249; ++_i1253) + uint32_t _size1250; + ::apache::thrift::protocol::TType _ktype1251; + ::apache::thrift::protocol::TType _vtype1252; + xfer += iprot->readMapBegin(_ktype1251, _vtype1252, _size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - int64_t _key1254; - xfer += iprot->readI64(_key1254); - std::string& _val1255 = this->metadata[_key1254]; - xfer += iprot->readBinary(_val1255); + int64_t _key1255; + xfer += iprot->readI64(_key1255); + std::string& _val1256 = this->metadata[_key1255]; + xfer += iprot->readBinary(_val1256); } xfer += iprot->readMapEnd(); } @@ -34572,11 +34625,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter1256; - for (_iter1256 = this->metadata.begin(); _iter1256 != this->metadata.end(); ++_iter1256) + std::map ::const_iterator _iter1257; + for (_iter1257 = this->metadata.begin(); _iter1257 != this->metadata.end(); ++_iter1257) { - xfer += oprot->writeI64(_iter1256->first); - xfer += oprot->writeBinary(_iter1256->second); + xfer += oprot->writeI64(_iter1257->first); + xfer += oprot->writeBinary(_iter1257->second); } xfer += oprot->writeMapEnd(); } @@ -34597,13 +34650,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other1257) { - metadata = other1257.metadata; - isSupported = other1257.isSupported; -} -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other1258) { +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other1258) { metadata = other1258.metadata; isSupported = other1258.isSupported; +} +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other1259) { + metadata = other1259.metadata; + isSupported = other1259.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -34655,14 +34708,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size1259; - ::apache::thrift::protocol::TType _etype1262; - xfer += iprot->readListBegin(_etype1262, _size1259); - this->fileIds.resize(_size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + uint32_t _size1260; + ::apache::thrift::protocol::TType _etype1263; + xfer += iprot->readListBegin(_etype1263, _size1260); + this->fileIds.resize(_size1260); + uint32_t _i1264; + for (_i1264 = 0; _i1264 < _size1260; ++_i1264) { - xfer += iprot->readI64(this->fileIds[_i1263]); + xfer += iprot->readI64(this->fileIds[_i1264]); } xfer += iprot->readListEnd(); } @@ -34693,10 +34746,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter1264; - for (_iter1264 = this->fileIds.begin(); _iter1264 != this->fileIds.end(); ++_iter1264) + std::vector ::const_iterator _iter1265; + for (_iter1265 = this->fileIds.begin(); _iter1265 != this->fileIds.end(); ++_iter1265) { - xfer += oprot->writeI64((*_iter1264)); + xfer += oprot->writeI64((*_iter1265)); } xfer += oprot->writeListEnd(); } @@ -34712,11 +34765,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other1265) { - fileIds = other1265.fileIds; -} -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other1266) { +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other1266) { fileIds = other1266.fileIds; +} +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other1267) { + fileIds = other1267.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -34781,11 +34834,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other1267) noexcept { - (void) other1267; -} -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other1268) noexcept { +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other1268) noexcept { (void) other1268; +} +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other1269) noexcept { + (void) other1269; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -34845,14 +34898,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size1269; - ::apache::thrift::protocol::TType _etype1272; - xfer += iprot->readListBegin(_etype1272, _size1269); - this->fileIds.resize(_size1269); - uint32_t _i1273; - for (_i1273 = 0; _i1273 < _size1269; ++_i1273) + uint32_t _size1270; + ::apache::thrift::protocol::TType _etype1273; + xfer += iprot->readListBegin(_etype1273, _size1270); + this->fileIds.resize(_size1270); + uint32_t _i1274; + for (_i1274 = 0; _i1274 < _size1270; ++_i1274) { - xfer += iprot->readI64(this->fileIds[_i1273]); + xfer += iprot->readI64(this->fileIds[_i1274]); } xfer += iprot->readListEnd(); } @@ -34865,14 +34918,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size1274; - ::apache::thrift::protocol::TType _etype1277; - xfer += iprot->readListBegin(_etype1277, _size1274); - this->metadata.resize(_size1274); - uint32_t _i1278; - for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + uint32_t _size1275; + ::apache::thrift::protocol::TType _etype1278; + xfer += iprot->readListBegin(_etype1278, _size1275); + this->metadata.resize(_size1275); + uint32_t _i1279; + for (_i1279 = 0; _i1279 < _size1275; ++_i1279) { - xfer += iprot->readBinary(this->metadata[_i1278]); + xfer += iprot->readBinary(this->metadata[_i1279]); } xfer += iprot->readListEnd(); } @@ -34883,9 +34936,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1279; - xfer += iprot->readI32(ecast1279); - this->type = static_cast(ecast1279); + int32_t ecast1280; + xfer += iprot->readI32(ecast1280); + this->type = static_cast(ecast1280); this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -34915,10 +34968,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter1280; - for (_iter1280 = this->fileIds.begin(); _iter1280 != this->fileIds.end(); ++_iter1280) + std::vector ::const_iterator _iter1281; + for (_iter1281 = this->fileIds.begin(); _iter1281 != this->fileIds.end(); ++_iter1281) { - xfer += oprot->writeI64((*_iter1280)); + xfer += oprot->writeI64((*_iter1281)); } xfer += oprot->writeListEnd(); } @@ -34927,10 +34980,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter1281; - for (_iter1281 = this->metadata.begin(); _iter1281 != this->metadata.end(); ++_iter1281) + std::vector ::const_iterator _iter1282; + for (_iter1282 = this->metadata.begin(); _iter1282 != this->metadata.end(); ++_iter1282) { - xfer += oprot->writeBinary((*_iter1281)); + xfer += oprot->writeBinary((*_iter1282)); } xfer += oprot->writeListEnd(); } @@ -34954,17 +35007,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other1282) { - fileIds = other1282.fileIds; - metadata = other1282.metadata; - type = other1282.type; - __isset = other1282.__isset; -} -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other1283) { +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other1283) { fileIds = other1283.fileIds; metadata = other1283.metadata; type = other1283.type; __isset = other1283.__isset; +} +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other1284) { + fileIds = other1284.fileIds; + metadata = other1284.metadata; + type = other1284.type; + __isset = other1284.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -35031,11 +35084,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other1284) noexcept { - (void) other1284; -} -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other1285) noexcept { +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other1285) noexcept { (void) other1285; +} +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other1286) noexcept { + (void) other1286; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -35085,14 +35138,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size1286; - ::apache::thrift::protocol::TType _etype1289; - xfer += iprot->readListBegin(_etype1289, _size1286); - this->fileIds.resize(_size1286); - uint32_t _i1290; - for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + uint32_t _size1287; + ::apache::thrift::protocol::TType _etype1290; + xfer += iprot->readListBegin(_etype1290, _size1287); + this->fileIds.resize(_size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - xfer += iprot->readI64(this->fileIds[_i1290]); + xfer += iprot->readI64(this->fileIds[_i1291]); } xfer += iprot->readListEnd(); } @@ -35123,10 +35176,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter1291; - for (_iter1291 = this->fileIds.begin(); _iter1291 != this->fileIds.end(); ++_iter1291) + std::vector ::const_iterator _iter1292; + for (_iter1292 = this->fileIds.begin(); _iter1292 != this->fileIds.end(); ++_iter1292) { - xfer += oprot->writeI64((*_iter1291)); + xfer += oprot->writeI64((*_iter1292)); } xfer += oprot->writeListEnd(); } @@ -35142,11 +35195,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other1292) { - fileIds = other1292.fileIds; -} -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other1293) { +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other1293) { fileIds = other1293.fileIds; +} +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other1294) { + fileIds = other1294.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -35234,11 +35287,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other1294) noexcept { - isSupported = other1294.isSupported; -} -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other1295) noexcept { +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other1295) noexcept { isSupported = other1295.isSupported; +} +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other1296) noexcept { + isSupported = other1296.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -35385,19 +35438,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other1296) { - dbName = other1296.dbName; - tblName = other1296.tblName; - partName = other1296.partName; - isAllParts = other1296.isAllParts; - __isset = other1296.__isset; -} -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other1297) { +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other1297) { dbName = other1297.dbName; tblName = other1297.tblName; partName = other1297.partName; isAllParts = other1297.isAllParts; __isset = other1297.__isset; +} +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other1298) { + dbName = other1298.dbName; + tblName = other1298.tblName; + partName = other1298.partName; + isAllParts = other1298.isAllParts; + __isset = other1298.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -35451,14 +35504,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size1298; - ::apache::thrift::protocol::TType _etype1301; - xfer += iprot->readListBegin(_etype1301, _size1298); - this->functions.resize(_size1298); - uint32_t _i1302; - for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + uint32_t _size1299; + ::apache::thrift::protocol::TType _etype1302; + xfer += iprot->readListBegin(_etype1302, _size1299); + this->functions.resize(_size1299); + uint32_t _i1303; + for (_i1303 = 0; _i1303 < _size1299; ++_i1303) { - xfer += this->functions[_i1302].read(iprot); + xfer += this->functions[_i1303].read(iprot); } xfer += iprot->readListEnd(); } @@ -35488,10 +35541,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter1303; - for (_iter1303 = this->functions.begin(); _iter1303 != this->functions.end(); ++_iter1303) + std::vector ::const_iterator _iter1304; + for (_iter1304 = this->functions.begin(); _iter1304 != this->functions.end(); ++_iter1304) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1304).write(oprot); } xfer += oprot->writeListEnd(); } @@ -35508,13 +35561,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other1304) { - functions = other1304.functions; - __isset = other1304.__isset; -} -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other1305) { +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other1305) { functions = other1305.functions; __isset = other1305.__isset; +} +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other1306) { + functions = other1306.functions; + __isset = other1306.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -35565,16 +35618,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size1306; - ::apache::thrift::protocol::TType _etype1309; - xfer += iprot->readListBegin(_etype1309, _size1306); - this->values.resize(_size1306); - uint32_t _i1310; - for (_i1310 = 0; _i1310 < _size1306; ++_i1310) + uint32_t _size1307; + ::apache::thrift::protocol::TType _etype1310; + xfer += iprot->readListBegin(_etype1310, _size1307); + this->values.resize(_size1307); + uint32_t _i1311; + for (_i1311 = 0; _i1311 < _size1307; ++_i1311) { - int32_t ecast1311; - xfer += iprot->readI32(ecast1311); - this->values[_i1310] = static_cast(ecast1311); + int32_t ecast1312; + xfer += iprot->readI32(ecast1312); + this->values[_i1311] = static_cast(ecast1312); } xfer += iprot->readListEnd(); } @@ -35605,10 +35658,10 @@ uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->values.size())); - std::vector ::const_iterator _iter1312; - for (_iter1312 = this->values.begin(); _iter1312 != this->values.end(); ++_iter1312) + std::vector ::const_iterator _iter1313; + for (_iter1313 = this->values.begin(); _iter1313 != this->values.end(); ++_iter1313) { - xfer += oprot->writeI32(static_cast((*_iter1312))); + xfer += oprot->writeI32(static_cast((*_iter1313))); } xfer += oprot->writeListEnd(); } @@ -35624,11 +35677,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other1313) { - values = other1313.values; -} -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other1314) { +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other1314) { values = other1314.values; +} +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other1315) { + values = other1315.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -35686,14 +35739,14 @@ uint32_t GetProjectionsSpec::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldList.clear(); - uint32_t _size1315; - ::apache::thrift::protocol::TType _etype1318; - xfer += iprot->readListBegin(_etype1318, _size1315); - this->fieldList.resize(_size1315); - uint32_t _i1319; - for (_i1319 = 0; _i1319 < _size1315; ++_i1319) + uint32_t _size1316; + ::apache::thrift::protocol::TType _etype1319; + xfer += iprot->readListBegin(_etype1319, _size1316); + this->fieldList.resize(_size1316); + uint32_t _i1320; + for (_i1320 = 0; _i1320 < _size1316; ++_i1320) { - xfer += iprot->readString(this->fieldList[_i1319]); + xfer += iprot->readString(this->fieldList[_i1320]); } xfer += iprot->readListEnd(); } @@ -35738,10 +35791,10 @@ uint32_t GetProjectionsSpec::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("fieldList", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fieldList.size())); - std::vector ::const_iterator _iter1320; - for (_iter1320 = this->fieldList.begin(); _iter1320 != this->fieldList.end(); ++_iter1320) + std::vector ::const_iterator _iter1321; + for (_iter1321 = this->fieldList.begin(); _iter1321 != this->fieldList.end(); ++_iter1321) { - xfer += oprot->writeString((*_iter1320)); + xfer += oprot->writeString((*_iter1321)); } xfer += oprot->writeListEnd(); } @@ -35768,17 +35821,17 @@ void swap(GetProjectionsSpec &a, GetProjectionsSpec &b) { swap(a.__isset, b.__isset); } -GetProjectionsSpec::GetProjectionsSpec(const GetProjectionsSpec& other1321) { - fieldList = other1321.fieldList; - includeParamKeyPattern = other1321.includeParamKeyPattern; - excludeParamKeyPattern = other1321.excludeParamKeyPattern; - __isset = other1321.__isset; -} -GetProjectionsSpec& GetProjectionsSpec::operator=(const GetProjectionsSpec& other1322) { +GetProjectionsSpec::GetProjectionsSpec(const GetProjectionsSpec& other1322) { fieldList = other1322.fieldList; includeParamKeyPattern = other1322.includeParamKeyPattern; excludeParamKeyPattern = other1322.excludeParamKeyPattern; __isset = other1322.__isset; +} +GetProjectionsSpec& GetProjectionsSpec::operator=(const GetProjectionsSpec& other1323) { + fieldList = other1323.fieldList; + includeParamKeyPattern = other1323.includeParamKeyPattern; + excludeParamKeyPattern = other1323.excludeParamKeyPattern; + __isset = other1323.__isset; return *this; } void GetProjectionsSpec::printTo(std::ostream& out) const { @@ -35924,14 +35977,14 @@ uint32_t GetTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _etype1326; - xfer += iprot->readListBegin(_etype1326, _size1323); - this->processorCapabilities.resize(_size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + this->processorCapabilities.resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += iprot->readString(this->processorCapabilities[_i1327]); + xfer += iprot->readString(this->processorCapabilities[_i1328]); } xfer += iprot->readListEnd(); } @@ -36017,10 +36070,10 @@ uint32_t GetTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) co 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 _iter1328; - for (_iter1328 = this->processorCapabilities.begin(); _iter1328 != this->processorCapabilities.end(); ++_iter1328) + std::vector ::const_iterator _iter1329; + for (_iter1329 = this->processorCapabilities.begin(); _iter1329 != this->processorCapabilities.end(); ++_iter1329) { - xfer += oprot->writeString((*_iter1328)); + xfer += oprot->writeString((*_iter1329)); } xfer += oprot->writeListEnd(); } @@ -36061,20 +36114,7 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other1329) { - dbName = other1329.dbName; - tblName = other1329.tblName; - capabilities = other1329.capabilities; - catName = other1329.catName; - validWriteIdList = other1329.validWriteIdList; - getColumnStats = other1329.getColumnStats; - processorCapabilities = other1329.processorCapabilities; - processorIdentifier = other1329.processorIdentifier; - engine = other1329.engine; - id = other1329.id; - __isset = other1329.__isset; -} -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other1330) { +GetTableRequest::GetTableRequest(const GetTableRequest& other1330) { dbName = other1330.dbName; tblName = other1330.tblName; capabilities = other1330.capabilities; @@ -36086,6 +36126,19 @@ GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other1330) { engine = other1330.engine; id = other1330.id; __isset = other1330.__isset; +} +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other1331) { + dbName = other1331.dbName; + tblName = other1331.tblName; + capabilities = other1331.capabilities; + catName = other1331.catName; + validWriteIdList = other1331.validWriteIdList; + getColumnStats = other1331.getColumnStats; + processorCapabilities = other1331.processorCapabilities; + processorIdentifier = other1331.processorIdentifier; + engine = other1331.engine; + id = other1331.id; + __isset = other1331.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -36202,15 +36255,15 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.__isset, b.__isset); } -GetTableResult::GetTableResult(const GetTableResult& other1331) { - table = other1331.table; - isStatsCompliant = other1331.isStatsCompliant; - __isset = other1331.__isset; -} -GetTableResult& GetTableResult::operator=(const GetTableResult& other1332) { +GetTableResult::GetTableResult(const GetTableResult& other1332) { table = other1332.table; isStatsCompliant = other1332.isStatsCompliant; __isset = other1332.__isset; +} +GetTableResult& GetTableResult::operator=(const GetTableResult& other1333) { + table = other1333.table; + isStatsCompliant = other1333.isStatsCompliant; + __isset = other1333.__isset; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -36305,14 +36358,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size1333; - ::apache::thrift::protocol::TType _etype1336; - xfer += iprot->readListBegin(_etype1336, _size1333); - this->tblNames.resize(_size1333); - uint32_t _i1337; - for (_i1337 = 0; _i1337 < _size1333; ++_i1337) + uint32_t _size1334; + ::apache::thrift::protocol::TType _etype1337; + xfer += iprot->readListBegin(_etype1337, _size1334); + this->tblNames.resize(_size1334); + uint32_t _i1338; + for (_i1338 = 0; _i1338 < _size1334; ++_i1338) { - xfer += iprot->readString(this->tblNames[_i1337]); + xfer += iprot->readString(this->tblNames[_i1338]); } xfer += iprot->readListEnd(); } @@ -36341,14 +36394,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1338; - ::apache::thrift::protocol::TType _etype1341; - xfer += iprot->readListBegin(_etype1341, _size1338); - this->processorCapabilities.resize(_size1338); - uint32_t _i1342; - for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + uint32_t _size1339; + ::apache::thrift::protocol::TType _etype1342; + xfer += iprot->readListBegin(_etype1342, _size1339); + this->processorCapabilities.resize(_size1339); + uint32_t _i1343; + for (_i1343 = 0; _i1343 < _size1339; ++_i1343) { - xfer += iprot->readString(this->processorCapabilities[_i1342]); + xfer += iprot->readString(this->processorCapabilities[_i1343]); } xfer += iprot->readListEnd(); } @@ -36408,10 +36461,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tblNames.size())); - std::vector ::const_iterator _iter1343; - for (_iter1343 = this->tblNames.begin(); _iter1343 != this->tblNames.end(); ++_iter1343) + std::vector ::const_iterator _iter1344; + for (_iter1344 = this->tblNames.begin(); _iter1344 != this->tblNames.end(); ++_iter1344) { - xfer += oprot->writeString((*_iter1343)); + xfer += oprot->writeString((*_iter1344)); } xfer += oprot->writeListEnd(); } @@ -36431,10 +36484,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1344; - for (_iter1344 = this->processorCapabilities.begin(); _iter1344 != this->processorCapabilities.end(); ++_iter1344) + std::vector ::const_iterator _iter1345; + for (_iter1345 = this->processorCapabilities.begin(); _iter1345 != this->processorCapabilities.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1344)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -36473,18 +36526,7 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other1345) { - dbName = other1345.dbName; - tblNames = other1345.tblNames; - capabilities = other1345.capabilities; - catName = other1345.catName; - processorCapabilities = other1345.processorCapabilities; - processorIdentifier = other1345.processorIdentifier; - projectionSpec = other1345.projectionSpec; - tablesPattern = other1345.tablesPattern; - __isset = other1345.__isset; -} -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other1346) { +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other1346) { dbName = other1346.dbName; tblNames = other1346.tblNames; capabilities = other1346.capabilities; @@ -36494,6 +36536,17 @@ GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other1346) projectionSpec = other1346.projectionSpec; tablesPattern = other1346.tablesPattern; __isset = other1346.__isset; +} +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other1347) { + dbName = other1347.dbName; + tblNames = other1347.tblNames; + capabilities = other1347.capabilities; + catName = other1347.catName; + processorCapabilities = other1347.processorCapabilities; + processorIdentifier = other1347.processorIdentifier; + projectionSpec = other1347.projectionSpec; + tablesPattern = other1347.tablesPattern; + __isset = other1347.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -36551,14 +36604,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size1347; - ::apache::thrift::protocol::TType _etype1350; - xfer += iprot->readListBegin(_etype1350, _size1347); - this->tables.resize(_size1347); - uint32_t _i1351; - for (_i1351 = 0; _i1351 < _size1347; ++_i1351) + uint32_t _size1348; + ::apache::thrift::protocol::TType _etype1351; + xfer += iprot->readListBegin(_etype1351, _size1348); + this->tables.resize(_size1348); + uint32_t _i1352; + for (_i1352 = 0; _i1352 < _size1348; ++_i1352) { - xfer += this->tables[_i1351].read(iprot); + xfer += this->tables[_i1352].read(iprot); } xfer += iprot->readListEnd(); } @@ -36589,10 +36642,10 @@ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tables.size())); - std::vector
::const_iterator _iter1352; - for (_iter1352 = this->tables.begin(); _iter1352 != this->tables.end(); ++_iter1352) + std::vector
::const_iterator _iter1353; + for (_iter1353 = this->tables.begin(); _iter1353 != this->tables.end(); ++_iter1353) { - xfer += (*_iter1352).write(oprot); + xfer += (*_iter1353).write(oprot); } xfer += oprot->writeListEnd(); } @@ -36608,11 +36661,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other1353) { - tables = other1353.tables; -} -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other1354) { +GetTablesResult::GetTablesResult(const GetTablesResult& other1354) { tables = other1354.tables; +} +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other1355) { + tables = other1355.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -36733,14 +36786,14 @@ uint32_t GetTablesExtRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1355; - ::apache::thrift::protocol::TType _etype1358; - xfer += iprot->readListBegin(_etype1358, _size1355); - this->processorCapabilities.resize(_size1355); - uint32_t _i1359; - for (_i1359 = 0; _i1359 < _size1355; ++_i1359) + uint32_t _size1356; + ::apache::thrift::protocol::TType _etype1359; + xfer += iprot->readListBegin(_etype1359, _size1356); + this->processorCapabilities.resize(_size1356); + uint32_t _i1360; + for (_i1360 = 0; _i1360 < _size1356; ++_i1360) { - xfer += iprot->readString(this->processorCapabilities[_i1359]); + xfer += iprot->readString(this->processorCapabilities[_i1360]); } xfer += iprot->readListEnd(); } @@ -36807,10 +36860,10 @@ uint32_t GetTablesExtRequest::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1360; - for (_iter1360 = this->processorCapabilities.begin(); _iter1360 != this->processorCapabilities.end(); ++_iter1360) + std::vector ::const_iterator _iter1361; + for (_iter1361 = this->processorCapabilities.begin(); _iter1361 != this->processorCapabilities.end(); ++_iter1361) { - xfer += oprot->writeString((*_iter1360)); + xfer += oprot->writeString((*_iter1361)); } xfer += oprot->writeListEnd(); } @@ -36838,17 +36891,7 @@ void swap(GetTablesExtRequest &a, GetTablesExtRequest &b) { swap(a.__isset, b.__isset); } -GetTablesExtRequest::GetTablesExtRequest(const GetTablesExtRequest& other1361) { - catalog = other1361.catalog; - database = other1361.database; - tableNamePattern = other1361.tableNamePattern; - requestedFields = other1361.requestedFields; - limit = other1361.limit; - processorCapabilities = other1361.processorCapabilities; - processorIdentifier = other1361.processorIdentifier; - __isset = other1361.__isset; -} -GetTablesExtRequest& GetTablesExtRequest::operator=(const GetTablesExtRequest& other1362) { +GetTablesExtRequest::GetTablesExtRequest(const GetTablesExtRequest& other1362) { catalog = other1362.catalog; database = other1362.database; tableNamePattern = other1362.tableNamePattern; @@ -36857,6 +36900,16 @@ GetTablesExtRequest& GetTablesExtRequest::operator=(const GetTablesExtRequest& o processorCapabilities = other1362.processorCapabilities; processorIdentifier = other1362.processorIdentifier; __isset = other1362.__isset; +} +GetTablesExtRequest& GetTablesExtRequest::operator=(const GetTablesExtRequest& other1363) { + catalog = other1363.catalog; + database = other1363.database; + tableNamePattern = other1363.tableNamePattern; + requestedFields = other1363.requestedFields; + limit = other1363.limit; + processorCapabilities = other1363.processorCapabilities; + processorIdentifier = other1363.processorIdentifier; + __isset = other1363.__isset; return *this; } void GetTablesExtRequest::printTo(std::ostream& out) const { @@ -36944,14 +36997,14 @@ uint32_t ExtendedTableInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->requiredReadCapabilities.clear(); - uint32_t _size1363; - ::apache::thrift::protocol::TType _etype1366; - xfer += iprot->readListBegin(_etype1366, _size1363); - this->requiredReadCapabilities.resize(_size1363); - uint32_t _i1367; - for (_i1367 = 0; _i1367 < _size1363; ++_i1367) + uint32_t _size1364; + ::apache::thrift::protocol::TType _etype1367; + xfer += iprot->readListBegin(_etype1367, _size1364); + this->requiredReadCapabilities.resize(_size1364); + uint32_t _i1368; + for (_i1368 = 0; _i1368 < _size1364; ++_i1368) { - xfer += iprot->readString(this->requiredReadCapabilities[_i1367]); + xfer += iprot->readString(this->requiredReadCapabilities[_i1368]); } xfer += iprot->readListEnd(); } @@ -36964,14 +37017,14 @@ uint32_t ExtendedTableInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->requiredWriteCapabilities.clear(); - uint32_t _size1368; - ::apache::thrift::protocol::TType _etype1371; - xfer += iprot->readListBegin(_etype1371, _size1368); - this->requiredWriteCapabilities.resize(_size1368); - uint32_t _i1372; - for (_i1372 = 0; _i1372 < _size1368; ++_i1372) + uint32_t _size1369; + ::apache::thrift::protocol::TType _etype1372; + xfer += iprot->readListBegin(_etype1372, _size1369); + this->requiredWriteCapabilities.resize(_size1369); + uint32_t _i1373; + for (_i1373 = 0; _i1373 < _size1369; ++_i1373) { - xfer += iprot->readString(this->requiredWriteCapabilities[_i1372]); + xfer += iprot->readString(this->requiredWriteCapabilities[_i1373]); } xfer += iprot->readListEnd(); } @@ -37012,10 +37065,10 @@ uint32_t ExtendedTableInfo::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("requiredReadCapabilities", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredReadCapabilities.size())); - std::vector ::const_iterator _iter1373; - for (_iter1373 = this->requiredReadCapabilities.begin(); _iter1373 != this->requiredReadCapabilities.end(); ++_iter1373) + std::vector ::const_iterator _iter1374; + for (_iter1374 = this->requiredReadCapabilities.begin(); _iter1374 != this->requiredReadCapabilities.end(); ++_iter1374) { - xfer += oprot->writeString((*_iter1373)); + xfer += oprot->writeString((*_iter1374)); } xfer += oprot->writeListEnd(); } @@ -37025,10 +37078,10 @@ uint32_t ExtendedTableInfo::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("requiredWriteCapabilities", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredWriteCapabilities.size())); - std::vector ::const_iterator _iter1374; - for (_iter1374 = this->requiredWriteCapabilities.begin(); _iter1374 != this->requiredWriteCapabilities.end(); ++_iter1374) + std::vector ::const_iterator _iter1375; + for (_iter1375 = this->requiredWriteCapabilities.begin(); _iter1375 != this->requiredWriteCapabilities.end(); ++_iter1375) { - xfer += oprot->writeString((*_iter1374)); + xfer += oprot->writeString((*_iter1375)); } xfer += oprot->writeListEnd(); } @@ -37048,19 +37101,19 @@ void swap(ExtendedTableInfo &a, ExtendedTableInfo &b) { swap(a.__isset, b.__isset); } -ExtendedTableInfo::ExtendedTableInfo(const ExtendedTableInfo& other1375) { - tblName = other1375.tblName; - accessType = other1375.accessType; - requiredReadCapabilities = other1375.requiredReadCapabilities; - requiredWriteCapabilities = other1375.requiredWriteCapabilities; - __isset = other1375.__isset; -} -ExtendedTableInfo& ExtendedTableInfo::operator=(const ExtendedTableInfo& other1376) { +ExtendedTableInfo::ExtendedTableInfo(const ExtendedTableInfo& other1376) { tblName = other1376.tblName; accessType = other1376.accessType; requiredReadCapabilities = other1376.requiredReadCapabilities; requiredWriteCapabilities = other1376.requiredWriteCapabilities; __isset = other1376.__isset; +} +ExtendedTableInfo& ExtendedTableInfo::operator=(const ExtendedTableInfo& other1377) { + tblName = other1377.tblName; + accessType = other1377.accessType; + requiredReadCapabilities = other1377.requiredReadCapabilities; + requiredWriteCapabilities = other1377.requiredWriteCapabilities; + __isset = other1377.__isset; return *this; } void ExtendedTableInfo::printTo(std::ostream& out) const { @@ -37248,16 +37301,7 @@ void swap(DropTableRequest &a, DropTableRequest &b) { swap(a.__isset, b.__isset); } -DropTableRequest::DropTableRequest(const DropTableRequest& other1377) { - catalogName = other1377.catalogName; - dbName = other1377.dbName; - tableName = other1377.tableName; - deleteData = other1377.deleteData; - envContext = other1377.envContext; - dropPartitions = other1377.dropPartitions; - __isset = other1377.__isset; -} -DropTableRequest& DropTableRequest::operator=(const DropTableRequest& other1378) { +DropTableRequest::DropTableRequest(const DropTableRequest& other1378) { catalogName = other1378.catalogName; dbName = other1378.dbName; tableName = other1378.tableName; @@ -37265,6 +37309,15 @@ DropTableRequest& DropTableRequest::operator=(const DropTableRequest& other1378) envContext = other1378.envContext; dropPartitions = other1378.dropPartitions; __isset = other1378.__isset; +} +DropTableRequest& DropTableRequest::operator=(const DropTableRequest& other1379) { + catalogName = other1379.catalogName; + dbName = other1379.dbName; + tableName = other1379.tableName; + deleteData = other1379.deleteData; + envContext = other1379.envContext; + dropPartitions = other1379.dropPartitions; + __isset = other1379.__isset; return *this; } void DropTableRequest::printTo(std::ostream& out) const { @@ -37351,14 +37404,14 @@ uint32_t GetDatabaseRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1379; - ::apache::thrift::protocol::TType _etype1382; - xfer += iprot->readListBegin(_etype1382, _size1379); - this->processorCapabilities.resize(_size1379); - uint32_t _i1383; - for (_i1383 = 0; _i1383 < _size1379; ++_i1383) + uint32_t _size1380; + ::apache::thrift::protocol::TType _etype1383; + xfer += iprot->readListBegin(_etype1383, _size1380); + this->processorCapabilities.resize(_size1380); + uint32_t _i1384; + for (_i1384 = 0; _i1384 < _size1380; ++_i1384) { - xfer += iprot->readString(this->processorCapabilities[_i1383]); + xfer += iprot->readString(this->processorCapabilities[_i1384]); } xfer += iprot->readListEnd(); } @@ -37406,10 +37459,10 @@ uint32_t GetDatabaseRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1384; - for (_iter1384 = this->processorCapabilities.begin(); _iter1384 != this->processorCapabilities.end(); ++_iter1384) + std::vector ::const_iterator _iter1385; + for (_iter1385 = this->processorCapabilities.begin(); _iter1385 != this->processorCapabilities.end(); ++_iter1385) { - xfer += oprot->writeString((*_iter1384)); + xfer += oprot->writeString((*_iter1385)); } xfer += oprot->writeListEnd(); } @@ -37434,19 +37487,19 @@ void swap(GetDatabaseRequest &a, GetDatabaseRequest &b) { swap(a.__isset, b.__isset); } -GetDatabaseRequest::GetDatabaseRequest(const GetDatabaseRequest& other1385) { - name = other1385.name; - catalogName = other1385.catalogName; - processorCapabilities = other1385.processorCapabilities; - processorIdentifier = other1385.processorIdentifier; - __isset = other1385.__isset; -} -GetDatabaseRequest& GetDatabaseRequest::operator=(const GetDatabaseRequest& other1386) { +GetDatabaseRequest::GetDatabaseRequest(const GetDatabaseRequest& other1386) { name = other1386.name; catalogName = other1386.catalogName; processorCapabilities = other1386.processorCapabilities; processorIdentifier = other1386.processorIdentifier; __isset = other1386.__isset; +} +GetDatabaseRequest& GetDatabaseRequest::operator=(const GetDatabaseRequest& other1387) { + name = other1387.name; + catalogName = other1387.catalogName; + processorCapabilities = other1387.processorCapabilities; + processorIdentifier = other1387.processorIdentifier; + __isset = other1387.__isset; return *this; } void GetDatabaseRequest::printTo(std::ostream& out) const { @@ -37557,13 +37610,13 @@ void swap(AlterDatabaseRequest &a, AlterDatabaseRequest &b) { swap(a.newDb, b.newDb); } -AlterDatabaseRequest::AlterDatabaseRequest(const AlterDatabaseRequest& other1387) { - oldDbName = other1387.oldDbName; - newDb = other1387.newDb; -} -AlterDatabaseRequest& AlterDatabaseRequest::operator=(const AlterDatabaseRequest& other1388) { +AlterDatabaseRequest::AlterDatabaseRequest(const AlterDatabaseRequest& other1388) { oldDbName = other1388.oldDbName; newDb = other1388.newDb; +} +AlterDatabaseRequest& AlterDatabaseRequest::operator=(const AlterDatabaseRequest& other1389) { + oldDbName = other1389.oldDbName; + newDb = other1389.newDb; return *this; } void AlterDatabaseRequest::printTo(std::ostream& out) const { @@ -37789,18 +37842,7 @@ void swap(DropDatabaseRequest &a, DropDatabaseRequest &b) { swap(a.__isset, b.__isset); } -DropDatabaseRequest::DropDatabaseRequest(const DropDatabaseRequest& other1389) { - name = other1389.name; - catalogName = other1389.catalogName; - ignoreUnknownDb = other1389.ignoreUnknownDb; - deleteData = other1389.deleteData; - cascade = other1389.cascade; - softDelete = other1389.softDelete; - txnId = other1389.txnId; - deleteManagedDir = other1389.deleteManagedDir; - __isset = other1389.__isset; -} -DropDatabaseRequest& DropDatabaseRequest::operator=(const DropDatabaseRequest& other1390) { +DropDatabaseRequest::DropDatabaseRequest(const DropDatabaseRequest& other1390) { name = other1390.name; catalogName = other1390.catalogName; ignoreUnknownDb = other1390.ignoreUnknownDb; @@ -37810,6 +37852,17 @@ DropDatabaseRequest& DropDatabaseRequest::operator=(const DropDatabaseRequest& o txnId = other1390.txnId; deleteManagedDir = other1390.deleteManagedDir; __isset = other1390.__isset; +} +DropDatabaseRequest& DropDatabaseRequest::operator=(const DropDatabaseRequest& other1391) { + name = other1391.name; + catalogName = other1391.catalogName; + ignoreUnknownDb = other1391.ignoreUnknownDb; + deleteData = other1391.deleteData; + cascade = other1391.cascade; + softDelete = other1391.softDelete; + txnId = other1391.txnId; + deleteManagedDir = other1391.deleteManagedDir; + __isset = other1391.__isset; return *this; } void DropDatabaseRequest::printTo(std::ostream& out) const { @@ -37962,19 +38015,19 @@ void swap(GetFunctionsRequest &a, GetFunctionsRequest &b) { swap(a.__isset, b.__isset); } -GetFunctionsRequest::GetFunctionsRequest(const GetFunctionsRequest& other1391) { - dbName = other1391.dbName; - catalogName = other1391.catalogName; - pattern = other1391.pattern; - returnNames = other1391.returnNames; - __isset = other1391.__isset; -} -GetFunctionsRequest& GetFunctionsRequest::operator=(const GetFunctionsRequest& other1392) { +GetFunctionsRequest::GetFunctionsRequest(const GetFunctionsRequest& other1392) { dbName = other1392.dbName; catalogName = other1392.catalogName; pattern = other1392.pattern; returnNames = other1392.returnNames; __isset = other1392.__isset; +} +GetFunctionsRequest& GetFunctionsRequest::operator=(const GetFunctionsRequest& other1393) { + dbName = other1393.dbName; + catalogName = other1393.catalogName; + pattern = other1393.pattern; + returnNames = other1393.returnNames; + __isset = other1393.__isset; return *this; } void GetFunctionsRequest::printTo(std::ostream& out) const { @@ -38033,14 +38086,14 @@ uint32_t GetFunctionsResponse::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->function_names.clear(); - uint32_t _size1393; - ::apache::thrift::protocol::TType _etype1396; - xfer += iprot->readListBegin(_etype1396, _size1393); - this->function_names.resize(_size1393); - uint32_t _i1397; - for (_i1397 = 0; _i1397 < _size1393; ++_i1397) + uint32_t _size1394; + ::apache::thrift::protocol::TType _etype1397; + xfer += iprot->readListBegin(_etype1397, _size1394); + this->function_names.resize(_size1394); + uint32_t _i1398; + for (_i1398 = 0; _i1398 < _size1394; ++_i1398) { - xfer += iprot->readString(this->function_names[_i1397]); + xfer += iprot->readString(this->function_names[_i1398]); } xfer += iprot->readListEnd(); } @@ -38053,14 +38106,14 @@ uint32_t GetFunctionsResponse::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size1398; - ::apache::thrift::protocol::TType _etype1401; - xfer += iprot->readListBegin(_etype1401, _size1398); - this->functions.resize(_size1398); - uint32_t _i1402; - for (_i1402 = 0; _i1402 < _size1398; ++_i1402) + uint32_t _size1399; + ::apache::thrift::protocol::TType _etype1402; + xfer += iprot->readListBegin(_etype1402, _size1399); + this->functions.resize(_size1399); + uint32_t _i1403; + for (_i1403 = 0; _i1403 < _size1399; ++_i1403) { - xfer += this->functions[_i1402].read(iprot); + xfer += this->functions[_i1403].read(iprot); } xfer += iprot->readListEnd(); } @@ -38090,10 +38143,10 @@ uint32_t GetFunctionsResponse::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("function_names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->function_names.size())); - std::vector ::const_iterator _iter1403; - for (_iter1403 = this->function_names.begin(); _iter1403 != this->function_names.end(); ++_iter1403) + std::vector ::const_iterator _iter1404; + for (_iter1404 = this->function_names.begin(); _iter1404 != this->function_names.end(); ++_iter1404) { - xfer += oprot->writeString((*_iter1403)); + xfer += oprot->writeString((*_iter1404)); } xfer += oprot->writeListEnd(); } @@ -38103,10 +38156,10 @@ uint32_t GetFunctionsResponse::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter1404; - for (_iter1404 = this->functions.begin(); _iter1404 != this->functions.end(); ++_iter1404) + std::vector ::const_iterator _iter1405; + for (_iter1405 = this->functions.begin(); _iter1405 != this->functions.end(); ++_iter1405) { - xfer += (*_iter1404).write(oprot); + xfer += (*_iter1405).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38124,15 +38177,15 @@ void swap(GetFunctionsResponse &a, GetFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetFunctionsResponse::GetFunctionsResponse(const GetFunctionsResponse& other1405) { - function_names = other1405.function_names; - functions = other1405.functions; - __isset = other1405.__isset; -} -GetFunctionsResponse& GetFunctionsResponse::operator=(const GetFunctionsResponse& other1406) { +GetFunctionsResponse::GetFunctionsResponse(const GetFunctionsResponse& other1406) { function_names = other1406.function_names; functions = other1406.functions; __isset = other1406.__isset; +} +GetFunctionsResponse& GetFunctionsResponse::operator=(const GetFunctionsResponse& other1407) { + function_names = other1407.function_names; + functions = other1407.functions; + __isset = other1407.__isset; return *this; } void GetFunctionsResponse::printTo(std::ostream& out) const { @@ -38241,13 +38294,13 @@ void swap(CmRecycleRequest &a, CmRecycleRequest &b) { swap(a.purge, b.purge); } -CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other1407) { - dataPath = other1407.dataPath; - purge = other1407.purge; -} -CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other1408) { +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other1408) { dataPath = other1408.dataPath; purge = other1408.purge; +} +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other1409) { + dataPath = other1409.dataPath; + purge = other1409.purge; return *this; } void CmRecycleRequest::printTo(std::ostream& out) const { @@ -38313,11 +38366,11 @@ void swap(CmRecycleResponse &a, CmRecycleResponse &b) { (void) b; } -CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other1409) noexcept { - (void) other1409; -} -CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other1410) noexcept { +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other1410) noexcept { (void) other1410; +} +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other1411) noexcept { + (void) other1411; return *this; } void CmRecycleResponse::printTo(std::ostream& out) const { @@ -38443,9 +38496,9 @@ uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1411; - xfer += iprot->readI32(ecast1411); - this->ownerType = static_cast(ecast1411); + int32_t ecast1412; + xfer += iprot->readI32(ecast1412); + this->ownerType = static_cast(ecast1412); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -38523,17 +38576,7 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other1412) { - dbName = other1412.dbName; - tableName = other1412.tableName; - tableType = other1412.tableType; - comments = other1412.comments; - catName = other1412.catName; - ownerName = other1412.ownerName; - ownerType = other1412.ownerType; - __isset = other1412.__isset; -} -TableMeta& TableMeta::operator=(const TableMeta& other1413) { +TableMeta::TableMeta(const TableMeta& other1413) { dbName = other1413.dbName; tableName = other1413.tableName; tableType = other1413.tableType; @@ -38542,6 +38585,16 @@ TableMeta& TableMeta::operator=(const TableMeta& other1413) { ownerName = other1413.ownerName; ownerType = other1413.ownerType; __isset = other1413.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other1414) { + dbName = other1414.dbName; + tableName = other1414.tableName; + tableType = other1414.tableType; + comments = other1414.comments; + catName = other1414.catName; + ownerName = other1414.ownerName; + ownerType = other1414.ownerType; + __isset = other1414.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -38655,13 +38708,13 @@ void swap(Materialization &a, Materialization &b) { swap(a.sourceTablesCompacted, b.sourceTablesCompacted); } -Materialization::Materialization(const Materialization& other1414) noexcept { - sourceTablesUpdateDeleteModified = other1414.sourceTablesUpdateDeleteModified; - sourceTablesCompacted = other1414.sourceTablesCompacted; -} -Materialization& Materialization::operator=(const Materialization& other1415) noexcept { +Materialization::Materialization(const Materialization& other1415) noexcept { sourceTablesUpdateDeleteModified = other1415.sourceTablesUpdateDeleteModified; sourceTablesCompacted = other1415.sourceTablesCompacted; +} +Materialization& Materialization::operator=(const Materialization& other1416) noexcept { + sourceTablesUpdateDeleteModified = other1416.sourceTablesUpdateDeleteModified; + sourceTablesCompacted = other1416.sourceTablesCompacted; return *this; } void Materialization::printTo(std::ostream& out) const { @@ -38739,9 +38792,9 @@ uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1416; - xfer += iprot->readI32(ecast1416); - this->status = static_cast(ecast1416); + int32_t ecast1417; + xfer += iprot->readI32(ecast1417); + this->status = static_cast(ecast1417); this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -38829,21 +38882,21 @@ void swap(WMResourcePlan &a, WMResourcePlan &b) { swap(a.__isset, b.__isset); } -WMResourcePlan::WMResourcePlan(const WMResourcePlan& other1417) { - name = other1417.name; - status = other1417.status; - queryParallelism = other1417.queryParallelism; - defaultPoolPath = other1417.defaultPoolPath; - ns = other1417.ns; - __isset = other1417.__isset; -} -WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other1418) { +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other1418) { name = other1418.name; status = other1418.status; queryParallelism = other1418.queryParallelism; defaultPoolPath = other1418.defaultPoolPath; ns = other1418.ns; __isset = other1418.__isset; +} +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other1419) { + name = other1419.name; + status = other1419.status; + queryParallelism = other1419.queryParallelism; + defaultPoolPath = other1419.defaultPoolPath; + ns = other1419.ns; + __isset = other1419.__isset; return *this; } void WMResourcePlan::printTo(std::ostream& out) const { @@ -38934,9 +38987,9 @@ uint32_t WMNullableResourcePlan::read(::apache::thrift::protocol::TProtocol* ipr break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1419; - xfer += iprot->readI32(ecast1419); - this->status = static_cast(ecast1419); + int32_t ecast1420; + xfer += iprot->readI32(ecast1420); + this->status = static_cast(ecast1420); this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -39051,17 +39104,7 @@ void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) { swap(a.__isset, b.__isset); } -WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1420) { - name = other1420.name; - status = other1420.status; - queryParallelism = other1420.queryParallelism; - isSetQueryParallelism = other1420.isSetQueryParallelism; - defaultPoolPath = other1420.defaultPoolPath; - isSetDefaultPoolPath = other1420.isSetDefaultPoolPath; - ns = other1420.ns; - __isset = other1420.__isset; -} -WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1421) { +WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1421) { name = other1421.name; status = other1421.status; queryParallelism = other1421.queryParallelism; @@ -39070,6 +39113,16 @@ WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResour isSetDefaultPoolPath = other1421.isSetDefaultPoolPath; ns = other1421.ns; __isset = other1421.__isset; +} +WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1422) { + name = other1422.name; + status = other1422.status; + queryParallelism = other1422.queryParallelism; + isSetQueryParallelism = other1422.isSetQueryParallelism; + defaultPoolPath = other1422.defaultPoolPath; + isSetDefaultPoolPath = other1422.isSetDefaultPoolPath; + ns = other1422.ns; + __isset = other1422.__isset; return *this; } void WMNullableResourcePlan::printTo(std::ostream& out) const { @@ -39260,16 +39313,7 @@ void swap(WMPool &a, WMPool &b) { swap(a.__isset, b.__isset); } -WMPool::WMPool(const WMPool& other1422) { - resourcePlanName = other1422.resourcePlanName; - poolPath = other1422.poolPath; - allocFraction = other1422.allocFraction; - queryParallelism = other1422.queryParallelism; - schedulingPolicy = other1422.schedulingPolicy; - ns = other1422.ns; - __isset = other1422.__isset; -} -WMPool& WMPool::operator=(const WMPool& other1423) { +WMPool::WMPool(const WMPool& other1423) { resourcePlanName = other1423.resourcePlanName; poolPath = other1423.poolPath; allocFraction = other1423.allocFraction; @@ -39277,6 +39321,15 @@ WMPool& WMPool::operator=(const WMPool& other1423) { schedulingPolicy = other1423.schedulingPolicy; ns = other1423.ns; __isset = other1423.__isset; +} +WMPool& WMPool::operator=(const WMPool& other1424) { + resourcePlanName = other1424.resourcePlanName; + poolPath = other1424.poolPath; + allocFraction = other1424.allocFraction; + queryParallelism = other1424.queryParallelism; + schedulingPolicy = other1424.schedulingPolicy; + ns = other1424.ns; + __isset = other1424.__isset; return *this; } void WMPool::printTo(std::ostream& out) const { @@ -39485,17 +39538,7 @@ void swap(WMNullablePool &a, WMNullablePool &b) { swap(a.__isset, b.__isset); } -WMNullablePool::WMNullablePool(const WMNullablePool& other1424) { - resourcePlanName = other1424.resourcePlanName; - poolPath = other1424.poolPath; - allocFraction = other1424.allocFraction; - queryParallelism = other1424.queryParallelism; - schedulingPolicy = other1424.schedulingPolicy; - isSetSchedulingPolicy = other1424.isSetSchedulingPolicy; - ns = other1424.ns; - __isset = other1424.__isset; -} -WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1425) { +WMNullablePool::WMNullablePool(const WMNullablePool& other1425) { resourcePlanName = other1425.resourcePlanName; poolPath = other1425.poolPath; allocFraction = other1425.allocFraction; @@ -39504,6 +39547,16 @@ WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1425) { isSetSchedulingPolicy = other1425.isSetSchedulingPolicy; ns = other1425.ns; __isset = other1425.__isset; +} +WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1426) { + resourcePlanName = other1426.resourcePlanName; + poolPath = other1426.poolPath; + allocFraction = other1426.allocFraction; + queryParallelism = other1426.queryParallelism; + schedulingPolicy = other1426.schedulingPolicy; + isSetSchedulingPolicy = other1426.isSetSchedulingPolicy; + ns = other1426.ns; + __isset = other1426.__isset; return *this; } void WMNullablePool::printTo(std::ostream& out) const { @@ -39694,16 +39747,7 @@ void swap(WMTrigger &a, WMTrigger &b) { swap(a.__isset, b.__isset); } -WMTrigger::WMTrigger(const WMTrigger& other1426) { - resourcePlanName = other1426.resourcePlanName; - triggerName = other1426.triggerName; - triggerExpression = other1426.triggerExpression; - actionExpression = other1426.actionExpression; - isInUnmanaged = other1426.isInUnmanaged; - ns = other1426.ns; - __isset = other1426.__isset; -} -WMTrigger& WMTrigger::operator=(const WMTrigger& other1427) { +WMTrigger::WMTrigger(const WMTrigger& other1427) { resourcePlanName = other1427.resourcePlanName; triggerName = other1427.triggerName; triggerExpression = other1427.triggerExpression; @@ -39711,6 +39755,15 @@ WMTrigger& WMTrigger::operator=(const WMTrigger& other1427) { isInUnmanaged = other1427.isInUnmanaged; ns = other1427.ns; __isset = other1427.__isset; +} +WMTrigger& WMTrigger::operator=(const WMTrigger& other1428) { + resourcePlanName = other1428.resourcePlanName; + triggerName = other1428.triggerName; + triggerExpression = other1428.triggerExpression; + actionExpression = other1428.actionExpression; + isInUnmanaged = other1428.isInUnmanaged; + ns = other1428.ns; + __isset = other1428.__isset; return *this; } void WMTrigger::printTo(std::ostream& out) const { @@ -39901,16 +39954,7 @@ void swap(WMMapping &a, WMMapping &b) { swap(a.__isset, b.__isset); } -WMMapping::WMMapping(const WMMapping& other1428) { - resourcePlanName = other1428.resourcePlanName; - entityType = other1428.entityType; - entityName = other1428.entityName; - poolPath = other1428.poolPath; - ordering = other1428.ordering; - ns = other1428.ns; - __isset = other1428.__isset; -} -WMMapping& WMMapping::operator=(const WMMapping& other1429) { +WMMapping::WMMapping(const WMMapping& other1429) { resourcePlanName = other1429.resourcePlanName; entityType = other1429.entityType; entityName = other1429.entityName; @@ -39918,6 +39962,15 @@ WMMapping& WMMapping::operator=(const WMMapping& other1429) { ordering = other1429.ordering; ns = other1429.ns; __isset = other1429.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other1430) { + resourcePlanName = other1430.resourcePlanName; + entityType = other1430.entityType; + entityName = other1430.entityName; + poolPath = other1430.poolPath; + ordering = other1430.ordering; + ns = other1430.ns; + __isset = other1430.__isset; return *this; } void WMMapping::printTo(std::ostream& out) const { @@ -40050,17 +40103,17 @@ void swap(WMPoolTrigger &a, WMPoolTrigger &b) { swap(a.__isset, b.__isset); } -WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1430) { - pool = other1430.pool; - trigger = other1430.trigger; - ns = other1430.ns; - __isset = other1430.__isset; -} -WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1431) { +WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1431) { pool = other1431.pool; trigger = other1431.trigger; ns = other1431.ns; __isset = other1431.__isset; +} +WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1432) { + pool = other1432.pool; + trigger = other1432.trigger; + ns = other1432.ns; + __isset = other1432.__isset; return *this; } void WMPoolTrigger::printTo(std::ostream& out) const { @@ -40141,14 +40194,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->pools.clear(); - uint32_t _size1432; - ::apache::thrift::protocol::TType _etype1435; - xfer += iprot->readListBegin(_etype1435, _size1432); - this->pools.resize(_size1432); - uint32_t _i1436; - for (_i1436 = 0; _i1436 < _size1432; ++_i1436) + uint32_t _size1433; + ::apache::thrift::protocol::TType _etype1436; + xfer += iprot->readListBegin(_etype1436, _size1433); + this->pools.resize(_size1433); + uint32_t _i1437; + for (_i1437 = 0; _i1437 < _size1433; ++_i1437) { - xfer += this->pools[_i1436].read(iprot); + xfer += this->pools[_i1437].read(iprot); } xfer += iprot->readListEnd(); } @@ -40161,14 +40214,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->mappings.clear(); - uint32_t _size1437; - ::apache::thrift::protocol::TType _etype1440; - xfer += iprot->readListBegin(_etype1440, _size1437); - this->mappings.resize(_size1437); - uint32_t _i1441; - for (_i1441 = 0; _i1441 < _size1437; ++_i1441) + uint32_t _size1438; + ::apache::thrift::protocol::TType _etype1441; + xfer += iprot->readListBegin(_etype1441, _size1438); + this->mappings.resize(_size1438); + uint32_t _i1442; + for (_i1442 = 0; _i1442 < _size1438; ++_i1442) { - xfer += this->mappings[_i1441].read(iprot); + xfer += this->mappings[_i1442].read(iprot); } xfer += iprot->readListEnd(); } @@ -40181,14 +40234,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1442; - ::apache::thrift::protocol::TType _etype1445; - xfer += iprot->readListBegin(_etype1445, _size1442); - this->triggers.resize(_size1442); - uint32_t _i1446; - for (_i1446 = 0; _i1446 < _size1442; ++_i1446) + uint32_t _size1443; + ::apache::thrift::protocol::TType _etype1446; + xfer += iprot->readListBegin(_etype1446, _size1443); + this->triggers.resize(_size1443); + uint32_t _i1447; + for (_i1447 = 0; _i1447 < _size1443; ++_i1447) { - xfer += this->triggers[_i1446].read(iprot); + xfer += this->triggers[_i1447].read(iprot); } xfer += iprot->readListEnd(); } @@ -40201,14 +40254,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->poolTriggers.clear(); - uint32_t _size1447; - ::apache::thrift::protocol::TType _etype1450; - xfer += iprot->readListBegin(_etype1450, _size1447); - this->poolTriggers.resize(_size1447); - uint32_t _i1451; - for (_i1451 = 0; _i1451 < _size1447; ++_i1451) + uint32_t _size1448; + ::apache::thrift::protocol::TType _etype1451; + xfer += iprot->readListBegin(_etype1451, _size1448); + this->poolTriggers.resize(_size1448); + uint32_t _i1452; + for (_i1452 = 0; _i1452 < _size1448; ++_i1452) { - xfer += this->poolTriggers[_i1451].read(iprot); + xfer += this->poolTriggers[_i1452].read(iprot); } xfer += iprot->readListEnd(); } @@ -40245,10 +40298,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 _iter1452; - for (_iter1452 = this->pools.begin(); _iter1452 != this->pools.end(); ++_iter1452) + std::vector ::const_iterator _iter1453; + for (_iter1453 = this->pools.begin(); _iter1453 != this->pools.end(); ++_iter1453) { - xfer += (*_iter1452).write(oprot); + xfer += (*_iter1453).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40258,10 +40311,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 _iter1453; - for (_iter1453 = this->mappings.begin(); _iter1453 != this->mappings.end(); ++_iter1453) + std::vector ::const_iterator _iter1454; + for (_iter1454 = this->mappings.begin(); _iter1454 != this->mappings.end(); ++_iter1454) { - xfer += (*_iter1453).write(oprot); + xfer += (*_iter1454).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40271,10 +40324,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 _iter1454; - for (_iter1454 = this->triggers.begin(); _iter1454 != this->triggers.end(); ++_iter1454) + std::vector ::const_iterator _iter1455; + for (_iter1455 = this->triggers.begin(); _iter1455 != this->triggers.end(); ++_iter1455) { - xfer += (*_iter1454).write(oprot); + xfer += (*_iter1455).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40284,10 +40337,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 _iter1455; - for (_iter1455 = this->poolTriggers.begin(); _iter1455 != this->poolTriggers.end(); ++_iter1455) + std::vector ::const_iterator _iter1456; + for (_iter1456 = this->poolTriggers.begin(); _iter1456 != this->poolTriggers.end(); ++_iter1456) { - xfer += (*_iter1455).write(oprot); + xfer += (*_iter1456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40308,21 +40361,21 @@ void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) { swap(a.__isset, b.__isset); } -WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1456) { - plan = other1456.plan; - pools = other1456.pools; - mappings = other1456.mappings; - triggers = other1456.triggers; - poolTriggers = other1456.poolTriggers; - __isset = other1456.__isset; -} -WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1457) { +WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1457) { plan = other1457.plan; pools = other1457.pools; mappings = other1457.mappings; triggers = other1457.triggers; poolTriggers = other1457.poolTriggers; __isset = other1457.__isset; +} +WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1458) { + plan = other1458.plan; + pools = other1458.pools; + mappings = other1458.mappings; + triggers = other1458.triggers; + poolTriggers = other1458.poolTriggers; + __isset = other1458.__isset; return *this; } void WMFullResourcePlan::printTo(std::ostream& out) const { @@ -40433,15 +40486,15 @@ void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1458) { - resourcePlan = other1458.resourcePlan; - copyFrom = other1458.copyFrom; - __isset = other1458.__isset; -} -WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1459) { +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1459) { resourcePlan = other1459.resourcePlan; copyFrom = other1459.copyFrom; __isset = other1459.__isset; +} +WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1460) { + resourcePlan = other1460.resourcePlan; + copyFrom = other1460.copyFrom; + __isset = other1460.__isset; return *this; } void WMCreateResourcePlanRequest::printTo(std::ostream& out) const { @@ -40507,11 +40560,11 @@ void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) { (void) b; } -WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1460) noexcept { - (void) other1460; -} -WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1461) noexcept { +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1461) noexcept { (void) other1461; +} +WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1462) noexcept { + (void) other1462; return *this; } void WMCreateResourcePlanResponse::printTo(std::ostream& out) const { @@ -40598,13 +40651,13 @@ void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1462) { - ns = other1462.ns; - __isset = other1462.__isset; -} -WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1463) { +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1463) { ns = other1463.ns; __isset = other1463.__isset; +} +WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1464) { + ns = other1464.ns; + __isset = other1464.__isset; return *this; } void WMGetActiveResourcePlanRequest::printTo(std::ostream& out) const { @@ -40692,13 +40745,13 @@ void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1464) { - resourcePlan = other1464.resourcePlan; - __isset = other1464.__isset; -} -WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1465) { +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1465) { resourcePlan = other1465.resourcePlan; __isset = other1465.__isset; +} +WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1466) { + resourcePlan = other1466.resourcePlan; + __isset = other1466.__isset; return *this; } void WMGetActiveResourcePlanResponse::printTo(std::ostream& out) const { @@ -40805,15 +40858,15 @@ void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1466) { - resourcePlanName = other1466.resourcePlanName; - ns = other1466.ns; - __isset = other1466.__isset; -} -WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1467) { +WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1467) { resourcePlanName = other1467.resourcePlanName; ns = other1467.ns; __isset = other1467.__isset; +} +WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1468) { + resourcePlanName = other1468.resourcePlanName; + ns = other1468.ns; + __isset = other1468.__isset; return *this; } void WMGetResourcePlanRequest::printTo(std::ostream& out) const { @@ -40902,13 +40955,13 @@ void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1468) { - resourcePlan = other1468.resourcePlan; - __isset = other1468.__isset; -} -WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1469) { +WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1469) { resourcePlan = other1469.resourcePlan; __isset = other1469.__isset; +} +WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1470) { + resourcePlan = other1470.resourcePlan; + __isset = other1470.__isset; return *this; } void WMGetResourcePlanResponse::printTo(std::ostream& out) const { @@ -40996,13 +41049,13 @@ void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1470) { - ns = other1470.ns; - __isset = other1470.__isset; -} -WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1471) { +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1471) { ns = other1471.ns; __isset = other1471.__isset; +} +WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1472) { + ns = other1472.ns; + __isset = other1472.__isset; return *this; } void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const { @@ -41053,14 +41106,14 @@ uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourcePlans.clear(); - uint32_t _size1472; - ::apache::thrift::protocol::TType _etype1475; - xfer += iprot->readListBegin(_etype1475, _size1472); - this->resourcePlans.resize(_size1472); - uint32_t _i1476; - for (_i1476 = 0; _i1476 < _size1472; ++_i1476) + uint32_t _size1473; + ::apache::thrift::protocol::TType _etype1476; + xfer += iprot->readListBegin(_etype1476, _size1473); + this->resourcePlans.resize(_size1473); + uint32_t _i1477; + for (_i1477 = 0; _i1477 < _size1473; ++_i1477) { - xfer += this->resourcePlans[_i1476].read(iprot); + xfer += this->resourcePlans[_i1477].read(iprot); } xfer += iprot->readListEnd(); } @@ -41090,10 +41143,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 _iter1477; - for (_iter1477 = this->resourcePlans.begin(); _iter1477 != this->resourcePlans.end(); ++_iter1477) + std::vector ::const_iterator _iter1478; + for (_iter1478 = this->resourcePlans.begin(); _iter1478 != this->resourcePlans.end(); ++_iter1478) { - xfer += (*_iter1477).write(oprot); + xfer += (*_iter1478).write(oprot); } xfer += oprot->writeListEnd(); } @@ -41110,13 +41163,13 @@ void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1478) { - resourcePlans = other1478.resourcePlans; - __isset = other1478.__isset; -} -WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1479) { +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1479) { resourcePlans = other1479.resourcePlans; __isset = other1479.__isset; +} +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1480) { + resourcePlans = other1480.resourcePlans; + __isset = other1480.__isset; return *this; } void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { @@ -41299,16 +41352,7 @@ void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1480) { - resourcePlanName = other1480.resourcePlanName; - resourcePlan = other1480.resourcePlan; - isEnableAndActivate = other1480.isEnableAndActivate; - isForceDeactivate = other1480.isForceDeactivate; - isReplace = other1480.isReplace; - ns = other1480.ns; - __isset = other1480.__isset; -} -WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1481) { +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1481) { resourcePlanName = other1481.resourcePlanName; resourcePlan = other1481.resourcePlan; isEnableAndActivate = other1481.isEnableAndActivate; @@ -41316,6 +41360,15 @@ WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterR isReplace = other1481.isReplace; ns = other1481.ns; __isset = other1481.__isset; +} +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1482) { + resourcePlanName = other1482.resourcePlanName; + resourcePlan = other1482.resourcePlan; + isEnableAndActivate = other1482.isEnableAndActivate; + isForceDeactivate = other1482.isForceDeactivate; + isReplace = other1482.isReplace; + ns = other1482.ns; + __isset = other1482.__isset; return *this; } void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { @@ -41408,13 +41461,13 @@ void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1482) { - fullResourcePlan = other1482.fullResourcePlan; - __isset = other1482.__isset; -} -WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1483) { +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1483) { fullResourcePlan = other1483.fullResourcePlan; __isset = other1483.__isset; +} +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1484) { + fullResourcePlan = other1484.fullResourcePlan; + __isset = other1484.__isset; return *this; } void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { @@ -41521,15 +41574,15 @@ void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1484) { - resourcePlanName = other1484.resourcePlanName; - ns = other1484.ns; - __isset = other1484.__isset; -} -WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1485) { +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1485) { resourcePlanName = other1485.resourcePlanName; ns = other1485.ns; __isset = other1485.__isset; +} +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1486) { + resourcePlanName = other1486.resourcePlanName; + ns = other1486.ns; + __isset = other1486.__isset; return *this; } void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { @@ -41586,14 +41639,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->errors.clear(); - uint32_t _size1486; - ::apache::thrift::protocol::TType _etype1489; - xfer += iprot->readListBegin(_etype1489, _size1486); - this->errors.resize(_size1486); - uint32_t _i1490; - for (_i1490 = 0; _i1490 < _size1486; ++_i1490) + uint32_t _size1487; + ::apache::thrift::protocol::TType _etype1490; + xfer += iprot->readListBegin(_etype1490, _size1487); + this->errors.resize(_size1487); + uint32_t _i1491; + for (_i1491 = 0; _i1491 < _size1487; ++_i1491) { - xfer += iprot->readString(this->errors[_i1490]); + xfer += iprot->readString(this->errors[_i1491]); } xfer += iprot->readListEnd(); } @@ -41606,14 +41659,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->warnings.clear(); - uint32_t _size1491; - ::apache::thrift::protocol::TType _etype1494; - xfer += iprot->readListBegin(_etype1494, _size1491); - this->warnings.resize(_size1491); - uint32_t _i1495; - for (_i1495 = 0; _i1495 < _size1491; ++_i1495) + uint32_t _size1492; + ::apache::thrift::protocol::TType _etype1495; + xfer += iprot->readListBegin(_etype1495, _size1492); + this->warnings.resize(_size1492); + uint32_t _i1496; + for (_i1496 = 0; _i1496 < _size1492; ++_i1496) { - xfer += iprot->readString(this->warnings[_i1495]); + xfer += iprot->readString(this->warnings[_i1496]); } xfer += iprot->readListEnd(); } @@ -41643,10 +41696,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 _iter1496; - for (_iter1496 = this->errors.begin(); _iter1496 != this->errors.end(); ++_iter1496) + std::vector ::const_iterator _iter1497; + for (_iter1497 = this->errors.begin(); _iter1497 != this->errors.end(); ++_iter1497) { - xfer += oprot->writeString((*_iter1496)); + xfer += oprot->writeString((*_iter1497)); } xfer += oprot->writeListEnd(); } @@ -41656,10 +41709,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 _iter1497; - for (_iter1497 = this->warnings.begin(); _iter1497 != this->warnings.end(); ++_iter1497) + std::vector ::const_iterator _iter1498; + for (_iter1498 = this->warnings.begin(); _iter1498 != this->warnings.end(); ++_iter1498) { - xfer += oprot->writeString((*_iter1497)); + xfer += oprot->writeString((*_iter1498)); } xfer += oprot->writeListEnd(); } @@ -41677,15 +41730,15 @@ void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) swap(a.__isset, b.__isset); } -WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1498) { - errors = other1498.errors; - warnings = other1498.warnings; - __isset = other1498.__isset; -} -WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1499) { +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1499) { errors = other1499.errors; warnings = other1499.warnings; __isset = other1499.__isset; +} +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1500) { + errors = other1500.errors; + warnings = other1500.warnings; + __isset = other1500.__isset; return *this; } void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { @@ -41793,15 +41846,15 @@ void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1500) { - resourcePlanName = other1500.resourcePlanName; - ns = other1500.ns; - __isset = other1500.__isset; -} -WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1501) { +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1501) { resourcePlanName = other1501.resourcePlanName; ns = other1501.ns; __isset = other1501.__isset; +} +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1502) { + resourcePlanName = other1502.resourcePlanName; + ns = other1502.ns; + __isset = other1502.__isset; return *this; } void WMDropResourcePlanRequest::printTo(std::ostream& out) const { @@ -41867,11 +41920,11 @@ void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { (void) b; } -WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1502) noexcept { - (void) other1502; -} -WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1503) noexcept { +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1503) noexcept { (void) other1503; +} +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1504) noexcept { + (void) other1504; return *this; } void WMDropResourcePlanResponse::printTo(std::ostream& out) const { @@ -41958,13 +42011,13 @@ void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1504) { - trigger = other1504.trigger; - __isset = other1504.__isset; -} -WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1505) { +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1505) { trigger = other1505.trigger; __isset = other1505.__isset; +} +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1506) { + trigger = other1506.trigger; + __isset = other1506.__isset; return *this; } void WMCreateTriggerRequest::printTo(std::ostream& out) const { @@ -42029,11 +42082,11 @@ void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) { (void) b; } -WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1506) noexcept { - (void) other1506; -} -WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1507) noexcept { +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1507) noexcept { (void) other1507; +} +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1508) noexcept { + (void) other1508; return *this; } void WMCreateTriggerResponse::printTo(std::ostream& out) const { @@ -42120,13 +42173,13 @@ void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1508) { - trigger = other1508.trigger; - __isset = other1508.__isset; -} -WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1509) { +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1509) { trigger = other1509.trigger; __isset = other1509.__isset; +} +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1510) { + trigger = other1510.trigger; + __isset = other1510.__isset; return *this; } void WMAlterTriggerRequest::printTo(std::ostream& out) const { @@ -42191,11 +42244,11 @@ void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) { (void) b; } -WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1510) noexcept { - (void) other1510; -} -WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1511) noexcept { +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1511) noexcept { (void) other1511; +} +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1512) noexcept { + (void) other1512; return *this; } void WMAlterTriggerResponse::printTo(std::ostream& out) const { @@ -42320,17 +42373,17 @@ void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1512) { - resourcePlanName = other1512.resourcePlanName; - triggerName = other1512.triggerName; - ns = other1512.ns; - __isset = other1512.__isset; -} -WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1513) { +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1513) { resourcePlanName = other1513.resourcePlanName; triggerName = other1513.triggerName; ns = other1513.ns; __isset = other1513.__isset; +} +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1514) { + resourcePlanName = other1514.resourcePlanName; + triggerName = other1514.triggerName; + ns = other1514.ns; + __isset = other1514.__isset; return *this; } void WMDropTriggerRequest::printTo(std::ostream& out) const { @@ -42397,11 +42450,11 @@ void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) { (void) b; } -WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1514) noexcept { - (void) other1514; -} -WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1515) noexcept { +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1515) noexcept { (void) other1515; +} +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1516) noexcept { + (void) other1516; return *this; } void WMDropTriggerResponse::printTo(std::ostream& out) const { @@ -42507,15 +42560,15 @@ void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequ swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1516) { - resourcePlanName = other1516.resourcePlanName; - ns = other1516.ns; - __isset = other1516.__isset; -} -WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1517) { +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1517) { resourcePlanName = other1517.resourcePlanName; ns = other1517.ns; __isset = other1517.__isset; +} +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1518) { + resourcePlanName = other1518.resourcePlanName; + ns = other1518.ns; + __isset = other1518.__isset; return *this; } void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { @@ -42567,14 +42620,14 @@ uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1518; - ::apache::thrift::protocol::TType _etype1521; - xfer += iprot->readListBegin(_etype1521, _size1518); - this->triggers.resize(_size1518); - uint32_t _i1522; - for (_i1522 = 0; _i1522 < _size1518; ++_i1522) + uint32_t _size1519; + ::apache::thrift::protocol::TType _etype1522; + xfer += iprot->readListBegin(_etype1522, _size1519); + this->triggers.resize(_size1519); + uint32_t _i1523; + for (_i1523 = 0; _i1523 < _size1519; ++_i1523) { - xfer += this->triggers[_i1522].read(iprot); + xfer += this->triggers[_i1523].read(iprot); } xfer += iprot->readListEnd(); } @@ -42604,10 +42657,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 _iter1523; - for (_iter1523 = this->triggers.begin(); _iter1523 != this->triggers.end(); ++_iter1523) + std::vector ::const_iterator _iter1524; + for (_iter1524 = this->triggers.begin(); _iter1524 != this->triggers.end(); ++_iter1524) { - xfer += (*_iter1523).write(oprot); + xfer += (*_iter1524).write(oprot); } xfer += oprot->writeListEnd(); } @@ -42624,13 +42677,13 @@ void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanRes swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1524) { - triggers = other1524.triggers; - __isset = other1524.__isset; -} -WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1525) { +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1525) { triggers = other1525.triggers; __isset = other1525.__isset; +} +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1526) { + triggers = other1526.triggers; + __isset = other1526.__isset; return *this; } void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { @@ -42718,13 +42771,13 @@ void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) { swap(a.__isset, b.__isset); } -WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1526) { - pool = other1526.pool; - __isset = other1526.__isset; -} -WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1527) { +WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1527) { pool = other1527.pool; __isset = other1527.__isset; +} +WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1528) { + pool = other1528.pool; + __isset = other1528.__isset; return *this; } void WMCreatePoolRequest::printTo(std::ostream& out) const { @@ -42789,11 +42842,11 @@ void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) { (void) b; } -WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1528) noexcept { - (void) other1528; -} -WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1529) noexcept { +WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1529) noexcept { (void) other1529; +} +WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1530) noexcept { + (void) other1530; return *this; } void WMCreatePoolResponse::printTo(std::ostream& out) const { @@ -42899,15 +42952,15 @@ void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) { swap(a.__isset, b.__isset); } -WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1530) { - pool = other1530.pool; - poolPath = other1530.poolPath; - __isset = other1530.__isset; -} -WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1531) { +WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1531) { pool = other1531.pool; poolPath = other1531.poolPath; __isset = other1531.__isset; +} +WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1532) { + pool = other1532.pool; + poolPath = other1532.poolPath; + __isset = other1532.__isset; return *this; } void WMAlterPoolRequest::printTo(std::ostream& out) const { @@ -42973,11 +43026,11 @@ void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) { (void) b; } -WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1532) noexcept { - (void) other1532; -} -WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1533) noexcept { +WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1533) noexcept { (void) other1533; +} +WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1534) noexcept { + (void) other1534; return *this; } void WMAlterPoolResponse::printTo(std::ostream& out) const { @@ -43102,17 +43155,17 @@ void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) { swap(a.__isset, b.__isset); } -WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1534) { - resourcePlanName = other1534.resourcePlanName; - poolPath = other1534.poolPath; - ns = other1534.ns; - __isset = other1534.__isset; -} -WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1535) { +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1535) { resourcePlanName = other1535.resourcePlanName; poolPath = other1535.poolPath; ns = other1535.ns; __isset = other1535.__isset; +} +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1536) { + resourcePlanName = other1536.resourcePlanName; + poolPath = other1536.poolPath; + ns = other1536.ns; + __isset = other1536.__isset; return *this; } void WMDropPoolRequest::printTo(std::ostream& out) const { @@ -43179,11 +43232,11 @@ void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) { (void) b; } -WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1536) noexcept { - (void) other1536; -} -WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1537) noexcept { +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1537) noexcept { (void) other1537; +} +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1538) noexcept { + (void) other1538; return *this; } void WMDropPoolResponse::printTo(std::ostream& out) const { @@ -43289,15 +43342,15 @@ void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) swap(a.__isset, b.__isset); } -WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1538) { - mapping = other1538.mapping; - update = other1538.update; - __isset = other1538.__isset; -} -WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1539) { +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1539) { mapping = other1539.mapping; update = other1539.update; __isset = other1539.__isset; +} +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1540) { + mapping = other1540.mapping; + update = other1540.update; + __isset = other1540.__isset; return *this; } void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { @@ -43363,11 +43416,11 @@ void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b (void) b; } -WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1540) noexcept { - (void) other1540; -} -WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1541) noexcept { +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1541) noexcept { (void) other1541; +} +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1542) noexcept { + (void) other1542; return *this; } void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { @@ -43454,13 +43507,13 @@ void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) { swap(a.__isset, b.__isset); } -WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1542) { - mapping = other1542.mapping; - __isset = other1542.__isset; -} -WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1543) { +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1543) { mapping = other1543.mapping; __isset = other1543.__isset; +} +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1544) { + mapping = other1544.mapping; + __isset = other1544.__isset; return *this; } void WMDropMappingRequest::printTo(std::ostream& out) const { @@ -43525,11 +43578,11 @@ void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) { (void) b; } -WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1544) noexcept { - (void) other1544; -} -WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1545) noexcept { +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1545) noexcept { (void) other1545; +} +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1546) noexcept { + (void) other1546; return *this; } void WMDropMappingResponse::printTo(std::ostream& out) const { @@ -43692,21 +43745,21 @@ void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToP swap(a.__isset, b.__isset); } -WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1546) { - resourcePlanName = other1546.resourcePlanName; - triggerName = other1546.triggerName; - poolPath = other1546.poolPath; - drop = other1546.drop; - ns = other1546.ns; - __isset = other1546.__isset; -} -WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1547) { +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1547) { resourcePlanName = other1547.resourcePlanName; triggerName = other1547.triggerName; poolPath = other1547.poolPath; drop = other1547.drop; ns = other1547.ns; __isset = other1547.__isset; +} +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1548) { + resourcePlanName = other1548.resourcePlanName; + triggerName = other1548.triggerName; + poolPath = other1548.poolPath; + drop = other1548.drop; + ns = other1548.ns; + __isset = other1548.__isset; return *this; } void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { @@ -43775,11 +43828,11 @@ void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerTo (void) b; } -WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1548) noexcept { - (void) other1548; -} -WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1549) noexcept { +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1549) noexcept { (void) other1549; +} +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1550) noexcept { + (void) other1550; return *this; } void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { @@ -43860,9 +43913,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1550; - xfer += iprot->readI32(ecast1550); - this->schemaType = static_cast(ecast1550); + int32_t ecast1551; + xfer += iprot->readI32(ecast1551); + this->schemaType = static_cast(ecast1551); this->__isset.schemaType = true; } else { xfer += iprot->skip(ftype); @@ -43894,9 +43947,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1551; - xfer += iprot->readI32(ecast1551); - this->compatibility = static_cast(ecast1551); + int32_t ecast1552; + xfer += iprot->readI32(ecast1552); + this->compatibility = static_cast(ecast1552); this->__isset.compatibility = true; } else { xfer += iprot->skip(ftype); @@ -43904,9 +43957,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1552; - xfer += iprot->readI32(ecast1552); - this->validationLevel = static_cast(ecast1552); + int32_t ecast1553; + xfer += iprot->readI32(ecast1553); + this->validationLevel = static_cast(ecast1553); this->__isset.validationLevel = true; } else { xfer += iprot->skip(ftype); @@ -44010,19 +44063,7 @@ void swap(ISchema &a, ISchema &b) { swap(a.__isset, b.__isset); } -ISchema::ISchema(const ISchema& other1553) { - schemaType = other1553.schemaType; - name = other1553.name; - catName = other1553.catName; - dbName = other1553.dbName; - compatibility = other1553.compatibility; - validationLevel = other1553.validationLevel; - canEvolve = other1553.canEvolve; - schemaGroup = other1553.schemaGroup; - description = other1553.description; - __isset = other1553.__isset; -} -ISchema& ISchema::operator=(const ISchema& other1554) { +ISchema::ISchema(const ISchema& other1554) { schemaType = other1554.schemaType; name = other1554.name; catName = other1554.catName; @@ -44033,6 +44074,18 @@ ISchema& ISchema::operator=(const ISchema& other1554) { schemaGroup = other1554.schemaGroup; description = other1554.description; __isset = other1554.__isset; +} +ISchema& ISchema::operator=(const ISchema& other1555) { + schemaType = other1555.schemaType; + name = other1555.name; + catName = other1555.catName; + dbName = other1555.dbName; + compatibility = other1555.compatibility; + validationLevel = other1555.validationLevel; + canEvolve = other1555.canEvolve; + schemaGroup = other1555.schemaGroup; + description = other1555.description; + __isset = other1555.__isset; return *this; } void ISchema::printTo(std::ostream& out) const { @@ -44160,17 +44213,17 @@ void swap(ISchemaName &a, ISchemaName &b) { swap(a.__isset, b.__isset); } -ISchemaName::ISchemaName(const ISchemaName& other1555) { - catName = other1555.catName; - dbName = other1555.dbName; - schemaName = other1555.schemaName; - __isset = other1555.__isset; -} -ISchemaName& ISchemaName::operator=(const ISchemaName& other1556) { +ISchemaName::ISchemaName(const ISchemaName& other1556) { catName = other1556.catName; dbName = other1556.dbName; schemaName = other1556.schemaName; __isset = other1556.__isset; +} +ISchemaName& ISchemaName::operator=(const ISchemaName& other1557) { + catName = other1557.catName; + dbName = other1557.dbName; + schemaName = other1557.schemaName; + __isset = other1557.__isset; return *this; } void ISchemaName::printTo(std::ostream& out) const { @@ -44275,15 +44328,15 @@ void swap(AlterISchemaRequest &a, AlterISchemaRequest &b) { swap(a.__isset, b.__isset); } -AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1557) { - name = other1557.name; - newSchema = other1557.newSchema; - __isset = other1557.__isset; -} -AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1558) { +AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1558) { name = other1558.name; newSchema = other1558.newSchema; __isset = other1558.__isset; +} +AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1559) { + name = other1559.name; + newSchema = other1559.newSchema; + __isset = other1559.__isset; return *this; } void AlterISchemaRequest::printTo(std::ostream& out) const { @@ -44400,14 +44453,14 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size1559; - ::apache::thrift::protocol::TType _etype1562; - xfer += iprot->readListBegin(_etype1562, _size1559); - this->cols.resize(_size1559); - uint32_t _i1563; - for (_i1563 = 0; _i1563 < _size1559; ++_i1563) + uint32_t _size1560; + ::apache::thrift::protocol::TType _etype1563; + xfer += iprot->readListBegin(_etype1563, _size1560); + this->cols.resize(_size1560); + uint32_t _i1564; + for (_i1564 = 0; _i1564 < _size1560; ++_i1564) { - xfer += this->cols[_i1563].read(iprot); + xfer += this->cols[_i1564].read(iprot); } xfer += iprot->readListEnd(); } @@ -44418,9 +44471,9 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1564; - xfer += iprot->readI32(ecast1564); - this->state = static_cast(ecast1564); + int32_t ecast1565; + xfer += iprot->readI32(ecast1565); + this->state = static_cast(ecast1565); this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -44498,10 +44551,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 _iter1565; - for (_iter1565 = this->cols.begin(); _iter1565 != this->cols.end(); ++_iter1565) + std::vector ::const_iterator _iter1566; + for (_iter1566 = this->cols.begin(); _iter1566 != this->cols.end(); ++_iter1566) { - xfer += (*_iter1565).write(oprot); + xfer += (*_iter1566).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44557,20 +44610,7 @@ void swap(SchemaVersion &a, SchemaVersion &b) { swap(a.__isset, b.__isset); } -SchemaVersion::SchemaVersion(const SchemaVersion& other1566) { - schema = other1566.schema; - version = other1566.version; - createdAt = other1566.createdAt; - cols = other1566.cols; - state = other1566.state; - description = other1566.description; - schemaText = other1566.schemaText; - fingerprint = other1566.fingerprint; - name = other1566.name; - serDe = other1566.serDe; - __isset = other1566.__isset; -} -SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1567) { +SchemaVersion::SchemaVersion(const SchemaVersion& other1567) { schema = other1567.schema; version = other1567.version; createdAt = other1567.createdAt; @@ -44582,6 +44622,19 @@ SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1567) { name = other1567.name; serDe = other1567.serDe; __isset = other1567.__isset; +} +SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1568) { + schema = other1568.schema; + version = other1568.version; + createdAt = other1568.createdAt; + cols = other1568.cols; + state = other1568.state; + description = other1568.description; + schemaText = other1568.schemaText; + fingerprint = other1568.fingerprint; + name = other1568.name; + serDe = other1568.serDe; + __isset = other1568.__isset; return *this; } void SchemaVersion::printTo(std::ostream& out) const { @@ -44693,15 +44746,15 @@ void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b) { swap(a.__isset, b.__isset); } -SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1568) { - schema = other1568.schema; - version = other1568.version; - __isset = other1568.__isset; -} -SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1569) { +SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1569) { schema = other1569.schema; version = other1569.version; __isset = other1569.__isset; +} +SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1570) { + schema = other1570.schema; + version = other1570.version; + __isset = other1570.__isset; return *this; } void SchemaVersionDescriptor::printTo(std::ostream& out) const { @@ -44828,17 +44881,17 @@ void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1570) { - colName = other1570.colName; - colNamespace = other1570.colNamespace; - type = other1570.type; - __isset = other1570.__isset; -} -FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1571) { +FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1571) { colName = other1571.colName; colNamespace = other1571.colNamespace; type = other1571.type; __isset = other1571.__isset; +} +FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1572) { + colName = other1572.colName; + colNamespace = other1572.colNamespace; + type = other1572.type; + __isset = other1572.__isset; return *this; } void FindSchemasByColsRqst::printTo(std::ostream& out) const { @@ -44890,14 +44943,14 @@ uint32_t FindSchemasByColsResp::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->schemaVersions.clear(); - uint32_t _size1572; - ::apache::thrift::protocol::TType _etype1575; - xfer += iprot->readListBegin(_etype1575, _size1572); - this->schemaVersions.resize(_size1572); - uint32_t _i1576; - for (_i1576 = 0; _i1576 < _size1572; ++_i1576) + uint32_t _size1573; + ::apache::thrift::protocol::TType _etype1576; + xfer += iprot->readListBegin(_etype1576, _size1573); + this->schemaVersions.resize(_size1573); + uint32_t _i1577; + for (_i1577 = 0; _i1577 < _size1573; ++_i1577) { - xfer += this->schemaVersions[_i1576].read(iprot); + xfer += this->schemaVersions[_i1577].read(iprot); } xfer += iprot->readListEnd(); } @@ -44926,10 +44979,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 _iter1577; - for (_iter1577 = this->schemaVersions.begin(); _iter1577 != this->schemaVersions.end(); ++_iter1577) + std::vector ::const_iterator _iter1578; + for (_iter1578 = this->schemaVersions.begin(); _iter1578 != this->schemaVersions.end(); ++_iter1578) { - xfer += (*_iter1577).write(oprot); + xfer += (*_iter1578).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44946,13 +44999,13 @@ void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1578) { - schemaVersions = other1578.schemaVersions; - __isset = other1578.__isset; -} -FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1579) { +FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1579) { schemaVersions = other1579.schemaVersions; __isset = other1579.__isset; +} +FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1580) { + schemaVersions = other1580.schemaVersions; + __isset = other1580.__isset; return *this; } void FindSchemasByColsResp::printTo(std::ostream& out) const { @@ -45055,15 +45108,15 @@ void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b) swap(a.__isset, b.__isset); } -MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1580) { - schemaVersion = other1580.schemaVersion; - serdeName = other1580.serdeName; - __isset = other1580.__isset; -} -MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1581) { +MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1581) { schemaVersion = other1581.schemaVersion; serdeName = other1581.serdeName; __isset = other1581.__isset; +} +MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1582) { + schemaVersion = other1582.schemaVersion; + serdeName = other1582.serdeName; + __isset = other1582.__isset; return *this; } void MapSchemaVersionToSerdeRequest::printTo(std::ostream& out) const { @@ -45124,9 +45177,9 @@ uint32_t SetSchemaVersionStateRequest::read(::apache::thrift::protocol::TProtoco break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1582; - xfer += iprot->readI32(ecast1582); - this->state = static_cast(ecast1582); + int32_t ecast1583; + xfer += iprot->readI32(ecast1583); + this->state = static_cast(ecast1583); this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -45169,15 +45222,15 @@ void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b) { swap(a.__isset, b.__isset); } -SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1583) { - schemaVersion = other1583.schemaVersion; - state = other1583.state; - __isset = other1583.__isset; -} -SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1584) { +SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1584) { schemaVersion = other1584.schemaVersion; state = other1584.state; __isset = other1584.__isset; +} +SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1585) { + schemaVersion = other1585.schemaVersion; + state = other1585.state; + __isset = other1585.__isset; return *this; } void SetSchemaVersionStateRequest::printTo(std::ostream& out) const { @@ -45264,13 +45317,13 @@ void swap(GetSerdeRequest &a, GetSerdeRequest &b) { swap(a.__isset, b.__isset); } -GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1585) { - serdeName = other1585.serdeName; - __isset = other1585.__isset; -} -GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1586) { +GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1586) { serdeName = other1586.serdeName; __isset = other1586.__isset; +} +GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1587) { + serdeName = other1587.serdeName; + __isset = other1587.__isset; return *this; } void GetSerdeRequest::printTo(std::ostream& out) const { @@ -45398,17 +45451,17 @@ void swap(RuntimeStat &a, RuntimeStat &b) { swap(a.__isset, b.__isset); } -RuntimeStat::RuntimeStat(const RuntimeStat& other1587) { - createTime = other1587.createTime; - weight = other1587.weight; - payload = other1587.payload; - __isset = other1587.__isset; -} -RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1588) { +RuntimeStat::RuntimeStat(const RuntimeStat& other1588) { createTime = other1588.createTime; weight = other1588.weight; payload = other1588.payload; __isset = other1588.__isset; +} +RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1589) { + createTime = other1589.createTime; + weight = other1589.weight; + payload = other1589.payload; + __isset = other1589.__isset; return *this; } void RuntimeStat::printTo(std::ostream& out) const { @@ -45518,13 +45571,13 @@ void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b) { swap(a.maxCreateTime, b.maxCreateTime); } -GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1589) noexcept { - maxWeight = other1589.maxWeight; - maxCreateTime = other1589.maxCreateTime; -} -GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1590) noexcept { +GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1590) noexcept { maxWeight = other1590.maxWeight; maxCreateTime = other1590.maxCreateTime; +} +GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1591) noexcept { + maxWeight = other1591.maxWeight; + maxCreateTime = other1591.maxCreateTime; return *this; } void GetRuntimeStatsRequest::printTo(std::ostream& out) const { @@ -45637,14 +45690,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1591; - ::apache::thrift::protocol::TType _etype1594; - xfer += iprot->readListBegin(_etype1594, _size1591); - this->primaryKeys.resize(_size1591); - uint32_t _i1595; - for (_i1595 = 0; _i1595 < _size1591; ++_i1595) + uint32_t _size1592; + ::apache::thrift::protocol::TType _etype1595; + xfer += iprot->readListBegin(_etype1595, _size1592); + this->primaryKeys.resize(_size1592); + uint32_t _i1596; + for (_i1596 = 0; _i1596 < _size1592; ++_i1596) { - xfer += this->primaryKeys[_i1595].read(iprot); + xfer += this->primaryKeys[_i1596].read(iprot); } xfer += iprot->readListEnd(); } @@ -45657,14 +45710,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1596; - ::apache::thrift::protocol::TType _etype1599; - xfer += iprot->readListBegin(_etype1599, _size1596); - this->foreignKeys.resize(_size1596); - uint32_t _i1600; - for (_i1600 = 0; _i1600 < _size1596; ++_i1600) + uint32_t _size1597; + ::apache::thrift::protocol::TType _etype1600; + xfer += iprot->readListBegin(_etype1600, _size1597); + this->foreignKeys.resize(_size1597); + uint32_t _i1601; + for (_i1601 = 0; _i1601 < _size1597; ++_i1601) { - xfer += this->foreignKeys[_i1600].read(iprot); + xfer += this->foreignKeys[_i1601].read(iprot); } xfer += iprot->readListEnd(); } @@ -45677,14 +45730,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1601; - ::apache::thrift::protocol::TType _etype1604; - xfer += iprot->readListBegin(_etype1604, _size1601); - this->uniqueConstraints.resize(_size1601); - uint32_t _i1605; - for (_i1605 = 0; _i1605 < _size1601; ++_i1605) + uint32_t _size1602; + ::apache::thrift::protocol::TType _etype1605; + xfer += iprot->readListBegin(_etype1605, _size1602); + this->uniqueConstraints.resize(_size1602); + uint32_t _i1606; + for (_i1606 = 0; _i1606 < _size1602; ++_i1606) { - xfer += this->uniqueConstraints[_i1605].read(iprot); + xfer += this->uniqueConstraints[_i1606].read(iprot); } xfer += iprot->readListEnd(); } @@ -45697,14 +45750,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1606; - ::apache::thrift::protocol::TType _etype1609; - xfer += iprot->readListBegin(_etype1609, _size1606); - this->notNullConstraints.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->notNullConstraints.resize(_size1607); + uint32_t _i1611; + for (_i1611 = 0; _i1611 < _size1607; ++_i1611) { - xfer += this->notNullConstraints[_i1610].read(iprot); + xfer += this->notNullConstraints[_i1611].read(iprot); } xfer += iprot->readListEnd(); } @@ -45717,14 +45770,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1611; - ::apache::thrift::protocol::TType _etype1614; - xfer += iprot->readListBegin(_etype1614, _size1611); - this->defaultConstraints.resize(_size1611); - uint32_t _i1615; - for (_i1615 = 0; _i1615 < _size1611; ++_i1615) + uint32_t _size1612; + ::apache::thrift::protocol::TType _etype1615; + xfer += iprot->readListBegin(_etype1615, _size1612); + this->defaultConstraints.resize(_size1612); + uint32_t _i1616; + for (_i1616 = 0; _i1616 < _size1612; ++_i1616) { - xfer += this->defaultConstraints[_i1615].read(iprot); + xfer += this->defaultConstraints[_i1616].read(iprot); } xfer += iprot->readListEnd(); } @@ -45737,14 +45790,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1616; - ::apache::thrift::protocol::TType _etype1619; - xfer += iprot->readListBegin(_etype1619, _size1616); - this->checkConstraints.resize(_size1616); - uint32_t _i1620; - for (_i1620 = 0; _i1620 < _size1616; ++_i1620) + uint32_t _size1617; + ::apache::thrift::protocol::TType _etype1620; + xfer += iprot->readListBegin(_etype1620, _size1617); + this->checkConstraints.resize(_size1617); + uint32_t _i1621; + for (_i1621 = 0; _i1621 < _size1617; ++_i1621) { - xfer += this->checkConstraints[_i1620].read(iprot); + xfer += this->checkConstraints[_i1621].read(iprot); } xfer += iprot->readListEnd(); } @@ -45757,14 +45810,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1621; - ::apache::thrift::protocol::TType _etype1624; - xfer += iprot->readListBegin(_etype1624, _size1621); - this->processorCapabilities.resize(_size1621); - uint32_t _i1625; - for (_i1625 = 0; _i1625 < _size1621; ++_i1625) + uint32_t _size1622; + ::apache::thrift::protocol::TType _etype1625; + xfer += iprot->readListBegin(_etype1625, _size1622); + this->processorCapabilities.resize(_size1622); + uint32_t _i1626; + for (_i1626 = 0; _i1626 < _size1622; ++_i1626) { - xfer += iprot->readString(this->processorCapabilities[_i1625]); + xfer += iprot->readString(this->processorCapabilities[_i1626]); } xfer += iprot->readListEnd(); } @@ -45813,10 +45866,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 _iter1626; - for (_iter1626 = this->primaryKeys.begin(); _iter1626 != this->primaryKeys.end(); ++_iter1626) + std::vector ::const_iterator _iter1627; + for (_iter1627 = this->primaryKeys.begin(); _iter1627 != this->primaryKeys.end(); ++_iter1627) { - xfer += (*_iter1626).write(oprot); + xfer += (*_iter1627).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45826,10 +45879,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 _iter1627; - for (_iter1627 = this->foreignKeys.begin(); _iter1627 != this->foreignKeys.end(); ++_iter1627) + std::vector ::const_iterator _iter1628; + for (_iter1628 = this->foreignKeys.begin(); _iter1628 != this->foreignKeys.end(); ++_iter1628) { - xfer += (*_iter1627).write(oprot); + xfer += (*_iter1628).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45839,10 +45892,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 _iter1628; - for (_iter1628 = this->uniqueConstraints.begin(); _iter1628 != this->uniqueConstraints.end(); ++_iter1628) + std::vector ::const_iterator _iter1629; + for (_iter1629 = this->uniqueConstraints.begin(); _iter1629 != this->uniqueConstraints.end(); ++_iter1629) { - xfer += (*_iter1628).write(oprot); + xfer += (*_iter1629).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45852,10 +45905,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 _iter1629; - for (_iter1629 = this->notNullConstraints.begin(); _iter1629 != this->notNullConstraints.end(); ++_iter1629) + std::vector ::const_iterator _iter1630; + for (_iter1630 = this->notNullConstraints.begin(); _iter1630 != this->notNullConstraints.end(); ++_iter1630) { - xfer += (*_iter1629).write(oprot); + xfer += (*_iter1630).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45865,10 +45918,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 _iter1630; - for (_iter1630 = this->defaultConstraints.begin(); _iter1630 != this->defaultConstraints.end(); ++_iter1630) + std::vector ::const_iterator _iter1631; + for (_iter1631 = this->defaultConstraints.begin(); _iter1631 != this->defaultConstraints.end(); ++_iter1631) { - xfer += (*_iter1630).write(oprot); + xfer += (*_iter1631).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45878,10 +45931,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 _iter1631; - for (_iter1631 = this->checkConstraints.begin(); _iter1631 != this->checkConstraints.end(); ++_iter1631) + std::vector ::const_iterator _iter1632; + for (_iter1632 = this->checkConstraints.begin(); _iter1632 != this->checkConstraints.end(); ++_iter1632) { - xfer += (*_iter1631).write(oprot); + xfer += (*_iter1632).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45891,10 +45944,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 _iter1632; - for (_iter1632 = this->processorCapabilities.begin(); _iter1632 != this->processorCapabilities.end(); ++_iter1632) + std::vector ::const_iterator _iter1633; + for (_iter1633 = this->processorCapabilities.begin(); _iter1633 != this->processorCapabilities.end(); ++_iter1633) { - xfer += oprot->writeString((*_iter1632)); + xfer += oprot->writeString((*_iter1633)); } xfer += oprot->writeListEnd(); } @@ -45925,20 +45978,7 @@ void swap(CreateTableRequest &a, CreateTableRequest &b) { swap(a.__isset, b.__isset); } -CreateTableRequest::CreateTableRequest(const CreateTableRequest& other1633) { - table = other1633.table; - envContext = other1633.envContext; - primaryKeys = other1633.primaryKeys; - foreignKeys = other1633.foreignKeys; - uniqueConstraints = other1633.uniqueConstraints; - notNullConstraints = other1633.notNullConstraints; - defaultConstraints = other1633.defaultConstraints; - checkConstraints = other1633.checkConstraints; - processorCapabilities = other1633.processorCapabilities; - processorIdentifier = other1633.processorIdentifier; - __isset = other1633.__isset; -} -CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& other1634) { +CreateTableRequest::CreateTableRequest(const CreateTableRequest& other1634) { table = other1634.table; envContext = other1634.envContext; primaryKeys = other1634.primaryKeys; @@ -45950,6 +45990,19 @@ CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& othe processorCapabilities = other1634.processorCapabilities; processorIdentifier = other1634.processorIdentifier; __isset = other1634.__isset; +} +CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& other1635) { + table = other1635.table; + envContext = other1635.envContext; + primaryKeys = other1635.primaryKeys; + foreignKeys = other1635.foreignKeys; + uniqueConstraints = other1635.uniqueConstraints; + notNullConstraints = other1635.notNullConstraints; + defaultConstraints = other1635.defaultConstraints; + checkConstraints = other1635.checkConstraints; + processorCapabilities = other1635.processorCapabilities; + processorIdentifier = other1635.processorIdentifier; + __isset = other1635.__isset; return *this; } void CreateTableRequest::printTo(std::ostream& out) const { @@ -46093,17 +46146,17 @@ uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size1635; - ::apache::thrift::protocol::TType _ktype1636; - ::apache::thrift::protocol::TType _vtype1637; - xfer += iprot->readMapBegin(_ktype1636, _vtype1637, _size1635); - uint32_t _i1639; - for (_i1639 = 0; _i1639 < _size1635; ++_i1639) + uint32_t _size1636; + ::apache::thrift::protocol::TType _ktype1637; + ::apache::thrift::protocol::TType _vtype1638; + xfer += iprot->readMapBegin(_ktype1637, _vtype1638, _size1636); + uint32_t _i1640; + for (_i1640 = 0; _i1640 < _size1636; ++_i1640) { - std::string _key1640; - xfer += iprot->readString(_key1640); - std::string& _val1641 = this->parameters[_key1640]; - xfer += iprot->readString(_val1641); + std::string _key1641; + xfer += iprot->readString(_key1641); + std::string& _val1642 = this->parameters[_key1641]; + xfer += iprot->readString(_val1642); } xfer += iprot->readMapEnd(); } @@ -46130,9 +46183,9 @@ uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* ipro break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1642; - xfer += iprot->readI32(ecast1642); - this->ownerType = static_cast(ecast1642); + int32_t ecast1643; + xfer += iprot->readI32(ecast1643); + this->ownerType = static_cast(ecast1643); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -46164,9 +46217,9 @@ uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* ipro break; case 11: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1643; - xfer += iprot->readI32(ecast1643); - this->type = static_cast(ecast1643); + int32_t ecast1644; + xfer += iprot->readI32(ecast1644); + this->type = static_cast(ecast1644); this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -46225,11 +46278,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 _iter1644; - for (_iter1644 = this->parameters.begin(); _iter1644 != this->parameters.end(); ++_iter1644) + std::map ::const_iterator _iter1645; + for (_iter1645 = this->parameters.begin(); _iter1645 != this->parameters.end(); ++_iter1645) { - xfer += oprot->writeString(_iter1644->first); - xfer += oprot->writeString(_iter1644->second); + xfer += oprot->writeString(_iter1645->first); + xfer += oprot->writeString(_iter1645->second); } xfer += oprot->writeMapEnd(); } @@ -46303,23 +46356,7 @@ void swap(CreateDatabaseRequest &a, CreateDatabaseRequest &b) { swap(a.__isset, b.__isset); } -CreateDatabaseRequest::CreateDatabaseRequest(const CreateDatabaseRequest& other1645) { - databaseName = other1645.databaseName; - description = other1645.description; - locationUri = other1645.locationUri; - parameters = other1645.parameters; - privileges = other1645.privileges; - ownerName = other1645.ownerName; - ownerType = other1645.ownerType; - catalogName = other1645.catalogName; - createTime = other1645.createTime; - managedLocationUri = other1645.managedLocationUri; - type = other1645.type; - dataConnectorName = other1645.dataConnectorName; - remote_dbname = other1645.remote_dbname; - __isset = other1645.__isset; -} -CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequest& other1646) { +CreateDatabaseRequest::CreateDatabaseRequest(const CreateDatabaseRequest& other1646) { databaseName = other1646.databaseName; description = other1646.description; locationUri = other1646.locationUri; @@ -46334,6 +46371,22 @@ CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequ dataConnectorName = other1646.dataConnectorName; remote_dbname = other1646.remote_dbname; __isset = other1646.__isset; +} +CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequest& other1647) { + databaseName = other1647.databaseName; + description = other1647.description; + locationUri = other1647.locationUri; + parameters = other1647.parameters; + privileges = other1647.privileges; + ownerName = other1647.ownerName; + ownerType = other1647.ownerType; + catalogName = other1647.catalogName; + createTime = other1647.createTime; + managedLocationUri = other1647.managedLocationUri; + type = other1647.type; + dataConnectorName = other1647.dataConnectorName; + remote_dbname = other1647.remote_dbname; + __isset = other1647.__isset; return *this; } void CreateDatabaseRequest::printTo(std::ostream& out) const { @@ -46433,11 +46486,11 @@ void swap(CreateDataConnectorRequest &a, CreateDataConnectorRequest &b) { swap(a.connector, b.connector); } -CreateDataConnectorRequest::CreateDataConnectorRequest(const CreateDataConnectorRequest& other1647) { - connector = other1647.connector; -} -CreateDataConnectorRequest& CreateDataConnectorRequest::operator=(const CreateDataConnectorRequest& other1648) { +CreateDataConnectorRequest::CreateDataConnectorRequest(const CreateDataConnectorRequest& other1648) { connector = other1648.connector; +} +CreateDataConnectorRequest& CreateDataConnectorRequest::operator=(const CreateDataConnectorRequest& other1649) { + connector = other1649.connector; return *this; } void CreateDataConnectorRequest::printTo(std::ostream& out) const { @@ -46525,11 +46578,11 @@ void swap(GetDataConnectorRequest &a, GetDataConnectorRequest &b) { swap(a.connectorName, b.connectorName); } -GetDataConnectorRequest::GetDataConnectorRequest(const GetDataConnectorRequest& other1649) { - connectorName = other1649.connectorName; -} -GetDataConnectorRequest& GetDataConnectorRequest::operator=(const GetDataConnectorRequest& other1650) { +GetDataConnectorRequest::GetDataConnectorRequest(const GetDataConnectorRequest& other1650) { connectorName = other1650.connectorName; +} +GetDataConnectorRequest& GetDataConnectorRequest::operator=(const GetDataConnectorRequest& other1651) { + connectorName = other1651.connectorName; return *this; } void GetDataConnectorRequest::printTo(std::ostream& out) const { @@ -46637,13 +46690,13 @@ void swap(AlterDataConnectorRequest &a, AlterDataConnectorRequest &b) { swap(a.newConnector, b.newConnector); } -AlterDataConnectorRequest::AlterDataConnectorRequest(const AlterDataConnectorRequest& other1651) { - connectorName = other1651.connectorName; - newConnector = other1651.newConnector; -} -AlterDataConnectorRequest& AlterDataConnectorRequest::operator=(const AlterDataConnectorRequest& other1652) { +AlterDataConnectorRequest::AlterDataConnectorRequest(const AlterDataConnectorRequest& other1652) { connectorName = other1652.connectorName; newConnector = other1652.newConnector; +} +AlterDataConnectorRequest& AlterDataConnectorRequest::operator=(const AlterDataConnectorRequest& other1653) { + connectorName = other1653.connectorName; + newConnector = other1653.newConnector; return *this; } void AlterDataConnectorRequest::printTo(std::ostream& out) const { @@ -46771,17 +46824,17 @@ void swap(DropDataConnectorRequest &a, DropDataConnectorRequest &b) { swap(a.__isset, b.__isset); } -DropDataConnectorRequest::DropDataConnectorRequest(const DropDataConnectorRequest& other1653) { - connectorName = other1653.connectorName; - ifNotExists = other1653.ifNotExists; - checkReferences = other1653.checkReferences; - __isset = other1653.__isset; -} -DropDataConnectorRequest& DropDataConnectorRequest::operator=(const DropDataConnectorRequest& other1654) { +DropDataConnectorRequest::DropDataConnectorRequest(const DropDataConnectorRequest& other1654) { connectorName = other1654.connectorName; ifNotExists = other1654.ifNotExists; checkReferences = other1654.checkReferences; __isset = other1654.__isset; +} +DropDataConnectorRequest& DropDataConnectorRequest::operator=(const DropDataConnectorRequest& other1655) { + connectorName = other1655.connectorName; + ifNotExists = other1655.ifNotExists; + checkReferences = other1655.checkReferences; + __isset = other1655.__isset; return *this; } void DropDataConnectorRequest::printTo(std::ostream& out) const { @@ -46871,11 +46924,11 @@ void swap(ScheduledQueryPollRequest &a, ScheduledQueryPollRequest &b) { swap(a.clusterNamespace, b.clusterNamespace); } -ScheduledQueryPollRequest::ScheduledQueryPollRequest(const ScheduledQueryPollRequest& other1655) { - clusterNamespace = other1655.clusterNamespace; -} -ScheduledQueryPollRequest& ScheduledQueryPollRequest::operator=(const ScheduledQueryPollRequest& other1656) { +ScheduledQueryPollRequest::ScheduledQueryPollRequest(const ScheduledQueryPollRequest& other1656) { clusterNamespace = other1656.clusterNamespace; +} +ScheduledQueryPollRequest& ScheduledQueryPollRequest::operator=(const ScheduledQueryPollRequest& other1657) { + clusterNamespace = other1657.clusterNamespace; return *this; } void ScheduledQueryPollRequest::printTo(std::ostream& out) const { @@ -46983,13 +47036,13 @@ void swap(ScheduledQueryKey &a, ScheduledQueryKey &b) { swap(a.clusterNamespace, b.clusterNamespace); } -ScheduledQueryKey::ScheduledQueryKey(const ScheduledQueryKey& other1657) { - scheduleName = other1657.scheduleName; - clusterNamespace = other1657.clusterNamespace; -} -ScheduledQueryKey& ScheduledQueryKey::operator=(const ScheduledQueryKey& other1658) { +ScheduledQueryKey::ScheduledQueryKey(const ScheduledQueryKey& other1658) { scheduleName = other1658.scheduleName; clusterNamespace = other1658.clusterNamespace; +} +ScheduledQueryKey& ScheduledQueryKey::operator=(const ScheduledQueryKey& other1659) { + scheduleName = other1659.scheduleName; + clusterNamespace = other1659.clusterNamespace; return *this; } void ScheduledQueryKey::printTo(std::ostream& out) const { @@ -47135,19 +47188,19 @@ void swap(ScheduledQueryPollResponse &a, ScheduledQueryPollResponse &b) { swap(a.__isset, b.__isset); } -ScheduledQueryPollResponse::ScheduledQueryPollResponse(const ScheduledQueryPollResponse& other1659) { - scheduleKey = other1659.scheduleKey; - executionId = other1659.executionId; - query = other1659.query; - user = other1659.user; - __isset = other1659.__isset; -} -ScheduledQueryPollResponse& ScheduledQueryPollResponse::operator=(const ScheduledQueryPollResponse& other1660) { +ScheduledQueryPollResponse::ScheduledQueryPollResponse(const ScheduledQueryPollResponse& other1660) { scheduleKey = other1660.scheduleKey; executionId = other1660.executionId; query = other1660.query; user = other1660.user; __isset = other1660.__isset; +} +ScheduledQueryPollResponse& ScheduledQueryPollResponse::operator=(const ScheduledQueryPollResponse& other1661) { + scheduleKey = other1661.scheduleKey; + executionId = other1661.executionId; + query = other1661.query; + user = other1661.user; + __isset = other1661.__isset; return *this; } void ScheduledQueryPollResponse::printTo(std::ostream& out) const { @@ -47334,16 +47387,7 @@ void swap(ScheduledQuery &a, ScheduledQuery &b) { swap(a.__isset, b.__isset); } -ScheduledQuery::ScheduledQuery(const ScheduledQuery& other1661) { - scheduleKey = other1661.scheduleKey; - enabled = other1661.enabled; - schedule = other1661.schedule; - user = other1661.user; - query = other1661.query; - nextExecution = other1661.nextExecution; - __isset = other1661.__isset; -} -ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1662) { +ScheduledQuery::ScheduledQuery(const ScheduledQuery& other1662) { scheduleKey = other1662.scheduleKey; enabled = other1662.enabled; schedule = other1662.schedule; @@ -47351,6 +47395,15 @@ ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1662) { query = other1662.query; nextExecution = other1662.nextExecution; __isset = other1662.__isset; +} +ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1663) { + scheduleKey = other1663.scheduleKey; + enabled = other1663.enabled; + schedule = other1663.schedule; + user = other1663.user; + query = other1663.query; + nextExecution = other1663.nextExecution; + __isset = other1663.__isset; return *this; } void ScheduledQuery::printTo(std::ostream& out) const { @@ -47409,9 +47462,9 @@ uint32_t ScheduledQueryMaintenanceRequest::read(::apache::thrift::protocol::TPro { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1663; - xfer += iprot->readI32(ecast1663); - this->type = static_cast(ecast1663); + int32_t ecast1664; + xfer += iprot->readI32(ecast1664); + this->type = static_cast(ecast1664); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -47465,13 +47518,13 @@ void swap(ScheduledQueryMaintenanceRequest &a, ScheduledQueryMaintenanceRequest swap(a.scheduledQuery, b.scheduledQuery); } -ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest& other1664) { - type = other1664.type; - scheduledQuery = other1664.scheduledQuery; -} -ScheduledQueryMaintenanceRequest& ScheduledQueryMaintenanceRequest::operator=(const ScheduledQueryMaintenanceRequest& other1665) { +ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest& other1665) { type = other1665.type; scheduledQuery = other1665.scheduledQuery; +} +ScheduledQueryMaintenanceRequest& ScheduledQueryMaintenanceRequest::operator=(const ScheduledQueryMaintenanceRequest& other1666) { + type = other1666.type; + scheduledQuery = other1666.scheduledQuery; return *this; } void ScheduledQueryMaintenanceRequest::printTo(std::ostream& out) const { @@ -47544,9 +47597,9 @@ uint32_t ScheduledQueryProgressInfo::read(::apache::thrift::protocol::TProtocol* break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1666; - xfer += iprot->readI32(ecast1666); - this->state = static_cast(ecast1666); + int32_t ecast1667; + xfer += iprot->readI32(ecast1667); + this->state = static_cast(ecast1667); isset_state = true; } else { xfer += iprot->skip(ftype); @@ -47622,19 +47675,19 @@ void swap(ScheduledQueryProgressInfo &a, ScheduledQueryProgressInfo &b) { swap(a.__isset, b.__isset); } -ScheduledQueryProgressInfo::ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo& other1667) { - scheduledExecutionId = other1667.scheduledExecutionId; - state = other1667.state; - executorQueryId = other1667.executorQueryId; - errorMessage = other1667.errorMessage; - __isset = other1667.__isset; -} -ScheduledQueryProgressInfo& ScheduledQueryProgressInfo::operator=(const ScheduledQueryProgressInfo& other1668) { +ScheduledQueryProgressInfo::ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo& other1668) { scheduledExecutionId = other1668.scheduledExecutionId; state = other1668.state; executorQueryId = other1668.executorQueryId; errorMessage = other1668.errorMessage; __isset = other1668.__isset; +} +ScheduledQueryProgressInfo& ScheduledQueryProgressInfo::operator=(const ScheduledQueryProgressInfo& other1669) { + scheduledExecutionId = other1669.scheduledExecutionId; + state = other1669.state; + executorQueryId = other1669.executorQueryId; + errorMessage = other1669.errorMessage; + __isset = other1669.__isset; return *this; } void ScheduledQueryProgressInfo::printTo(std::ostream& out) const { @@ -47752,14 +47805,14 @@ uint32_t AlterPartitionsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + uint32_t _size1670; + ::apache::thrift::protocol::TType _etype1673; + xfer += iprot->readListBegin(_etype1673, _size1670); + this->partitions.resize(_size1670); + uint32_t _i1674; + for (_i1674 = 0; _i1674 < _size1670; ++_i1674) { - xfer += this->partitions[_i1673].read(iprot); + xfer += this->partitions[_i1674].read(iprot); } xfer += iprot->readListEnd(); } @@ -47804,14 +47857,14 @@ uint32_t AlterPartitionsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionColSchema.clear(); - uint32_t _size1674; - ::apache::thrift::protocol::TType _etype1677; - xfer += iprot->readListBegin(_etype1677, _size1674); - this->partitionColSchema.resize(_size1674); - uint32_t _i1678; - for (_i1678 = 0; _i1678 < _size1674; ++_i1678) + uint32_t _size1675; + ::apache::thrift::protocol::TType _etype1678; + xfer += iprot->readListBegin(_etype1678, _size1675); + this->partitionColSchema.resize(_size1675); + uint32_t _i1679; + for (_i1679 = 0; _i1679 < _size1675; ++_i1679) { - xfer += this->partitionColSchema[_i1678].read(iprot); + xfer += this->partitionColSchema[_i1679].read(iprot); } xfer += iprot->readListEnd(); } @@ -47859,10 +47912,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 _iter1679; - for (_iter1679 = this->partitions.begin(); _iter1679 != this->partitions.end(); ++_iter1679) + std::vector ::const_iterator _iter1680; + for (_iter1680 = this->partitions.begin(); _iter1680 != this->partitions.end(); ++_iter1680) { - xfer += (*_iter1679).write(oprot); + xfer += (*_iter1680).write(oprot); } xfer += oprot->writeListEnd(); } @@ -47892,10 +47945,10 @@ uint32_t AlterPartitionsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); - std::vector ::const_iterator _iter1680; - for (_iter1680 = this->partitionColSchema.begin(); _iter1680 != this->partitionColSchema.end(); ++_iter1680) + std::vector ::const_iterator _iter1681; + for (_iter1681 = this->partitionColSchema.begin(); _iter1681 != this->partitionColSchema.end(); ++_iter1681) { - xfer += (*_iter1680).write(oprot); + xfer += (*_iter1681).write(oprot); } xfer += oprot->writeListEnd(); } @@ -47920,19 +47973,7 @@ void swap(AlterPartitionsRequest &a, AlterPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AlterPartitionsRequest::AlterPartitionsRequest(const AlterPartitionsRequest& other1681) { - catName = other1681.catName; - dbName = other1681.dbName; - tableName = other1681.tableName; - partitions = other1681.partitions; - environmentContext = other1681.environmentContext; - writeId = other1681.writeId; - validWriteIdList = other1681.validWriteIdList; - skipColumnSchemaForPartition = other1681.skipColumnSchemaForPartition; - partitionColSchema = other1681.partitionColSchema; - __isset = other1681.__isset; -} -AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsRequest& other1682) { +AlterPartitionsRequest::AlterPartitionsRequest(const AlterPartitionsRequest& other1682) { catName = other1682.catName; dbName = other1682.dbName; tableName = other1682.tableName; @@ -47943,6 +47984,18 @@ AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsR skipColumnSchemaForPartition = other1682.skipColumnSchemaForPartition; partitionColSchema = other1682.partitionColSchema; __isset = other1682.__isset; +} +AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsRequest& other1683) { + catName = other1683.catName; + dbName = other1683.dbName; + tableName = other1683.tableName; + partitions = other1683.partitions; + environmentContext = other1683.environmentContext; + writeId = other1683.writeId; + validWriteIdList = other1683.validWriteIdList; + skipColumnSchemaForPartition = other1683.skipColumnSchemaForPartition; + partitionColSchema = other1683.partitionColSchema; + __isset = other1683.__isset; return *this; } void AlterPartitionsRequest::printTo(std::ostream& out) const { @@ -48058,14 +48111,14 @@ uint32_t AppendPartitionsRequest::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1683; - ::apache::thrift::protocol::TType _etype1686; - xfer += iprot->readListBegin(_etype1686, _size1683); - this->partVals.resize(_size1683); - uint32_t _i1687; - for (_i1687 = 0; _i1687 < _size1683; ++_i1687) + uint32_t _size1684; + ::apache::thrift::protocol::TType _etype1687; + xfer += iprot->readListBegin(_etype1687, _size1684); + this->partVals.resize(_size1684); + uint32_t _i1688; + for (_i1688 = 0; _i1688 < _size1684; ++_i1688) { - xfer += iprot->readString(this->partVals[_i1687]); + xfer += iprot->readString(this->partVals[_i1688]); } xfer += iprot->readListEnd(); } @@ -48125,10 +48178,10 @@ uint32_t AppendPartitionsRequest::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1688; - for (_iter1688 = this->partVals.begin(); _iter1688 != this->partVals.end(); ++_iter1688) + std::vector ::const_iterator _iter1689; + for (_iter1689 = this->partVals.begin(); _iter1689 != this->partVals.end(); ++_iter1689) { - xfer += oprot->writeString((*_iter1688)); + xfer += oprot->writeString((*_iter1689)); } xfer += oprot->writeListEnd(); } @@ -48155,16 +48208,7 @@ void swap(AppendPartitionsRequest &a, AppendPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AppendPartitionsRequest::AppendPartitionsRequest(const AppendPartitionsRequest& other1689) { - catalogName = other1689.catalogName; - dbName = other1689.dbName; - tableName = other1689.tableName; - name = other1689.name; - partVals = other1689.partVals; - environmentContext = other1689.environmentContext; - __isset = other1689.__isset; -} -AppendPartitionsRequest& AppendPartitionsRequest::operator=(const AppendPartitionsRequest& other1690) { +AppendPartitionsRequest::AppendPartitionsRequest(const AppendPartitionsRequest& other1690) { catalogName = other1690.catalogName; dbName = other1690.dbName; tableName = other1690.tableName; @@ -48172,6 +48216,15 @@ AppendPartitionsRequest& AppendPartitionsRequest::operator=(const AppendPartitio partVals = other1690.partVals; environmentContext = other1690.environmentContext; __isset = other1690.__isset; +} +AppendPartitionsRequest& AppendPartitionsRequest::operator=(const AppendPartitionsRequest& other1691) { + catalogName = other1691.catalogName; + dbName = other1691.dbName; + tableName = other1691.tableName; + name = other1691.name; + partVals = other1691.partVals; + environmentContext = other1691.environmentContext; + __isset = other1691.__isset; return *this; } void AppendPartitionsRequest::printTo(std::ostream& out) const { @@ -48241,11 +48294,11 @@ void swap(AlterPartitionsResponse &a, AlterPartitionsResponse &b) { (void) b; } -AlterPartitionsResponse::AlterPartitionsResponse(const AlterPartitionsResponse& other1691) noexcept { - (void) other1691; -} -AlterPartitionsResponse& AlterPartitionsResponse::operator=(const AlterPartitionsResponse& other1692) noexcept { +AlterPartitionsResponse::AlterPartitionsResponse(const AlterPartitionsResponse& other1692) noexcept { (void) other1692; +} +AlterPartitionsResponse& AlterPartitionsResponse::operator=(const AlterPartitionsResponse& other1693) noexcept { + (void) other1693; return *this; } void AlterPartitionsResponse::printTo(std::ostream& out) const { @@ -48354,14 +48407,14 @@ uint32_t RenamePartitionRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - 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) + uint32_t _size1694; + ::apache::thrift::protocol::TType _etype1697; + xfer += iprot->readListBegin(_etype1697, _size1694); + this->partVals.resize(_size1694); + uint32_t _i1698; + for (_i1698 = 0; _i1698 < _size1694; ++_i1698) { - xfer += iprot->readString(this->partVals[_i1697]); + xfer += iprot->readString(this->partVals[_i1698]); } xfer += iprot->readListEnd(); } @@ -48443,10 +48496,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 _iter1698; - for (_iter1698 = this->partVals.begin(); _iter1698 != this->partVals.end(); ++_iter1698) + std::vector ::const_iterator _iter1699; + for (_iter1699 = this->partVals.begin(); _iter1699 != this->partVals.end(); ++_iter1699) { - xfer += oprot->writeString((*_iter1698)); + xfer += oprot->writeString((*_iter1699)); } xfer += oprot->writeListEnd(); } @@ -48489,18 +48542,7 @@ void swap(RenamePartitionRequest &a, RenamePartitionRequest &b) { swap(a.__isset, b.__isset); } -RenamePartitionRequest::RenamePartitionRequest(const RenamePartitionRequest& other1699) { - catName = other1699.catName; - dbName = other1699.dbName; - tableName = other1699.tableName; - partVals = other1699.partVals; - newPart = other1699.newPart; - validWriteIdList = other1699.validWriteIdList; - txnId = other1699.txnId; - clonePart = other1699.clonePart; - __isset = other1699.__isset; -} -RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionRequest& other1700) { +RenamePartitionRequest::RenamePartitionRequest(const RenamePartitionRequest& other1700) { catName = other1700.catName; dbName = other1700.dbName; tableName = other1700.tableName; @@ -48510,6 +48552,17 @@ RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionR txnId = other1700.txnId; clonePart = other1700.clonePart; __isset = other1700.__isset; +} +RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionRequest& other1701) { + catName = other1701.catName; + dbName = other1701.dbName; + tableName = other1701.tableName; + partVals = other1701.partVals; + newPart = other1701.newPart; + validWriteIdList = other1701.validWriteIdList; + txnId = other1701.txnId; + clonePart = other1701.clonePart; + __isset = other1701.__isset; return *this; } void RenamePartitionRequest::printTo(std::ostream& out) const { @@ -48581,11 +48634,11 @@ void swap(RenamePartitionResponse &a, RenamePartitionResponse &b) { (void) b; } -RenamePartitionResponse::RenamePartitionResponse(const RenamePartitionResponse& other1701) noexcept { - (void) other1701; -} -RenamePartitionResponse& RenamePartitionResponse::operator=(const RenamePartitionResponse& other1702) noexcept { +RenamePartitionResponse::RenamePartitionResponse(const RenamePartitionResponse& other1702) noexcept { (void) other1702; +} +RenamePartitionResponse& RenamePartitionResponse::operator=(const RenamePartitionResponse& other1703) noexcept { + (void) other1703; return *this; } void RenamePartitionResponse::printTo(std::ostream& out) const { @@ -48741,14 +48794,14 @@ uint32_t AlterTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1703; - ::apache::thrift::protocol::TType _etype1706; - xfer += iprot->readListBegin(_etype1706, _size1703); - this->processorCapabilities.resize(_size1703); - uint32_t _i1707; - for (_i1707 = 0; _i1707 < _size1703; ++_i1707) + uint32_t _size1704; + ::apache::thrift::protocol::TType _etype1707; + xfer += iprot->readListBegin(_etype1707, _size1704); + this->processorCapabilities.resize(_size1704); + uint32_t _i1708; + for (_i1708 = 0; _i1708 < _size1704; ++_i1708) { - xfer += iprot->readString(this->processorCapabilities[_i1707]); + xfer += iprot->readString(this->processorCapabilities[_i1708]); } xfer += iprot->readListEnd(); } @@ -48840,10 +48893,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 _iter1708; - for (_iter1708 = this->processorCapabilities.begin(); _iter1708 != this->processorCapabilities.end(); ++_iter1708) + std::vector ::const_iterator _iter1709; + for (_iter1709 = this->processorCapabilities.begin(); _iter1709 != this->processorCapabilities.end(); ++_iter1709) { - xfer += oprot->writeString((*_iter1708)); + xfer += oprot->writeString((*_iter1709)); } xfer += oprot->writeListEnd(); } @@ -48885,21 +48938,7 @@ void swap(AlterTableRequest &a, AlterTableRequest &b) { swap(a.__isset, b.__isset); } -AlterTableRequest::AlterTableRequest(const AlterTableRequest& other1709) { - catName = other1709.catName; - dbName = other1709.dbName; - tableName = other1709.tableName; - table = other1709.table; - environmentContext = other1709.environmentContext; - writeId = other1709.writeId; - validWriteIdList = other1709.validWriteIdList; - processorCapabilities = other1709.processorCapabilities; - processorIdentifier = other1709.processorIdentifier; - expectedParameterKey = other1709.expectedParameterKey; - expectedParameterValue = other1709.expectedParameterValue; - __isset = other1709.__isset; -} -AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other1710) { +AlterTableRequest::AlterTableRequest(const AlterTableRequest& other1710) { catName = other1710.catName; dbName = other1710.dbName; tableName = other1710.tableName; @@ -48912,6 +48951,20 @@ AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other17 expectedParameterKey = other1710.expectedParameterKey; expectedParameterValue = other1710.expectedParameterValue; __isset = other1710.__isset; +} +AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other1711) { + catName = other1711.catName; + dbName = other1711.dbName; + tableName = other1711.tableName; + table = other1711.table; + environmentContext = other1711.environmentContext; + writeId = other1711.writeId; + validWriteIdList = other1711.validWriteIdList; + processorCapabilities = other1711.processorCapabilities; + processorIdentifier = other1711.processorIdentifier; + expectedParameterKey = other1711.expectedParameterKey; + expectedParameterValue = other1711.expectedParameterValue; + __isset = other1711.__isset; return *this; } void AlterTableRequest::printTo(std::ostream& out) const { @@ -48986,11 +49039,11 @@ void swap(AlterTableResponse &a, AlterTableResponse &b) { (void) b; } -AlterTableResponse::AlterTableResponse(const AlterTableResponse& other1711) noexcept { - (void) other1711; -} -AlterTableResponse& AlterTableResponse::operator=(const AlterTableResponse& other1712) noexcept { +AlterTableResponse::AlterTableResponse(const AlterTableResponse& other1712) noexcept { (void) other1712; +} +AlterTableResponse& AlterTableResponse::operator=(const AlterTableResponse& other1713) noexcept { + (void) other1713; return *this; } void AlterTableResponse::printTo(std::ostream& out) const { @@ -49043,9 +49096,9 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip { case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1713; - xfer += iprot->readI32(ecast1713); - this->filterMode = static_cast(ecast1713); + int32_t ecast1714; + xfer += iprot->readI32(ecast1714); + this->filterMode = static_cast(ecast1714); this->__isset.filterMode = true; } else { xfer += iprot->skip(ftype); @@ -49055,14 +49108,14 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filters.clear(); - uint32_t _size1714; - ::apache::thrift::protocol::TType _etype1717; - xfer += iprot->readListBegin(_etype1717, _size1714); - this->filters.resize(_size1714); - uint32_t _i1718; - for (_i1718 = 0; _i1718 < _size1714; ++_i1718) + uint32_t _size1715; + ::apache::thrift::protocol::TType _etype1718; + xfer += iprot->readListBegin(_etype1718, _size1715); + this->filters.resize(_size1715); + uint32_t _i1719; + for (_i1719 = 0; _i1719 < _size1715; ++_i1719) { - xfer += iprot->readString(this->filters[_i1718]); + xfer += iprot->readString(this->filters[_i1719]); } xfer += iprot->readListEnd(); } @@ -49097,10 +49150,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 _iter1719; - for (_iter1719 = this->filters.begin(); _iter1719 != this->filters.end(); ++_iter1719) + std::vector ::const_iterator _iter1720; + for (_iter1720 = this->filters.begin(); _iter1720 != this->filters.end(); ++_iter1720) { - xfer += oprot->writeString((*_iter1719)); + xfer += oprot->writeString((*_iter1720)); } xfer += oprot->writeListEnd(); } @@ -49118,15 +49171,15 @@ void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b) { swap(a.__isset, b.__isset); } -GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1720) { - filterMode = other1720.filterMode; - filters = other1720.filters; - __isset = other1720.__isset; -} -GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1721) { +GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1721) { filterMode = other1721.filterMode; filters = other1721.filters; __isset = other1721.__isset; +} +GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1722) { + filterMode = other1722.filterMode; + filters = other1722.filters; + __isset = other1722.__isset; return *this; } void GetPartitionsFilterSpec::printTo(std::ostream& out) const { @@ -49177,14 +49230,14 @@ uint32_t GetPartitionsResponse::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionSpec.clear(); - uint32_t _size1722; - ::apache::thrift::protocol::TType _etype1725; - xfer += iprot->readListBegin(_etype1725, _size1722); - this->partitionSpec.resize(_size1722); - uint32_t _i1726; - for (_i1726 = 0; _i1726 < _size1722; ++_i1726) + uint32_t _size1723; + ::apache::thrift::protocol::TType _etype1726; + xfer += iprot->readListBegin(_etype1726, _size1723); + this->partitionSpec.resize(_size1723); + uint32_t _i1727; + for (_i1727 = 0; _i1727 < _size1723; ++_i1727) { - xfer += this->partitionSpec[_i1726].read(iprot); + xfer += this->partitionSpec[_i1727].read(iprot); } xfer += iprot->readListEnd(); } @@ -49213,10 +49266,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 _iter1727; - for (_iter1727 = this->partitionSpec.begin(); _iter1727 != this->partitionSpec.end(); ++_iter1727) + std::vector ::const_iterator _iter1728; + for (_iter1728 = this->partitionSpec.begin(); _iter1728 != this->partitionSpec.end(); ++_iter1728) { - xfer += (*_iter1727).write(oprot); + xfer += (*_iter1728).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49233,13 +49286,13 @@ void swap(GetPartitionsResponse &a, GetPartitionsResponse &b) { swap(a.__isset, b.__isset); } -GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1728) { - partitionSpec = other1728.partitionSpec; - __isset = other1728.__isset; -} -GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1729) { +GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1729) { partitionSpec = other1729.partitionSpec; __isset = other1729.__isset; +} +GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1730) { + partitionSpec = other1730.partitionSpec; + __isset = other1730.__isset; return *this; } void GetPartitionsResponse::printTo(std::ostream& out) const { @@ -49376,14 +49429,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1730; - ::apache::thrift::protocol::TType _etype1733; - xfer += iprot->readListBegin(_etype1733, _size1730); - this->groupNames.resize(_size1730); - uint32_t _i1734; - for (_i1734 = 0; _i1734 < _size1730; ++_i1734) + uint32_t _size1731; + ::apache::thrift::protocol::TType _etype1734; + xfer += iprot->readListBegin(_etype1734, _size1731); + this->groupNames.resize(_size1731); + uint32_t _i1735; + for (_i1735 = 0; _i1735 < _size1731; ++_i1735) { - xfer += iprot->readString(this->groupNames[_i1734]); + xfer += iprot->readString(this->groupNames[_i1735]); } xfer += iprot->readListEnd(); } @@ -49412,14 +49465,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1735; - ::apache::thrift::protocol::TType _etype1738; - xfer += iprot->readListBegin(_etype1738, _size1735); - this->processorCapabilities.resize(_size1735); - uint32_t _i1739; - for (_i1739 = 0; _i1739 < _size1735; ++_i1739) + uint32_t _size1736; + ::apache::thrift::protocol::TType _etype1739; + xfer += iprot->readListBegin(_etype1739, _size1736); + this->processorCapabilities.resize(_size1736); + uint32_t _i1740; + for (_i1740 = 0; _i1740 < _size1736; ++_i1740) { - xfer += iprot->readString(this->processorCapabilities[_i1739]); + xfer += iprot->readString(this->processorCapabilities[_i1740]); } xfer += iprot->readListEnd(); } @@ -49488,10 +49541,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 _iter1740; - for (_iter1740 = this->groupNames.begin(); _iter1740 != this->groupNames.end(); ++_iter1740) + std::vector ::const_iterator _iter1741; + for (_iter1741 = this->groupNames.begin(); _iter1741 != this->groupNames.end(); ++_iter1741) { - xfer += oprot->writeString((*_iter1740)); + xfer += oprot->writeString((*_iter1741)); } xfer += oprot->writeListEnd(); } @@ -49509,10 +49562,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 _iter1741; - for (_iter1741 = this->processorCapabilities.begin(); _iter1741 != this->processorCapabilities.end(); ++_iter1741) + std::vector ::const_iterator _iter1742; + for (_iter1742 = this->processorCapabilities.begin(); _iter1742 != this->processorCapabilities.end(); ++_iter1742) { - xfer += oprot->writeString((*_iter1741)); + xfer += oprot->writeString((*_iter1742)); } xfer += oprot->writeListEnd(); } @@ -49549,21 +49602,7 @@ void swap(GetPartitionsRequest &a, GetPartitionsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1742) { - catName = other1742.catName; - dbName = other1742.dbName; - tblName = other1742.tblName; - withAuth = other1742.withAuth; - user = other1742.user; - groupNames = other1742.groupNames; - projectionSpec = other1742.projectionSpec; - filterSpec = other1742.filterSpec; - processorCapabilities = other1742.processorCapabilities; - processorIdentifier = other1742.processorIdentifier; - validWriteIdList = other1742.validWriteIdList; - __isset = other1742.__isset; -} -GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1743) { +GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1743) { catName = other1743.catName; dbName = other1743.dbName; tblName = other1743.tblName; @@ -49576,6 +49615,20 @@ GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest processorIdentifier = other1743.processorIdentifier; validWriteIdList = other1743.validWriteIdList; __isset = other1743.__isset; +} +GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1744) { + catName = other1744.catName; + dbName = other1744.dbName; + tblName = other1744.tblName; + withAuth = other1744.withAuth; + user = other1744.user; + groupNames = other1744.groupNames; + projectionSpec = other1744.projectionSpec; + filterSpec = other1744.filterSpec; + processorCapabilities = other1744.processorCapabilities; + processorIdentifier = other1744.processorIdentifier; + validWriteIdList = other1744.validWriteIdList; + __isset = other1744.__isset; return *this; } void GetPartitionsRequest::printTo(std::ostream& out) const { @@ -49770,16 +49823,7 @@ void swap(GetFieldsRequest &a, GetFieldsRequest &b) { swap(a.__isset, b.__isset); } -GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1744) { - catName = other1744.catName; - dbName = other1744.dbName; - tblName = other1744.tblName; - envContext = other1744.envContext; - validWriteIdList = other1744.validWriteIdList; - id = other1744.id; - __isset = other1744.__isset; -} -GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1745) { +GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1745) { catName = other1745.catName; dbName = other1745.dbName; tblName = other1745.tblName; @@ -49787,6 +49831,15 @@ GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1745) validWriteIdList = other1745.validWriteIdList; id = other1745.id; __isset = other1745.__isset; +} +GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1746) { + catName = other1746.catName; + dbName = other1746.dbName; + tblName = other1746.tblName; + envContext = other1746.envContext; + validWriteIdList = other1746.validWriteIdList; + id = other1746.id; + __isset = other1746.__isset; return *this; } void GetFieldsRequest::printTo(std::ostream& out) const { @@ -49842,14 +49895,14 @@ uint32_t GetFieldsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1746; - ::apache::thrift::protocol::TType _etype1749; - xfer += iprot->readListBegin(_etype1749, _size1746); - this->fields.resize(_size1746); - uint32_t _i1750; - for (_i1750 = 0; _i1750 < _size1746; ++_i1750) + uint32_t _size1747; + ::apache::thrift::protocol::TType _etype1750; + xfer += iprot->readListBegin(_etype1750, _size1747); + this->fields.resize(_size1747); + uint32_t _i1751; + for (_i1751 = 0; _i1751 < _size1747; ++_i1751) { - xfer += this->fields[_i1750].read(iprot); + xfer += this->fields[_i1751].read(iprot); } xfer += iprot->readListEnd(); } @@ -49880,10 +49933,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 _iter1751; - for (_iter1751 = this->fields.begin(); _iter1751 != this->fields.end(); ++_iter1751) + std::vector ::const_iterator _iter1752; + for (_iter1752 = this->fields.begin(); _iter1752 != this->fields.end(); ++_iter1752) { - xfer += (*_iter1751).write(oprot); + xfer += (*_iter1752).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49899,11 +49952,11 @@ void swap(GetFieldsResponse &a, GetFieldsResponse &b) { swap(a.fields, b.fields); } -GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1752) { - fields = other1752.fields; -} -GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1753) { +GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1753) { fields = other1753.fields; +} +GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1754) { + fields = other1754.fields; return *this; } void GetFieldsResponse::printTo(std::ostream& out) const { @@ -50088,16 +50141,7 @@ void swap(GetSchemaRequest &a, GetSchemaRequest &b) { swap(a.__isset, b.__isset); } -GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1754) { - catName = other1754.catName; - dbName = other1754.dbName; - tblName = other1754.tblName; - envContext = other1754.envContext; - validWriteIdList = other1754.validWriteIdList; - id = other1754.id; - __isset = other1754.__isset; -} -GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1755) { +GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1755) { catName = other1755.catName; dbName = other1755.dbName; tblName = other1755.tblName; @@ -50105,6 +50149,15 @@ GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1755) validWriteIdList = other1755.validWriteIdList; id = other1755.id; __isset = other1755.__isset; +} +GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1756) { + catName = other1756.catName; + dbName = other1756.dbName; + tblName = other1756.tblName; + envContext = other1756.envContext; + validWriteIdList = other1756.validWriteIdList; + id = other1756.id; + __isset = other1756.__isset; return *this; } void GetSchemaRequest::printTo(std::ostream& out) const { @@ -50160,14 +50213,14 @@ uint32_t GetSchemaResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1756; - ::apache::thrift::protocol::TType _etype1759; - xfer += iprot->readListBegin(_etype1759, _size1756); - this->fields.resize(_size1756); - uint32_t _i1760; - for (_i1760 = 0; _i1760 < _size1756; ++_i1760) + uint32_t _size1757; + ::apache::thrift::protocol::TType _etype1760; + xfer += iprot->readListBegin(_etype1760, _size1757); + this->fields.resize(_size1757); + uint32_t _i1761; + for (_i1761 = 0; _i1761 < _size1757; ++_i1761) { - xfer += this->fields[_i1760].read(iprot); + xfer += this->fields[_i1761].read(iprot); } xfer += iprot->readListEnd(); } @@ -50198,10 +50251,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 _iter1761; - for (_iter1761 = this->fields.begin(); _iter1761 != this->fields.end(); ++_iter1761) + std::vector ::const_iterator _iter1762; + for (_iter1762 = this->fields.begin(); _iter1762 != this->fields.end(); ++_iter1762) { - xfer += (*_iter1761).write(oprot); + xfer += (*_iter1762).write(oprot); } xfer += oprot->writeListEnd(); } @@ -50217,11 +50270,11 @@ void swap(GetSchemaResponse &a, GetSchemaResponse &b) { swap(a.fields, b.fields); } -GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1762) { - fields = other1762.fields; -} -GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1763) { +GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1763) { fields = other1763.fields; +} +GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1764) { + fields = other1764.fields; return *this; } void GetSchemaResponse::printTo(std::ostream& out) const { @@ -50321,14 +50374,14 @@ uint32_t GetPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1764; - ::apache::thrift::protocol::TType _etype1767; - xfer += iprot->readListBegin(_etype1767, _size1764); - this->partVals.resize(_size1764); - uint32_t _i1768; - for (_i1768 = 0; _i1768 < _size1764; ++_i1768) + uint32_t _size1765; + ::apache::thrift::protocol::TType _etype1768; + xfer += iprot->readListBegin(_etype1768, _size1765); + this->partVals.resize(_size1765); + uint32_t _i1769; + for (_i1769 = 0; _i1769 < _size1765; ++_i1769) { - xfer += iprot->readString(this->partVals[_i1768]); + xfer += iprot->readString(this->partVals[_i1769]); } xfer += iprot->readListEnd(); } @@ -50392,10 +50445,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 _iter1769; - for (_iter1769 = this->partVals.begin(); _iter1769 != this->partVals.end(); ++_iter1769) + std::vector ::const_iterator _iter1770; + for (_iter1770 = this->partVals.begin(); _iter1770 != this->partVals.end(); ++_iter1770) { - xfer += oprot->writeString((*_iter1769)); + xfer += oprot->writeString((*_iter1770)); } xfer += oprot->writeListEnd(); } @@ -50427,16 +50480,7 @@ void swap(GetPartitionRequest &a, GetPartitionRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1770) { - catName = other1770.catName; - dbName = other1770.dbName; - tblName = other1770.tblName; - partVals = other1770.partVals; - validWriteIdList = other1770.validWriteIdList; - id = other1770.id; - __isset = other1770.__isset; -} -GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1771) { +GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1771) { catName = other1771.catName; dbName = other1771.dbName; tblName = other1771.tblName; @@ -50444,6 +50488,15 @@ GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& o validWriteIdList = other1771.validWriteIdList; id = other1771.id; __isset = other1771.__isset; +} +GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1772) { + catName = other1772.catName; + dbName = other1772.dbName; + tblName = other1772.tblName; + partVals = other1772.partVals; + validWriteIdList = other1772.validWriteIdList; + id = other1772.id; + __isset = other1772.__isset; return *this; } void GetPartitionRequest::printTo(std::ostream& out) const { @@ -50536,11 +50589,11 @@ void swap(GetPartitionResponse &a, GetPartitionResponse &b) { swap(a.partition, b.partition); } -GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1772) { - partition = other1772.partition; -} -GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1773) { +GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1773) { partition = other1773.partition; +} +GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1774) { + partition = other1774.partition; return *this; } void GetPartitionResponse::printTo(std::ostream& out) const { @@ -50782,19 +50835,7 @@ void swap(PartitionsRequest &a, PartitionsRequest &b) { swap(a.__isset, b.__isset); } -PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1774) { - catName = other1774.catName; - dbName = other1774.dbName; - tblName = other1774.tblName; - maxParts = other1774.maxParts; - validWriteIdList = other1774.validWriteIdList; - id = other1774.id; - skipColumnSchemaForPartition = other1774.skipColumnSchemaForPartition; - includeParamKeyPattern = other1774.includeParamKeyPattern; - excludeParamKeyPattern = other1774.excludeParamKeyPattern; - __isset = other1774.__isset; -} -PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1775) { +PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1775) { catName = other1775.catName; dbName = other1775.dbName; tblName = other1775.tblName; @@ -50805,6 +50846,18 @@ PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other17 includeParamKeyPattern = other1775.includeParamKeyPattern; excludeParamKeyPattern = other1775.excludeParamKeyPattern; __isset = other1775.__isset; +} +PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1776) { + catName = other1776.catName; + dbName = other1776.dbName; + tblName = other1776.tblName; + maxParts = other1776.maxParts; + validWriteIdList = other1776.validWriteIdList; + id = other1776.id; + skipColumnSchemaForPartition = other1776.skipColumnSchemaForPartition; + includeParamKeyPattern = other1776.includeParamKeyPattern; + excludeParamKeyPattern = other1776.excludeParamKeyPattern; + __isset = other1776.__isset; return *this; } void PartitionsRequest::printTo(std::ostream& out) const { @@ -50863,14 +50916,14 @@ uint32_t PartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1776; - ::apache::thrift::protocol::TType _etype1779; - xfer += iprot->readListBegin(_etype1779, _size1776); - this->partitions.resize(_size1776); - uint32_t _i1780; - for (_i1780 = 0; _i1780 < _size1776; ++_i1780) + uint32_t _size1777; + ::apache::thrift::protocol::TType _etype1780; + xfer += iprot->readListBegin(_etype1780, _size1777); + this->partitions.resize(_size1777); + uint32_t _i1781; + for (_i1781 = 0; _i1781 < _size1777; ++_i1781) { - xfer += this->partitions[_i1780].read(iprot); + xfer += this->partitions[_i1781].read(iprot); } xfer += iprot->readListEnd(); } @@ -50901,10 +50954,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 _iter1781; - for (_iter1781 = this->partitions.begin(); _iter1781 != this->partitions.end(); ++_iter1781) + std::vector ::const_iterator _iter1782; + for (_iter1782 = this->partitions.begin(); _iter1782 != this->partitions.end(); ++_iter1782) { - xfer += (*_iter1781).write(oprot); + xfer += (*_iter1782).write(oprot); } xfer += oprot->writeListEnd(); } @@ -50920,11 +50973,11 @@ void swap(PartitionsResponse &a, PartitionsResponse &b) { swap(a.partitions, b.partitions); } -PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1782) { - partitions = other1782.partitions; -} -PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1783) { +PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1783) { partitions = other1783.partitions; +} +PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1784) { + partitions = other1784.partitions; return *this; } void PartitionsResponse::printTo(std::ostream& out) const { @@ -51139,18 +51192,7 @@ void swap(GetPartitionsByFilterRequest &a, GetPartitionsByFilterRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsByFilterRequest::GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest& other1784) { - catName = other1784.catName; - dbName = other1784.dbName; - tblName = other1784.tblName; - filter = other1784.filter; - maxParts = other1784.maxParts; - skipColumnSchemaForPartition = other1784.skipColumnSchemaForPartition; - includeParamKeyPattern = other1784.includeParamKeyPattern; - excludeParamKeyPattern = other1784.excludeParamKeyPattern; - __isset = other1784.__isset; -} -GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetPartitionsByFilterRequest& other1785) { +GetPartitionsByFilterRequest::GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest& other1785) { catName = other1785.catName; dbName = other1785.dbName; tblName = other1785.tblName; @@ -51160,6 +51202,17 @@ GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetP includeParamKeyPattern = other1785.includeParamKeyPattern; excludeParamKeyPattern = other1785.excludeParamKeyPattern; __isset = other1785.__isset; +} +GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetPartitionsByFilterRequest& other1786) { + catName = other1786.catName; + dbName = other1786.dbName; + tblName = other1786.tblName; + filter = other1786.filter; + maxParts = other1786.maxParts; + skipColumnSchemaForPartition = other1786.skipColumnSchemaForPartition; + includeParamKeyPattern = other1786.includeParamKeyPattern; + excludeParamKeyPattern = other1786.excludeParamKeyPattern; + __isset = other1786.__isset; return *this; } void GetPartitionsByFilterRequest::printTo(std::ostream& out) const { @@ -51271,14 +51324,14 @@ uint32_t GetPartitionNamesPsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partValues.clear(); - uint32_t _size1786; - ::apache::thrift::protocol::TType _etype1789; - xfer += iprot->readListBegin(_etype1789, _size1786); - this->partValues.resize(_size1786); - uint32_t _i1790; - for (_i1790 = 0; _i1790 < _size1786; ++_i1790) + uint32_t _size1787; + ::apache::thrift::protocol::TType _etype1790; + xfer += iprot->readListBegin(_etype1790, _size1787); + this->partValues.resize(_size1787); + uint32_t _i1791; + for (_i1791 = 0; _i1791 < _size1787; ++_i1791) { - xfer += iprot->readString(this->partValues[_i1790]); + xfer += iprot->readString(this->partValues[_i1791]); } xfer += iprot->readListEnd(); } @@ -51349,10 +51402,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 _iter1791; - for (_iter1791 = this->partValues.begin(); _iter1791 != this->partValues.end(); ++_iter1791) + std::vector ::const_iterator _iter1792; + for (_iter1792 = this->partValues.begin(); _iter1792 != this->partValues.end(); ++_iter1792) { - xfer += oprot->writeString((*_iter1791)); + xfer += oprot->writeString((*_iter1792)); } xfer += oprot->writeListEnd(); } @@ -51390,17 +51443,7 @@ void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1792) { - catName = other1792.catName; - dbName = other1792.dbName; - tblName = other1792.tblName; - partValues = other1792.partValues; - maxParts = other1792.maxParts; - validWriteIdList = other1792.validWriteIdList; - id = other1792.id; - __isset = other1792.__isset; -} -GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1793) { +GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1793) { catName = other1793.catName; dbName = other1793.dbName; tblName = other1793.tblName; @@ -51409,6 +51452,16 @@ GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetParti validWriteIdList = other1793.validWriteIdList; id = other1793.id; __isset = other1793.__isset; +} +GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1794) { + catName = other1794.catName; + dbName = other1794.dbName; + tblName = other1794.tblName; + partValues = other1794.partValues; + maxParts = other1794.maxParts; + validWriteIdList = other1794.validWriteIdList; + id = other1794.id; + __isset = other1794.__isset; return *this; } void GetPartitionNamesPsRequest::printTo(std::ostream& out) const { @@ -51465,14 +51518,14 @@ uint32_t GetPartitionNamesPsResponse::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1794; - ::apache::thrift::protocol::TType _etype1797; - xfer += iprot->readListBegin(_etype1797, _size1794); - this->names.resize(_size1794); - uint32_t _i1798; - for (_i1798 = 0; _i1798 < _size1794; ++_i1798) + uint32_t _size1795; + ::apache::thrift::protocol::TType _etype1798; + xfer += iprot->readListBegin(_etype1798, _size1795); + this->names.resize(_size1795); + uint32_t _i1799; + for (_i1799 = 0; _i1799 < _size1795; ++_i1799) { - xfer += iprot->readString(this->names[_i1798]); + xfer += iprot->readString(this->names[_i1799]); } xfer += iprot->readListEnd(); } @@ -51503,10 +51556,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 _iter1799; - for (_iter1799 = this->names.begin(); _iter1799 != this->names.end(); ++_iter1799) + std::vector ::const_iterator _iter1800; + for (_iter1800 = this->names.begin(); _iter1800 != this->names.end(); ++_iter1800) { - xfer += oprot->writeString((*_iter1799)); + xfer += oprot->writeString((*_iter1800)); } xfer += oprot->writeListEnd(); } @@ -51522,11 +51575,11 @@ void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b) { swap(a.names, b.names); } -GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1800) { - names = other1800.names; -} -GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1801) { +GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1801) { names = other1801.names; +} +GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1802) { + names = other1802.names; return *this; } void GetPartitionNamesPsResponse::printTo(std::ostream& out) const { @@ -51661,14 +51714,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1802; - ::apache::thrift::protocol::TType _etype1805; - xfer += iprot->readListBegin(_etype1805, _size1802); - this->partVals.resize(_size1802); - uint32_t _i1806; - for (_i1806 = 0; _i1806 < _size1802; ++_i1806) + uint32_t _size1803; + ::apache::thrift::protocol::TType _etype1806; + xfer += iprot->readListBegin(_etype1806, _size1803); + this->partVals.resize(_size1803); + uint32_t _i1807; + for (_i1807 = 0; _i1807 < _size1803; ++_i1807) { - xfer += iprot->readString(this->partVals[_i1806]); + xfer += iprot->readString(this->partVals[_i1807]); } xfer += iprot->readListEnd(); } @@ -51697,14 +51750,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1807; - ::apache::thrift::protocol::TType _etype1810; - xfer += iprot->readListBegin(_etype1810, _size1807); - this->groupNames.resize(_size1807); - uint32_t _i1811; - for (_i1811 = 0; _i1811 < _size1807; ++_i1811) + uint32_t _size1808; + ::apache::thrift::protocol::TType _etype1811; + xfer += iprot->readListBegin(_etype1811, _size1808); + this->groupNames.resize(_size1808); + uint32_t _i1812; + for (_i1812 = 0; _i1812 < _size1808; ++_i1812) { - xfer += iprot->readString(this->groupNames[_i1811]); + xfer += iprot->readString(this->groupNames[_i1812]); } xfer += iprot->readListEnd(); } @@ -51757,14 +51810,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1812; - ::apache::thrift::protocol::TType _etype1815; - xfer += iprot->readListBegin(_etype1815, _size1812); - this->partNames.resize(_size1812); - uint32_t _i1816; - for (_i1816 = 0; _i1816 < _size1812; ++_i1816) + uint32_t _size1813; + ::apache::thrift::protocol::TType _etype1816; + xfer += iprot->readListBegin(_etype1816, _size1813); + this->partNames.resize(_size1813); + uint32_t _i1817; + for (_i1817 = 0; _i1817 < _size1813; ++_i1817) { - xfer += iprot->readString(this->partNames[_i1816]); + xfer += iprot->readString(this->partNames[_i1817]); } xfer += iprot->readListEnd(); } @@ -51811,10 +51864,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 _iter1817; - for (_iter1817 = this->partVals.begin(); _iter1817 != this->partVals.end(); ++_iter1817) + std::vector ::const_iterator _iter1818; + for (_iter1818 = this->partVals.begin(); _iter1818 != this->partVals.end(); ++_iter1818) { - xfer += oprot->writeString((*_iter1817)); + xfer += oprot->writeString((*_iter1818)); } xfer += oprot->writeListEnd(); } @@ -51834,10 +51887,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 _iter1818; - for (_iter1818 = this->groupNames.begin(); _iter1818 != this->groupNames.end(); ++_iter1818) + std::vector ::const_iterator _iter1819; + for (_iter1819 = this->groupNames.begin(); _iter1819 != this->groupNames.end(); ++_iter1819) { - xfer += oprot->writeString((*_iter1818)); + xfer += oprot->writeString((*_iter1819)); } xfer += oprot->writeListEnd(); } @@ -51872,10 +51925,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 13); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter1819; - for (_iter1819 = this->partNames.begin(); _iter1819 != this->partNames.end(); ++_iter1819) + std::vector ::const_iterator _iter1820; + for (_iter1820 = this->partNames.begin(); _iter1820 != this->partNames.end(); ++_iter1820) { - xfer += oprot->writeString((*_iter1819)); + xfer += oprot->writeString((*_iter1820)); } xfer += oprot->writeListEnd(); } @@ -51904,23 +51957,7 @@ void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b) swap(a.__isset, b.__isset); } -GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1820) { - catName = other1820.catName; - dbName = other1820.dbName; - tblName = other1820.tblName; - partVals = other1820.partVals; - maxParts = other1820.maxParts; - userName = other1820.userName; - groupNames = other1820.groupNames; - validWriteIdList = other1820.validWriteIdList; - id = other1820.id; - skipColumnSchemaForPartition = other1820.skipColumnSchemaForPartition; - includeParamKeyPattern = other1820.includeParamKeyPattern; - excludeParamKeyPattern = other1820.excludeParamKeyPattern; - partNames = other1820.partNames; - __isset = other1820.__isset; -} -GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1821) { +GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1821) { catName = other1821.catName; dbName = other1821.dbName; tblName = other1821.tblName; @@ -51935,6 +51972,22 @@ GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const excludeParamKeyPattern = other1821.excludeParamKeyPattern; partNames = other1821.partNames; __isset = other1821.__isset; +} +GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1822) { + catName = other1822.catName; + dbName = other1822.dbName; + tblName = other1822.tblName; + partVals = other1822.partVals; + maxParts = other1822.maxParts; + userName = other1822.userName; + groupNames = other1822.groupNames; + validWriteIdList = other1822.validWriteIdList; + id = other1822.id; + skipColumnSchemaForPartition = other1822.skipColumnSchemaForPartition; + includeParamKeyPattern = other1822.includeParamKeyPattern; + excludeParamKeyPattern = other1822.excludeParamKeyPattern; + partNames = other1822.partNames; + __isset = other1822.__isset; return *this; } void GetPartitionsPsWithAuthRequest::printTo(std::ostream& out) const { @@ -51997,14 +52050,14 @@ uint32_t GetPartitionsPsWithAuthResponse::read(::apache::thrift::protocol::TProt if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1822; - ::apache::thrift::protocol::TType _etype1825; - xfer += iprot->readListBegin(_etype1825, _size1822); - this->partitions.resize(_size1822); - uint32_t _i1826; - for (_i1826 = 0; _i1826 < _size1822; ++_i1826) + uint32_t _size1823; + ::apache::thrift::protocol::TType _etype1826; + xfer += iprot->readListBegin(_etype1826, _size1823); + this->partitions.resize(_size1823); + uint32_t _i1827; + for (_i1827 = 0; _i1827 < _size1823; ++_i1827) { - xfer += this->partitions[_i1826].read(iprot); + xfer += this->partitions[_i1827].read(iprot); } xfer += iprot->readListEnd(); } @@ -52035,10 +52088,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 _iter1827; - for (_iter1827 = this->partitions.begin(); _iter1827 != this->partitions.end(); ++_iter1827) + std::vector ::const_iterator _iter1828; + for (_iter1828 = this->partitions.begin(); _iter1828 != this->partitions.end(); ++_iter1828) { - xfer += (*_iter1827).write(oprot); + xfer += (*_iter1828).write(oprot); } xfer += oprot->writeListEnd(); } @@ -52054,11 +52107,11 @@ void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b swap(a.partitions, b.partitions); } -GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1828) { - partitions = other1828.partitions; -} -GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1829) { +GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1829) { partitions = other1829.partitions; +} +GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1830) { + partitions = other1830.partitions; return *this; } void GetPartitionsPsWithAuthResponse::printTo(std::ostream& out) const { @@ -52244,16 +52297,7 @@ void swap(ReplicationMetrics &a, ReplicationMetrics &b) { swap(a.__isset, b.__isset); } -ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1830) { - scheduledExecutionId = other1830.scheduledExecutionId; - policy = other1830.policy; - dumpExecutionId = other1830.dumpExecutionId; - metadata = other1830.metadata; - progress = other1830.progress; - messageFormat = other1830.messageFormat; - __isset = other1830.__isset; -} -ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1831) { +ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1831) { scheduledExecutionId = other1831.scheduledExecutionId; policy = other1831.policy; dumpExecutionId = other1831.dumpExecutionId; @@ -52261,6 +52305,15 @@ ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& othe progress = other1831.progress; messageFormat = other1831.messageFormat; __isset = other1831.__isset; +} +ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1832) { + scheduledExecutionId = other1832.scheduledExecutionId; + policy = other1832.policy; + dumpExecutionId = other1832.dumpExecutionId; + metadata = other1832.metadata; + progress = other1832.progress; + messageFormat = other1832.messageFormat; + __isset = other1832.__isset; return *this; } void ReplicationMetrics::printTo(std::ostream& out) const { @@ -52316,14 +52369,14 @@ uint32_t ReplicationMetricList::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->replicationMetricList.clear(); - uint32_t _size1832; - ::apache::thrift::protocol::TType _etype1835; - xfer += iprot->readListBegin(_etype1835, _size1832); - this->replicationMetricList.resize(_size1832); - uint32_t _i1836; - for (_i1836 = 0; _i1836 < _size1832; ++_i1836) + uint32_t _size1833; + ::apache::thrift::protocol::TType _etype1836; + xfer += iprot->readListBegin(_etype1836, _size1833); + this->replicationMetricList.resize(_size1833); + uint32_t _i1837; + for (_i1837 = 0; _i1837 < _size1833; ++_i1837) { - xfer += this->replicationMetricList[_i1836].read(iprot); + xfer += this->replicationMetricList[_i1837].read(iprot); } xfer += iprot->readListEnd(); } @@ -52354,10 +52407,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 _iter1837; - for (_iter1837 = this->replicationMetricList.begin(); _iter1837 != this->replicationMetricList.end(); ++_iter1837) + std::vector ::const_iterator _iter1838; + for (_iter1838 = this->replicationMetricList.begin(); _iter1838 != this->replicationMetricList.end(); ++_iter1838) { - xfer += (*_iter1837).write(oprot); + xfer += (*_iter1838).write(oprot); } xfer += oprot->writeListEnd(); } @@ -52373,11 +52426,11 @@ void swap(ReplicationMetricList &a, ReplicationMetricList &b) { swap(a.replicationMetricList, b.replicationMetricList); } -ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1838) { - replicationMetricList = other1838.replicationMetricList; -} -ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1839) { +ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1839) { replicationMetricList = other1839.replicationMetricList; +} +ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1840) { + replicationMetricList = other1840.replicationMetricList; return *this; } void ReplicationMetricList::printTo(std::ostream& out) const { @@ -52503,17 +52556,17 @@ void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b) { swap(a.__isset, b.__isset); } -GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1840) { - scheduledExecutionId = other1840.scheduledExecutionId; - policy = other1840.policy; - dumpExecutionId = other1840.dumpExecutionId; - __isset = other1840.__isset; -} -GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1841) { +GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1841) { scheduledExecutionId = other1841.scheduledExecutionId; policy = other1841.policy; dumpExecutionId = other1841.dumpExecutionId; __isset = other1841.__isset; +} +GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1842) { + scheduledExecutionId = other1842.scheduledExecutionId; + policy = other1842.policy; + dumpExecutionId = other1842.dumpExecutionId; + __isset = other1842.__isset; return *this; } void GetReplicationMetricsRequest::printTo(std::ostream& out) const { @@ -52566,16 +52619,16 @@ uint32_t GetOpenTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->excludeTxnTypes.clear(); - uint32_t _size1842; - ::apache::thrift::protocol::TType _etype1845; - xfer += iprot->readListBegin(_etype1845, _size1842); - this->excludeTxnTypes.resize(_size1842); - uint32_t _i1846; - for (_i1846 = 0; _i1846 < _size1842; ++_i1846) + uint32_t _size1843; + ::apache::thrift::protocol::TType _etype1846; + xfer += iprot->readListBegin(_etype1846, _size1843); + this->excludeTxnTypes.resize(_size1843); + uint32_t _i1847; + for (_i1847 = 0; _i1847 < _size1843; ++_i1847) { - int32_t ecast1847; - xfer += iprot->readI32(ecast1847); - this->excludeTxnTypes[_i1846] = static_cast(ecast1847); + int32_t ecast1848; + xfer += iprot->readI32(ecast1848); + this->excludeTxnTypes[_i1847] = static_cast(ecast1848); } xfer += iprot->readListEnd(); } @@ -52605,10 +52658,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 _iter1848; - for (_iter1848 = this->excludeTxnTypes.begin(); _iter1848 != this->excludeTxnTypes.end(); ++_iter1848) + std::vector ::const_iterator _iter1849; + for (_iter1849 = this->excludeTxnTypes.begin(); _iter1849 != this->excludeTxnTypes.end(); ++_iter1849) { - xfer += oprot->writeI32(static_cast((*_iter1848))); + xfer += oprot->writeI32(static_cast((*_iter1849))); } xfer += oprot->writeListEnd(); } @@ -52625,13 +52678,13 @@ void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1849) { - excludeTxnTypes = other1849.excludeTxnTypes; - __isset = other1849.__isset; -} -GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1850) { +GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1850) { excludeTxnTypes = other1850.excludeTxnTypes; __isset = other1850.__isset; +} +GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1851) { + excludeTxnTypes = other1851.excludeTxnTypes; + __isset = other1851.__isset; return *this; } void GetOpenTxnsRequest::printTo(std::ostream& out) const { @@ -52759,15 +52812,15 @@ void swap(StoredProcedureRequest &a, StoredProcedureRequest &b) { swap(a.procName, b.procName); } -StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1851) { - catName = other1851.catName; - dbName = other1851.dbName; - procName = other1851.procName; -} -StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1852) { +StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1852) { catName = other1852.catName; dbName = other1852.dbName; procName = other1852.procName; +} +StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1853) { + catName = other1853.catName; + dbName = other1853.dbName; + procName = other1853.procName; return *this; } void StoredProcedureRequest::printTo(std::ostream& out) const { @@ -52877,15 +52930,15 @@ void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b) { swap(a.__isset, b.__isset); } -ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1853) { - catName = other1853.catName; - dbName = other1853.dbName; - __isset = other1853.__isset; -} -ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1854) { +ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1854) { catName = other1854.catName; dbName = other1854.dbName; __isset = other1854.__isset; +} +ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1855) { + catName = other1855.catName; + dbName = other1855.dbName; + __isset = other1855.__isset; return *this; } void ListStoredProcedureRequest::printTo(std::ostream& out) const { @@ -53040,21 +53093,21 @@ void swap(StoredProcedure &a, StoredProcedure &b) { swap(a.__isset, b.__isset); } -StoredProcedure::StoredProcedure(const StoredProcedure& other1855) { - name = other1855.name; - dbName = other1855.dbName; - catName = other1855.catName; - ownerName = other1855.ownerName; - source = other1855.source; - __isset = other1855.__isset; -} -StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1856) { +StoredProcedure::StoredProcedure(const StoredProcedure& other1856) { name = other1856.name; dbName = other1856.dbName; catName = other1856.catName; ownerName = other1856.ownerName; source = other1856.source; __isset = other1856.__isset; +} +StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1857) { + name = other1857.name; + dbName = other1857.dbName; + catName = other1857.catName; + ownerName = other1857.ownerName; + source = other1857.source; + __isset = other1857.__isset; return *this; } void StoredProcedure::printTo(std::ostream& out) const { @@ -53229,16 +53282,7 @@ void swap(AddPackageRequest &a, AddPackageRequest &b) { swap(a.__isset, b.__isset); } -AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1857) { - catName = other1857.catName; - dbName = other1857.dbName; - packageName = other1857.packageName; - ownerName = other1857.ownerName; - header = other1857.header; - body = other1857.body; - __isset = other1857.__isset; -} -AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1858) { +AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1858) { catName = other1858.catName; dbName = other1858.dbName; packageName = other1858.packageName; @@ -53246,6 +53290,15 @@ AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other18 header = other1858.header; body = other1858.body; __isset = other1858.__isset; +} +AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1859) { + catName = other1859.catName; + dbName = other1859.dbName; + packageName = other1859.packageName; + ownerName = other1859.ownerName; + header = other1859.header; + body = other1859.body; + __isset = other1859.__isset; return *this; } void AddPackageRequest::printTo(std::ostream& out) const { @@ -53378,15 +53431,15 @@ void swap(GetPackageRequest &a, GetPackageRequest &b) { swap(a.packageName, b.packageName); } -GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1859) { - catName = other1859.catName; - dbName = other1859.dbName; - packageName = other1859.packageName; -} -GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1860) { +GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1860) { catName = other1860.catName; dbName = other1860.dbName; packageName = other1860.packageName; +} +GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1861) { + catName = other1861.catName; + dbName = other1861.dbName; + packageName = other1861.packageName; return *this; } void GetPackageRequest::printTo(std::ostream& out) const { @@ -53516,15 +53569,15 @@ void swap(DropPackageRequest &a, DropPackageRequest &b) { swap(a.packageName, b.packageName); } -DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1861) { - catName = other1861.catName; - dbName = other1861.dbName; - packageName = other1861.packageName; -} -DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1862) { +DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1862) { catName = other1862.catName; dbName = other1862.dbName; packageName = other1862.packageName; +} +DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1863) { + catName = other1863.catName; + dbName = other1863.dbName; + packageName = other1863.packageName; return *this; } void DropPackageRequest::printTo(std::ostream& out) const { @@ -53634,15 +53687,15 @@ void swap(ListPackageRequest &a, ListPackageRequest &b) { swap(a.__isset, b.__isset); } -ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1863) { - catName = other1863.catName; - dbName = other1863.dbName; - __isset = other1863.__isset; -} -ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1864) { +ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1864) { catName = other1864.catName; dbName = other1864.dbName; __isset = other1864.__isset; +} +ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1865) { + catName = other1865.catName; + dbName = other1865.dbName; + __isset = other1865.__isset; return *this; } void ListPackageRequest::printTo(std::ostream& out) const { @@ -53814,16 +53867,7 @@ void swap(Package &a, Package &b) { swap(a.__isset, b.__isset); } -Package::Package(const Package& other1865) { - catName = other1865.catName; - dbName = other1865.dbName; - packageName = other1865.packageName; - ownerName = other1865.ownerName; - header = other1865.header; - body = other1865.body; - __isset = other1865.__isset; -} -Package& Package::operator=(const Package& other1866) { +Package::Package(const Package& other1866) { catName = other1866.catName; dbName = other1866.dbName; packageName = other1866.packageName; @@ -53831,6 +53875,15 @@ Package& Package::operator=(const Package& other1866) { header = other1866.header; body = other1866.body; __isset = other1866.__isset; +} +Package& Package::operator=(const Package& other1867) { + catName = other1867.catName; + dbName = other1867.dbName; + packageName = other1867.packageName; + ownerName = other1867.ownerName; + header = other1867.header; + body = other1867.body; + __isset = other1867.__isset; return *this; } void Package::printTo(std::ostream& out) const { @@ -53962,17 +54015,17 @@ void swap(GetAllWriteEventInfoRequest &a, GetAllWriteEventInfoRequest &b) { swap(a.__isset, b.__isset); } -GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1867) { - txnId = other1867.txnId; - dbName = other1867.dbName; - tableName = other1867.tableName; - __isset = other1867.__isset; -} -GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1868) { +GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1868) { txnId = other1868.txnId; dbName = other1868.dbName; tableName = other1868.tableName; __isset = other1868.__isset; +} +GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1869) { + txnId = other1869.txnId; + dbName = other1869.dbName; + tableName = other1869.tableName; + __isset = other1869.__isset; return *this; } void GetAllWriteEventInfoRequest::printTo(std::ostream& out) const { @@ -54060,13 +54113,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other1869) : TException() { - message = other1869.message; - __isset = other1869.__isset; -} -MetaException& MetaException::operator=(const MetaException& other1870) { +MetaException::MetaException(const MetaException& other1870) : TException() { message = other1870.message; __isset = other1870.__isset; +} +MetaException& MetaException::operator=(const MetaException& other1871) { + message = other1871.message; + __isset = other1871.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -54163,13 +54216,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other1871) : TException() { - message = other1871.message; - __isset = other1871.__isset; -} -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1872) { +UnknownTableException::UnknownTableException(const UnknownTableException& other1872) : TException() { message = other1872.message; __isset = other1872.__isset; +} +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1873) { + message = other1873.message; + __isset = other1873.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -54266,13 +54319,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other1873) : TException() { - message = other1873.message; - __isset = other1873.__isset; -} -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1874) { +UnknownDBException::UnknownDBException(const UnknownDBException& other1874) : TException() { message = other1874.message; __isset = other1874.__isset; +} +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1875) { + message = other1875.message; + __isset = other1875.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -54369,13 +54422,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1875) : TException() { - message = other1875.message; - __isset = other1875.__isset; -} -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1876) { +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1876) : TException() { message = other1876.message; __isset = other1876.__isset; +} +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1877) { + message = other1877.message; + __isset = other1877.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -54472,13 +54525,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1877) : TException() { - message = other1877.message; - __isset = other1877.__isset; -} -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1878) { +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1878) : TException() { message = other1878.message; __isset = other1878.__isset; +} +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1879) { + message = other1879.message; + __isset = other1879.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -54575,13 +54628,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1879) : TException() { - message = other1879.message; - __isset = other1879.__isset; -} -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1880) { +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1880) : TException() { message = other1880.message; __isset = other1880.__isset; +} +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1881) { + message = other1881.message; + __isset = other1881.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -54678,13 +54731,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1881) : TException() { - message = other1881.message; - __isset = other1881.__isset; -} -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1882) { +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1882) : TException() { message = other1882.message; __isset = other1882.__isset; +} +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1883) { + message = other1883.message; + __isset = other1883.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -54781,13 +54834,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1883) : TException() { - message = other1883.message; - __isset = other1883.__isset; -} -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1884) { +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1884) : TException() { message = other1884.message; __isset = other1884.__isset; +} +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1885) { + message = other1885.message; + __isset = other1885.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -54884,13 +54937,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1885) : TException() { - message = other1885.message; - __isset = other1885.__isset; -} -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1886) { +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1886) : TException() { message = other1886.message; __isset = other1886.__isset; +} +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1887) { + message = other1887.message; + __isset = other1887.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -54987,13 +55040,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1887) : TException() { - message = other1887.message; - __isset = other1887.__isset; -} -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1888) { +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1888) : TException() { message = other1888.message; __isset = other1888.__isset; +} +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1889) { + message = other1889.message; + __isset = other1889.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -55090,13 +55143,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other1889) : TException() { - message = other1889.message; - __isset = other1889.__isset; -} -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1890) { +InvalidInputException::InvalidInputException(const InvalidInputException& other1890) : TException() { message = other1890.message; __isset = other1890.__isset; +} +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1891) { + message = other1891.message; + __isset = other1891.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -55193,13 +55246,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1891) : TException() { - message = other1891.message; - __isset = other1891.__isset; -} -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1892) { +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1892) : TException() { message = other1892.message; __isset = other1892.__isset; +} +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1893) { + message = other1893.message; + __isset = other1893.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -55296,13 +55349,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1893) : TException() { - message = other1893.message; - __isset = other1893.__isset; -} -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1894) { +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1894) : TException() { message = other1894.message; __isset = other1894.__isset; +} +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1895) { + message = other1895.message; + __isset = other1895.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -55399,13 +55452,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other1895) : TException() { - message = other1895.message; - __isset = other1895.__isset; -} -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1896) { +TxnOpenException::TxnOpenException(const TxnOpenException& other1896) : TException() { message = other1896.message; __isset = other1896.__isset; +} +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1897) { + message = other1897.message; + __isset = other1897.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -55502,13 +55555,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1897) : TException() { - message = other1897.message; - __isset = other1897.__isset; -} -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1898) { +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1898) : TException() { message = other1898.message; __isset = other1898.__isset; +} +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1899) { + message = other1899.message; + __isset = other1899.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { @@ -55605,13 +55658,13 @@ void swap(CompactionAbortedException &a, CompactionAbortedException &b) { swap(a.__isset, b.__isset); } -CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1899) : TException() { - message = other1899.message; - __isset = other1899.__isset; -} -CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1900) { +CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1900) : TException() { message = other1900.message; __isset = other1900.__isset; +} +CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1901) { + message = other1901.message; + __isset = other1901.__isset; return *this; } void CompactionAbortedException::printTo(std::ostream& out) const { @@ -55708,13 +55761,13 @@ void swap(NoSuchCompactionException &a, NoSuchCompactionException &b) { swap(a.__isset, b.__isset); } -NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1901) : TException() { - message = other1901.message; - __isset = other1901.__isset; -} -NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1902) { +NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1902) : TException() { message = other1902.message; __isset = other1902.__isset; +} +NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1903) { + message = other1903.message; + __isset = other1903.__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 4b51c9e1c356..cdf5fe415965 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 @@ -268,6 +268,19 @@ std::ostream& operator<<(std::ostream& out, const DatabaseType::type& val); std::string to_string(const DatabaseType::type& val); +struct NullOrderingType { + enum type { + NULLS_FIRST = 1, + NULLS_LAST = 2 + }; +}; + +extern const std::map _NullOrderingType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const NullOrderingType::type& val); + +std::string to_string(const NullOrderingType::type& val); + struct FunctionType { enum type { JAVA = 1 @@ -3775,9 +3788,10 @@ void swap(SerDeInfo &a, SerDeInfo &b); std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj); typedef struct _Order__isset { - _Order__isset() : col(false), order(false) {} + _Order__isset() : col(false), order(false), nullOrdering(true) {} bool col :1; bool order :1; + bool nullOrdering :1; } _Order__isset; class Order : public virtual ::apache::thrift::TBase { @@ -3787,12 +3801,20 @@ class Order : public virtual ::apache::thrift::TBase { Order& operator=(const Order&); Order() noexcept : col(), - order(0) { + order(0), + nullOrdering((NullOrderingType::type)2) { + nullOrdering = (NullOrderingType::type)2; + } virtual ~Order() noexcept; std::string col; int32_t order; + /** + * + * @see NullOrderingType + */ + NullOrderingType::type nullOrdering; _Order__isset __isset; @@ -3800,12 +3822,18 @@ class Order : public virtual ::apache::thrift::TBase { void __set_order(const int32_t val); + void __set_nullOrdering(const NullOrderingType::type val); + bool operator == (const Order & rhs) const { if (!(col == rhs.col)) return false; if (!(order == rhs.order)) return false; + if (__isset.nullOrdering != rhs.__isset.nullOrdering) + return false; + else if (__isset.nullOrdering && !(nullOrdering == rhs.nullOrdering)) + return false; return true; } bool operator != (const Order &rhs) const { diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NullOrderingType.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NullOrderingType.java new file mode 100644 index 000000000000..1743821ef891 --- /dev/null +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NullOrderingType.java @@ -0,0 +1,43 @@ +/** + * Autogenerated by Thrift Compiler (0.16.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + + +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.16.0)") +public enum NullOrderingType implements org.apache.thrift.TEnum { + NULLS_FIRST(1), + NULLS_LAST(2); + + private final int value; + + private NullOrderingType(int value) { + this.value = value; + } + + /** + * Get the integer value of this enum value, as defined in the Thrift IDL. + */ + public int getValue() { + return value; + } + + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + @org.apache.thrift.annotation.Nullable + public static NullOrderingType findByValue(int value) { + switch (value) { + case 1: + return NULLS_FIRST; + case 2: + return NULLS_LAST; + default: + return null; + } + } +} diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Order.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Order.java index de457ef2cbc3..250aba7cfb8e 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Order.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Order.java @@ -13,17 +13,24 @@ private static final org.apache.thrift.protocol.TField COL_FIELD_DESC = new org.apache.thrift.protocol.TField("col", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("order", org.apache.thrift.protocol.TType.I32, (short)2); + private static final org.apache.thrift.protocol.TField NULL_ORDERING_FIELD_DESC = new org.apache.thrift.protocol.TField("nullOrdering", org.apache.thrift.protocol.TType.I32, (short)3); private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new OrderStandardSchemeFactory(); private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new OrderTupleSchemeFactory(); private @org.apache.thrift.annotation.Nullable java.lang.String col; // required private int order; // required + private @org.apache.thrift.annotation.Nullable NullOrderingType nullOrdering; // 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 { COL((short)1, "col"), - ORDER((short)2, "order"); + ORDER((short)2, "order"), + /** + * + * @see NullOrderingType + */ + NULL_ORDERING((short)3, "nullOrdering"); private static final java.util.Map byName = new java.util.HashMap(); @@ -43,6 +50,8 @@ public static _Fields findByThriftId(int fieldId) { return COL; case 2: // ORDER return ORDER; + case 3: // NULL_ORDERING + return NULL_ORDERING; default: return null; } @@ -86,6 +95,7 @@ public java.lang.String getFieldName() { // isset id assignments private static final int __ORDER_ISSET_ID = 0; private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.NULL_ORDERING}; 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); @@ -93,11 +103,15 @@ public java.lang.String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.ORDER, new org.apache.thrift.meta_data.FieldMetaData("order", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.NULL_ORDERING, new org.apache.thrift.meta_data.FieldMetaData("nullOrdering", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, NullOrderingType.class))); metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Order.class, metaDataMap); } public Order() { + this.nullOrdering = org.apache.hadoop.hive.metastore.api.NullOrderingType.NULLS_LAST; + } public Order( @@ -119,6 +133,9 @@ public Order(Order other) { this.col = other.col; } this.order = other.order; + if (other.isSetNullOrdering()) { + this.nullOrdering = other.nullOrdering; + } } public Order deepCopy() { @@ -130,6 +147,8 @@ public void clear() { this.col = null; setOrderIsSet(false); this.order = 0; + this.nullOrdering = org.apache.hadoop.hive.metastore.api.NullOrderingType.NULLS_LAST; + } @org.apache.thrift.annotation.Nullable @@ -178,6 +197,38 @@ public void setOrderIsSet(boolean value) { __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ORDER_ISSET_ID, value); } + /** + * + * @see NullOrderingType + */ + @org.apache.thrift.annotation.Nullable + public NullOrderingType getNullOrdering() { + return this.nullOrdering; + } + + /** + * + * @see NullOrderingType + */ + public void setNullOrdering(@org.apache.thrift.annotation.Nullable NullOrderingType nullOrdering) { + this.nullOrdering = nullOrdering; + } + + public void unsetNullOrdering() { + this.nullOrdering = null; + } + + /** Returns true if field nullOrdering is set (has been assigned a value) and false otherwise */ + public boolean isSetNullOrdering() { + return this.nullOrdering != null; + } + + public void setNullOrderingIsSet(boolean value) { + if (!value) { + this.nullOrdering = null; + } + } + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { switch (field) { case COL: @@ -196,6 +247,14 @@ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable } break; + case NULL_ORDERING: + if (value == null) { + unsetNullOrdering(); + } else { + setNullOrdering((NullOrderingType)value); + } + break; + } } @@ -208,6 +267,9 @@ public java.lang.Object getFieldValue(_Fields field) { case ORDER: return getOrder(); + case NULL_ORDERING: + return getNullOrdering(); + } throw new java.lang.IllegalStateException(); } @@ -223,6 +285,8 @@ public boolean isSet(_Fields field) { return isSetCol(); case ORDER: return isSetOrder(); + case NULL_ORDERING: + return isSetNullOrdering(); } throw new java.lang.IllegalStateException(); } @@ -258,6 +322,15 @@ public boolean equals(Order that) { return false; } + boolean this_present_nullOrdering = true && this.isSetNullOrdering(); + boolean that_present_nullOrdering = true && that.isSetNullOrdering(); + if (this_present_nullOrdering || that_present_nullOrdering) { + if (!(this_present_nullOrdering && that_present_nullOrdering)) + return false; + if (!this.nullOrdering.equals(that.nullOrdering)) + return false; + } + return true; } @@ -271,6 +344,10 @@ public int hashCode() { hashCode = hashCode * 8191 + order; + hashCode = hashCode * 8191 + ((isSetNullOrdering()) ? 131071 : 524287); + if (isSetNullOrdering()) + hashCode = hashCode * 8191 + nullOrdering.getValue(); + return hashCode; } @@ -302,6 +379,16 @@ public int compareTo(Order other) { return lastComparison; } } + lastComparison = java.lang.Boolean.compare(isSetNullOrdering(), other.isSetNullOrdering()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNullOrdering()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nullOrdering, other.nullOrdering); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -334,6 +421,16 @@ public java.lang.String toString() { sb.append("order:"); sb.append(this.order); first = false; + if (isSetNullOrdering()) { + if (!first) sb.append(", "); + sb.append("nullOrdering:"); + if (this.nullOrdering == null) { + sb.append("null"); + } else { + sb.append(this.nullOrdering); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -395,6 +492,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, Order struct) throw org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 3: // NULL_ORDERING + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.nullOrdering = org.apache.hadoop.hive.metastore.api.NullOrderingType.findByValue(iprot.readI32()); + struct.setNullOrderingIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -416,6 +521,13 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, Order struct) thro oprot.writeFieldBegin(ORDER_FIELD_DESC); oprot.writeI32(struct.order); oprot.writeFieldEnd(); + if (struct.nullOrdering != null) { + if (struct.isSetNullOrdering()) { + oprot.writeFieldBegin(NULL_ORDERING_FIELD_DESC); + oprot.writeI32(struct.nullOrdering.getValue()); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -440,19 +552,25 @@ public void write(org.apache.thrift.protocol.TProtocol prot, Order struct) throw if (struct.isSetOrder()) { optionals.set(1); } - oprot.writeBitSet(optionals, 2); + if (struct.isSetNullOrdering()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); if (struct.isSetCol()) { oprot.writeString(struct.col); } if (struct.isSetOrder()) { oprot.writeI32(struct.order); } + if (struct.isSetNullOrdering()) { + oprot.writeI32(struct.nullOrdering.getValue()); + } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, Order struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; - java.util.BitSet incoming = iprot.readBitSet(2); + java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { struct.col = iprot.readString(); struct.setColIsSet(true); @@ -461,6 +579,10 @@ public void read(org.apache.thrift.protocol.TProtocol prot, Order struct) throws struct.order = iprot.readI32(); struct.setOrderIsSet(true); } + if (incoming.get(2)) { + struct.nullOrdering = org.apache.hadoop.hive.metastore.api.NullOrderingType.findByValue(iprot.readI32()); + struct.setNullOrderingIsSet(true); + } } } diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/NullOrderingType.php b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/NullOrderingType.php new file mode 100644 index 000000000000..01abff757817 --- /dev/null +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/NullOrderingType.php @@ -0,0 +1,30 @@ + 'NULLS_FIRST', + 2 => 'NULLS_LAST', + ); +} + diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/Order.php b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/Order.php index 0ea6b7422f62..22a5d556faed 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/Order.php +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/Order.php @@ -31,6 +31,12 @@ class Order 'isRequired' => false, 'type' => TType::I32, ), + 3 => array( + 'var' => 'nullOrdering', + 'isRequired' => false, + 'type' => TType::I32, + 'class' => '\metastore\NullOrderingType', + ), ); /** @@ -41,6 +47,10 @@ class Order * @var int */ public $order = null; + /** + * @var int + */ + public $nullOrdering = 2; public function __construct($vals = null) { @@ -51,6 +61,9 @@ public function __construct($vals = null) if (isset($vals['order'])) { $this->order = $vals['order']; } + if (isset($vals['nullOrdering'])) { + $this->nullOrdering = $vals['nullOrdering']; + } } } @@ -87,6 +100,13 @@ public function read($input) $xfer += $input->skip($ftype); } break; + case 3: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->nullOrdering); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -111,6 +131,11 @@ public function write($output) $xfer += $output->writeI32($this->order); $xfer += $output->writeFieldEnd(); } + if ($this->nullOrdering !== null) { + $xfer += $output->writeFieldBegin('nullOrdering', TType::I32, 3); + $xfer += $output->writeI32($this->nullOrdering); + $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 c20c5d80babb..b583ff159df1 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 @@ -347,6 +347,21 @@ class DatabaseType(object): } +class NullOrderingType(object): + NULLS_FIRST = 1 + NULLS_LAST = 2 + + _VALUES_TO_NAMES = { + 1: "NULLS_FIRST", + 2: "NULLS_LAST", + } + + _NAMES_TO_VALUES = { + "NULLS_FIRST": 1, + "NULLS_LAST": 2, + } + + class FunctionType(object): JAVA = 1 @@ -4507,13 +4522,15 @@ class Order(object): Attributes: - col - order + - nullOrdering """ - def __init__(self, col=None, order=None,): + def __init__(self, col=None, order=None, nullOrdering=2,): self.col = col self.order = order + self.nullOrdering = nullOrdering def read(self, iprot): if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: @@ -4534,6 +4551,11 @@ def read(self, iprot): self.order = iprot.readI32() else: iprot.skip(ftype) + elif fid == 3: + if ftype == TType.I32: + self.nullOrdering = iprot.readI32() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -4552,6 +4574,10 @@ def write(self, oprot): oprot.writeFieldBegin('order', TType.I32, 2) oprot.writeI32(self.order) oprot.writeFieldEnd() + if self.nullOrdering is not None: + oprot.writeFieldBegin('nullOrdering', TType.I32, 3) + oprot.writeI32(self.nullOrdering) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -32378,6 +32404,7 @@ def __ne__(self, other): None, # 0 (1, TType.STRING, 'col', 'UTF8', None, ), # 1 (2, TType.I32, 'order', None, None, ), # 2 + (3, TType.I32, 'nullOrdering', None, 2, ), # 3 ) all_structs.append(SkewedInfo) SkewedInfo.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 9a794ba58f0c..2ae332baa2aa 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 @@ -152,6 +152,13 @@ module DatabaseType VALID_VALUES = Set.new([NATIVE, REMOTE]).freeze end +module NullOrderingType + NULLS_FIRST = 1 + NULLS_LAST = 2 + VALUE_MAP = {1 => "NULLS_FIRST", 2 => "NULLS_LAST"} + VALID_VALUES = Set.new([NULLS_FIRST, NULLS_LAST]).freeze +end + module FunctionType JAVA = 1 VALUE_MAP = {1 => "JAVA"} @@ -1856,15 +1863,20 @@ class Order include ::Thrift::Struct, ::Thrift::Struct_Union COL = 1 ORDER = 2 + NULLORDERING = 3 FIELDS = { COL => {:type => ::Thrift::Types::STRING, :name => 'col'}, - ORDER => {:type => ::Thrift::Types::I32, :name => 'order'} + ORDER => {:type => ::Thrift::Types::I32, :name => 'order'}, + NULLORDERING => {:type => ::Thrift::Types::I32, :name => 'nullOrdering', :default => 2, :optional => true, :enum_class => ::NullOrderingType} } def struct_fields; FIELDS; end def validate + unless @nullOrdering.nil? || ::NullOrderingType::VALID_VALUES.include?(@nullOrdering) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field nullOrdering!') + end end ::Thrift::Struct.generate_accessors self 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 6f146f2d30eb..c025b905c8e0 100644 --- a/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift +++ b/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift @@ -281,6 +281,11 @@ enum DatabaseType { REMOTE = 2 } +enum NullOrderingType { + NULLS_FIRST = 1, + NULLS_LAST = 2 +} + struct HiveObjectRef{ 1: HiveObjectType objectType, 2: string dbName, @@ -450,9 +455,10 @@ struct SerDeInfo { } // sort order of a column (column name along with asc(1)/desc(0)) -struct Order { - 1: string col, // sort column name - 2: i32 order // asc(1) or desc(0) +struct Order{ + 1: string col, // sort column name + 2: i32 order, // asc(1) or desc(0) + 3: optional NullOrderingType nullOrdering = NullOrderingType.NULLS_LAST //null ordering, nulls_last or nulls_first } // this object holds all the information about skewed table