Efficient transaction-controlled synchronous replication.
If a standby is broadcasting reply messages and we have named
one or more standbys in synchronous_standby_names then allow
users who set synchronous_replication to wait for commit, which
then provides strict data integrity guarantees. Design avoids
sending and receiving transaction state information so minimises
bookkeeping overheads. We synchronize with the highest priority
standby that is connected and ready to synchronize. Other standbys
can be defined to takeover in case of standby failure.
This version has very strict behaviour; more relaxed options
may be added at a later date.
Simon Riggs and Fujii Masao, with reviews by Yeb Havinga, Jaime
Casanova, Heikki Linnakangas and Robert Haas, plus the assistance
of many other design reviewers.

Support data-modifying commands (INSERT/UPDATE/DELETE)INWITH.
This patch implements data-modifying WITH queries according TO the
semantics that the updates ALL happen WITH the same command counter VALUE,ANDIN an unspecified ORDER. Therefore one WITH clause can't see the
effects of another, nor can the outer query see the effects other than
through the RETURNING values. And attempts to do conflicting updates will
have unpredictable results. We'll need TO document ALL that.
This commit just fixes the code; documentation updates are waiting ON
author.
Marko Tiikkaja AND Hitoshi Harada

Well, saying that on particular date someone committed patch, wouldn't be really telling. In fact various bits and pieces of underlying logic have been committed for a long time, but now we finally have some functionality visible and available to end users.

This became the case thanks to these two commits, both committed on 20th of February, by Tom Lane.

Add contrib/file_fdw foreign-data wrapper for reading files via COPY.
This is both very useful in its own right, and an important test case
for the core FDW support.
This commit includes a small refactoring of copy.c to expose its option
checking code as a separately callable function. The original patch
submission duplicated hundreds of lines of that code, which seemed pretty
unmaintainable.
Shigeru Hanada, reviewed by Itagaki Takahiro and Tom Lane

Add transaction-level advisory locks.
They share the same locking namespace with the existing session-level
advisory locks, but they are automatically released at the end of the
current transaction and cannot be released explicitly via unlock
functions.
Marko Tiikkaja, reviewed by me.

Convert Postgres arrays to Perl arrays on PL/perl input arguments
More generally, arrays are turned in Perl array references, and row and
composite types are turned into Perl hash references. This is done
recursively, in a way that's natural to every Perl programmer.
To avoid a backwards compatibility hit, the string representation of
each structure is also available if the function requests it.
Authors: Alexey Klyukin and Alex Hunsaker.
Some code cleanups by me.

Teach ALTERTABLE..SETDATATYPETO avoid SOMETABLE rewrites.WHEN the OLDTYPEISBINARY coercible TO the NEWTYPEAND the USING
clause does NOTCHANGE the COLUMN contents, we can avoid a FULLTABLE
rewrite, though any indexes ON the affected COLUMNS will still need
TO be rebuilt. This applies,FOR example,WHEN changing a VARCHARCOLUMNTO be OFTYPE text.
The prior coding assumed that the SETOF operations that force a
rewrite IS identical TO the SETOF operations that must be propagated
TOTABLES making USEOF the affected TABLE's rowtype. This is
no longer true: even though the tuples in those tables wouldn't
need TO be modified, the DATATYPECHANGE invalidate indexes built
USING those composite TYPECOLUMNS. Indexes ON the TABLE we're
actually modifying can be invalidated too, of course, but the
existing machinery is sufficient to handle that case.
Along the way, add some debugging messages that make it possible
to understand what operations ALTER TABLE is actually performing
in these cases.
Noah Misch and Robert Haas

Later on, on 15th, he committed second patch with few more cases where rewrite can be avoided.