Final pgindent + perltidy run for v10.

Author: tglsfdc

src/backend/access/hash/hashpage.c

@@ -1320,10 +1320,10 @@ _hash_splitbucket(Relation rel,
 	/*
 	 * If possible, clean up the old bucket.  We might not be able to do this
 	 * if someone else has a pin on it, but if not then we can go ahead.  This
-	 * isn't absolutely necessary, but it reduces bloat; if we don't do it now,
-	 * VACUUM will do it eventually, but maybe not until new overflow pages
-	 * have been allocated.  Note that there's no need to clean up the new
-	 * bucket.
+	 * isn't absolutely necessary, but it reduces bloat; if we don't do it
+	 * now, VACUUM will do it eventually, but maybe not until new overflow
+	 * pages have been allocated.  Note that there's no need to clean up the
+	 * new bucket.
 	 */
 	if (IsBufferCleanupOK(bucket_obuf))
 	{

src/backend/access/transam/slru.c

@@ -233,7 +233,7 @@ SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns,
 		}
 
 		/* Should fit to estimated shmem size */
-		Assert(ptr - (char *) shared  <= SimpleLruShmemSize(nslots, nlsns));
+		Assert(ptr - (char *) shared <= SimpleLruShmemSize(nslots, nlsns));
 	}
 	else
 		Assert(found);

src/backend/catalog/namespace.c

@@ -3802,14 +3802,14 @@ InitTempTableNamespace(void)
 						get_database_name(MyDatabaseId))));
 
 	/*
-	 * Do not allow a Hot Standby session to make temp tables.  Aside
-	 * from problems with modifying the system catalogs, there is a naming
+	 * Do not allow a Hot Standby session to make temp tables.  Aside from
+	 * problems with modifying the system catalogs, there is a naming
 	 * conflict: pg_temp_N belongs to the session with BackendId N on the
-	 * master, not to a hot standby session with the same BackendId.  We should not
-	 * be able to get here anyway due to XactReadOnly checks, but let's just
-	 * make real sure.  Note that this also backstops various operations that
-	 * allow XactReadOnly transactions to modify temp tables; they'd need
-	 * RecoveryInProgress checks if not for this.
+	 * master, not to a hot standby session with the same BackendId.  We
+	 * should not be able to get here anyway due to XactReadOnly checks, but
+	 * let's just make real sure.  Note that this also backstops various
+	 * operations that allow XactReadOnly transactions to modify temp tables;
+	 * they'd need RecoveryInProgress checks if not for this.
 	 */
 	if (RecoveryInProgress())
 		ereport(ERROR,

src/backend/catalog/partition.c

@@ -728,9 +728,9 @@ check_new_partition_bound(char *relname, Relation parent,
 							 errmsg("empty range bound specified for partition \"%s\"",
 									relname),
 							 errdetail("Specified lower bound %s is greater than or equal to upper bound %s.",
-								get_range_partbound_string(spec->lowerdatums),
-								get_range_partbound_string(spec->upperdatums)),
-								parser_errposition(pstate, spec->location)));
+									   get_range_partbound_string(spec->lowerdatums),
+									   get_range_partbound_string(spec->upperdatums)),
+							 parser_errposition(pstate, spec->location)));
 				}
 
 				if (partdesc->nparts > 0)

src/backend/commands/copy.c

@@ -1454,7 +1454,7 @@ BeginCopy(ParseState *pstate,
 			 */
 			if (cstate->transition_capture != NULL)
 			{
-				int		i;
+				int			i;
 
 				cstate->transition_tupconv_maps = (TupleConversionMap **)
 					palloc0(sizeof(TupleConversionMap *) *
@@ -2651,6 +2651,7 @@ CopyFrom(CopyState cstate)
 					cstate->transition_capture->tcs_map = NULL;
 				}
 			}
+
 			/*
 			 * We might need to convert from the parent rowtype to the
 			 * partition rowtype.

src/backend/commands/subscriptioncmds.c

@@ -919,9 +919,10 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
 	LWLockAcquire(LogicalRepWorkerLock, LW_SHARED);
 	subworkers = logicalrep_workers_find(subid, false);
 	LWLockRelease(LogicalRepWorkerLock);
-	foreach (lc, subworkers)
+	foreach(lc, subworkers)
 	{
 		LogicalRepWorker *w = (LogicalRepWorker *) lfirst(lc);
+
 		if (slotname)
 			logicalrep_worker_stop(w->subid, w->relid);
 		else

src/backend/commands/tablecmds.c

@@ -13509,8 +13509,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
 	 * having to construct this list again, so we request the strongest lock
 	 * on all partitions.  We need the strongest lock, because we may decide
 	 * to scan them if we find out that the table being attached (or its leaf
-	 * partitions) may contain rows that violate the partition constraint.
-	 * If the table has a constraint that would prevent such rows, which by
+	 * partitions) may contain rows that violate the partition constraint. If
+	 * the table has a constraint that would prevent such rows, which by
 	 * definition is present in all the partitions, we need not scan the
 	 * table, nor its partitions.  But we cannot risk a deadlock by taking a
 	 * weaker lock now and the stronger one only when needed.

src/backend/commands/trigger.c

@@ -2071,11 +2071,11 @@ FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc)
 {
 	if (trigdesc != NULL)
 	{
-		int		i;
+		int			i;
 
 		for (i = 0; i < trigdesc->numtriggers; ++i)
 		{
-			Trigger	   *trigger = &trigdesc->triggers[i];
+			Trigger    *trigger = &trigdesc->triggers[i];
 
 			if (trigger->tgoldtable != NULL || trigger->tgnewtable != NULL)
 				return trigger->tgname;
@@ -5253,12 +5253,12 @@ AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo,
 	 */
 	if (row_trigger && transition_capture != NULL)
 	{
-		HeapTuple original_insert_tuple = transition_capture->tcs_original_insert_tuple;
+		HeapTuple	original_insert_tuple = transition_capture->tcs_original_insert_tuple;
 		TupleConversionMap *map = transition_capture->tcs_map;
-		bool delete_old_table = transition_capture->tcs_delete_old_table;
-		bool update_old_table = transition_capture->tcs_update_old_table;
-		bool update_new_table = transition_capture->tcs_update_new_table;
-		bool insert_new_table = transition_capture->tcs_insert_new_table;;
+		bool		delete_old_table = transition_capture->tcs_delete_old_table;
+		bool		update_old_table = transition_capture->tcs_update_old_table;
+		bool		update_new_table = transition_capture->tcs_update_new_table;
+		bool		insert_new_table = transition_capture->tcs_insert_new_table;;
 
 		if ((event == TRIGGER_EVENT_DELETE && delete_old_table) ||
 			(event == TRIGGER_EVENT_UPDATE && update_old_table))

src/backend/commands/vacuumlazy.c

@@ -529,11 +529,11 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats,
 	 * safely set for relfrozenxid or relminmxid.
 	 *
 	 * Before entering the main loop, establish the invariant that
-	 * next_unskippable_block is the next block number >= blkno that we
-	 * can't skip based on the visibility map, either all-visible for a
-	 * regular scan or all-frozen for an aggressive scan.  We set it to
-	 * nblocks if there's no such block.  We also set up the skipping_blocks
-	 * flag correctly at this stage.
+	 * next_unskippable_block is the next block number >= blkno that we can't
+	 * skip based on the visibility map, either all-visible for a regular scan
+	 * or all-frozen for an aggressive scan.  We set it to nblocks if there's
+	 * no such block.  We also set up the skipping_blocks flag correctly at
+	 * this stage.
 	 *
 	 * Note: The value returned by visibilitymap_get_status could be slightly
 	 * out-of-date, since we make this test before reading the corresponding

src/backend/executor/execProcnode.c

@@ -411,9 +411,9 @@ ExecProcNodeFirst(PlanState *node)
 	/*
 	 * Perform stack depth check during the first execution of the node.  We
 	 * only do so the first time round because it turns out to not be cheap on
-	 * some common architectures (eg. x86).  This relies on the assumption that
-	 * ExecProcNode calls for a given plan node will always be made at roughly
-	 * the same stack depth.
+	 * some common architectures (eg. x86).  This relies on the assumption
+	 * that ExecProcNode calls for a given plan node will always be made at
+	 * roughly the same stack depth.
 	 */
 	check_stack_depth();