v9-0010-Run-pgindent.patch

From 3f807e0601224654085f947bab5d4def3bde4fdf Mon Sep 17 00:00:00 2001
From: Richard Guo <guofenglinux@gmail.com>
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