From 3f807e0601224654085f947bab5d4def3bde4fdf Mon Sep 17 00:00:00 2001 From: Richard Guo Date: Wed, 3 Jul 2024 16:24:39 +0900 Subject: [PATCH v9 10/10] Run pgindent --- src/backend/optimizer/geqo/geqo_eval.c | 19 ++++--- src/backend/optimizer/path/allpaths.c | 74 ++++++++++++------------- src/backend/optimizer/path/joinrels.c | 20 ++++--- src/backend/optimizer/plan/initsplan.c | 24 ++++---- src/backend/optimizer/plan/planner.c | 8 +-- src/backend/optimizer/util/appendinfo.c | 2 +- src/backend/optimizer/util/relnode.c | 69 +++++++++++------------ src/include/nodes/pathnodes.h | 10 ++-- src/tools/pgindent/typedefs.list | 4 ++ 9 files changed, 119 insertions(+), 111 deletions(-) diff --git a/src/backend/optimizer/geqo/geqo_eval.c b/src/backend/optimizer/geqo/geqo_eval.c index 278857d767..2851bed282 100644 --- a/src/backend/optimizer/geqo/geqo_eval.c +++ b/src/backend/optimizer/geqo/geqo_eval.c @@ -87,8 +87,9 @@ geqo_eval(PlannerInfo *root, Gene *tour, int num_gene) * already contain some entries. The newly added entries will be recycled * by the MemoryContextDelete below, so we must ensure that each list of * the RelInfoList structures is restored to its former state before - * exiting. We can do this by truncating each list to its original length. - * NOTE this assumes that any added entries are appended at the end! + * exiting. We can do this by truncating each list to its original + * length. NOTE this assumes that any added entries are appended at the + * end! * * We also must take care not to mess up the outer hash tables of the * RelInfoList structures, if any. We can do this by just temporarily @@ -136,8 +137,8 @@ geqo_eval(PlannerInfo *root, Gene *tour, int num_gene) /* * Restore each of the list in join_rel_list, agg_info_list and - * upper_rels[UPPERREL_PARTIAL_GROUP_AGG] to its former state, and put back - * original hashtable if any. + * upper_rels[UPPERREL_PARTIAL_GROUP_AGG] to its former state, and put + * back original hashtable if any. */ root->join_rel_list->items = list_truncate(root->join_rel_list->items, savelength_join_rel); @@ -308,14 +309,14 @@ merge_clump(PlannerInfo *root, List *clumps, Clump *new_clump, int num_gene, /* * Except for the topmost scan/join rel, consider generating - * partial aggregation paths for the grouped relation on top of the - * paths of this rel. After that, we're done creating paths for - * the grouped relation, so run set_cheapest(). + * partial aggregation paths for the grouped relation on top + * of the paths of this rel. After that, we're done creating + * paths for the grouped relation, so run set_cheapest(). */ if (!bms_equal(joinrel->relids, root->all_query_rels)) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; rel_grouped = find_grouped_rel(root, joinrel->relids, &agg_info); diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index 359eee3486..3602dcacfa 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -360,19 +360,19 @@ setup_base_grouped_rels(PlannerInfo *root) for (rti = 1; rti < root->simple_rel_array_size; rti++) { - RelOptInfo *rel = root->simple_rel_array[rti]; - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel = root->simple_rel_array[rti]; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; /* there may be empty slots corresponding to non-baserel RTEs */ if (rel == NULL) continue; - Assert(rel->relid == rti); /* sanity check on array */ + Assert(rel->relid == rti); /* sanity check on array */ /* - * Ignore RTEs that are not simple rels. Note that we need to consider - * "other rels" here. + * Ignore RTEs that are not simple rels. Note that we need to + * consider "other rels" here. */ if (!IS_SIMPLE_REL(rel)) continue; @@ -1366,8 +1366,8 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, static void set_grouped_rel_pathlist(PlannerInfo *root, RelOptInfo *rel) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; /* Add paths to the grouped base relation if one exists. */ rel_grouped = find_grouped_rel(root, rel->relids, @@ -3419,8 +3419,8 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, get_agg_clause_costs(root, AGGSPLIT_INITIAL_SERIAL, &agg_costs); /* - * Determine whether it's possible to perform sort-based implementations of - * grouping. + * Determine whether it's possible to perform sort-based implementations + * of grouping. */ can_sort = grouping_is_sortable(agg_info->group_clauses); @@ -3481,9 +3481,9 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, int presorted_keys; /* - * Since the path originates from the non-grouped relation which is - * not aware of eager aggregation, we must ensure that it provides - * the correct input for the partial aggregation. + * Since the path originates from the non-grouped relation which + * is not aware of eager aggregation, we must ensure that it + * provides the correct input for the partial aggregation. */ path = (Path *) create_projection_path(root, rel_grouped, @@ -3527,8 +3527,8 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, } /* - * qual is NIL because the HAVING clause cannot be evaluated until the - * final value of the aggregate is known. + * qual is NIL because the HAVING clause cannot be evaluated until + * the final value of the aggregate is known. */ path = (Path *) create_agg_path(root, rel_grouped, @@ -3558,9 +3558,9 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, int presorted_keys; /* - * Since the path originates from the non-grouped relation which is - * not aware of eager aggregation, we must ensure that it provides - * the correct input for the partial aggregation. + * Since the path originates from the non-grouped relation which + * is not aware of eager aggregation, we must ensure that it + * provides the correct input for the partial aggregation. */ path = (Path *) create_projection_path(root, rel_grouped, @@ -3605,8 +3605,8 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, } /* - * qual is NIL because the HAVING clause cannot be evaluated until the - * final value of the aggregate is known. + * qual is NIL because the HAVING clause cannot be evaluated until + * the final value of the aggregate is known. */ path = (Path *) create_agg_path(root, rel_grouped, @@ -3628,12 +3628,12 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, */ if (can_hash && cheapest_total_path != NULL) { - Path *path; + Path *path; /* * Since the path originates from the non-grouped relation which is - * not aware of eager aggregation, we must ensure that it provides - * the correct input for the partial aggregation. + * not aware of eager aggregation, we must ensure that it provides the + * correct input for the partial aggregation. */ path = (Path *) create_projection_path(root, rel_grouped, @@ -3641,8 +3641,8 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, agg_info->agg_input); /* - * qual is NIL because the HAVING clause cannot be evaluated until - * the final value of the aggregate is known. + * qual is NIL because the HAVING clause cannot be evaluated until the + * final value of the aggregate is known. */ path = (Path *) create_agg_path(root, rel_grouped, @@ -3663,12 +3663,12 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, */ if (can_hash && cheapest_partial_path != NULL) { - Path *path; + Path *path; /* * Since the path originates from the non-grouped relation which is - * not aware of eager aggregation, we must ensure that it provides - * the correct input for the partial aggregation. + * not aware of eager aggregation, we must ensure that it provides the + * correct input for the partial aggregation. */ path = (Path *) create_projection_path(root, rel_grouped, @@ -3676,8 +3676,8 @@ generate_grouped_paths(PlannerInfo *root, RelOptInfo *rel_grouped, agg_info->agg_input); /* - * qual is NIL because the HAVING clause cannot be evaluated until - * the final value of the aggregate is known. + * qual is NIL because the HAVING clause cannot be evaluated until the + * final value of the aggregate is known. */ path = (Path *) create_agg_path(root, rel_grouped, @@ -3880,14 +3880,14 @@ standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels) /* * Except for the topmost scan/join rel, consider generating - * partial aggregation paths for the grouped relation on top of the - * paths of this rel. After that, we're done creating paths for - * the grouped relation, so run set_cheapest(). + * partial aggregation paths for the grouped relation on top of + * the paths of this rel. After that, we're done creating paths + * for the grouped relation, so run set_cheapest(). */ if (!bms_equal(rel->relids, root->all_query_rels)) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; rel_grouped = find_grouped_rel(root, rel->relids, &agg_info); @@ -4777,8 +4777,8 @@ generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel) rel->top_parent_relids : rel->relids, root->all_query_rels)) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; rel_grouped = find_grouped_rel(root, child_rel->relids, &agg_info); diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 78a88c9d3b..23bbef15f0 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -905,12 +905,12 @@ make_grouped_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, RelOptInfo *joinrel, SpecialJoinInfo *sjinfo, List *restrictlist) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info = NULL; - RelOptInfo *rel1_grouped; - RelOptInfo *rel2_grouped; - bool rel1_empty; - bool rel2_empty; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info = NULL; + RelOptInfo *rel1_grouped; + RelOptInfo *rel2_grouped; + bool rel1_empty; + bool rel2_empty; /* * If there are no aggregate expressions or grouping expressions, eager @@ -975,9 +975,9 @@ make_grouped_join_rel(PlannerInfo *root, RelOptInfo *rel1, /* * Join of two grouped relations is currently not supported. In such a * case, grouping of one side would change the occurrence of the other - * side's aggregate transient states on the input of the final aggregation. - * This can be handled by adjusting the transient states, but it's not - * worth the effort for now. + * side's aggregate transient states on the input of the final + * aggregation. This can be handled by adjusting the transient states, but + * it's not worth the effort for now. */ if (!rel1_empty && !rel2_empty) return; @@ -989,6 +989,7 @@ make_grouped_join_rel(PlannerInfo *root, RelOptInfo *rel1, sjinfo, restrictlist); populate_joinrel_with_paths(root, rel1_grouped, rel2, rel_grouped, sjinfo, restrictlist); + /* * It shouldn't happen that we have marked rel1_grouped as dummy in * populate_joinrel_with_paths due to provably constant-false join @@ -1003,6 +1004,7 @@ make_grouped_join_rel(PlannerInfo *root, RelOptInfo *rel1, sjinfo, restrictlist); populate_joinrel_with_paths(root, rel1, rel2_grouped, rel_grouped, sjinfo, restrictlist); + /* * It shouldn't happen that we have marked rel2_grouped as dummy in * populate_joinrel_with_paths due to provably constant-false join diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c index 9f05edfbac..f093ef0f13 100644 --- a/src/backend/optimizer/plan/initsplan.c +++ b/src/backend/optimizer/plan/initsplan.c @@ -430,9 +430,9 @@ create_agg_clause_infos(PlannerInfo *root) } /* - * Aggregates within the HAVING clause need to be processed in the same way - * as those in the targetlist. Note that HAVING can contain Aggrefs but - * not WindowFuncs. + * Aggregates within the HAVING clause need to be processed in the same + * way as those in the targetlist. Note that HAVING can contain Aggrefs + * but not WindowFuncs. */ if (root->parse->havingQual != NULL) { @@ -504,10 +504,10 @@ create_grouping_expr_infos(PlannerInfo *root) SortGroupClause *sgc = lfirst_node(SortGroupClause, lc); TargetEntry *tle = get_sortgroupclause_tle(sgc, root->processed_tlist); TypeCacheEntry *tce; - Oid equalimageproc; - Oid eq_op; - List *eq_opfamilies; - Oid btree_opfamily; + Oid equalimageproc; + Oid eq_op; + List *eq_opfamilies; + Oid btree_opfamily; Assert(tle->ressortgroupref > 0); @@ -518,11 +518,11 @@ create_grouping_expr_infos(PlannerInfo *root) return; /* - * Eager aggregation is only possible if equality of grouping keys - * per the equality operator implies bitwise equality. Otherwise, if - * we put keys of different byte images into the same group, we lose - * some information that may be needed to evaluate join clauses above - * the pushed-down aggregate node, or the WHERE clause. + * Eager aggregation is only possible if equality of grouping keys per + * the equality operator implies bitwise equality. Otherwise, if we + * put keys of different byte images into the same group, we lose some + * information that may be needed to evaluate join clauses above the + * pushed-down aggregate node, or the WHERE clause. * * For example, the NUMERIC data type is not supported because values * that fall into the same group according to the equality operator diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index b69efb3cd1..72a45f1b01 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -4084,8 +4084,8 @@ create_ordinary_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, /* * Now choose the best path(s) for partially_grouped_rel. * - * Note that the non-partial paths can come either from the Gather above or - * from eager aggregation. + * Note that the non-partial paths can come either from the Gather above + * or from eager aggregation. */ if (partially_grouped_rel && partially_grouped_rel->pathlist) set_cheapest(partially_grouped_rel); @@ -7245,8 +7245,8 @@ create_partial_grouping_paths(PlannerInfo *root, /* * It is possible that the partially_grouped_rel created by eager - * aggregation is dummy. In this case we just set it to NULL. It might be - * created again by the following logic if possible. + * aggregation is dummy. In this case we just set it to NULL. It might + * be created again by the following logic if possible. */ if (partially_grouped_rel && IS_DUMMY_REL(partially_grouped_rel)) partially_grouped_rel = NULL; diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c index 08de77d439..27ac853c0a 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -542,7 +542,7 @@ adjust_appendrel_attrs_mutator(Node *node, if (oldtarget->sortgrouprefs) { - Size nbytes = list_length(oldtarget->exprs) * sizeof(Index); + Size nbytes = list_length(oldtarget->exprs) * sizeof(Index); newtarget->exprs = (List *) adjust_appendrel_attrs_mutator((Node *) oldtarget->exprs, diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index 91013e1a80..55ff082b9b 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -47,7 +47,7 @@ typedef struct RelInfoEntry { Relids relids; /* hash key --- MUST BE FIRST */ void *data; -} RelInfoEntry; +} RelInfoEntry; static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *input_rel, @@ -435,13 +435,13 @@ RelOptInfo * build_simple_grouped_rel(PlannerInfo *root, int relid, RelAggInfo **agg_info_p) { - RelOptInfo *rel_plain; - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_plain; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; /* - * We should have available aggregate expressions and grouping expressions, - * otherwise we cannot reach here. + * We should have available aggregate expressions and grouping + * expressions, otherwise we cannot reach here. */ Assert(root->agg_clause_list != NIL); Assert(root->group_expr_list != NIL); @@ -481,7 +481,7 @@ build_simple_grouped_rel(PlannerInfo *root, int relid, RelOptInfo * build_grouped_rel(PlannerInfo *root, RelOptInfo *rel_plain) { - RelOptInfo *rel_grouped; + RelOptInfo *rel_grouped; rel_grouped = makeNode(RelOptInfo); memcpy(rel_grouped, rel_plain, sizeof(RelOptInfo)); @@ -2672,13 +2672,13 @@ create_rel_agg_info(PlannerInfo *root, RelOptInfo *rel) /* * If this is a child rel, the grouped rel for its parent rel must have - * been created if it can. So we can just use parent's RelAggInfo if there - * is one, with appropriate variable substitutions. + * been created if it can. So we can just use parent's RelAggInfo if + * there is one, with appropriate variable substitutions. */ if (IS_OTHER_REL(rel)) { - RelOptInfo *rel_grouped; - RelAggInfo *agg_info; + RelOptInfo *rel_grouped; + RelAggInfo *agg_info; Assert(!bms_is_empty(rel->top_parent_relids)); rel_grouped = find_grouped_rel(root, rel->top_parent_relids, &agg_info); @@ -2761,8 +2761,8 @@ create_rel_agg_info(PlannerInfo *root, RelOptInfo *rel) * Initialize the SortGroupClause. * * As the final aggregation will not use this grouping expression, - * we don't care whether sortop is < or >. The value of nulls_first - * should not matter for the same reason. + * we don't care whether sortop is < or >. The value of + * nulls_first should not matter for the same reason. */ cl->tleSortGroupRef = ++sortgroupref; get_sort_group_operators(var->vartype, @@ -2826,7 +2826,7 @@ create_rel_agg_info(PlannerInfo *root, RelOptInfo *rel) foreach(lc, root->agg_clause_list) { AggClauseInfo *ac_info = lfirst_node(AggClauseInfo, lc); - Aggref *aggref; + Aggref *aggref; Assert(IsA(ac_info->aggref, Aggref)); @@ -2848,8 +2848,8 @@ create_rel_agg_info(PlannerInfo *root, RelOptInfo *rel) result->agg_input = agg_input; /* - * The number of aggregation input rows is simply the number of rows of the - * non-grouped relation, which should have been estimated by now. + * The number of aggregation input rows is simply the number of rows of + * the non-grouped relation, which should have been estimated by now. */ result->input_rows = rel->rows; @@ -2920,7 +2920,8 @@ eager_aggregation_possible_for_relation(PlannerInfo *root, RelOptInfo *rel) Assert(IsA(ac_info->aggref, Aggref)); /* - * Give up if any aggregate needs relations other than the current one. + * Give up if any aggregate needs relations other than the current + * one. * * If the aggregate needs the current rel plus anything else, then the * problem is that grouping of the current relation could make some @@ -3012,7 +3013,7 @@ init_grouping_targets(PlannerInfo *root, RelOptInfo *rel, } else { - bool safe_to_push; + bool safe_to_push; if (is_var_needed_by_join(root, (Var *) expr, rel, &safe_to_push)) { @@ -3024,17 +3025,17 @@ init_grouping_targets(PlannerInfo *root, RelOptInfo *rel, return false; /* - * The expression is needed for a join, however it's neither in - * the GROUP BY clause nor can it be derived from it using EC. - * (Otherwise it would have already been added to the targets - * above.) We need to construct a special SortGroupClause for - * this expression. + * The expression is needed for a join, however it's neither + * in the GROUP BY clause nor can it be derived from it using + * EC. (Otherwise it would have already been added to the + * targets above.) We need to construct a special + * SortGroupClause for this expression. * * Note that its tleSortGroupRef needs to be unique within * agg_input, so we need to postpone creation of this * SortGroupClause until we're done with the iteration of - * rel->reltarget->exprs. And it makes sense for the caller to - * do some more checks before it starts to create those + * rel->reltarget->exprs. And it makes sense for the caller + * to do some more checks before it starts to create those * SortGroupClauses. */ *group_exprs_extra_p = lappend(*group_exprs_extra_p, expr); @@ -3045,9 +3046,9 @@ init_grouping_targets(PlannerInfo *root, RelOptInfo *rel, * Another reason we might need this variable is that some * aggregate pushed down to this relation references it. In * such a case, add it to "agg_input", but not to "target". - * However, if the aggregate is not the only reason for the var - * to be in the target, some more checks need to be performed - * below. + * However, if the aggregate is not the only reason for the + * var to be in the target, some more checks need to be + * performed below. */ add_new_column_to_pathtarget(agg_input, expr); } @@ -3101,8 +3102,8 @@ init_grouping_targets(PlannerInfo *root, RelOptInfo *rel, * expression but not referenced by any join. * * If the eager aggregation will support generic grouping - * expression in the future, create_rel_agg_info() will have to add - * this variable to "agg_input" target and also add the whole + * expression in the future, create_rel_agg_info() will have to + * add this variable to "agg_input" target and also add the whole * generic expression to "target". */ return false; @@ -3128,7 +3129,7 @@ is_var_in_aggref_only(PlannerInfo *root, Var *var) foreach(lc, root->agg_clause_list) { AggClauseInfo *ac_info = lfirst_node(AggClauseInfo, lc); - List *vars; + List *vars; Assert(IsA(ac_info->aggref, Aggref)); @@ -3188,9 +3189,9 @@ is_var_needed_by_join(PlannerInfo *root, Var *var, RelOptInfo *rel, attno = var->varattno - baserel->min_attr; /* - * If the baserel this Var belongs to can be nulled by outer joins that are - * above the current rel, then it is not safe to use this Var as a grouping - * key at current rel level. + * If the baserel this Var belongs to can be nulled by outer joins that + * are above the current rel, then it is not safe to use this Var as a + * grouping key at current rel level. */ *safe_to_push = bms_is_subset(baserel->nulling_relids, rel->relids); diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h index 4ce70f256d..e32d96769c 100644 --- a/src/include/nodes/pathnodes.h +++ b/src/include/nodes/pathnodes.h @@ -291,7 +291,7 @@ struct PlannerInfo * join_rel_list is a list of all join-relation RelOptInfos we have * considered in this planning run. */ - RelInfoList *join_rel_list; /* list of join-relation RelOptInfos */ + RelInfoList *join_rel_list; /* list of join-relation RelOptInfos */ /* * When doing a dynamic-programming-style join search, join_rel_level[k] @@ -435,7 +435,7 @@ struct PlannerInfo * Upper-rel RelOptInfos. Use fetch_upper_rel() to get any particular * upper rel. */ - RelInfoList upper_rels[UPPERREL_FINAL + 1] pg_node_attr(read_write_ignore); + RelInfoList upper_rels[UPPERREL_FINAL + 1] pg_node_attr(read_write_ignore); /* * list of grouped relation RelAggInfos. One instance of RelAggInfo per @@ -1147,10 +1147,10 @@ typedef struct RelAggInfo struct PathTarget *agg_input; /* estimated number of input tuples for the grouped paths */ - Cardinality input_rows; + Cardinality input_rows; - /* estimated number of result tuples of the grouped relation*/ - Cardinality grouped_rows; + /* estimated number of result tuples of the grouped relation */ + Cardinality grouped_rows; /* a list of SortGroupClause's */ List *group_clauses; diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index e6c1caf649..4019a5fee9 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -41,6 +41,7 @@ AfterTriggersTableData AfterTriggersTransData Agg AggClauseCosts +AggClauseInfo AggInfo AggPath AggSplit @@ -1058,6 +1059,7 @@ GrantTargetType Group GroupByOrdering GroupClause +GroupExprInfo GroupPath GroupPathExtraData GroupResultPath @@ -2364,12 +2366,14 @@ ReindexObjectType ReindexParams ReindexStmt ReindexType +RelAggInfo RelFileLocator RelFileLocatorBackend RelFileNumber RelIdCacheEnt RelInfo RelInfoArr +RelInfoList RelMapFile RelMapping RelOptInfo -- 2.43.0