Fixed testing instruction in readme

Dropped connection's encode/decode methods

Added hacking info to readme

tox definitions and tools configurations tweaked to work out of the box.

Close #3

Added connection autocommit

Added automatic transaction start

Reduce loaders selection time a bit

Fixed loaders bookkeeping

Tweaking to fethcmany/all in Python code

Cache the result of the query mangling

Code refactored so that only the PostgresQuery object is exposed
and mangling doesn't use the variables as input so it can be cached.

Fixed linter errors found by new flake8 version

Fixed isBusy/getResult loop

Missing a continuation which would have likely lead to block.

Added generators implementation in cython

Generators types moved to proto module

No need to store a generic c encoder

The only one we care about is utf-8, the only other available is ascii,
but in case of ascii we don't decode and return the bytes.

Utf8 decoding optimized

Ignore profile files

Added a few module headers

RowLoader moved from adapt to transform module

It's only used by the Transformer and it doesn't need to be exposed.

Optimized dumpers registration moved to own modules

Dropped some of the function signatures from the .pyd files as they are
not used cross-module.

Test both the c and the python implementation on tox

Skip hostaddr test with libpq < 12 too for the moment

mypy test on setup.py dropped

Types info for distutils are utterly broken.

Include cython in the sdist package

Also fixed everything else that should be needed to test the C
implementation on travis.

Dropped utils.typing in favour of proto package

Added protocol for different implementations of Transform

mypy passes all the ckecks.

Dropped unknown loader, using text/bytea ones

Added c bytea loaders

Added proper binary integer decoding in cython

Added mapping from python Loader to C and context extraction

RowLoader definition shared into adapt

Baby steps registering c optimised adapters

Just registered some so far, not using the map yet

Keep pq_cython as an extension separate from the rest

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.