I used a copy of Citus' CONTRIBUTING.md as a starting point.

I removed sections that are not relevant to pgcopydb, and added some
more sections about documentation and running tests.

I also added references to the CONTRIBUTING.md file in the README.md and
in documentation page about installing pgcopydb. While I was at it, I
also removed the outdated installation instructions from the README.md
file, and replaced them with a reference to the documentation page.

Co-authored-by: Dimitri Fontaine <dim@tapoueh.org>

The copy-db command is deprecated and will get removed from pgcopydb on
next release, please upgrade your scripts and integrations.

Apologies for such a small edit.
Always leave things better than you found them!

* Fix typo: ther -> the

* Consistent casing in help messages

* Update versions in docs to latest

* Consistent forked process names in design docs

* Update package list in rockylinux

* Fix indentation in pgcopydb help message

* Fix typo: Create and exports -> Create and export

* Update some version outputs

* Fix typo

* Update version output using official docker image

* Release v0.12.

* Fix a warning found by debian C compiler.

* A round of documentation updates.

* Improve section about pgcopydb stream commands being for unit testing.

Some of those commands are not for testing only, not anymore. Document that,
and link to detailed examples that have been added to the main pgcopydb
clone --follow documentation.

* A pass at improving pgcopydb docs.

* Add coverage for the new filtering commands.

* pgcopydb copy blobs

New command to support copying large objects from the source to the target
database instances, in a streaming fashion: we avoid spilling the large
object data to disk altogether.

* Integrate an auxiliary process in the main table-data part.

Now the large objects are automatically copied over from the source to the
target database. The concurrency is limited to 1 by the way the code is
written at the moment.

These options are passed through to the pg_restore command and might be
useful when dealing with no-superuser access on the target database
instance, which is common in hosted Postgres environments.

We have to implement direct SQL support for the sequences as there is no way
to convince pg_dump to take care of the sequences without also taking care
of the whole DATA section, which includes TABLE DATA and blobs.

Those commands allow for running individual steps of the main command in
isolation. That should be useful to debug operations, or in some advanced
use cases when just one of the steps is required.

The new commands make more sense now. We got rid of the non-implemented
per-table operation modes that aren't interesting anyway, and implement
actually interesting sub-commands now with the schema manipulation bits.

  pgcopydb
    copy-db  Copy an entire database from source to target
  + dump     Dump database objects from a Postgres instance
  + restore  Restore database objects into a Postgres instance
  + list     List database objects from a Postgres instance
    help     print help message
    version  print pgcopydb version

  pgcopydb dump
    schema     Dump source database schema as custom files in target directory
    pre-data   Dump source database pre-data schema as custom files in target directory
    post-data  Dump source database post-data schema as custom files in target directory

  pgcopydb restore
    schema     Restore a database schema from custom files to target database
    pre-data   Restore a database pre-data schema from custom file to target database
    post-data  Restore a database post-data schema from custom file to target database

  pgcopydb list
    tables   List all the source tables to copy data from
    indexes  List all the indexes to create again after copying the data

Makes it easier to read and makes the env support possible to discover while
waiting for the proper documentation and manual pages to show up.

It's far simpler to use the COPY protocol here compared to maybe running
subprocesses with a pipe for pg_dump | pg_restore as initially planned. Also
the buffering is all up to Postgres' copy API, so the code is still pretty
simple overall.