Don't clobber the exception on rollback error in connection exit

Better integration between C copy functions and C transformer

Added copy Format helpers to handle text/binary differences

Added parallel worker to COPY FROM

Have a background writer to push data down the connection while the main
thread is CPU-bound to encode data.

Use a thread to implement the sync worker, a task to implement the
asyncio one.

End-of-copy logic moved from exit to finish gen

Added some docs about binary parameters/values.

Dropped format argument to cursor: use binary= instead

This should make pretty unneeded to import the Format object in client
code.

Define MAXINT8LEN as a constant

Dropped intermediate dumpers cache in C transformer too

Dropped intermediate C Transformer cache creating loaders

Keep in the instance cache the RowLoader instance.

Less work to create a C Transformer

Don't create a new transformer if the query is repeated on a cursor

Added reference leak test for other fetch methods

Fixed fake string creation: never create \x00 byte

Choose automatically text or binary format using %s placeholders

A format can be enforced using %b or %t placeholders.

Use binary formats dumpers if available, otherwise use text dumpers.
Python str are an exception: prefer text dumper, because it will dump
with format 0, so Postgres can cast the value to any format.

Special-case empty lists to be always dumped as textual unknown '{}' so
that Postgres can cast them into whatever array it fancies.

Transformer.dump_sequence returns a list of formats too

Added xfail to a binary empty array test

Fixing it requires reconsidering how to deal with parameters formats.

Also fixed xpass to make sure to spot the tests to fix after fixing the
above.

Dropped explicit support for Postgres 9.6

People can still use it, but they should likely disable stored procedure
on a connection and avoid to use executemany, on top of adding plenty of
cast.

Don't return None as text in Python 9.6

This makes to require a cast on pretty much any placeholder that might
receive a None, which is really asking too much.

Exploratory commit to test what can be done with PG 9.6. The result
shows that in PG 9.6 it's pretty much impossible to use prepared
statements: neither for executemany nor for preparation. Tests failing:

- tests/test_cursor.py::test_executemany_null_first
- tests/test_cursor_async.py::test_executemany_null_first
- tests/test_prepared.py::test_different_types
- tests/test_prepared_async.py::test_different_types

all with: psycopg3.errors.IndeterminateDatatype: could not determine
data type of parameter $x

Added random data generator and test for memory leaks

Only implemented for binary types, as they are less than text...

Use cdll instead of pydll in ctypes pq wrapper

cdll releases the GIL. Even for callback functions it doesn't seem a
problem.

Added [] in the representation of array columns

Added dumpers row

Speed up repeated dumps on the same query (e.g. in executemany, in copy,
for composite types).

Things are a bit iffy around empty list dumping. As a tradeoff, prefer
that empty list don't behave too differently from non-empty list, but
accept that text and binary work differently (because it doesn't seem
possible to pass an array as unknown in binary, whereas in text '{}'
works ok).

Set sub-dumper on array dumper on creation in Transformer

Fixes binary dump of empty array and other unforeseen problems such as
the same array dumper dumping lists with two different elements.

Added test to reproduce array bug found with random data

Add a reference on the ViewBuffer to the object owning the memory

Added randomisation of tests run

Fixed a test dealing with an unpredictable libpq behaviour

Finish correctly a COPY TO operation reading copy.rows()

Close #23

Added note to remember to document multiple statements + binary

Reporting pq import error improved

List all the reasons why the implementations failed to import, e.g.

```
Attempts made:
- error importing 'c' wrapper: No module named 'psycopg3_c'
- error importing 'binary' wrapper: No module named 'psycopg3_binary'
- error importing 'python' wrapper: module 'ctypes' has no attribute 'pydll'
```

Fixed raising unicode encode errors in C

Added freelist to PGresult

Added repr and slots to Json wrappers

Added comment to remember what the array structure is

Don't use Python enums in C PGconn.status

Leftover from previous cleaning.

Make cursor.query/params available after closing too

Useful to debug what went wrong with a statement after a cursor context
is exited.

Avoid local import raising exception in text encoder

Added C implementation of binary copy load

Return value of the copy read function redefined as memoryview to avoid
unneeded data copying.

Added C implementation of text copy load

Added reading row-by-row from Copy

Added result status in PGresult and Cursor repr

Further C code streamlining

Some refcount care in tight loops

Added test to verify that the C adapters are registered correctly

Return type of fetch methods improved

Fixed executemany

D'oh

Added Transformer.dump_sequence()

Don't deal with the python-level connection in C adapters

Use the libpq-level connection to shed some overhead.

Added C interface to Transformer.get_dumper

The Python churning around that call was visible.

Optimise dumping int to text

Code lifted from Postgres sources. However there is no config phase here
so it will require tweaking to work with other compilers or architectures)

Added text copy implementation in C

Accumulate lines into a buffer to send copy data in larger chunks

Work around __weakref__ + __slots__ + Generics bug on Python 3.6

See bug https://bugs.python.org/issue41451

Define better registering, importing, subclassing adapters.

- The C dumpers cannot be subclassed. Subclassing from Python makes
  difficult to use the c fast path, unless doing relatively expensive
  checks.

- C optimised classes are chosen on registration. The types module only
  exposes the Python objects, so they can be documented and subclassed.

Override adapter in the respective type modules

This way they are properly exposed to the rest of the Python code.

Note that it will need some trickery to be able to subclass them in
Python: overridden adapter will need the C fast path bypassed if
subclassing is detected.

Export C int subclasses dumpers to Python

Added guards to allow subclassing C adapters

Not sure this is the way to go though. Subclassing might be a rare
enough case to just make the classes final.

The check is implemented at instance level: it would be more efficient
to implement it at class level, however I don't know how to store class
attribute or implement metaclasses in Cython.

Don't make C types subclassable

C types are no more exposed in types, so they won't get subclassed by
final users.

Checking for subclass in adaptation is expensive, so I'd rather not do
it.

Check if a class has a matching optimised class (with the same name) at
registration time.

Dropped use of decorator to register builtin adapters

Although the registration function is unwieldy already, it's good to get
more flexibility in when it should happen.

It also convinced me that flat is better than nested so the
psycopg3.types can be the facade for all the type-related objects.

More important, it should allow to override certain objects with C
equivalents.

Added int4 C dumper

Added C float dumpers

Added C helper for binary copy formatting

Create the waiting selector only after the first wait

Sometimes there is no need to wait at all, if the generator exits on the
first result. It happens especially in copy.

Copy objects refactoring to isolate the row format function

Added c interface to dumpers

Global replace of src -> cls params and attribs

Added AdaptersMap.get_loader(), get_dumper() methods

Internal refactoring to keep separate maps for different formats rather
than using tuples as keys, both in the AdaptersMap and Transformer.

Dumper.src renamed to cls.

Using new types registration system on the C implementation too

Loder and Dumper text/binary decorator unified as "builtin"

Allow registration by builtin name too and on several arguments for
terseness.

Dropped unneeded assignment

Dropped format parameter from register

Now the loaders/dumper declare their format themselves.

Added guard for lazy import to avoid the import statement

I'm mot so sure it's always so fast to re-import.

Added Loader.format and Dumper.format

Don't convert fformat and binary_tuples to Format in C pq wrapper

Fixed binary copy with empty content

Dropped async/sync code duplication using high level generators

Use slots on PostgresQuery object

Fast-path in query preparation to skip expensive isinstance

Added slots on cursor

Added backer @MaterializeInc. Thank you :)

Merge branch 'c-optimise'

Make testable, and test, the different waiting implementation

Also fixed segfault calling flush on a closed connection.

Added epoll-based wait() implementation

Only used if the EpollSelector would (i.e. epoll is available and it's
the best thing on the menu). Saves noticeable time over the
EpollSelector as there's less Python stuff going on and can use ONESHOT
+ MOD_CTL.

More tweaks to the Transformer C code

Tweaking generators.execute C code

Use the C api to create memoryview objects

Use cython type declarations for bytes too

Use cython type declaration rather than python annotation for int

It gives directly a c variable.

Don't use enums for libpq arguments

We might want to have speed there. Enums can be returned from high-level
objects such as the Connection.info object to be implemented.

Added guard to avoid failure on __del__ of unborn connection

Set public module for PQerror

Module psycopg3_c.pq_cython renamed to psycopg3_c.pq

psycopg3_c files reorganised in directories. Still unable to split and
localise pxd files, but now it's already cleaner.

Travis keeps failing in funny ways, so skipping fork tests (they pass ok
locally).

Fixed comment after adapters refactoring

Avoid catching exceptions for dict lookup in C

Further use of the C api to reduce some cython checking

More efficient rows loading

Iterate by columns first, so that choices regarding the loader can be
done only once instead of once per row.

Added Transformer.load_rows()

There is some good optimisation to be had moving in C the two loops.

Some C optimisation of the Transformer object

Don't use a list of 2-tuples to set types, use two lists of scalars.

Optimise access to PGresult data

Access the underlying data structure instead of using the libpq
functions.

We shouldn't, but the speed increase is noticeable.

Internal functions moved out of cython class

Avoid a vpointer lookup for them

Release the gil around the exec/send libpq functions

Added guard for negative numbers in load_row

Also added a reminder to review the C implementation for performance.

Added repr of several objects

Show the underlying connection basic identification and status.

Raise a resource warning if a connection is deleted while open