Add documentation for the server-side cursors

Make sue ServerCursor.execute() can be used more than once

Don't clobber error leaving a ServerCursor block with a broken connection

Add name to the ServerCursor repr()

NamedCursor renamed to ServerCursor

In psycopg2 they are not a separate class as they are in psycopg3.

They still need a mandatory name, but having a name is not their
defining trait.

Add test for all the documented NamedCursor interface

Fix docs after AsyncConnection.cursor() made non-async

AsyncConnection.cursor() is no more async

Even after implementing server-side cursors there is not really a reason
for it to be.

Close correctly named cursors in corner cases

Make sure you can use a named cursor to "steal" a portal

Add docs for Cursor.scroll()

Add scrollable tests

Add named cursor scroll

Add cursor.scroll()

Fix rownumber during iteration in named cursors

Add fetch methods to named cursors

Add Cursor.rownumber attribute

Delete the Postgres cursor when closing a named cursor

Added classes for named cursors

Only execute implemented, with a describe roundtrip to get the
portal description.

Added pgconn.send_describe_prepared, send_describe_portal

You don't want a psycoGP, no

Added set_jsonb_loads/dumps functions to customise JSON adaptation

Dropped dumps function from the Json/Jsonb wrappers.

Added JSON documentation.

Add some docs on TypeInfo and adaptation docs corrections

Expose TypeInfo objects from the `psycopg3.types` package

Register arrays using the TypeInfo object

TypeInfo and subclasses implementations moved together to a dedicated module,
sharing more uniform interface and implementation.

Allow mypy to run from root dir

Added @healthchecks, @ferpection, @abegerho to the backers file

Thank you very much :)

Detect the range oid from the subtype for non-builtins too

Add AdaptersMap.types map

Use the map from the adapters when it's needed to look up for a type
info.

Probably there are other places where to make use of it.

Add py.typed marker file to installed package

Proud to have @yougov backing us!

Fixed comment

Fixed dumping of integer ranges

Dump time and timestamp naive and tz-aware with the respective oids

Using the tz version of the data types is ok enough for most uses,
because Postgres can downgrade the type to naive, but ranges don't have
an implicit cast and the exact type of the range subtype is necessary.

Have a single Range class, not one per subtype

There are two problems here, so this doesn't work. One, which will be
solved, is to have a registry of types attached to an adaptation
context: a TODO in already several places, so this will be solved.
Before that we don't really have a way to find back e.g. the oid of a
custom range on strings starting from Range('a', 'b').

The second problem, more serious, is that Postgres doesn't cast
int4range <-> int8range and tsrange <-> tstzrange. The latter pair can
be solved with a two steps dumper choosing between tz aware and not. The
first I don't have in mind how to solve it: Given Range(1,2) I wouldn't
know if int4 or int8 should be used, and Postgres doesn't seem very
forgiving. Probably we should go unknown.

Added docs for AsyncCursor.stream()

Mypy version bumped to 0.800

Added Cursor.stream() to support fetch in single-row mode

Added a few docstrings on types registry

Run black on the builtin oids

Array dumper ligtened up

Don't fetch a string dumper on init, dropped sub_oid attribute.

Added two-steps dumpers implementation in C too

Don't require a Transformer roundtrip to choose the specific int dumper

They are static object, they require no customisation with the
connection. I don't expect anyone wanting to subclass them; if they
do they will deal with the whole 5 objects.

Added test to verify queries failing if int is dumped as int8 or numeric

I wanted these so badly.

Adapt the dumper used to the value of the objects

Added a second dispatch to allow a dumper to upgrade to a specialised
version. Currently used to dump int to the smallest Postgres type
holding that value and to dump lists of object into typed arrays.

This change allows to write queries more naturally as no ``::int`` cast
should be needed anymore e.g. in date + int or jsonb ->> int.

Only Python implementation; C version to be implemented yet.

Use prepared statements machinery for executemany

Don't use the anonymous prepared statement anymore, as it doesn't allow
to manage different types.

Copyright year bumped

egg-info dirs ignored from the root gitignore file to help ag to skpt
them.

Command used:

    ag -l copyright | xargs sed -i "s/\(.*copyright[^0-9]*\)\([0-9]\+\)\(-[0-9]\+\)\?\(.*Psycopg.*\)/\1\2-$(date +%Y)\4/I"

More uniform names for internal objects

Added tests to detect leaks on copy from

Added leak test for async cursor

Leak and correctness tests separated.

Added random tests for data copy

Declare all loaders to receive an object supporting the buffer interface

There isn't in mypy such an object, so just use `Union[bytes, bytearray,
memoryview]`

Avoid a memory copy passing data from the Transformer to the loaders.

I had started exercising this code path by adding copy tests, but after
dropping the extra copy the same path is now exercised by any select, so
I've stopped doing that.

Allow passing a list of names to copy.set_types()

Also improved TypeRegistry by recognising a type name even if includes
the array marker '[]' and added get_oid() function.

No test for this object as it's considered internal and leveraged by
several other tests, but I'm sure I will regret it.

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()