if we already have a stronger lock due to the index's table being the
update target table of the query.  Same optimization I applied earlier
at the table level.  There doesn't seem to be much interest in the more
radical idea of not locking indexes at all, so do what we can ...

relation if it's already been locked by execMain.c as either a result
relation or a FOR UPDATE/SHARE relation.  This avoids an extra trip to
the shared lock manager state.  Per my suggestion yesterday.

< * Change NUMERIC to enforce the maximum precision, and increase it
> * Change NUMERIC to enforce the maximum precision

<   be cleared when a heap tuple is expired.  Another idea is to maintain
<   a bitmap of heap pages where all rows are visible to all backends,
<   and allow index lookups to reference that bitmap to avoid heap
<   lookups, perhaps the same bitmap we might add someday to determine
<   which heap pages need vacuuming.
>   be cleared when a heap tuple is expired.
>
>   Another idea is to maintain a bitmap of heap pages where all rows
>   are visible to all backends, and allow index lookups to reference
>   that bitmap to avoid heap lookups, perhaps the same bitmap we might
>   add someday to determine which heap pages need vacuuming.  Frequently
>   accessed bitmaps would have to be stored in shared memory.  One 8k
>   page of bitmaps could track 512MB of heap pages.

child plan nodes until we have acquired lock on the relation to scan.
The relative order of initialization of plan nodes isn't real important in
other cases, but it's critical here because one is supposed to lock a
relation before its indexes, not vice versa.  The original coding was at
least vulnerable to deadlock against DROP INDEX, and perhaps worse things.

<   the heap.  One way to allow this is to set a bit to index tuples
>   the heap.  One way to allow this is to set a bit on index tuples
<   be cleared when a heap tuple is expired.
<
>   be cleared when a heap tuple is expired.  Another idea is to maintain
>   a bitmap of heap pages where all rows are visible to all backends,
>   and allow index lookups to reference that bitmap to avoid heap
>   lookups, perhaps the same bitmap we might add someday to determine
>   which heap pages need vacuuming.

>   [merge]
378a380
>   [merge]

< * Add MERGE command that does UPDATE/DELETE, or on failure, INSERT (rules,
<   triggers?)
> * Add SQL-standard MERGE command, typically used to merge two tables
>
>   This is similar to UPDATE, then for unmatched rows, INSERT.
>   Whether concurrent access allows modifications which could cause
>   row loss is implementation independent.
>
> * Add REPLACE or UPSERT command that does UPDATE, or on failure, INSERT

Also add a retry for Unixen returning EINTR, which hasn't been reported
as an issue but at least theoretically could be.  Patch by Qingqing Zhou,
some minor adjustments by me.

Michael Fuhr.

change errno.  No reported bugs here, but why take a chance?

#2075: consider an index redundant if any of its index conditions were already
used, rather than if all of them were.  Also, make the selectivity comparison
a bit fuzzy, so that very small differences in estimated selectivities don't
skew the results.

- Made several variables "const char *" instead of "char *" as proposed by Qingqing Zhou <zhouqq@cs.toronto.edu>.
- Replaced all strdup() calls by ECPGstrdup().
- Set ecpg library version to 5.2.
- Set ecpg version to 4.2.1.

< #A hyphen, "-", marks changes that will appear in the upcoming 8.1 release.#
> #A hyphen, "-", marks changes that will appear in the upcoming 8.2 release.#

< * Remove Win32 rename/unlink looping if unnecessary

the executor.  This allows, for example, JDBC clients to use '?' bound
parameters in these commands.  Per gripe from Virag Saksena.

it's worth probing the outer relation for emptiness before building the
hash table.  To wit, if we're rescanning a join previously performed,
remember whether we found it nonempty the previous time, and don't bother
with the probe if it was nonempty.  This buys back the performance lost
in examples like Mario Weilguni's.

and IFNULL.

Backpatch to 8.1.X.

> * Allow COMMENT ON to accept an expression rather than just a string

After a proposal by Martijn van Oosterhout (not exactly his patch though).

Per suggestion from Tom Lane.

one child or the other had a problem: they did not leave the node in a
state that ExecReScanHashJoin would understand.  In particular it would
tend to fail to reset the child plans when needed.  Per report from
Mario Weilguni.

crash when analyzing tables with expressional indexes.

Per report from Frank van Vugt.

ScalarArrayOpExpr when possible, that is, whenever there is an array type
for the values of the expression list.  This completes the project I've
been working on to improve the speed of index searches with long IN lists,
as per discussion back in mid-October.

I did not force initdb, but until you do one you will see failures in the
"rules" regression test, because some of the standard system views use IN
and their compiled formats have changed.

they were broken-out AND or OR lists.  The least grotty way to do this
seemed to be to set up a general mechanism for handling nodes as though
they were ANDs or ORs.  There's no other immediate use for it, but perhaps
we might want to use the mechanism someday for things like BETWEEN
SYMMETRIC.

per buildfarm report from platypus, even though older versions let it pass.

"ctid IN (list)" will still work after we convert IN to ScalarArrayOpExpr.
Make some minor efficiency improvements while at it, such as ensuring that
multiple TIDs are fetched in physical heap order.  And fix EXPLAIN so that
it shows what's really going on for a TID scan.