findJsonbValueFromSuperHeader() primitive type ordering

Only jsonb arrays are subscriptable

uniqueifyJsonbArray() hasNonUniq coverage

Process JSON data types

Remove header includes, unneeded after refactoring

fix hstore Makefile

fix field name for estSize in hstore_to_jsonb*.

Merge branch 'master' into jsonb_and_hstore

Conflicts:
src/include/catalog/pg_amproc.h

Notes on pair deduplication

Improve checkStringLen() error message

JsonbValue.size is an estimate

Further elucidate key, value, pair differences

Extensive comments on findJsonbValueFromSuperHeader

findJsonbValueFromSuperHeaderLen() lives in jsonfuncs.c

Better findJsonbValueFromSuperHeader* assertions

Further small tweaks to compareJsonbSuperHeaderValue

Take more care within compareJsonbSuperHeaderValue().

Prior coding did not take sufficient care in using internal Jsonb type
as a tie-breaker in all situations.  The prior practice of using a
JsonbIteratorNext() return code as a tie-breaker was bogus, or was at
the very least incredibly fragile.

change oids to avoid upstream conflict with recent commit

Harmonize macro alignment

On second thought, have macros live in jsonb.h

First-draft release notes for 9.3.4.

As usual, the release notes for older branches will be made by cutting
these down, but put them up for community review first.

Update time zone data files to tzdata release 2014a.

DST law changes in Fiji, Turkey; historical changes in Israel, Ukraine.

Fix copyright year

Rename jsonb_support.c to jsonb_util.c

initdb required: Refactor hashing

Do some variability and commonality analysis among jsonb_hash and the
jsonb_hash_ops opclass.  Eliminate some redundant code.  Totally remove
the slightly dubious practice of using a CRC32 for hashing.

Clarify point in some jsonfuncs.c operator functions

The danger of this error message causing confusion is quite acute if we
assume that expressional indexing will be used extensively, because the
restriction on, say, calling the "jsonb -> text" operator only on what
jsonb internally knows to be an object effectively makes every such
expressional index a constraint on same (at least without some further
care).

Note this general risk in the documentation, too.

Delete hstore--1.2.sql

More comments on default GIN opclass

Refactor deepContains(), and move to jsonb_support.c

Tweak the deepContains() implementation. Add extensive comments where
before there were very few.

The new location seems more appropriate, and allows jsonb_ops.c to
consist only of client functions to what could broadly be classified as
"walker infrastructure" that now all lives in jsonb_support.c.

A few other jsonb_support.c tweaks are made in passing.

Similar emphasis for other containment operators

Document ? operator limitation

Fix race condition in B-tree page deletion.

In short, we don't allow a page to be deleted if it's the rightmost child
of its parent, but that situation can change after we check for it.

Problem
-------

We check that the page to be deleted is not the rightmost child of its
parent, and then lock its left sibling, the page itself, its right sibling,
and the parent, in that order. However, if the parent page is split after
the check but before acquiring the locks, the target page might become the
rightmost child, if the split happens at the right place. That leads to an
error in vacuum (I reproduced this by setting a breakpoint in debugger):

ERROR:  failed to delete rightmost child 41 of block 3 in index "foo_pkey"

We currently re-check that the page is still the rightmost child, and throw
the above error if it's not. We could easily just give up rather than throw
an error, but that approach doesn't scale to half-dead pages. To recap,
although we don't normally allow deleting the rightmost child, if the page
is the *only* child of its parent, we delete the child page and mark the
parent page as half-dead in one atomic operation. But before we do that, we
check that the parent can later be deleted, by checking that it in turn is
not the rightmost child of the grandparent (potentially recursing all the
way up to the root). But the same situation can arise there - the
grandparent can be split while we're not holding the locks. We end up with
a half-dead page that we cannot delete.

To make things worse, the keyspace of the deleted page has already been
transferred to its right sibling. As the README points out, the keyspace at
the grandparent level is "out-of-whack" until the half-dead page is deleted,
and if enough tuples with keys in the transferred keyspace are inserted, the
page might get split and a downlink might be inserted into the grandparent
that is out-of-order. That might not cause any serious problem if it's
transient (as the README ponders), but is surely bad if it stays that way.

Solution
--------

This patch changes the page deletion algorithm to avoid that problem. After
checking that the topmost page in the chain of to-be-deleted pages is not
the rightmost child of its parent, and then deleting the pages from bottom
up, unlink the pages from top to bottom. This way, the intermediate stages
are similar to the intermediate stages in page splitting, and there is no
transient stage where the keyspace is "out-of-whack". The topmost page in
the to-be-deleted chain doesn't have a downlink pointing to it, like a page
split before the downlink has been inserted.

This also allows us to get rid of the cleanup step after WAL recovery, if we
crash during page deletion. The deletion will be continued at next VACUUM,
but the tree is consistent for searches and insertions at every step.

This bug is old, all supported versions are affected, but this patch is too
big to back-patch (and changes the WAL record formats of related records).
We have not heard any reports of the bug from users, so clearly it's not
easy to bump into. Maybe backpatch later, after this has had some field
testing.

Reviewed by Kevin Grittner and Peter Geoghegan.

initdb required: GIN compare support function

Previously, the jsonb_ops GIN opclass followed the example of
gin_hstore_ops in using bttextcmp() as its support function 1.  This
makes a certain amount of sense, since the opclass storage format is
text in both cases.  However, there is no need to pay the additional
overhead of collation-aware comparisons, since the ordering of keys
serialized as text within a gin_jsonb_ops GIN B-Tree is merely an
implementation detail of no consequence to users.

In passing, perform a little diff minimization.

Remarks on GIN numeric textual storage

Prevent interrupts while reporting non-ERROR elog messages.

This should eliminate the risk of recursive entry to syslog(3), which
appears to be the cause of the hang reported in bug #9551 from James
Morton.

Arguably, the real problem here is auth.c's willingness to turn on
ImmediateInterruptOK while executing fairly wide swaths of backend code.
We may well need to work at narrowing the code ranges in which the
authentication_timeout interrupt is enabled.  For the moment, though,
this is a cheap and reasonably noninvasive fix for a field-reported
failure; the other approach would be complex and not necessarily
bug-free itself.

Back-patch to all supported branches.

Be careful about freeing memory in comparator

Use a possibly less confusing name for turning a json string into a jsonb.

Significant further JsonbIteratorNext() clean-up

Clarify issues around memory management, and the role of each of the
helper functions at each point.

Allow psql to print COPY command status in more cases.

Previously, psql would print the "COPY nnn" command status only for COPY
commands executed server-side.  Now it will print that for frontend copies
too (including \copy).  However, we continue to suppress the command status
for COPY TO STDOUT, since in that case the copy data has been routed to the
same place that the command status would go, and there is a risk of the
status line being mistaken for another line of COPY data.  Doing that would
break existing scripts, and it doesn't seem worth the benefit --- this case
seems fairly analogous to SELECT, for which we also suppress the command
status.

Kumar Rajeev Rastogi, with substantial review by Amit Khandekar

Avoid transaction-commit race condition while receiving a NOTIFY message.

Use TransactionIdIsInProgress, then TransactionIdDidCommit, to distinguish
whether a NOTIFY message's originating transaction is in progress,
committed, or aborted.  The previous coding could accept a message from a
transaction that was still in-progress according to the PGPROC array;
if the client were fast enough at starting a new transaction, it might fail
to see table rows added/updated by the message-sending transaction.  Which
of course would usually be the point of receiving the message.  We noted
this type of race condition long ago in tqual.c, but async.c overlooked it.

The race condition probably cannot occur unless there are multiple NOTIFY
senders in action, since an individual backend doesn't send NOTIFY signals
until well after it's done committing.  But if two senders commit in close
succession, it's certainly possible that we could see the second sender's
message within the race condition window while responding to the signal
from the first one.

Per bug #9557 from Marko Tiikkaja.  This patch is slightly more invasive
than what he proposed, since it removes the now-redundant
TransactionIdDidAbort call.

Back-patch to 9.0, where the current NOTIFY implementation was introduced.

Fix a couple of typos in docs.

Thom Brown

Add GIN_SEARCH_MODE_ALL test coverage

More dead code removal

Macro alignment consistency

Prefer sizeof(type)

This especially applies to memory allocation.  There were a number of
expressions that rather confusingly referenced dereferenced anonymous
struct members and things like that.

Comments on findJsonbValueFromSuperHeader()

Fix-up jsonb macros

Consistent variable naming

jsonb.h macro alignment

Remove more dead code in jsonb_exists_all()

Remove more dead code

C comments:  remove odd blank lines after #ifdef WIN32 lines

A few more

Remove dead code

gconv shows that the jbvBinary switch case within putStringConversion()
to be dead code.  This is unsurprising, as this is not one of the
contexts in which a scalar can be a binary.

C comments:  remove odd blank lines after #ifdef WIN32 lines

Remove questionable coding practices

Don't return a pointer to static memory in a couple of functions.  Just
palloc() it and be done.  There is no reason to think we're particularly
sensitive to leaking memory in the relevant contexts (although I should
revisit memory leaks within B-Tree support function 1).

Also, don't XOR togther enum constants and WJB_* constants within
JsonbIteratorNext().

Clean-up "compression walking"

This doesn't have much to do with actual compression.  It actually
concerns converting an arbitrary JsonbValue to a 4 byte uncompressed
varlena representation (i.e. a Jsonb).  So stop using the misleading
term  compression, and start calling it conversion.  Use the type system
sensibly.  Clean-up and comment the code more generally.

Introduce "superheader" abstraction

This makes it clearer how the nested structure can be interacted with
through either a varlena Jsonb buffer pointer, or a (nested) pointer to
a Jentry (which has a header...so we might be accessing that through
what is nominally a superheader pointer, and it doesn't matter).

This makes the structure of much of jsonb_support.c a lot clearer.

Correct serialize/deserialize confusion

Clarify role of dataProper

Clean up iterator struct

Only WAL-log the modified portion in an UPDATE, if possible.

When a row is updated, and the new tuple version is put on the same page as
the old one, only WAL-log the part of the new tuple that's not identical to
the old. This saves significantly on the amount of WAL that needs to be
written, in the common case that most fields are not modified.

Amit Kapila, with a lot of back and forth with me, Robert Haas, and others.

Remove unused python-style negative subscripting code

Items on GIN data pages are no longer always 6 bytes; update gincostestimate.

Also improve the comments a bit.

Show PIDs of lock holders and waiters in log_lock_waits log message.

Christian Kruse, reviewed by Kumar Rajeev Rastogi.

test_decoding: Documentation fix.

Andres Freund

Fix incorrect assertion about historical snapshots.

Also fix some nearby comments.

Andres Freund

Comment fixes related to logical decoding.

Andres Freund, per complaints by Peter Eisentraut.

Allow opclasses to provide tri-valued GIN consistent functions.

With the GIN "fast scan" feature, GIN can skip items without fetching all
the keys for them, if it can prove that they don't match regardless of
those keys. So far, it has done the proving by calling the boolean
consistent function with all combinations of TRUE/FALSE for the unfetched
keys, but since that's O(n^2), it becomes unfeasible with more than a few
keys. We can avoid calling consistent with all the combinations, if we can
tell the operator class implementation directly which keys are unknown.

This commit includes a triConsistent function for the built-in array and
tsvector opclasses.

Alexander Korotkov, with some changes by me.

Remove path separator

Minor simplification

Remove unnecessary header includes

Use hash_any(), not crc32

In WAL replay, restore GIN metapage unconditionally to avoid torn page.

We don't take a full-page image of the GIN metapage; instead, the WAL record
contains all the information required to reconstruct it from scratch. But
to avoid torn page hazards, we must re-initialize it from the WAL record
every time, even if it already has a greater LSN, similar to how normal full
page images are restored.

This was highly unlikely to cause any problems in practice, because the GIN
metapage is small. We rely on an update smaller than a 512 byte disk sector
to be atomic elsewhere, at least in pg_control. But better safe than sorry,
and this would be easy to overlook if more fields are added to the metapage
so that it's no longer small.

Reported by Noah Misch. Backpatch to all supported versions.

Trim some operator code

Relocate some support functions

Formalize enum value assert pattern

Use lengthCompareJsonbStringValue where possible.

This clarifies the role of length-based sorting, and lexical sorting.

Restructure loop

Don't incorrectly free iterators after all

Make some insufficient effort to not leak memory in bt support 1 routine

Clean up around lexical comparisons

Merge remote-tracking branch 'feodor/jsonb_and_hstore' into jsonb_and_hstore

Refactor, cleaning up mess around unique-ifying

Add hstore_to_jsonb, hstore_to_jsonb_loose functions and cast

compareJsonbStringValue is private

Made possible by last commit

Move array to jsonb sorted array function

Note on binary search

Remove == true idiom

Clean-up padding of unaligned jsonb internal types

Clean-up tree walk logic. Remove unnecessary callback.

Lose unnecessary walkUncompressedJsonbDo indirection

Remove GiST support

Given time pressures, and the fact that there is an unknown bug, it
makes sense to drop this for 9.4.

jsonb_1.out fixes missed earlier

Tweaks

JsonbIteratorGet() name and position altered.

Consistently use the term "scalar" in preference to the RFC term
"primitive" internally.

Fix from Alexander for jsonb_hash_ops @> issue

Merge branch 'master' into jsonb

Fix tracking of psql script line numbers during \copy from another place.

Commit 08146775acd8bfe0fcc509c71857abb928697171 changed do_copy() to
temporarily scribble on pset.cur_cmd_source.  That was a mighty ugly bit of
code in any case, but in particular it broke handleCopyIn's ability to tell
whether it was reading from the current script source file (in which case
pset.lineno should be incremented for each line of COPY data), or from
someplace else (in which case it shouldn't).  The former case still worked,
the latter not so much.  The visible effect was that line numbers reported
for errors in a script file would be wrong if there were an earlier \copy
that was reading anything other than inline-in-the-script-file data.

To fix, introduce another pset field that holds the file do_copy wants the
COPY code to use.  This is a little bit ugly, but less so than passing the
file down explicitly through several layers that aren't COPY-specific.

Extracted from a larger patch by Kumar Rajeev Rastogi; that patch also
changes printing of COPY command tags, which is not a bug fix and shouldn't
get back-patched.  This particular idea was from a suggestion by Amit
Khandekar, if I'm reading the thread correctly.

Back-patch to 9.2 where the faulty code was introduced.

Allow dynamic shared memory segments to be kept until shutdown.

Amit Kapila, reviewed by Kyotaro Horiguchi, with some further
changes by me.

Allow logical decoding via the walsender interface.

In order for this to work, walsenders need the optional ability to
connect to a database, so the "replication" keyword now allows true
or false, for backward-compatibility, and the new value "database"
(which causes the "dbname" parameter to be respected).

walsender needs to loop not only when idle but also when sending
decoded data to the user and when waiting for more xlog data to decode.
This means that there are now three separate loops inside walsender.c;
although some refactoring has been done here, this is still a bit ugly.

Andres Freund, with contributions from Álvaro Herrera, and further
review by me.

Teach on_exit_reset() to discard pending cleanups for dsm.

If a postmaster child invokes fork() and then calls on_exit_reset, that
should be sufficient to let it exit() without breaking anything, but
dynamic shared memory broke that by not updating on_exit_reset() to
discard callbacks registered with dynamic shared memory segments.

Per investigation of a complaint from Tom Lane.