Update typedefs.list and re-run pgindent

Discussion: http://postgr.es/m/CA+TgmoaA9=1RWKtBWpDaj+sF3Stgc8sHgf5z=KGtbjwPLQVDMA@mail.gmail.com

4 files changed, 26 insertions, 24 deletions

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index d14ef31eae2..e5e29565646 100644
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -1118,7 +1118,7 @@ is_parallel_safe(PlannerInfo *root, Node *node)
 
 			foreach(l2, initsubplan->setParam)
 				context.safe_param_ids = lcons_int(lfirst_int(l2),
-											context.safe_param_ids);
+												   context.safe_param_ids);
 		}
 	}
 
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 68dee0f5010..02bbbc0647c 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -2412,7 +2412,7 @@ apply_projection_to_path(PlannerInfo *root,
 	 * workers can help project.  But if there is something that is not
 	 * parallel-safe in the target expressions, then we can't.
 	 */
-	if ((IsA(path, GatherPath) || IsA(path, GatherMergePath)) &&
+	if ((IsA(path, GatherPath) ||IsA(path, GatherMergePath)) &&
 		is_parallel_safe(root, (Node *) target->exprs))
 	{
 		/*
@@ -2421,9 +2421,9 @@ apply_projection_to_path(PlannerInfo *root,
 		 * It seems unlikely at present that there could be any other
 		 * references to the subpath, but better safe than sorry.
 		 *
-		 * Note that we don't change the parallel path's cost estimates; it might
-		 * be appropriate to do so, to reflect the fact that the bulk of the
-		 * target evaluation will happen in workers.
+		 * Note that we don't change the parallel path's cost estimates; it
+		 * might be appropriate to do so, to reflect the fact that the bulk of
+		 * the target evaluation will happen in workers.
 		 */
 		if (IsA(path, GatherPath))
 		{
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 9d35a41e221..199a2631a11 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1825,7 +1825,7 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey  partkey;
+	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
@@ -1890,8 +1890,8 @@ find_partition_scheme(PlannerInfo *root, Relation relation)
 
 	/*
 	 * Did not find matching partition scheme. Create one copying relevant
-	 * information from the relcache. We need to copy the contents of the array
-	 * since the relcache entry may not survive after we have closed the
+	 * information from the relcache. We need to copy the contents of the
+	 * array since the relcache entry may not survive after we have closed the
 	 * relation.
 	 */
 	part_scheme = (PartitionScheme) palloc0(sizeof(PartitionSchemeData));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index cb94c318a71..674cfc6b067 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -873,11 +873,11 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
 			continue;
 
 		/*
-		 * Otherwise, anything in a baserel or joinrel targetlist ought to be a
-		 * Var. Children of a partitioned table may have ConvertRowtypeExpr
-		 * translating whole-row Var of a child to that of the parent. Children
-		 * of an inherited table or subquery child rels can not directly
-		 * participate in a join, so other kinds of nodes here.
+		 * Otherwise, anything in a baserel or joinrel targetlist ought to be
+		 * a Var. Children of a partitioned table may have ConvertRowtypeExpr
+		 * translating whole-row Var of a child to that of the parent.
+		 * Children of an inherited table or subquery child rels can not
+		 * directly participate in a join, so other kinds of nodes here.
 		 */
 		if (IsA(var, Var))
 		{
@@ -901,7 +901,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
 				child_expr = (ConvertRowtypeExpr *) childvar;
 				childvar = (Var *) child_expr->arg;
 			}
-			Assert(IsA(childvar, Var) && childvar->varattno == 0);
+			Assert(IsA(childvar, Var) &&childvar->varattno == 0);
 
 			baserel = find_base_rel(root, childvar->varno);
 			ndx = 0 - baserel->min_attr;
@@ -1666,18 +1666,19 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 	partnatts = joinrel->part_scheme->partnatts;
 	joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
 	joinrel->nullable_partexprs =
-		(List **) palloc0(sizeof(List *) *partnatts);
+		(List **) palloc0(sizeof(List *) * partnatts);
 
 	/*
 	 * Construct partition keys for the join.
 	 *
 	 * An INNER join between two partitioned relations can be regarded as
-	 * partitioned by either key expression.  For example, A INNER JOIN B ON A.a =
-	 * B.b can be regarded as partitioned on A.a or on B.b; they are equivalent.
+	 * partitioned by either key expression.  For example, A INNER JOIN B ON
+	 * A.a = B.b can be regarded as partitioned on A.a or on B.b; they are
+	 * equivalent.
 	 *
 	 * For a SEMI or ANTI join, the result can only be regarded as being
-	 * partitioned in the same manner as the outer side, since the inner columns
-	 * are not retained.
+	 * partitioned in the same manner as the outer side, since the inner
+	 * columns are not retained.
 	 *
 	 * An OUTER join like (A LEFT JOIN B ON A.a = B.b) may produce rows with
 	 * B.b NULL. These rows may not fit the partitioning conditions imposed on
@@ -1686,11 +1687,12 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 	 * expressions from the OUTER side only.  However, because all
 	 * commonly-used comparison operators are strict, the presence of nulls on
 	 * the outer side doesn't cause any problem; they can't match anything at
-	 * future join levels anyway.  Therefore, we track two sets of expressions:
-	 * those that authentically partition the relation (partexprs) and those
-	 * that partition the relation with the exception that extra nulls may be
-	 * present (nullable_partexprs).  When the comparison operator is strict,
-	 * the latter is just as good as the former.
+	 * future join levels anyway.  Therefore, we track two sets of
+	 * expressions: those that authentically partition the relation
+	 * (partexprs) and those that partition the relation with the exception
+	 * that extra nulls may be present (nullable_partexprs).  When the
+	 * comparison operator is strict, the latter is just as good as the
+	 * former.
 	 */
 	for (cnt = 0; cnt < partnatts; cnt++)
 	{