Fix misc typos.

hlinnaka · hlinnaka · commit 29602295bacf · 2015-09-05T11:36:24.000+03:00
Oskari Saarenmaa. Backpatch to stable branches where applicable.
diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c
@@ -362,7 +362,7 @@ gbt_ts_penalty(PG_FUNCTION_ARGS)
 				newdbl[2];
 
 	/*
-	 * We are allways using "double" timestamps here. Precision should be good
+	 * We are always using "double" timestamps here. Precision should be good
 	 * enough.
 	 */
 	orgdbl[0] = ((double) origentry->lower);
diff --git a/contrib/btree_gist/btree_utils_var.c b/contrib/btree_gist/btree_utils_var.c
@@ -51,7 +51,7 @@ gbt_var_decompress(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(entry);
 }
 
-/* Returns a better readable representaion of variable key ( sets pointer ) */
+/* Returns a better readable representation of variable key ( sets pointer ) */
 GBT_VARKEY_R
 gbt_var_key_readable(const GBT_VARKEY *k)
 {
diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
@@ -819,7 +819,7 @@ cube_inter(PG_FUNCTION_ARGS)
 									Max(LL_COORD(b, i), UR_COORD(b, i))
 			);
 	}
-	/* continue on the higher dimemsions only present in 'a' */
+	/* continue on the higher dimensions only present in 'a' */
 	for (; i < DIM(a); i++)
 	{
 		result->x[i] = Max(0,
diff --git a/doc/src/sgml/sources.sgml b/doc/src/sgml/sources.sgml
@@ -251,7 +251,7 @@ ereport(ERROR,
    </listitem>
    <listitem>
     <para>
-     <function>errdetail_log_plural(const char *fmt_singuar, const char
+     <function>errdetail_log_plural(const char *fmt_singular, const char
      *fmt_plural, unsigned long n, ...)</function> is like
      <function>errdetail_log</>, but with support for various plural forms of
      the message.
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
@@ -807,7 +807,7 @@ heap_modify_tuple(HeapTuple tuple,
 	 * repl information, as appropriate.
 	 *
 	 * NOTE: it's debatable whether to use heap_deform_tuple() here or just
-	 * heap_getattr() only the non-replaced colums.  The latter could win if
+	 * heap_getattr() only the non-replaced columns.  The latter could win if
 	 * there are many replaced columns and few non-replaced ones. However,
 	 * heap_deform_tuple costs only O(N) while the heap_getattr way would cost
 	 * O(N^2) if there are many non-replaced columns, so it seems better to
diff --git a/src/backend/access/gin/ginfast.c b/src/backend/access/gin/ginfast.c
@@ -881,8 +881,8 @@ ginInsertCleanup(GinState *ginstate,
 												 * locking */
 
 			/*
-			 * remove readed pages from pending list, at this point all
-			 * content of readed pages is in regular structure
+			 * remove read pages from pending list, at this point all
+			 * content of read pages is in regular structure
 			 */
 			if (shiftList(index, metabuffer, blkno, stats))
 			{
diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c
@@ -578,7 +578,7 @@ gist_box_picksplit(PG_FUNCTION_ARGS)
 		 * We first consider splits where b is the lower bound of an entry.
 		 * We iterate through all entries, and for each b, calculate the
 		 * smallest possible a. Then we consider splits where a is the
-		 * uppper bound of an entry, and for each a, calculate the greatest
+		 * upper bound of an entry, and for each a, calculate the greatest
 		 * possible b.
 		 *
 		 * In the above example, the first loop would consider splits:
@@ -628,7 +628,7 @@ gist_box_picksplit(PG_FUNCTION_ARGS)
 		}
 
 		/*
-		 * Iterate over upper bound of left group finding greates possible
+		 * Iterate over upper bound of left group finding greatest possible
 		 * lower bound of right group.
 		 */
 		i1 = nentries - 1;
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
@@ -5311,7 +5311,7 @@ heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid,
  *
  * The initial tuple is assumed to be already locked.
  *
- * This function doesn't check visibility, it just inconditionally marks the
+ * This function doesn't check visibility, it just unconditionally marks the
  * tuple(s) as locked.  If any tuple in the updated chain is being deleted
  * concurrently (or updated with the key being modified), sleep until the
  * transaction doing it is finished.
@@ -5798,7 +5798,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
 			/*
 			 * NB -- some of these transformations are only valid because we
 			 * know the return Xid is a tuple updater (i.e. not merely a
-			 * locker.) Also note that the only reason we don't explicitely
+			 * locker.) Also note that the only reason we don't explicitly
 			 * worry about HEAP_KEYS_UPDATED is because it lives in
 			 * t_infomask2 rather than t_infomask.
 			 */
diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
@@ -763,9 +763,9 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
  *
  * Crash-Safety: This module diverts from the usual patterns of doing WAL
  * since it cannot rely on checkpoint flushing out all buffers and thus
- * waiting for exlusive locks on buffers. Usually the XLogInsert() covering
+ * waiting for exclusive locks on buffers. Usually the XLogInsert() covering
  * buffer modifications is performed while the buffer(s) that are being
- * modified are exlusively locked guaranteeing that both the WAL record and
+ * modified are exclusively locked guaranteeing that both the WAL record and
  * the modified heap are on either side of the checkpoint. But since the
  * mapping files we log aren't in shared_buffers that interlock doesn't work.
  *
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
@@ -931,7 +931,7 @@ cost_tidscan(Path *path, PlannerInfo *root,
 
 	/*
 	 * The TID qual expressions will be computed once, any other baserestrict
-	 * quals once per retrived tuple.
+	 * quals once per retrieved tuple.
 	 */
 	cost_qual_eval(&tid_qual_cost, tidquals, root);
 
diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c
@@ -819,7 +819,7 @@ format_operator_internal(Oid operator_oid, bool force_qualify)
 
 		/*
 		 * Would this oper be found (given the right args) by regoperatorin?
-		 * If not, or if caller explicitely requests it, we need to qualify
+		 * If not, or if caller explicitly requests it, we need to qualify
 		 * it.
 		 */
 		if (force_qualify || !OperatorIsVisible(operator_oid))

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ gbt_var_decompress(PG_FUNCTION_ARGS)`
`51`	`51`	`PG_RETURN_POINTER(entry);`
`52`	`52`	`}`
`53`	`53`
`54`		`-/* Returns a better readable representaion of variable key ( sets pointer ) */`
	`54`	`+/* Returns a better readable representation of variable key ( sets pointer ) */`
`55`	`55`	`GBT_VARKEY_R`
`56`	`56`	`gbt_var_key_readable(const GBT_VARKEY *k)`
`57`	`57`	`{`
Original file line number	Diff line number	Diff line change
`@@ -819,7 +819,7 @@ cube_inter(PG_FUNCTION_ARGS)`
`819`	`819`	`Max(LL_COORD(b, i), UR_COORD(b, i))`
`820`	`820`	`);`
`821`	`821`	`}`
`822`		`- /* continue on the higher dimemsions only present in 'a' */`
	`822`	`+ /* continue on the higher dimensions only present in 'a' */`
`823`	`823`	`for (; i < DIM(a); i++)`
`824`	`824`	`{`
`825`	`825`	`result->x[i] = Max(0,`
Original file line number	Diff line number	Diff line change
`@@ -807,7 +807,7 @@ heap_modify_tuple(HeapTuple tuple,`
`807`	`807`	`* repl information, as appropriate.`
`808`	`808`	`*`
`809`	`809`	`* NOTE: it's debatable whether to use heap_deform_tuple() here or just`
`810`		`- * heap_getattr() only the non-replaced colums. The latter could win if`
	`810`	`+ * heap_getattr() only the non-replaced columns. The latter could win if`
`811`	`811`	`* there are many replaced columns and few non-replaced ones. However,`
`812`	`812`	`* heap_deform_tuple costs only O(N) while the heap_getattr way would cost`
`813`	`813`	`* O(N^2) if there are many non-replaced columns, so it seems better to`
Original file line number	Diff line number	Diff line change
`@@ -763,9 +763,9 @@ raw_heap_insert(RewriteState state, HeapTuple tup)`
`763`	`763`	`*`
`764`	`764`	`* Crash-Safety: This module diverts from the usual patterns of doing WAL`
`765`	`765`	`* since it cannot rely on checkpoint flushing out all buffers and thus`
`766`		`- * waiting for exlusive locks on buffers. Usually the XLogInsert() covering`
	`766`	`+ * waiting for exclusive locks on buffers. Usually the XLogInsert() covering`
`767`	`767`	`* buffer modifications is performed while the buffer(s) that are being`
`768`		`- * modified are exlusively locked guaranteeing that both the WAL record and`
	`768`	`+ * modified are exclusively locked guaranteeing that both the WAL record and`
`769`	`769`	`* the modified heap are on either side of the checkpoint. But since the`
`770`	`770`	`* mapping files we log aren't in shared_buffers that interlock doesn't work.`
`771`	`771`	`*`