More consistent names for numeric adaptation functions

Skip flake check of the .eggs dir

Don't import Python API function from the main cpython package

Importing from there seems deprecated.

[skip ci]

Fixed import of optimized Transformer

Import it if the C module is used, not just if it's available.

Avoid creating an intermadiate tuple

We are now around 18x the basic Python performance

[skip ci] Certain type conversion are stubbed out, so tests won't pass.

An ounce faster by using an array of loaders instead of a list

Added some C decoders stubs

The speedup compared to the pure Python implementation is now 16x.

Playing around using a static definition for PQresult.

Added basic cython implementation of the Transform object

Just an about straight conversion from Python

pq objects defined as proto rather than stub

Added result to transformer, fetching data from there

Some ctypes tweaking to create better C

Small fixes to the ctypes module

Added conforming psycopg3.pq implementation in cython

Pq fixtures in their own module, report the implementation being tested.

added __impl__ constant to ctypes pq module

Minor optimizations to data fetching in the cursor

Shaved a few percents here and there out of profile indications.

Added async implementation for executemany, fetchmany, fetchall

Dropped tempenv fixture

The pytest monkeypatch fixture does it

Fixed connect parameters

Raise an error with no params, accept keywords only.

connection and cursor's close() made async

Dropped close() on __del__ for cursor: it is of no utility. The
important thing is that PGresult frees its memory and that happens at
PGresult's own __del__.

Define connection.close as asynchronous

Fixed dispatcher -> dispchar typo

Added stub for the pq package

Needed as the dynamic import of the modle confuses mypy

Added helper object to convert Python query into a Postgres query

The object helps keeping some state between preparing and executing,
useful in executemany so preparation can happen only once.

Added first implementation of executemany based on prepared queries

There's a lot of repetition here

Added async query prepare functions in pq wrapper

exec generator split in send and receive

It was actually not needed: I thought erroneously that sending prepared
statements only needed the send bit. However the change is ok and could
also clean up the types around these generator adding a generic PQGen[]
type (with different return values).

cursor.conn renamed to connection

libpq protocol generators moved to their own module

Added cursor.status property and exposing ExecStatus on the cursor

Added connection.status property

Exposing ConnStatus and TransactionStatus on the connection object.

Added .close() and .closed on connection and cursor

Added connection status check on send_query

Added test to verify pq.error_message() is sane on null args

Ensure a valid connection with escaping functions

Guard for null connections in exec functions

Added test for idempotent PGresult.clear()

reset and poll fail too if the connection is gone

More care with functions returning null in PGconn methods

ctypes stub changed: by default the function returning bytes can return
NULL. The ones which never do it are few, so these are the ones which
get special-cased.

More care in None return values from libpq result functions

Added barebone implementation of dbapi 2.0

Several methods not tested yet, fetch method not added yet to async
cursor.

Fixed some shenanigan around connection params

The libpq function return None for an invalid connection: take that into
account in the function signature and usage.

Dropped asymmetry between sync and async connection for the encoding
setter: use for both a set_client_encoding() function. This way it's
easy to keep the getter on the base class.

The big rename: adapters -> dumpers, typecasters -> loaders.

Fixed composite info query to work for pg <= 10

creating a row() on the fly caused the error "record type has not been
registered"

Added tuple text adaptation

It cannot return a record oid, Postgres is not happy to parse it, so
return it as text.

Fixed formats in query with repeated arguments

Fixed test that wasn't checking the format.

Added composite.fetch_info_async

fetchone() made async on async cursor

register_array() renamed to array.register()

Fixed registration scope of composite array adapters

Added typecasting of composite types

Added cast from varchar, bpchar, name

Note that bpchar (i.e. the output format for "char" - with quotes) and
name are always decoded, even if the db is SQL_ASCII, because these
types are mostly used in system catalogs and there should be no such
crap as unencded data there.

Added tests for all numeric types arrays

Dropped ArrayCaster, expose register_array function instead

The function only associates array_oid -> base_oid. Looking up the right
typecaster happens at cast time: this way composite adapters (record,
list) can use the caster register in the right context.

All the types for which there is an adapter gets an array caster now.

Really use the context to transform components types

It works for arrays and records, except for text arrays because the
decorator registers the TypeCaster directly, not the oid. This must
change, we need a different decorator/registration.

The Transformer is an adaptation context

Dropped cursor from Adapter, TypeCaster, Transformer. Added adapters and
casters map on Trasformer.

Solves a problem of customization in composite types: if a type is
customized now composite types containing that type use the same
customization. Also fixed a circular reference between transformer and
cursor.

Work around mypy error of Format not exposed by psycopg3.adapt

Added binary cast of record type

Added Transformer.cast_sequence() in place of cast_row()

The function is more generic and the Transformer doesn't have to wrap a
PGresult anymore.

Added text cast of records

Dropped accepting None as Transformer.cast() input

More efficient if we only accept non-null results.

Less global objects in types.array module

Added xfailing tests to remember what is left to implement

Cleanup of the array adapter algorithm

Check that arrays contain consistent objects.

Dropped spurious comment

Added adaptation of binary arrays

Added binary array adaptation for test types and some numeric types.

Consistent name of 'format' parameter

Also really use function caches in Transformer

Consistent 'src' name for the first argument of the adapters

'cls' is messy when it comes to class methods.

Added cast of binary arrays

Fixed typing typo

Adaptation context transferred to the adapters objects

Use classmethod instead of staticmethod to play better with inheritance

Added array tests for sql_ascii db and bytea

Fixed TypeCasterType and AdapterType types

The previous signature meant an instance of Adapter/TypeCaster or a function,
but we meant a class actually. The error costed some cursing and some
casting to the right type (in mypy sense, not in psyco sense)

Added wrapper for escape_bytea with no connection

Changed unescape_bytea to be a normal method. The pgconn is now
optional.

Typecaster renamed to TypeCaster

Because I have ArrayCaster, will have RangeCaster etc.

Added basic array adaptation infrastructure

Fixed names of wrapper functions

Added object to map oid and data types

Added array delimiter to the data types info

Cleanup of the encodings table and lookup

Handle sql_ascii encoding as binary

Added pq.Escaping object and bytea adaptation

Added connection.encoding

Added bytes adaptation

Added binary typecasting of int, float, bool.

'pgresult' is part of the Cursor interface

The same way 'pgconn' is a public property of the Connection.

Modules import to register builtin types moved to types package

exceptions module renamed to errors

To be part of the public interface, for compatibility with psycopg2

Module adaptation renamed to adapt

I figure out this is part of the external interface. Let's give it a
nice name.

Added text types conversion for numeric types and bools

Plenty of tests, too.

Added tests about adapters/casters selection, some fixes

- Added Transformer.cast() function;
- Can return binary results even with no input parameters;
- libpq functions accept sequences rather than lists.

Include None in AdaptContext

Using Union[None...] instead of Optional[... is a choice. None has a
meaning, it means global, not optional.

Definition with a wrong default changed into declaration

Added mypy tests on travis

Added install instruction to readme

Use == instead of is to check the Wait states

Now they are integers so is, while it works, is an implementation
detail.

Use the selectors module instead of select

Choose a better way to wait for readyness than select if available.

Also fixed an error in both sync and async waiting: don't discard the
result of send().