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

Adaptation context reworked

Don't use a sequence of dictionaries, but a single copy-on-write
structure, which is cheaper to explore.

Added a protocol representing all the objects that can be used as
adaptation context in order to avoid cascades of isinstance.

The difference in behaviour is that changing global adapters doesn't
affect already created connections which had been customised, and likely
customised cursors are not affected by global and connection changes.
The utility of the previous behaviour doesn't seem anything on which
people would build an empire on, the new behaviour is good as well.

Dropped unused Transformer attribute

Dropped tox from dev requirements

Prepared statements management moved to a purpose class

The function to maintain prepared statements is no more a generator

Just generate the necessary statements, yield will happen only if
necessary.

Dropped "unknown loader", use the text loader for everything

Register the C implementation on all the types where it is useful.

Implement fetch* not in term of iter

Shave some time on lists reallocation, but especially avoid going
through __aiter__ on async, because profiling showed some 20% of the
time spent there.

This makes me rethink the entire giving async interface for things that are
already on the client side. Feels like that, in order to implement server-side
cursor, we are shedding speed on the common use of async connections.

Exclude .pyx files from sdist package

This way install only depends on the .c files compiled by us.

Merge branch 'ctypes-reorganisation'

Fixed typos in cython

Dropped 'impl' alias for libpq in cython

psycopg3_c packages moved closer to where they are used

Things were compiling well because everything goes into the same namespace.

Other psycopg3_c.pq_cython objects split in modules

Further PGconn code moving and stricter declarations

PGconn code moved to pq directory

Dropped __init__ file from types, which is not a package

Use a strict PGconn type on Escaping.__init__ definition definition

Escaping code moved to psycopg3_c/pq dir

libpq cython declarations moved to psycopg3_c/pq package

Merge branch 'prepared-statements'

Added note to remember to review preparation in executemany

Added documentation for prepared statements

PostgresQuery const initialisation moved to the class

Use text oid for text/unknown types on PG 9.6

This creates a difference between PG 96 and >= 10 as in the latter less
casts are required. However unknown oid cannot be used to prepare queries
in PG 9.6.

Added first implementation of prepared statements support

Implement connection/cursor procedures as generators

Generators are common to both sync and async code so there is much less
code duplication, which will be useful in the light of doing more
complex things such as prepared transactions.

As a side effect of the refactoring, operations on closed connections
are raised as OperationalError rather than InterfaceError because
connection closure may depend on external factors.

Dropped fd from PQGen stream: the having the fd in the middle of the
`Ready` values made more difficult to chain more than one operation in
the same generator. The fd is not passed as extra parameter.

Register automatically the array loader on all the builtins

Also added reg* types to the known builtins. This way regtype[] is
loaded as a list of strings.

Better use of Cython public properties

Enable cython faster call convention

Release the gil around functions known to be slow

Profiling some time ago showed that these functions take relevant time.
Other paths will be reviewed.

https://www.varrazzo.com/blog/2020/05/19/a-trip-into-optimisation/

Added website to sponsors file

Added @postgrespro sponsor!

Thank you Oleg!

Added _oid C attribute to CDumper

Reduce re-allocations in objects quoting

Fixed broken previous commit

escape_string, escape_identifier use buffers too

Make wider use of Composite.as_bytes

Added buffer object to wrap libpq memory

Several code paths extended to deal with objects implementing the buffer
protocol instead of just bytes: this allows to perform less memory copy.

Added sql.Composable.as_bytes method to use in preference of as_string
(you may do without decoding altogether).

Added bytearray and memoryview dumpers

Also manage these objects when they rich the libp param passing.

Dropped use of a couple of constants in json

Added docs about string/binary adaptation

Sponsorship by @commandprompt - Thank you very much @jdatcmd

Added @mailupinc sponsor. Thank you!

Sponsorship by @phenopolis from @pontikos

Thank you very much, Niko!

Updated sponsorship by @gporcari @genropy

Grazie tantissime, Giovanni!

Backers file converted to yaml

It will be displayed at https://www.psycopg.org/sponsors/

Added several range tests and fixed a pasto error

Merge branch 'range-adaptation'

Added range type fetching and registration

Fixed quoting of [ ] chars for range types: unlike for composite they
need quoting.

Fetch/register composite made methods of a CompositeInfo class.