git.postgresql.org Git - postgresql.git/commitdiff

diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c

index c746c2319c3fff2c9be7d16840085ff9c8455aaf..ab22b271d339ac300fe7c7839dafaa256584280b 100644 (file)

--- a/contrib/btree_gist/btree_ts.c

+++ b/contrib/btree_gist/btree_ts.c

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

index 8105a3b03507da77ea989991acfaaff970dddbad..70b3794325b535306488643da52069221587b10f 100644 (file)

--- a/contrib/btree_gist/btree_utils_var.c

+++ b/contrib/btree_gist/btree_utils_var.c

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

index 113c66383ac36b0d71c927b8f1d36fb73e0c6ce3..a6be59ec93fbf9018787b7def9fe4dede4e5684a 100644 (file)

--- a/contrib/cube/cube.c

+++ b/contrib/cube/cube.c

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/ref/alter_role.sgml b/doc/src/sgml/ref/alter_role.sgml

index e97bf4c9d282e27da928068289230b6eac0c0453..7638817b830a1eb73ab59174591fe6eaf3378453 100644 (file)

--- a/doc/src/sgml/ref/alter_role.sgml

+++ b/doc/src/sgml/ref/alter_role.sgml

<term>CURRENT_USER</term>

<listitem>

<para>

- Alter the current user instead of an explicitely identified role.

+ Alter the current user instead of an explicitly identified role.

</para>

</listitem>

</varlistentry>

<term>SESSION_USER</term>

<listitem>

<para>

- Alter the current session user instead of an explicitely identified

+ Alter the current session user instead of an explicitly identified

role.

</para>

</listitem>

diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml

index a535e225b9e20edebbd96697741f88d2c3e109c2..59f10f08ce1b31a59bd9d0f2578690bbc779c1b1 100644 (file)

--- a/doc/src/sgml/release-9.5.sgml

+++ b/doc/src/sgml/release-9.5.sgml

<!--

2014年07月01日 [9f03ca9] Robert..: Avoid copying index tuples when building an ind..

-->

- Speed up CREATE INDEX by avoiding unneccessary memory copies (Robert Haas)

+ Speed up CREATE INDEX by avoiding unnecessary memory copies (Robert Haas)

</para>

</listitem>

-->

<para>

Allow changing of the <acronym>WAL</acronym>

- logging status of a table ater creation with <link

+ logging status of a table after creation with <link

linkend="SQL-ALTERTABLE"><command>ALTER TABLE .. SET LOGGED /

UNLOGGED</></> (Fabr&iacute;zio de Royes Mello)

</para>

diff --git a/doc/src/sgml/sources.sgml b/doc/src/sgml/sources.sgml

index aa2080742d48329d277e9766f88f9d4348b7980d..d6461ec3f2a50d16c53e5c40cbd87dae4b126205 100644 (file)

--- a/doc/src/sgml/sources.sgml

+++ b/doc/src/sgml/sources.sgml

</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/brin/brin_revmap.c b/src/backend/access/brin/brin_revmap.c

index 62d440f76b8497fee1abfa3de1079ff534ab588f..8c55f16f83836cdb42153f59afbcfa9ab47c4fd5 100644 (file)

--- a/src/backend/access/brin/brin_revmap.c

+++ b/src/backend/access/brin/brin_revmap.c

* it's not long enough.

*

* The returned buffer is also recorded in the revmap struct; finishing that

- * releases the buffer, therefore the caller needn't do it explicitely.

+ * releases the buffer, therefore the caller needn't do it explicitly.

*/

Buffer

brinLockRevmapPageForUpdate(BrinRevmap *revmap, BlockNumber heapBlk)

* Obtain and return a buffer containing the revmap page for the given heap

* page. The revmap must have been previously extended to cover that page.

* The returned buffer is also recorded in the revmap struct; finishing that

- * releases the buffer, therefore the caller needn't do it explicitely.

+ * releases the buffer, therefore the caller needn't do it explicitly.

*/

static Buffer

revmap_get_buffer(BrinRevmap *revmap, BlockNumber heapBlk)

diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c

index 045e0a780b85482e0ecaebf1f17ab7d8535a265b..94955b7e9832133af6ff62510f80ffb47dde123a 100644 (file)

--- a/src/backend/access/common/heaptuple.c

+++ b/src/backend/access/common/heaptuple.c

* 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

index 54e593d8a974d5de9b73d00ba97a57f549bd1c86..ae446653a956a3b830d18013dd5e812c13448759 100644 (file)

--- a/src/backend/access/gin/ginfast.c

+++ b/src/backend/access/gin/ginfast.c

* 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

index 4cea3f1be18d9d51cff60dff85422e7e80c27dd5..22ae31c0f878a3d8884ad621714b53a81ca355de 100644 (file)

--- a/src/backend/access/gist/gistproc.c

+++ b/src/backend/access/gist/gistproc.c

* 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:

}

/*

- * 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

index 3701d8e59d5368a664e71b32829d34180f002860..bcf987124fded27ba94c4b174ad002223fdba6c6 100644 (file)

--- a/src/backend/access/heap/heapam.c

+++ b/src/backend/access/heap/heapam.c

*

* 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.

/*

* 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

index bcce3e35d5eb8a4fff8142774d6cb2810121a8bc..6a6fc3bf11dab4a890bd8b68ad3276a5b42a19a8 100644 (file)

--- a/src/backend/access/heap/rewriteheap.c

+++ b/src/backend/access/heap/rewriteheap.c

*

* 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/access/transam/xact.c b/src/backend/access/transam/xact.c

index ae9e850a5ee3ad992c37571fb74d33489b2c9a61..56a1cb4211603284e8ba8a1a795fe751e601570a 100644 (file)

--- a/src/backend/access/transam/xact.c

+++ b/src/backend/access/transam/xact.c

* When running as a parallel worker, we place only a single

* TransactionStateData on the parallel worker's state stack, and the XID

* reflected there will be that of the *innermost* currently-active

- * subtransaction in the backend that initiated paralllelism. However,

+ * subtransaction in the backend that initiated parallelism. However,

* GetTopTransactionId() and TransactionIdIsCurrentTransactionId()

* need to return the same answers in the parallel worker as they would have

* in the user backend, so we need some additional bookkeeping.

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c

index 7069f6041102e6cb995316a3d951fe61adc0d367..d107d76a3c04d9027a19236a4138a86e73475330 100644 (file)

--- a/src/backend/optimizer/path/costsize.c

+++ b/src/backend/optimizer/path/costsize.c

/*

* 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/replication/logical/origin.c b/src/backend/replication/logical/origin.c

index c219590a9bbe29cfcc2c9526d0c347d452c9368c..b5fa3d866b4cd19ad0a8a9268067c3de5cc9bf0b 100644 (file)

--- a/src/backend/replication/logical/origin.c

+++ b/src/backend/replication/logical/origin.c

{

ereport(ERROR,

(errcode(ERRCODE_OBJECT_IN_USE),

- errmsg("replication identiefer %d is already active for pid %d",

+ errmsg("replication identifier %d is already active for pid %d",

curstate->roident, curstate->acquired_by)));

}

diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c

index 0bfeb5e3fd76cf9c1f2b134c58d4f04c494587bb..53e71dcf57f66b9f9ecf60a4ff509d6bd6d8dd4a 100644 (file)

--- a/src/backend/utils/adt/regproc.c

+++ b/src/backend/utils/adt/regproc.c

/*

* 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))

diff --git a/src/include/storage/lwlock.h b/src/include/storage/lwlock.h

index f2ff6a06f0187feb89f87e7d5b42d44645b7bdae..84a6fc7fa01c27a442e7b917cdd58eac3d803813 100644 (file)

--- a/src/include/storage/lwlock.h

+++ b/src/include/storage/lwlock.h

slock_t mutex; /* Protects LWLock and queue of PGPROCs */

uint16 tranche; /* tranche ID */

- pg_atomic_uint32 state; /* state of exlusive/nonexclusive lockers */

+ pg_atomic_uint32 state; /* state of exclusive/nonexclusive lockers */

#ifdef LOCK_DEBUG

pg_atomic_uint32 nwaiters; /* number of waiters */

#endif

dlist_head waiters; /* list of waiting PGPROCs */

#ifdef LOCK_DEBUG

- struct PGPROC *owner; /* last exlusive owner of the lock */

+ struct PGPROC *owner; /* last exclusive owner of the lock */

#endif

} LWLock;