Force pool num_workers to be > 0

it might work with num_workers = 0, however it's not trivial, there is
some deadlock to avoid at creation time.

Allow the pool to grow

Make the pool maintenance tasks base class abstract

Delete an eventual task-pool loop in StopWorker too

Add pool docstrings

Add connection pool close()

When the pool is closed, raise an exception in the thread of the clients
already waiting and refuse new requests. Let the current request finish
anyway.

Make sure the pool can be deleted with no warning

Make sure to delete reference loops between the pool and the maintenance
tasks after they have run.

Do not raise a warning if a connection in a pool is deleted without
being closed as this is a normal condition (imagining a pool being
created as a global object).

Add pool context test

Awake the pool client outside the critical section

Reset the connection status returning it to the pool

Add basic pool functionality test for queuing and timeout

Display the name in the connection pool repr

Add ConnectionPool class sketch

It has a pool of connections alright, workers, clients waiting list.

Only minconn implemented, no maintenance thread etc. It's a start.

@logilab is backing psycopg3!

Merci beaucoup!

Welcoming @dalibo as backer

Vive la France!

Fix concurrency test

It was blocking because the committer was a too busy loop never yielding
to the other worker.

Use gather instead of wait in tests to be coro friendly

Bump mypy version

ci: get token to rebuild docs from secrets

Merge branch 'ci-gh-actions'

Yaml lint

Run leak tests with both text and binary output

At the moment the output text is actually skipped but it will run once
text input is no more xfailed.

Fix binary argument of conn.cursor() in tests

Argument 'binary' of connection.cursor() should be a bool.
This follows up on 467d20bd0315a62b4c7377d8a0b170ece08ef99c (change from
'format' to 'binary').

ci: consistent uppercase in steps titles

ci: Test with Python 3.9 and PostgreSQL 13

Test different combination of Python and Postgres in the different
implementation to cover more cases.

ci: Allow lint and test on any branch

ci: colour tests output

tox: use the github action "python" value as toxenv name

ci; Use PG* env vars to define the connection string

ci: Fix test dsn

The github runner /etc/host file is pretty broken and localhost resolves
to ipv6, so use 127.0.0.1 to connect.

ci: sort out connection to postgresql service

ci: split tests in one job for each implementation

To simplify the matrix

ci: move tests to gh actions

ci: move docs building to gh actions

ci: move lint task to gh actions

Update script to trigger docs rebuild to use travis-ci.com

Retry server-side cursor tests on del

Warnings seem unreliably to receive. Also print any eventual unexpected
warning: pytest doesn't do it automatically.

Add fixture to help retrying flaky tests

Tried to use a couple of pytest plugins for retrying but they don't work
well with asyncio.

Make the DBAPI errors appear defined in the psycopg3 module

Drop psycopg3.pq.PQerror

Use an OperationalError instead (of which PQerror was a subclass), which
is better documented.

Add doc example about how to detect a disconnection

Add Connection.fileno()

Fix return error without exception on PQsocket call of broken connection

Still some weirdness here around: the method raises an exception on my
box (both with unix and tcp socket) but it seems to raise still a valid
number on certain databases on Travis. Make sure, in the test, at least
that it is a reasonable value.

Fix documentation of Cursor.pgresult

Merge branch 'row-factory'

Add tuple_row test

Make the nametuple_row() test independent from other tests

Add test for row_factory with cursor.stream()

Optimise the cython path around the use of row_maker

Make cursor.row_factory writable

Make the row_maker non-optional

Use the `tuple` type as return value for `tuple_row()`, which has a
valid interface and can also be used in the Cython code to fast-path the
case where the tuples created internally are good enough.

Fix use of TypeInfo with connections using dict_row

Actually always use dict_row as it makes things easier (we do create a
dict out of the query to pass kwargs...)

Relax the RowFactory signature to make it accept `dict_row()` and
`namedtuple_row()` too.

Add public package attributes

They are useful to allow people to annotate programs with psycopg3 types.

Fix type specification for `namedtuple_row()`

Fix row factory docs examples

Make the row_factory attribute non-nullable

Added a `tuple_row()` factory for completeness. Note that it returns None, not
a callable, and the row_maker on the Transformer hasn't changed. The
signature of RowFactory now allows that.

This
makes simpler to specify the row_factory option on `conn.cursor()`: None
means default (the connection `row_factory`), specifying `tuple_row()`
overrides it to the normal tuplish behaviour.

Drop row_factory param from Connection.execute()

The method is not present on cursor.execute: either it's on both or on
none. Erring on the side of a less complex interface for the moment...

Add namedtuple_row row factory

Implementation for namedtuple class cache and fields name sanitizing is
taken from psycogp2.

Document row factories

We document the row_factory argument of *Connection.execute() as well as
the row_factory attribute on Connection.

We add a new page in advanced section explaining the concepts of row
factories, providing examples and documenting built-in row factories.

Fix guard for platforms missing epoll

See #34

Don't use epoll module definitions if it's not the default selector

Close #34

Move docs example statement where it makes more sense

Start a 'psycopg3.rows' module with dict_row()

Merge pull request #33 from dlax/tox-docs

add a tox environment to build the docs

Add a tox environment to build the docs

Make lru_cache usage in libpq_docs compatible with python 3.7

The "user_function" version (allowing uncalled lru_cache) is only
available since python 3.8.

Add row_factory as connection attribute and connect argument

When passing 'row_factory' to connect(), respective attribute will be
set on the connection instance. This will be used as default at cursor
creation and can be overridden with conn.cursor(row_factory=...) or
conn.execute(row_factory=...).

We use a '_null_row_factory' marker to handle None-value passed to
.cursor() or .execute() for disabling the default row factory.

Fix server-side cursors docs typos

Reported by @lelit, thank you!

Let Transformer.make_row property's setter accept None

Add tests to verify broken queries or other statements in server-side cursors

Enforce passing a single statement by making sure to use the advanced
query protocol.

Set up row maker and loaders only once in a server-side cursor lifetime

It wasn't happening once per movement, as I was fearing, but it was happening
exactly twice: once on DECLARE, once on describe_portal(). We actually
don't care about the DECLARE result: it was being set on the cursor only
to detect errors, so now that's done manually.

Fix setting row maker on nextset()

The test was broken and didn't test that the row_factory function was
really called.

Merge branch 'master' into row-factory

Merge branch 'tx-no-auto-loaders'

Don't recalculate loaders when not needed

The case it's not needed is when the new result is guaranteed to have
the same fields as the previous one. This happens querying in single-row
mode and on server-side cursors fetch.

Dropped Transformer.pgresult setter, use set_result

Can pass a boolean to tell it to skip setting row loaders

Fix fetch*() return type annotation on server-side cursors

Add tests to verify row_factory works with server-side cursors too

Merge branch 'master' into row-factory

Merge branch 'server-side-cursors'

Test server-side cursor hold

Default server-side cursor scrollable to not defined

Add documentation for the server-side cursors

Add tests for cursor's row_factory with nextset()

Add row_factory argument to connection.execute()

Move the row maker as a Transformer attribute

Instead of carrying the row maker (_make_row attribute) on the cursor
and possibly calling it to transform each row in cursor methods, we
define a 'make_row' attribute on Transformer that is possibly used in
load_row() and load_rows().

In the Python implementation of Transformer.load_rows(), we use tuple as
as make_row() when the attribute is unset.

In the Cython implementation, we make 'make_row' a plain property with a
'_make_row' attribute under the hood. We finally transform individual or
list of records using self.make_row().

Add constraints to the Row type variable

We constrain Row to be either a Tuple[Any, ...] (for the case no row
factory is in use) or Any (otherwise).

This avoids the artificial cast() in cursor code and will make changes
in followup commits much easier.

Use no row factory in TypeInfo.fetch*()

TypeInfo.fetch() and TypeInfo.fetch_async() delegate results processing
to TypeInfo._fetch() which only handle results as tuples. Therefore, we
build the cursor with no row factory to guarantee this. Still we need to
add a type hint on 'recs' variable because this cannot be inferred (this
fixes the mypy error introduced in previous commits).

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

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

Make row factory optional

We change the default value of row_factory argument in
connection.cursor() to None and thus use a keyword argument.

On cursor side, we only set the '_make_row' attribute if a 'row_factory'
got passed and we guard all possible calls to _make_row() by an
'if self._make_row' to avoid a Python call per row. Note that, on the
other hand, we now need to cast 'row' values to the 'Row' type in order
to satisfy type checking.

The default_row_factory() is now useless and thus dropped.

Add name to the ServerCursor repr()

Of of fixing typos

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.

Specify keyword-only args on Connection and Cursor execute()

Typo fix

Add test for all the documented NamedCursor interface

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

Introduce row_factory option in connection.cursor()

We add a row_factory keyword argument in connection.cursor() and cursor
classes that will be used to produce individual rows of the result set.

A RowFactory can be implemented as a class with a __call__ method
accepting raw values and initialized with a cursor instance; the
RowFactory instance is created when results are available. Type
definitions for RowFactory (and its respective RowMaker) are defined as
callback protocols so as to allow user to define a row factory without
the need for writing a class.

The default row factory returns values unchanged.

AsyncConnection.cursor() is no more async

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