asyncpg-0.13.0/ 0000775 0003720 0003720 00000000000 13172407445 014110 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/MANIFEST.in 0000664 0003720 0003720 00000000322 13172407302 015633 0 ustar travis travis 0000000 0000000 recursive-include docs *.py *.rst
recursive-include examples *.py
recursive-include tests *.py *.pem
recursive-include asyncpg *.pyx *.pxd *.pxi *.py *.c *.h
include LICENSE README.rst Makefile performance.png
asyncpg-0.13.0/README.rst 0000664 0003720 0003720 00000005054 13172407302 015573 0 ustar travis travis 0000000 0000000 asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio
=======================================================================
.. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master
:target: https://travis-ci.org/MagicStack/asyncpg
.. image:: https://ci.appveyor.com/api/projects/status/9rwppnxphgc8bqoj/branch/master?svg=true
:target: https://ci.appveyor.com/project/magicstack/asyncpg
.. image:: https://img.shields.io/pypi/v/asyncpg.svg
:target: https://pypi.python.org/pypi/asyncpg
**asyncpg** is a database interface library designed specifically for
PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python's ``asyncio``
framework. You can read more about asyncpg in an introductory
`blog post `_.
asyncpg requires Python 3.5 or later and is supported for PostgreSQL
versions 9.2 to 10.
Documentation
-------------
The project documentation can be found
`here `_.
Performance
-----------
In our testing asyncpg is, on average, **3x** faster than psycopg2
(and its asyncio variant -- aiopg).
.. image:: performance.png
:target: http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/
The above results are a geometric mean of benchmarks obtained with PostgreSQL
`client driver benchmarking toolbench `_.
Features
--------
asyncpg implements PostgreSQL server protocol natively and exposes its
features directly, as opposed to hiding them behind a generic facade
like DB-API.
This enables asyncpg to have easy-to-use support for:
* **prepared statements**
* **scrollable cursors**
* **partial iteration** on query results
* automatic encoding and decoding of composite types, arrays,
and any combination of those
* straightforward support for custom data types
Installation
------------
asyncpg is available on PyPI and has no dependencies.
Use pip to install::
$ pip install asyncpg
Basic Usage
-----------
.. code-block:: python
import asyncio
import asyncpg
async def run():
conn = await asyncpg.connect(user='user', password='password',
database='database', host='127.0.0.1')
values = await conn.fetch('''SELECT * FROM mytable''')
await conn.close()
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
License
-------
asyncpg is developed and distributed under the Apache 2.0 license.
asyncpg-0.13.0/LICENSE 0000664 0003720 0003720 00000026312 13172407302 015111 0 ustar travis travis 0000000 0000000 Copyright (C) 2016-present the asyncpg authors and contributors.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright (C) 2016-present the asyncpg authors and contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
asyncpg-0.13.0/tests/ 0000775 0003720 0003720 00000000000 13172407445 015252 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/tests/test__sourcecode.py 0000664 0003720 0003720 00000002305 13172407302 021145 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import os
import subprocess
import sys
import unittest
def find_root():
return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
class TestFlake8(unittest.TestCase):
def test_flake8(self):
root_path = find_root()
config_path = os.path.join(root_path, '.flake8')
if not os.path.exists(config_path):
raise RuntimeError('could not locate .flake8 file')
try:
import flake8 # NoQA
except ImportError:
raise unittest.SkipTest('flake8 module is missing')
try:
subprocess.run(
[sys.executable, '-m', 'flake8', '--config', config_path],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=root_path)
except subprocess.CalledProcessError as ex:
output = ex.output.decode()
raise AssertionError(
'flake8 validation failed:\n{}'.format(output)) from None
asyncpg-0.13.0/tests/test__environment.py 0000664 0003720 0003720 00000001625 13172407302 021362 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import os
import unittest
import asyncpg
import asyncpg.serverversion
from asyncpg import _testbase as tb
class TestEnvironment(tb.ConnectedTestCase):
@unittest.skipIf(not os.environ.get('PGVERSION'),
"environ[PGVERSION] is not set")
async def test_environment_server_version(self):
pgver = os.environ.get('PGVERSION')
env_ver = asyncpg.serverversion.split_server_version_string(pgver)
srv_ver = self.con.get_server_version()
self.assertEqual(
env_ver[:2], srv_ver[:2],
'Expecting PostgreSQL version {pgver}, got {maj}.{min}.'.format(
pgver=pgver, maj=srv_ver.major, min=srv_ver.minor)
)
asyncpg-0.13.0/tests/test_cache_invalidation.py 0000664 0003720 0003720 00000006161 13172407302 022463 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncpg
from asyncpg import _testbase as tb
class TestCacheInvalidation(tb.ConnectedTestCase):
async def test_prepare_cache_invalidation_silent(self):
await self.con.execute('CREATE TABLE tab1(a int, b int)')
try:
await self.con.execute('INSERT INTO tab1 VALUES (1, 2)')
result = await self.con.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, 2))
await self.con.execute(
'ALTER TABLE tab1 ALTER COLUMN b SET DATA TYPE text')
result = await self.con.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, '2'))
finally:
await self.con.execute('DROP TABLE tab1')
async def test_prepare_cache_invalidation_in_transaction(self):
await self.con.execute('CREATE TABLE tab1(a int, b int)')
try:
await self.con.execute('INSERT INTO tab1 VALUES (1, 2)')
result = await self.con.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, 2))
await self.con.execute(
'ALTER TABLE tab1 ALTER COLUMN b SET DATA TYPE text')
with self.assertRaisesRegex(asyncpg.InvalidCachedStatementError,
'cached statement plan is invalid'):
async with self.con.transaction():
result = await self.con.fetchrow('SELECT * FROM tab1')
# This is now OK,
result = await self.con.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, '2'))
finally:
await self.con.execute('DROP TABLE tab1')
async def test_prepare_cache_invalidation_in_pool(self):
pool = await self.create_pool(database='postgres',
min_size=2, max_size=2)
await self.con.execute('CREATE TABLE tab1(a int, b int)')
try:
await self.con.execute('INSERT INTO tab1 VALUES (1, 2)')
con1 = await pool.acquire()
con2 = await pool.acquire()
result = await con1.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, 2))
result = await con2.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, 2))
await self.con.execute(
'ALTER TABLE tab1 ALTER COLUMN b SET DATA TYPE text')
# con1 tries the same plan, will invalidate the cache
# for the entire pool.
result = await con1.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, '2'))
async with con2.transaction():
# This should work, as con1 should have invalidated
# the plan cache.
result = await con2.fetchrow('SELECT * FROM tab1')
self.assertEqual(result, (1, '2'))
finally:
await self.con.execute('DROP TABLE tab1')
await pool.close()
asyncpg-0.13.0/tests/test_exceptions.py 0000664 0003720 0003720 00000003355 13172407302 021042 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncpg
from asyncpg import _testbase as tb
class TestExceptions(tb.ConnectedTestCase):
def test_exceptions_exported(self):
for err in ('PostgresError', 'SubstringError', 'InterfaceError'):
self.assertTrue(hasattr(asyncpg, err))
self.assertIn(err, asyncpg.__all__)
for err in ('PostgresMessage',):
self.assertFalse(hasattr(asyncpg, err))
self.assertNotIn(err, asyncpg.__all__)
self.assertIsNone(asyncpg.PostgresError.schema_name)
async def test_exceptions_unpacking(self):
try:
await self.con.execute('SELECT * FROM _nonexistent_')
except asyncpg.UndefinedTableError as e:
self.assertEqual(e.sqlstate, '42P01')
self.assertEqual(e.position, '15')
self.assertEqual(e.query, 'SELECT * FROM _nonexistent_')
self.assertIsNotNone(e.severity)
else:
self.fail('UndefinedTableError not raised')
async def test_exceptions_str(self):
try:
await self.con.execute('''
CREATE FUNCTION foo() RETURNS bool AS $$ $$ LANGUAGE SQL;
''')
except asyncpg.InvalidFunctionDefinitionError as e:
self.assertEqual(
e.detail,
"Function's final statement must be SELECT or "
"INSERT/UPDATE/DELETE RETURNING.")
self.assertIn(
'DETAIL: Function', str(e)
)
else:
self.fail('InvalidFunctionDefinitionError not raised')
asyncpg-0.13.0/tests/test_cursor.py 0000664 0003720 0003720 00000012523 13172407302 020173 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncpg
import inspect
from asyncpg import _testbase as tb
class TestIterableCursor(tb.ConnectedTestCase):
async def test_cursor_iterable_01(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
expected = await st.fetch()
for prefetch in range(1, 25):
with self.subTest(prefetch=prefetch):
async with self.con.transaction():
result = []
async for rec in st.cursor(prefetch=prefetch):
result.append(rec)
self.assertEqual(
result, expected,
'result != expected for prefetch={}'.format(prefetch))
async def test_cursor_iterable_02(self):
# Test that it's not possible to create a cursor without hold
# outside of a transaction
s = await self.con.prepare(
'DECLARE t BINARY CURSOR WITHOUT HOLD FOR SELECT 1')
with self.assertRaises(asyncpg.NoActiveSQLTransactionError):
await s.fetch()
# Now test that statement.cursor() does not let you
# iterate over it outside of a transaction
st = await self.con.prepare('SELECT generate_series(0, 20)')
it = st.cursor(prefetch=5).__aiter__()
if inspect.isawaitable(it):
it = await it
with self.assertRaisesRegex(asyncpg.NoActiveSQLTransactionError,
'cursor cannot be created.*transaction'):
await it.__anext__()
async def test_cursor_iterable_03(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
it = st.cursor().__aiter__()
if inspect.isawaitable(it):
it = await it
st._state.mark_closed()
with self.assertRaisesRegex(asyncpg.InterfaceError,
'statement is closed'):
async for _ in it: # NOQA
pass
async def test_cursor_iterable_04(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
st._state.mark_closed()
with self.assertRaisesRegex(asyncpg.InterfaceError,
'statement is closed'):
async for _ in st.cursor(): # NOQA
pass
async def test_cursor_iterable_05(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
for prefetch in range(-1, 1):
with self.subTest(prefetch=prefetch):
with self.assertRaisesRegex(asyncpg.InterfaceError,
'must be greater than zero'):
async for _ in st.cursor(prefetch=prefetch): # NOQA
pass
async def test_cursor_iterable_06(self):
recs = []
async with self.con.transaction():
async for rec in self.con.cursor(
'SELECT generate_series(0, $1::int)', 10):
recs.append(rec)
self.assertEqual(recs, [(i,) for i in range(11)])
class TestCursor(tb.ConnectedTestCase):
async def test_cursor_01(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
with self.assertRaisesRegex(asyncpg.NoActiveSQLTransactionError,
'cursor cannot be created.*transaction'):
await st.cursor()
async def test_cursor_02(self):
st = await self.con.prepare('SELECT generate_series(0, 20)')
async with self.con.transaction():
cur = await st.cursor()
for i in range(-1, 1):
with self.assertRaisesRegex(asyncpg.InterfaceError,
'greater than zero'):
await cur.fetch(i)
res = await cur.fetch(2)
self.assertEqual(res, [(0,), (1,)])
rec = await cur.fetchrow()
self.assertEqual(rec, (2,))
r = repr(cur)
self.assertTrue(r.startswith('
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import asyncpg
from asyncpg import connection as pg_connection
from asyncpg import _testbase as tb
MAX_RUNTIME = 0.5
class TestTimeout(tb.ConnectedTestCase):
async def test_timeout_01(self):
for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}:
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
meth = getattr(self.con, methname)
await meth('select pg_sleep(10)', timeout=0.02)
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async def test_timeout_02(self):
st = await self.con.prepare('select pg_sleep(10)')
for methname in {'fetch', 'fetchrow', 'fetchval'}:
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
meth = getattr(st, methname)
await meth(timeout=0.02)
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async def test_timeout_03(self):
task = self.loop.create_task(
self.con.fetch('select pg_sleep(10)', timeout=0.2))
await asyncio.sleep(0.05, loop=self.loop)
task.cancel()
with self.assertRaises(asyncio.CancelledError), \
self.assertRunUnder(MAX_RUNTIME):
await task
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async def test_timeout_04(self):
st = await self.con.prepare('select pg_sleep(10)', timeout=0.1)
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
async with self.con.transaction():
async for _ in st.cursor(timeout=0.1): # NOQA
pass
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
st = await self.con.prepare('select pg_sleep(10)', timeout=0.1)
async with self.con.transaction():
cur = await st.cursor()
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
await cur.fetch(1, timeout=0.1)
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async def test_timeout_05(self):
# Stress-test timeouts - try to trigger a race condition
# between a cancellation request to Postgres and next
# query (SELECT 1)
for _ in range(500):
with self.assertRaises(asyncio.TimeoutError):
await self.con.fetch('SELECT pg_sleep(1)', timeout=1e-10)
self.assertEqual(await self.con.fetch('SELECT 1'), [(1,)])
async def test_timeout_06(self):
async with self.con.transaction():
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
async for _ in self.con.cursor( # NOQA
'select pg_sleep(10)', timeout=0.1):
pass
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async with self.con.transaction():
cur = await self.con.cursor('select pg_sleep(10)')
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
await cur.fetch(1, timeout=0.1)
async with self.con.transaction():
cur = await self.con.cursor('select pg_sleep(10)')
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
await cur.forward(1, timeout=1e-10)
async with self.con.transaction():
cur = await self.con.cursor('select pg_sleep(10)')
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
await cur.fetchrow(timeout=0.1)
async with self.con.transaction():
cur = await self.con.cursor('select pg_sleep(10)')
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
await cur.fetchrow(timeout=0.1)
with self.assertRaises(asyncpg.InFailedSQLTransactionError):
await cur.fetch(1)
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
async def test_invalid_timeout(self):
for command_timeout in ('a', False, -1):
with self.subTest(command_timeout=command_timeout):
with self.assertRaisesRegex(ValueError,
'invalid command_timeout'):
await self.cluster.connect(
database='postgres', loop=self.loop,
command_timeout=command_timeout)
# Note: negative timeouts are OK for method calls.
for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}:
for timeout in ('a', False):
with self.subTest(timeout=timeout):
with self.assertRaisesRegex(ValueError, 'invalid timeout'):
await self.con.execute('SELECT 1', timeout=timeout)
class TestConnectionCommandTimeout(tb.ConnectedTestCase):
@tb.with_connection_options(command_timeout=0.2)
async def test_command_timeout_01(self):
for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}:
with self.assertRaises(asyncio.TimeoutError), \
self.assertRunUnder(MAX_RUNTIME):
meth = getattr(self.con, methname)
await meth('select pg_sleep(10)')
self.assertEqual(await self.con.fetch('select 1'), [(1,)])
class SlowPrepareConnection(pg_connection.Connection):
"""Connection class to test timeouts."""
async def _get_statement(self, query, timeout):
await asyncio.sleep(0.3, loop=self._loop)
return await super()._get_statement(query, timeout)
class TestTimeoutCoversPrepare(tb.ConnectedTestCase):
@tb.with_connection_options(connection_class=SlowPrepareConnection,
command_timeout=0.3)
async def test_timeout_covers_prepare_01(self):
for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}:
with self.assertRaises(asyncio.TimeoutError):
meth = getattr(self.con, methname)
await meth('select pg_sleep($1)', 0.2)
asyncpg-0.13.0/tests/test_utils.py 0000664 0003720 0003720 00000002256 13172407302 020020 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the ayncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import datetime
from asyncpg import utils
from asyncpg import _testbase as tb
class TestUtils(tb.ConnectedTestCase):
async def test_mogrify_simple(self):
cases = [
('timestamp',
datetime.datetime(2016, 10, 10),
"SELECT '2016-10-10 00:00:00'::timestamp"),
('int[]',
[[1, 2], [3, 4]],
"SELECT '{{1,2},{3,4}}'::int[]"),
]
for typename, data, expected in cases:
with self.subTest(value=data, type=typename):
mogrified = await utils._mogrify(
self.con, 'SELECT $1::{}'.format(typename), [data])
self.assertEqual(mogrified, expected)
async def test_mogrify_multiple(self):
mogrified = await utils._mogrify(
self.con, 'SELECT $1::int, $2::int[]',
[1, [2, 3, 4, 5]])
expected = "SELECT '1'::int, '{2,3,4,5}'::int[]"
self.assertEqual(mogrified, expected)
asyncpg-0.13.0/tests/test_execute.py 0000664 0003720 0003720 00000011574 13172407302 020325 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import asyncpg
from asyncpg import _testbase as tb
class TestExecuteScript(tb.ConnectedTestCase):
async def test_execute_script_1(self):
self.assertEqual(self.con._protocol.queries_count, 0)
status = await self.con.execute('''
SELECT 1;
SELECT true FROM pg_type WHERE false = true;
SELECT generate_series(0, 9);
''')
self.assertEqual(self.con._protocol.queries_count, 1)
self.assertEqual(status, 'SELECT 10')
async def test_execute_script_2(self):
status = await self.con.execute('''
CREATE TABLE mytab (a int);
''')
self.assertEqual(status, 'CREATE TABLE')
try:
status = await self.con.execute('''
INSERT INTO mytab (a) VALUES ($1), ($2)
''', 10, 20)
self.assertEqual(status, 'INSERT 0 2')
finally:
await self.con.execute('DROP TABLE mytab')
async def test_execute_script_3(self):
with self.assertRaisesRegex(asyncpg.PostgresSyntaxError,
'cannot insert multiple commands'):
await self.con.execute('''
CREATE TABLE mytab (a int);
INSERT INTO mytab (a) VALUES ($1), ($2);
''', 10, 20)
async def test_execute_script_check_transactionality(self):
with self.assertRaises(asyncpg.PostgresError):
await self.con.execute('''
CREATE TABLE mytab (a int);
SELECT * FROM mytab WHERE 1 / 0 = 1;
''')
with self.assertRaisesRegex(asyncpg.PostgresError,
'"mytab" does not exist'):
await self.con.prepare('''
SELECT * FROM mytab
''')
async def test_execute_exceptions_1(self):
with self.assertRaisesRegex(asyncpg.PostgresError,
'relation "__dne__" does not exist'):
await self.con.execute('select * from __dne__')
async def test_execute_script_interrupted_close(self):
fut = self.loop.create_task(
self.con.execute('''SELECT pg_sleep(10)'''))
await asyncio.sleep(0.2, loop=self.loop)
self.assertFalse(self.con.is_closed())
await self.con.close()
self.assertTrue(self.con.is_closed())
with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError,
'closed in the middle'):
await fut
async def test_execute_script_interrupted_terminate(self):
fut = self.loop.create_task(
self.con.execute('''SELECT pg_sleep(10)'''))
await asyncio.sleep(0.2, loop=self.loop)
self.assertFalse(self.con.is_closed())
self.con.terminate()
self.assertTrue(self.con.is_closed())
with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError,
'closed in the middle'):
await fut
self.con.terminate()
async def test_execute_many_1(self):
await self.con.execute('CREATE TEMP TABLE exmany (a text, b int)')
try:
result = await self.con.executemany('''
INSERT INTO exmany VALUES($1, $2)
''', [
('a', 1), ('b', 2), ('c', 3), ('d', 4)
])
self.assertIsNone(result)
result = await self.con.fetch('''
SELECT * FROM exmany
''')
self.assertEqual(result, [
('a', 1), ('b', 2), ('c', 3), ('d', 4)
])
# Empty set
result = await self.con.executemany('''
INSERT INTO exmany VALUES($1, $2)
''', ())
result = await self.con.fetch('''
SELECT * FROM exmany
''')
self.assertEqual(result, [
('a', 1), ('b', 2), ('c', 3), ('d', 4)
])
finally:
await self.con.execute('DROP TABLE exmany')
async def test_execute_many_2(self):
await self.con.execute('CREATE TEMP TABLE exmany (b int)')
try:
bad_data = ([1 / 0] for v in range(10))
with self.assertRaises(ZeroDivisionError):
async with self.con.transaction():
await self.con.executemany('''
INSERT INTO exmany VALUES($1)
''', bad_data)
good_data = ([v] for v in range(10))
async with self.con.transaction():
await self.con.executemany('''
INSERT INTO exmany VALUES($1)
''', good_data)
finally:
await self.con.execute('DROP TABLE exmany')
asyncpg-0.13.0/tests/test_introspection.py 0000664 0003720 0003720 00000006124 13172407302 021556 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
from asyncpg import _testbase as tb
MAX_RUNTIME = 0.1
class TestIntrospection(tb.ConnectedTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.adminconn = cls.loop.run_until_complete(
cls.cluster.connect(database='postgres', loop=cls.loop))
cls.loop.run_until_complete(
cls.adminconn.execute('CREATE DATABASE asyncpg_intro_test'))
@classmethod
def tearDownClass(cls):
cls.loop.run_until_complete(
cls.adminconn.execute('DROP DATABASE asyncpg_intro_test'))
cls.loop.run_until_complete(cls.adminconn.close())
cls.adminconn = None
super().tearDownClass()
@tb.with_connection_options(database='asyncpg_intro_test')
async def test_introspection_on_large_db(self):
await self.con.execute(
'CREATE TABLE base ({})'.format(
','.join('c{:02} varchar'.format(n) for n in range(50))
)
)
for n in range(1000):
await self.con.execute(
'CREATE TABLE child_{:04} () inherits (base)'.format(n)
)
with self.assertRunUnder(MAX_RUNTIME):
await self.con.fetchval('SELECT $1::int[]', [1, 2])
@tb.with_connection_options(statement_cache_size=0)
async def test_introspection_no_stmt_cache_01(self):
self.assertEqual(self.con._stmt_cache.get_max_size(), 0)
await self.con.fetchval('SELECT $1::int[]', [1, 2])
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS hstore
''')
try:
await self.con.set_builtin_type_codec(
'hstore', codec_name='pg_contrib.hstore')
finally:
await self.con.execute('''
DROP EXTENSION hstore
''')
self.assertEqual(self.con._uid, 0)
@tb.with_connection_options(max_cacheable_statement_size=1)
async def test_introspection_no_stmt_cache_02(self):
# max_cacheable_statement_size will disable caching both for
# the user query and for the introspection query.
await self.con.fetchval('SELECT $1::int[]', [1, 2])
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS hstore
''')
try:
await self.con.set_builtin_type_codec(
'hstore', codec_name='pg_contrib.hstore')
finally:
await self.con.execute('''
DROP EXTENSION hstore
''')
self.assertEqual(self.con._uid, 0)
@tb.with_connection_options(max_cacheable_statement_size=10000)
async def test_introspection_no_stmt_cache_03(self):
# max_cacheable_statement_size will disable caching for
# the user query but not for the introspection query.
await self.con.fetchval(
"SELECT $1::int[], '{foo}'".format(foo='a' * 10000), [1, 2])
self.assertEqual(self.con._uid, 1)
asyncpg-0.13.0/tests/test_cancellation.py 0000664 0003720 0003720 00000006155 13172407302 021316 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import asyncpg
from asyncpg import _testbase as tb
class TestCancellation(tb.ConnectedTestCase):
async def test_cancellation_01(self):
st1000 = await self.con.prepare('SELECT 1000')
async def test0():
val = await self.con.execute('SELECT 42')
self.assertEqual(val, 'SELECT 1')
async def test1():
val = await self.con.fetchval('SELECT 42')
self.assertEqual(val, 42)
async def test2():
val = await self.con.fetchrow('SELECT 42')
self.assertEqual(val, (42,))
async def test3():
val = await self.con.fetch('SELECT 42')
self.assertEqual(val, [(42,)])
async def test4():
val = await self.con.prepare('SELECT 42')
self.assertEqual(await val.fetchval(), 42)
async def test5():
self.assertEqual(await st1000.fetchval(), 1000)
async def test6():
self.assertEqual(await st1000.fetchrow(), (1000,))
async def test7():
self.assertEqual(await st1000.fetch(), [(1000,)])
async def test8():
cur = await st1000.cursor()
self.assertEqual(await cur.fetchrow(), (1000,))
for test in {test0, test1, test2, test3, test4, test5,
test6, test7, test8}:
with self.subTest(testfunc=test), self.assertRunUnder(1):
st = await self.con.prepare('SELECT pg_sleep(20)')
task = self.loop.create_task(st.fetch())
await asyncio.sleep(0.05, loop=self.loop)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
await task
async with self.con.transaction():
await test()
async def test_cancellation_02(self):
st = await self.con.prepare('SELECT 1')
task = self.loop.create_task(st.fetch())
await asyncio.sleep(0.05, loop=self.loop)
task.cancel()
self.assertEqual(await task, [(1,)])
async def test_cancellation_03(self):
with self.assertRaises(asyncpg.InFailedSQLTransactionError):
async with self.con.transaction():
task = self.loop.create_task(
self.con.fetch('SELECT pg_sleep(20)'))
await asyncio.sleep(0.05, loop=self.loop)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
await task
await self.con.fetch('SELECT generate_series(0, 100)')
self.assertEqual(
await self.con.fetchval('SELECT 42'),
42)
async def test_cancellation_04(self):
await self.con.fetchval('SELECT pg_sleep(0)')
waiter = asyncio.Future(loop=self.loop)
self.con._cancel_current_command(waiter)
await waiter
self.assertEqual(await self.con.fetchval('SELECT 42'), 42)
asyncpg-0.13.0/tests/test_transaction.py 0000664 0003720 0003720 00000012204 13172407302 021177 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncpg
from asyncpg import _testbase as tb
class TestTransaction(tb.ConnectedTestCase):
async def test_transaction_regular(self):
self.assertIsNone(self.con._top_xact)
tr = self.con.transaction()
self.assertIsNone(self.con._top_xact)
with self.assertRaises(ZeroDivisionError):
async with tr as with_tr:
self.assertIs(self.con._top_xact, tr)
# We don't return the transaction object from __aenter__,
# to make it harder for people to use '.rollback()' and
# '.commit()' from within an 'async with' block.
self.assertIsNone(with_tr)
await self.con.execute('''
CREATE TABLE mytab (a int);
''')
1 / 0
self.assertIsNone(self.con._top_xact)
with self.assertRaisesRegex(asyncpg.PostgresError,
'"mytab" does not exist'):
await self.con.prepare('''
SELECT * FROM mytab
''')
async def test_transaction_nested(self):
self.assertIsNone(self.con._top_xact)
tr = self.con.transaction()
self.assertIsNone(self.con._top_xact)
with self.assertRaises(ZeroDivisionError):
async with tr:
self.assertIs(self.con._top_xact, tr)
await self.con.execute('''
CREATE TABLE mytab (a int);
''')
async with self.con.transaction():
self.assertIs(self.con._top_xact, tr)
await self.con.execute('''
INSERT INTO mytab (a) VALUES (1), (2);
''')
self.assertIs(self.con._top_xact, tr)
with self.assertRaises(ZeroDivisionError):
in_tr = self.con.transaction()
async with in_tr:
self.assertIs(self.con._top_xact, tr)
await self.con.execute('''
INSERT INTO mytab (a) VALUES (3), (4);
''')
1 / 0
st = await self.con.prepare('SELECT * FROM mytab;')
recs = []
async for rec in st.cursor():
recs.append(rec)
self.assertEqual(len(recs), 2)
self.assertEqual(recs[0][0], 1)
self.assertEqual(recs[1][0], 2)
self.assertIs(self.con._top_xact, tr)
1 / 0
self.assertIs(self.con._top_xact, None)
with self.assertRaisesRegex(asyncpg.PostgresError,
'"mytab" does not exist'):
await self.con.prepare('''
SELECT * FROM mytab
''')
async def test_transaction_interface_errors(self):
self.assertIsNone(self.con._top_xact)
tr = self.con.transaction(readonly=True, isolation='serializable')
with self.assertRaisesRegex(asyncpg.InterfaceError,
'cannot start; .* already started'):
async with tr:
await tr.start()
self.assertTrue(repr(tr).startswith(
'
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import datetime
import io
import tempfile
import asyncpg
from asyncpg import _testbase as tb
from asyncpg import compat
class TestCopyFrom(tb.ConnectedTestCase):
async def test_copy_from_table_basics(self):
await self.con.execute('''
CREATE TABLE copytab(a text, "b~" text, i int);
INSERT INTO copytab (a, "b~", i) (
SELECT 'a' || i::text, 'b' || i::text, i
FROM generate_series(1, 5) AS i
);
INSERT INTO copytab (a, "b~", i) VALUES('*', NULL, NULL);
''')
try:
f = io.BytesIO()
# Basic functionality.
res = await self.con.copy_from_table('copytab', output=f)
self.assertEqual(res, 'COPY 6')
output = f.getvalue().decode().split('\n')
self.assertEqual(
output,
[
'a1\tb1\t1',
'a2\tb2\t2',
'a3\tb3\t3',
'a4\tb4\t4',
'a5\tb5\t5',
'*\t\\N\t\\N',
''
]
)
# Test parameters.
await self.con.execute('SET search_path=none')
f.seek(0)
f.truncate()
res = await self.con.copy_from_table(
'copytab', output=f, columns=('a', 'b~'),
schema_name='public', format='csv',
delimiter='|', null='n-u-l-l', header=True,
quote='*', escape='!', force_quote=('a',))
output = f.getvalue().decode().split('\n')
self.assertEqual(
output,
[
'a|b~',
'*a1*|b1',
'*a2*|b2',
'*a3*|b3',
'*a4*|b4',
'*a5*|b5',
'*!**|n-u-l-l',
''
]
)
await self.con.execute('SET search_path=public')
finally:
await self.con.execute('DROP TABLE public.copytab')
async def test_copy_from_table_large_rows(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
INSERT INTO copytab (a, b) (
SELECT
repeat('a' || i::text, 500000),
repeat('b' || i::text, 500000)
FROM
generate_series(1, 5) AS i
);
''')
try:
f = io.BytesIO()
# Basic functionality.
res = await self.con.copy_from_table('copytab', output=f)
self.assertEqual(res, 'COPY 5')
output = f.getvalue().decode().split('\n')
self.assertEqual(
output,
[
'a1' * 500000 + '\t' + 'b1' * 500000,
'a2' * 500000 + '\t' + 'b2' * 500000,
'a3' * 500000 + '\t' + 'b3' * 500000,
'a4' * 500000 + '\t' + 'b4' * 500000,
'a5' * 500000 + '\t' + 'b5' * 500000,
''
]
)
finally:
await self.con.execute('DROP TABLE public.copytab')
async def test_copy_from_query_basics(self):
f = io.BytesIO()
res = await self.con.copy_from_query('''
SELECT
repeat('a' || i::text, 500000),
repeat('b' || i::text, 500000)
FROM
generate_series(1, 5) AS i
''', output=f)
self.assertEqual(res, 'COPY 5')
output = f.getvalue().decode().split('\n')
self.assertEqual(
output,
[
'a1' * 500000 + '\t' + 'b1' * 500000,
'a2' * 500000 + '\t' + 'b2' * 500000,
'a3' * 500000 + '\t' + 'b3' * 500000,
'a4' * 500000 + '\t' + 'b4' * 500000,
'a5' * 500000 + '\t' + 'b5' * 500000,
''
]
)
async def test_copy_from_query_with_args(self):
f = io.BytesIO()
res = await self.con.copy_from_query('''
SELECT
i, i * 10
FROM
generate_series(1, 5) AS i
WHERE
i = $1
''', 3, output=f)
self.assertEqual(res, 'COPY 1')
output = f.getvalue().decode().split('\n')
self.assertEqual(
output,
[
'3\t30',
''
]
)
async def test_copy_from_query_to_path(self):
with tempfile.NamedTemporaryFile() as f:
f.close()
await self.con.copy_from_query('''
SELECT
i, i * 10
FROM
generate_series(1, 5) AS i
WHERE
i = $1
''', 3, output=f.name)
with open(f.name, 'rb') as fr:
output = fr.read().decode().split('\n')
self.assertEqual(
output,
[
'3\t30',
''
]
)
async def test_copy_from_query_to_path_like(self):
with tempfile.NamedTemporaryFile() as f:
f.close()
class Path:
def __init__(self, path):
self.path = path
def __fspath__(self):
return self.path
await self.con.copy_from_query('''
SELECT
i, i * 10
FROM
generate_series(1, 5) AS i
WHERE
i = $1
''', 3, output=Path(f.name))
with open(f.name, 'rb') as fr:
output = fr.read().decode().split('\n')
self.assertEqual(
output,
[
'3\t30',
''
]
)
async def test_copy_from_query_to_bad_output(self):
with self.assertRaisesRegex(TypeError, 'output is expected to be'):
await self.con.copy_from_query('''
SELECT
i, i * 10
FROM
generate_series(1, 5) AS i
WHERE
i = $1
''', 3, output=1)
async def test_copy_from_query_to_sink(self):
with tempfile.NamedTemporaryFile() as f:
async def writer(data):
# Sleeping here to simulate slow output sink to test
# backpressure.
await asyncio.sleep(0.05, loop=self.loop)
f.write(data)
await self.con.copy_from_query('''
SELECT
repeat('a', 500)
FROM
generate_series(1, 5000) AS i
''', output=writer)
f.seek(0)
output = f.read().decode().split('\n')
self.assertEqual(
output,
[
'a' * 500
] * 5000 + ['']
)
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
async def test_copy_from_query_cancellation_explicit(self):
async def writer(data):
# Sleeping here to simulate slow output sink to test
# backpressure.
await asyncio.sleep(0.5, loop=self.loop)
coro = self.con.copy_from_query('''
SELECT
repeat('a', 500)
FROM
generate_series(1, 5000) AS i
''', output=writer)
task = self.loop.create_task(coro)
await asyncio.sleep(0.7, loop=self.loop)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
await task
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
async def test_copy_from_query_cancellation_on_sink_error(self):
async def writer(data):
await asyncio.sleep(0.05, loop=self.loop)
raise RuntimeError('failure')
coro = self.con.copy_from_query('''
SELECT
repeat('a', 500)
FROM
generate_series(1, 5000) AS i
''', output=writer)
task = self.loop.create_task(coro)
with self.assertRaises(RuntimeError):
await task
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
async def test_copy_from_query_cancellation_while_waiting_for_data(self):
async def writer(data):
pass
coro = self.con.copy_from_query('''
SELECT
pg_sleep(60)
FROM
generate_series(1, 5000) AS i
''', output=writer)
task = self.loop.create_task(coro)
await asyncio.sleep(0.7, loop=self.loop)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
await task
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
async def test_copy_from_query_timeout_1(self):
async def writer(data):
await asyncio.sleep(0.05, loop=self.loop)
coro = self.con.copy_from_query('''
SELECT
repeat('a', 500)
FROM
generate_series(1, 5000) AS i
''', output=writer, timeout=0.10)
task = self.loop.create_task(coro)
with self.assertRaises(asyncio.TimeoutError):
await task
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
async def test_copy_from_query_timeout_2(self):
async def writer(data):
try:
await asyncio.sleep(10, loop=self.loop)
except asyncio.TimeoutError:
raise
else:
self.fail('TimeoutError not raised')
coro = self.con.copy_from_query('''
SELECT
repeat('a', 500)
FROM
generate_series(1, 5000) AS i
''', output=writer, timeout=0.10)
task = self.loop.create_task(coro)
with self.assertRaises(asyncio.TimeoutError):
await task
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
class TestCopyTo(tb.ConnectedTestCase):
async def test_copy_to_table_basics(self):
await self.con.execute('''
CREATE TABLE copytab(a text, "b~" text, i int);
''')
try:
f = io.BytesIO()
f.write(
'\n'.join([
'a1\tb1\t1',
'a2\tb2\t2',
'a3\tb3\t3',
'a4\tb4\t4',
'a5\tb5\t5',
'*\t\\N\t\\N',
''
]).encode('utf-8')
)
f.seek(0)
res = await self.con.copy_to_table('copytab', source=f)
self.assertEqual(res, 'COPY 6')
output = await self.con.fetch("""
SELECT * FROM copytab ORDER BY a
""")
self.assertEqual(
output,
[
('*', None, None),
('a1', 'b1', 1),
('a2', 'b2', 2),
('a3', 'b3', 3),
('a4', 'b4', 4),
('a5', 'b5', 5),
]
)
# Test parameters.
await self.con.execute('TRUNCATE copytab')
await self.con.execute('SET search_path=none')
f.seek(0)
f.truncate()
f.write(
'\n'.join([
'a|b~',
'*a1*|b1',
'*a2*|b2',
'*a3*|b3',
'*a4*|b4',
'*a5*|b5',
'*!**|*n-u-l-l*',
'n-u-l-l|bb'
]).encode('utf-8')
)
f.seek(0)
if self.con.get_server_version() < (9, 4):
force_null = None
forced_null_expected = 'n-u-l-l'
else:
force_null = ('b~',)
forced_null_expected = None
res = await self.con.copy_to_table(
'copytab', source=f, columns=('a', 'b~'),
schema_name='public', format='csv',
delimiter='|', null='n-u-l-l', header=True,
quote='*', escape='!', force_not_null=('a',),
force_null=force_null)
self.assertEqual(res, 'COPY 7')
await self.con.execute('SET search_path=public')
output = await self.con.fetch("""
SELECT * FROM copytab ORDER BY a
""")
self.assertEqual(
output,
[
('*', forced_null_expected, None),
('a1', 'b1', None),
('a2', 'b2', None),
('a3', 'b3', None),
('a4', 'b4', None),
('a5', 'b5', None),
('n-u-l-l', 'bb', None),
]
)
finally:
await self.con.execute('DROP TABLE public.copytab')
async def test_copy_to_table_large_rows(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
''')
try:
class _Source:
def __init__(self):
self.rowcount = 0
@compat.aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
if self.rowcount >= 100:
raise StopAsyncIteration
else:
self.rowcount += 1
return b'a1' * 500000 + b'\t' + b'b1' * 500000 + b'\n'
res = await self.con.copy_to_table('copytab', source=_Source())
self.assertEqual(res, 'COPY 100')
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_to_table_from_bytes_like(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
''')
try:
data = memoryview((b'a1' * 500 + b'\t' + b'b1' * 500 + b'\n') * 2)
res = await self.con.copy_to_table('copytab', source=data)
self.assertEqual(res, 'COPY 2')
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_to_table_fail_in_source_1(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
''')
try:
class _Source:
def __init__(self):
self.rowcount = 0
@compat.aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
raise RuntimeError('failure in source')
with self.assertRaisesRegex(RuntimeError, 'failure in source'):
await self.con.copy_to_table('copytab', source=_Source())
# Check that the protocol has recovered.
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_to_table_fail_in_source_2(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
''')
try:
class _Source:
def __init__(self):
self.rowcount = 0
@compat.aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
if self.rowcount == 0:
self.rowcount += 1
return b'a\tb\n'
else:
raise RuntimeError('failure in source')
with self.assertRaisesRegex(RuntimeError, 'failure in source'):
await self.con.copy_to_table('copytab', source=_Source())
# Check that the protocol has recovered.
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_to_table_timeout(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b text);
''')
try:
class _Source:
def __init__(self, loop):
self.rowcount = 0
self.loop = loop
@compat.aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
self.rowcount += 1
await asyncio.sleep(60, loop=self.loop)
return b'a1' * 50 + b'\t' + b'b1' * 50 + b'\n'
with self.assertRaises(asyncio.TimeoutError):
await self.con.copy_to_table(
'copytab', source=_Source(self.loop), timeout=0.10)
# Check that the protocol has recovered.
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_records_to_table_1(self):
await self.con.execute('''
CREATE TABLE copytab(a text, b int, c timestamptz);
''')
try:
date = datetime.datetime.now(tz=datetime.timezone.utc)
delta = datetime.timedelta(days=1)
records = [
('a-{}'.format(i), i, date + delta)
for i in range(100)
]
records.append(('a-100', None, None))
res = await self.con.copy_records_to_table(
'copytab', records=records)
self.assertEqual(res, 'COPY 101')
finally:
await self.con.execute('DROP TABLE copytab')
async def test_copy_records_to_table_no_binary_codec(self):
await self.con.execute('''
CREATE TABLE copytab(a uuid);
''')
try:
def _encoder(value):
return value
def _decoder(value):
return value
await self.con.set_type_codec(
'uuid', encoder=_encoder, decoder=_decoder,
schema='pg_catalog', format='text'
)
records = [('2975ab9a-f79c-4ab4-9be5-7bc134d952f0',)]
with self.assertRaisesRegex(
asyncpg.InternalClientError, 'no binary format encoder'):
await self.con.copy_records_to_table(
'copytab', records=records)
finally:
await self.con.reset_type_codec(
'uuid', schema='pg_catalog'
)
await self.con.execute('DROP TABLE copytab')
asyncpg-0.13.0/tests/test_record.py 0000664 0003720 0003720 00000024310 13172407302 020131 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import contextlib
import collections
import gc
import pickle
import sys
import asyncpg
from asyncpg import _testbase as tb
from asyncpg.protocol.protocol import _create_record as Record
R_A = collections.OrderedDict([('a', 0)])
R_AB = collections.OrderedDict([('a', 0), ('b', 1)])
R_AC = collections.OrderedDict([('a', 0), ('c', 1)])
R_ABC = collections.OrderedDict([('a', 0), ('b', 1), ('c', 2)])
class TestRecord(tb.ConnectedTestCase):
@contextlib.contextmanager
def checkref(self, *objs):
cnt = [sys.getrefcount(objs[i]) for i in range(len(objs))]
yield
for _ in range(3):
gc.collect()
for i in range(len(objs)):
before = cnt[i]
after = sys.getrefcount(objs[i])
if before != after:
self.fail('refcounts differ for {!r}: {:+}'.format(
objs[i], after - before))
def test_record_gc(self):
elem = object()
mapping = {}
with self.checkref(mapping, elem):
r = Record(mapping, (elem,))
del r
key = 'spam'
val = int('101010')
mapping = {key: val}
with self.checkref(key, val):
r = Record(mapping, (0,))
with self.assertRaises(KeyError):
r[key]
del r
key = 'spam'
val = 'ham'
mapping = {key: val}
with self.checkref(key, val):
r = Record(mapping, (0,))
with self.assertRaises(KeyError):
r[key]
del r
def test_record_freelist_ok(self):
for _ in range(10000):
Record(R_A, (42,))
Record(R_AB, (42, 42,))
def test_record_len_getindex(self):
r = Record(R_A, (42,))
self.assertEqual(len(r), 1)
self.assertEqual(r[0], 42)
self.assertEqual(r['a'], 42)
r = Record(R_AB, (42, 43))
self.assertEqual(len(r), 2)
self.assertEqual(r[0], 42)
self.assertEqual(r[1], 43)
self.assertEqual(r['a'], 42)
self.assertEqual(r['b'], 43)
with self.assertRaisesRegex(IndexError,
'record index out of range'):
r[1000]
with self.assertRaisesRegex(KeyError, 'spam'):
r['spam']
with self.assertRaisesRegex(KeyError, 'spam'):
Record(None, (1,))['spam']
with self.assertRaisesRegex(KeyError, 'spam'):
Record({'spam': 123}, (1,))['spam']
def test_record_slice(self):
r = Record(R_ABC, (1, 2, 3))
self.assertEqual(r[:], (1, 2, 3))
self.assertEqual(r[:1], (1,))
self.assertEqual(r[::-1], (3, 2, 1))
self.assertEqual(r[::-2], (3, 1))
self.assertEqual(r[1:2], (2,))
self.assertEqual(r[2:2], ())
def test_record_immutable(self):
r = Record(R_A, (42,))
with self.assertRaisesRegex(TypeError, 'does not support item'):
r[0] = 1
def test_record_repr(self):
self.assertEqual(
repr(Record(R_A, (42,))),
'')
self.assertEqual(
repr(Record(R_AB, (42, -1))),
'')
# test invalid records just in case
with self.assertRaisesRegex(RuntimeError, 'invalid .* mapping'):
repr(Record(R_A, (42, 43)))
self.assertEqual(repr(Record(R_AB, (42,))), '')
class Key:
def __str__(self):
1 / 0
def __repr__(self):
1 / 0
with self.assertRaises(ZeroDivisionError):
repr(Record({Key(): 0}, (42,)))
with self.assertRaises(ZeroDivisionError):
repr(Record(R_A, (Key(),)))
def test_record_iter(self):
r = Record(R_AB, (42, 43))
with self.checkref(r):
self.assertEqual(iter(r).__length_hint__(), 2)
self.assertEqual(tuple(r), (42, 43))
def test_record_values(self):
r = Record(R_AB, (42, 43))
vv = r.values()
self.assertEqual(tuple(vv), (42, 43))
self.assertTrue(repr(vv).startswith('')
self.assertEqual(str(r), '')
with self.assertRaisesRegex(KeyError, 'aaa'):
r['aaa']
self.assertEqual(dict(r.items()), {})
self.assertEqual(list(r.keys()), [])
self.assertEqual(list(r.values()), [])
async def test_record_duplicate_colnames(self):
"""Test that Record handles duplicate column names."""
records_descs = [
[('a', 1)],
[('a', 1), ('a', 2)],
[('a', 1), ('b', 2), ('a', 3)],
[('a', 1), ('b', 2), ('a', 3), ('c', 4), ('b', 5)],
]
for desc in records_descs:
items = collections.OrderedDict(desc)
query = 'SELECT ' + ', '.join(
['{} as {}'.format(p[1], p[0]) for p in desc])
with self.subTest(query=query):
r = await self.con.fetchrow(query)
for idx, (field, val) in enumerate(desc):
self.assertEqual(r[idx], val)
self.assertEqual(r[field], items[field])
expected_repr = ''.format(
' '.join('{}={}'.format(p[0], p[1]) for p in desc))
self.assertEqual(repr(r), expected_repr)
self.assertEqual(list(r.items()), desc)
self.assertEqual(list(r.values()), [p[1] for p in desc])
self.assertEqual(list(r.keys()), [p[0] for p in desc])
async def test_record_isinstance(self):
"""Test that Record works with isinstance."""
r = await self.con.fetchrow('SELECT 1 as a, 2 as b')
self.assertTrue(isinstance(r, asyncpg.Record))
async def test_record_no_new(self):
"""Instances of Record cannot be directly created."""
with self.assertRaisesRegex(
TypeError, "cannot create 'asyncpg.Record' instances"):
asyncpg.Record()
asyncpg-0.13.0/tests/certs/ 0000775 0003720 0003720 00000000000 13172407445 016372 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/tests/certs/ca.cert.pem 0000664 0003720 0003720 00000004173 13172407302 020411 0 ustar travis travis 0000000 0000000 -----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
asyncpg-0.13.0/tests/certs/server.cert.pem 0000664 0003720 0003720 00000004724 13172407302 021336 0 ustar travis travis 0000000 0000000 -----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
asyncpg-0.13.0/tests/certs/server.key.pem 0000664 0003720 0003720 00000006257 13172407302 021174 0 ustar travis travis 0000000 0000000 -----BEGIN RSA PRIVATE KEY-----
MIIJKgIBAAKCAgEA+0WH9PX4a6Tsnp7xtUbZ51c77aqVagdfj9xYJPqD3X7u2Odf
yyYivZ91DiS23acfLOEQOfBNn2ZFcrLaXy33UAXo1VcvCsKNJY4FfS9A5OBZ4UTL
peagrTnZuRS4KMadg0V9jb5au6+s7jExPty9c+nZ59Kd6IbkPn31l9K5rj4/2WvG
pIj9k5YaXswJVBiTWGKxP9a3xMb9CG9bqNCD5kXo+1K2oDJyGE3mj6QSjlnFw6NN
f+dCOGWSs7JHMNZVVtRG2qsEIssZgpHseu9he684ZqdqrMCG6wBDW58sUBp6Dt6z
jyTLefs8ht0tT+ZcmPno2G3mgs1bLyQsQB8a7fqzzaW6wPwdZJBGO/qI7Zr/30VD
I7InLmxbg62tdrTP4CibXWfe6Qoi6xSNZd7FvP2OoCA7Nk6HahdwDocInB9fWV2j
jkqyeIdDSd9QUItCUSgyVm+XefO/T8B75PNCykyWAMMDGOBE706KZh4oXeMORoYp
LxsbtL0/7n/JPwQDHeLQHHRjiw2ydxH2/940jngnL1YCqWiUq06FPvl3zn+Qgim+
kIhfJeYuQ8zxdh8P7Ay4i5neuum+FQZspPiSzx6jMQIOu+e+iBP2AIdu/UQK+JPU
epE2Pt5aEyuzgNEbg0cR6tQ3rJCbj0DdtU26ale5EeD8y1JYCXEYkED88bMCAwEA
AQKCAgEAtof0E8b7B3dvTGs6Ou2VLbD5H9VjZPqmOONgRLyXPjgPWhH6TKEPa6CC
cBvLm4jj5L46A1zFhp3MpV23tJy3o7InSZNj4PUjg7x/0EibY6h2omZPadz3q97y
grjCbxyZH9tDMcyuLNmZTg7+LyQ7nBCs8vLVMy2KcLsfxYKW0DT4PQFF9BBv5N6N
mX+u5yBTKUnIaQ+Zv6Ct/4qlkySmLIlsjeWwNP9wUqeEbaRKto4QU+Y1Tky4li9z
OoavoJKSu9jI/+BryLqxdWB74XIz5p2K40eK/qN9Xwl55PzkO+x/7n1pAvs/tQUF
GxNg70Hw0k/5DgAIC80SCFTGsG3oKLgPm1BS7Njoz8xcQvtZrYOKfEg/NOjUAWTE
SvXoLRqTQ4bUS6F6VgSA+qEEXrKFGt+ViddXrfuyXow5ZXjstgwuuZSzjLTM9LPF
tKEeB+hYbjpg0C7KuRGG5MfQ6eY8TjB3JCBGSBPw/4gv4DzkRoI2e2Qvgon6pNUT
ZiQMmuQHX3d+5QQErzUgAYF401DBi+9kG6e78hZ5uG3lTUOW372jcAkdkD/DdC1B
GMt7esIoyrO/57gFQXaFIQjSneWPiaxtYxUqpjbc0lCIfwYr3QFYzumZwUErJljl
CxDJ2ejW6ONUXDPRbzprHFDi0y71G7WRT7ZmwoQY/q/Yxwg3mAECggEBAP8+cgZl
001Np3M78KUYuUhDt+6J+ZujJnpCdsWqf0H0cxIA/FL6zpnyYP7nkum/QphE9CST
jFew1/JnuCtHHzE9BryChjL+kjXswFAhGncsP+UjPI1AEliFhPHIfBF25N3LYBvU
IO4syLLUsJsWlAaUbXBD29bSRUYwNPkspmblluZaKdS5fJQR9tiEUkNlPeUcjaMl
Mhblo4r3lZYMkJqm11DGlNUnXb5/kCMq0D+kvhVvoHfRqk5G30m9Yu0QSR6dVlgi
HiPXodNJSz0BZpfM/FXdnhAYnIANgPZS/St9JjpFeDTvo6vZgF9be+Tt29Zm7gxZ
4hvoPCUwE5LhKjMCggEBAPwEEssXK3qkrIYRe1gJjxAkpTHWj5w18QNRRsDvNIT3
Ode2MtloeOl2csIRtvVZWEHWuFiQyvDbVXQvmoeJT+K1acw0mOOkXLME2BLOHTkJ
bYU5zd+dnF3W3CaOUagpesP7QZYiqdso88EugFDt5KtonFRtp/YNY4HxmEahE2I2
KGVN6rFV5WIZsJyXhNCvacci1ZnJqwN/43Vx5ejsqjtypi1XAKlYzGj0ktDbOFGR
vZQdR5Q8rYQ+V7Bypwzbchq9+Udh3Xd8VmosADE0OoATDU6m1SHvsZMxZ83vcs/8
pkwtzMlzo3q/yPSG+jTU7kq0PE8z628ol5sFZrFMmoECggEATQpHFmFDnvCSWzi7
UMmemw49hRVGLtDWu042VUE5+elTlhqQDme/Vj4PQsEY2c6txhIB8sxKLumktHjT
4NQtuQnnb5yh7uBhtz8HaOgk+dV0T7AMBcJSBz/9uZC+yfKt77gEAUJM0jbYOQnz
aEwvT7EbOyhwQW3kFORWCOOOMj6YBl0uhRObY4HslLuTrN3xCadNpPGEJd8YNsi1
8L1IJDW5hZr6rz+bjvUnx0WT57HM4eF4eNHi6o9/s90i79TbjQ8GUcGygTUDlido
OziiA62OeEhU/hy/l/L7et3fpnG2yR3Qw4GVUDhtA9s0EQwuL4+PyFCU68Fz7fGN
5uZpewKCAQEAvBAmHhwaPBlrDVk6XEY11mwiQoDFBmNSiZE7ZXqcDKWZKpoyc/78
S+wyUxR5HbognHEpfB4A86AZsuxbOs2DKcELRHHzrdzXuFfjDpV1RTz91699LGQn
bfeKrdMCqKTbkiiLlwgjDQMQc5bJ9pqwTCFyl6aE8p6nJS8u3XYSSvXzSzXL764T
0RMusox3dmuQWiRqlarizWfAS8JFOX5ywo4Z6DfGrJkxYRkx/l25N1W0zTTUV5C4
Q7lqIqhMdNHF4qLlxRkI9cN5kR1ov08kYLLW+VySLBL8xsTVm94WJZN6XdrHuYVr
94vq4F9hk89aS7EYWFp8VKVMDUkIi0KJAQKCAQEAmt1zJ9MP2xDIbNCY1Kuk3Zoy
oYcCqijK6i/9Aeu+9w8U1hSrcU5SOF4VQbDwB00RzzDPL7K4e77GulEDnanKnEpX
eu4lYuhCgG/G7uECU8jLOUQUVp8c4Fcyp29T0pTkow15TLifUOXAfQGfe8jK/SvI
jpAAwxBDwQ4HNGA3y3HOzmIt5riRLGahASxDpyTDBmFiuRPwyXNxEoO6ZMtaSL9t
ThhMc74EU8qFBBnzfaKkUZshB9jkcpQq800M99Wj5t31A4mNwz1tmAEM/Wvvbhea
Yx2I+nS6CQhg0DMAxGqalTTLWxjY4NK+j6Mb5FVpXGJ5yUef2TWVRUymm5XlSA==
-----END RSA PRIVATE KEY-----
asyncpg-0.13.0/tests/test_test.py 0000664 0003720 0003720 00000002431 13172407302 017632 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import types
import unittest
from asyncpg import _testbase as tb
class BaseSimpleTestCase:
async def test_tests_zero_error(self):
await asyncio.sleep(0.01, loop=self.loop)
1 / 0
class TestTests(unittest.TestCase):
def test_tests_fail_1(self):
SimpleTestCase = types.new_class('SimpleTestCase',
(BaseSimpleTestCase, tb.TestCase))
suite = unittest.TestSuite()
suite.addTest(SimpleTestCase('test_tests_zero_error'))
result = unittest.TestResult()
suite.run(result)
self.assertIn('ZeroDivisionError', result.errors[0][1])
class TestHelpers(tb.TestCase):
async def test_tests_assertLoopErrorHandlerCalled_01(self):
with self.assertRaisesRegex(AssertionError, r'no message.*was logged'):
with self.assertLoopErrorHandlerCalled('aa'):
self.loop.call_exception_handler({'message': 'bb a bb'})
with self.assertLoopErrorHandlerCalled('aa'):
self.loop.call_exception_handler({'message': 'bbaabb'})
asyncpg-0.13.0/tests/test_prepare.py 0000664 0003720 0003720 00000050000 13172407302 020304 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import asyncpg
import gc
import unittest
from asyncpg import _testbase as tb
from asyncpg import exceptions
class TestPrepare(tb.ConnectedTestCase):
async def test_prepare_01(self):
self.assertEqual(self.con._protocol.queries_count, 0)
st = await self.con.prepare('SELECT 1 = $1 AS test')
self.assertEqual(self.con._protocol.queries_count, 0)
self.assertEqual(st.get_query(), 'SELECT 1 = $1 AS test')
rec = await st.fetchrow(1)
self.assertEqual(self.con._protocol.queries_count, 1)
self.assertTrue(rec['test'])
self.assertEqual(len(rec), 1)
self.assertEqual(False, await st.fetchval(10))
self.assertEqual(self.con._protocol.queries_count, 2)
async def test_prepare_02(self):
with self.assertRaisesRegex(Exception, 'column "a" does not exist'):
await self.con.prepare('SELECT a')
async def test_prepare_03(self):
cases = [
('text', ("'NULL'", 'NULL'), [
'aaa',
None
]),
('decimal', ('0', 0), [
123,
123.5,
None
])
]
for type, (none_name, none_val), vals in cases:
st = await self.con.prepare('''
SELECT CASE WHEN $1::{type} IS NULL THEN {default}
ELSE $1::{type} END'''.format(
type=type, default=none_name))
for val in vals:
with self.subTest(type=type, value=val):
res = await st.fetchval(val)
if val is None:
self.assertEqual(res, none_val)
else:
self.assertEqual(res, val)
async def test_prepare_04(self):
s = await self.con.prepare('SELECT $1::smallint')
self.assertEqual(await s.fetchval(10), 10)
s = await self.con.prepare('SELECT $1::smallint * 2')
self.assertEqual(await s.fetchval(10), 20)
s = await self.con.prepare('SELECT generate_series(5,10)')
self.assertEqual(await s.fetchval(), 5)
# Since the "execute" message was sent with a limit=1,
# we will receive a PortalSuspended message, instead of
# CommandComplete. Which means there will be no status
# message set.
self.assertIsNone(s.get_statusmsg())
# Repeat the same test for 'fetchrow()'.
self.assertEqual(await s.fetchrow(), (5,))
self.assertIsNone(s.get_statusmsg())
async def test_prepare_05_unknownoid(self):
s = await self.con.prepare("SELECT 'test'")
self.assertEqual(await s.fetchval(), 'test')
async def test_prepare_06_interrupted_close(self):
stmt = await self.con.prepare('''SELECT pg_sleep(10)''')
fut = self.loop.create_task(stmt.fetch())
await asyncio.sleep(0.2, loop=self.loop)
self.assertFalse(self.con.is_closed())
await self.con.close()
self.assertTrue(self.con.is_closed())
with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError,
'closed in the middle'):
await fut
# Test that it's OK to call close again
await self.con.close()
async def test_prepare_07_interrupted_terminate(self):
stmt = await self.con.prepare('''SELECT pg_sleep(10)''')
fut = self.loop.create_task(stmt.fetchval())
await asyncio.sleep(0.2, loop=self.loop)
self.assertFalse(self.con.is_closed())
self.con.terminate()
self.assertTrue(self.con.is_closed())
with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError,
'closed in the middle'):
await fut
# Test that it's OK to call terminate again
self.con.terminate()
async def test_prepare_08_big_result(self):
stmt = await self.con.prepare('select generate_series(0,10000)')
result = await stmt.fetch()
self.assertEqual(len(result), 10001)
self.assertEqual(
[r[0] for r in result],
list(range(10001)))
async def test_prepare_09_raise_error(self):
# Stress test ReadBuffer.read_cstr()
msg = '0' * 1024 * 100
query = """
DO language plpgsql $$
BEGIN
RAISE EXCEPTION '{}';
END
$$;""".format(msg)
stmt = await self.con.prepare(query)
with self.assertRaisesRegex(asyncpg.RaiseError, msg):
with tb.silence_asyncio_long_exec_warning():
await stmt.fetchval()
async def test_prepare_10_stmt_lru(self):
cache = self.con._stmt_cache
query = 'select {}'
cache_max = cache.get_max_size()
iter_max = cache_max * 2 + 11
# First, we have no cached statements.
self.assertEqual(len(cache), 0)
stmts = []
for i in range(iter_max):
s = await self.con.prepare(query.format(i))
self.assertEqual(await s.fetchval(), i)
stmts.append(s)
# At this point our cache should be full.
self.assertEqual(len(cache), cache_max)
self.assertTrue(all(not s.closed for s in cache.iter_statements()))
# Since there are references to the statements (`stmts` list),
# no statements are scheduled to be closed.
self.assertEqual(len(self.con._stmts_to_close), 0)
# Removing refs to statements and preparing a new statement
# will cause connection to cleanup any stale statements.
stmts.clear()
gc.collect()
# Now we have a bunch of statements that have no refs to them
# scheduled to be closed.
self.assertEqual(len(self.con._stmts_to_close), iter_max - cache_max)
self.assertTrue(all(s.closed for s in self.con._stmts_to_close))
self.assertTrue(all(not s.closed for s in cache.iter_statements()))
zero = await self.con.prepare(query.format(0))
# Hence, all stale statements should be closed now.
self.assertEqual(len(self.con._stmts_to_close), 0)
# The number of cached statements will stay the same though.
self.assertEqual(len(cache), cache_max)
self.assertTrue(all(not s.closed for s in cache.iter_statements()))
# After closing all statements will be closed.
await self.con.close()
self.assertEqual(len(self.con._stmts_to_close), 0)
self.assertEqual(len(cache), 0)
# An attempt to perform an operation on a closed statement
# will trigger an error.
with self.assertRaisesRegex(asyncpg.InterfaceError, 'is closed'):
await zero.fetchval()
async def test_prepare_11_stmt_gc(self):
# Test that prepared statements should stay in the cache after
# they are GCed.
cache = self.con._stmt_cache
# First, we have no cached statements.
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 0)
# The prepared statement that we'll create will be GCed
# right await. However, its state should be still in
# in the statements LRU cache.
await self.con.prepare('select 1')
gc.collect()
self.assertEqual(len(cache), 1)
self.assertEqual(len(self.con._stmts_to_close), 0)
async def test_prepare_12_stmt_gc(self):
# Test that prepared statements are closed when there is no space
# for them in the LRU cache and there are no references to them.
cache = self.con._stmt_cache
cache_max = cache.get_max_size()
# First, we have no cached statements.
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 0)
stmt = await self.con.prepare('select 100000000')
self.assertEqual(len(cache), 1)
self.assertEqual(len(self.con._stmts_to_close), 0)
for i in range(cache_max):
await self.con.prepare('select {}'.format(i))
self.assertEqual(len(cache), cache_max)
self.assertEqual(len(self.con._stmts_to_close), 0)
del stmt
gc.collect()
self.assertEqual(len(cache), cache_max)
self.assertEqual(len(self.con._stmts_to_close), 1)
async def test_prepare_13_connect(self):
v = await self.con.fetchval(
'SELECT $1::smallint AS foo', 10, column='foo')
self.assertEqual(v, 10)
r = await self.con.fetchrow('SELECT $1::smallint * 2 AS test', 10)
self.assertEqual(r['test'], 20)
rows = await self.con.fetch('SELECT generate_series(0,$1::int)', 3)
self.assertEqual([r[0] for r in rows], [0, 1, 2, 3])
async def test_prepare_14_explain(self):
# Test simple EXPLAIN.
stmt = await self.con.prepare('SELECT typname FROM pg_type')
plan = await stmt.explain()
self.assertEqual(plan[0]['Plan']['Relation Name'], 'pg_type')
# Test "EXPLAIN ANALYZE".
stmt = await self.con.prepare(
'SELECT typname, typlen FROM pg_type WHERE typlen > $1')
plan = await stmt.explain(2, analyze=True)
self.assertEqual(plan[0]['Plan']['Relation Name'], 'pg_type')
self.assertIn('Actual Total Time', plan[0]['Plan'])
# Test that 'EXPLAIN ANALYZE' is executed in a transaction
# that gets rollbacked.
tr = self.con.transaction()
await tr.start()
try:
await self.con.execute('CREATE TABLE mytab (a int)')
stmt = await self.con.prepare(
'INSERT INTO mytab (a) VALUES (1), (2)')
plan = await stmt.explain(analyze=True)
self.assertEqual(plan[0]['Plan']['Operation'], 'Insert')
# Check that no data was inserted
res = await self.con.fetch('SELECT * FROM mytab')
self.assertEqual(res, [])
finally:
await tr.rollback()
async def test_prepare_15_stmt_gc_cache_disabled(self):
# Test that even if the statements cache is off, we're still
# cleaning up GCed statements.
cache = self.con._stmt_cache
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 0)
# Disable cache
cache.set_max_size(0)
stmt = await self.con.prepare('select 100000000')
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 0)
del stmt
gc.collect()
# After GC, _stmts_to_close should contain stmt's state
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 1)
# Next "prepare" call will trigger a cleanup
stmt = await self.con.prepare('select 1')
self.assertEqual(len(cache), 0)
self.assertEqual(len(self.con._stmts_to_close), 0)
del stmt
async def test_prepare_16_command_result(self):
async def status(query):
stmt = await self.con.prepare(query)
await stmt.fetch()
return stmt.get_statusmsg()
try:
self.assertEqual(
await status('CREATE TABLE mytab (a int)'),
'CREATE TABLE')
self.assertEqual(
await status('INSERT INTO mytab (a) VALUES (1), (2)'),
'INSERT 0 2')
self.assertEqual(
await status('SELECT a FROM mytab'),
'SELECT 2')
self.assertEqual(
await status('UPDATE mytab SET a = 3 WHERE a = 1'),
'UPDATE 1')
finally:
self.assertEqual(
await status('DROP TABLE mytab'),
'DROP TABLE')
async def test_prepare_17_stmt_closed_lru(self):
st = await self.con.prepare('SELECT 1')
st._state.mark_closed()
with self.assertRaisesRegex(asyncpg.InterfaceError, 'is closed'):
await st.fetch()
st = await self.con.prepare('SELECT 1')
self.assertEqual(await st.fetchval(), 1)
async def test_prepare_18_empty_result(self):
# test EmptyQueryResponse protocol message
st = await self.con.prepare('')
self.assertEqual(await st.fetch(), [])
self.assertIsNone(await st.fetchval())
self.assertIsNone(await st.fetchrow())
self.assertEqual(await self.con.fetch(''), [])
self.assertIsNone(await self.con.fetchval(''))
self.assertIsNone(await self.con.fetchrow(''))
async def test_prepare_19_concurrent_calls(self):
st = self.loop.create_task(self.con.fetchval(
'SELECT ROW(pg_sleep(0.1), 1)'))
# Wait for some time to make sure the first query is fully
# prepared (!) and is now awaiting the results (!!).
await asyncio.sleep(0.01, loop=self.loop)
with self.assertRaisesRegex(asyncpg.InterfaceError,
'another operation'):
await self.con.execute('SELECT 2')
self.assertEqual(await st, (None, 1))
async def test_prepare_20_concurrent_calls(self):
expected = ((None, 1),)
for methname, val in [('fetch', [expected]),
('fetchval', expected[0]),
('fetchrow', expected)]:
with self.subTest(meth=methname):
meth = getattr(self.con, methname)
vf = self.loop.create_task(
meth('SELECT ROW(pg_sleep(0.1), 1)'))
await asyncio.sleep(0.01, loop=self.loop)
with self.assertRaisesRegex(asyncpg.InterfaceError,
'another operation'):
await meth('SELECT 2')
self.assertEqual(await vf, val)
async def test_prepare_21_errors(self):
stmt = await self.con.prepare('SELECT 10 / $1::int')
with self.assertRaises(asyncpg.DivisionByZeroError):
await stmt.fetchval(0)
self.assertEqual(await stmt.fetchval(5), 2)
async def test_prepare_22_empty(self):
# Support for empty target list was added in PostgreSQL 9.4
if self.server_version < (9, 4):
raise unittest.SkipTest(
'PostgreSQL servers < 9.4 do not support empty target list.')
result = await self.con.fetchrow('SELECT')
self.assertEqual(result, ())
self.assertEqual(repr(result), '')
async def test_prepare_statement_invalid(self):
await self.con.execute('CREATE TABLE tab1(a int, b int)')
try:
await self.con.execute('INSERT INTO tab1 VALUES (1, 2)')
stmt = await self.con.prepare('SELECT * FROM tab1')
await self.con.execute(
'ALTER TABLE tab1 ALTER COLUMN b SET DATA TYPE text')
with self.assertRaisesRegex(asyncpg.InvalidCachedStatementError,
'cached statement plan is invalid'):
await stmt.fetchrow()
finally:
await self.con.execute('DROP TABLE tab1')
@tb.with_connection_options(statement_cache_size=0)
async def test_prepare_23_no_stmt_cache_seq(self):
self.assertEqual(self.con._stmt_cache.get_max_size(), 0)
async def check_simple():
# Run a simple query a few times.
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
self.assertEqual(await self.con.fetchval('SELECT 2'), 2)
self.assertEqual(await self.con.fetchval('SELECT 1'), 1)
await check_simple()
# Run a query that timeouts.
with self.assertRaises(asyncio.TimeoutError):
await self.con.fetchrow('select pg_sleep(10)', timeout=0.02)
# Check that we can run new queries after a timeout.
await check_simple()
# Try a cursor/timeout combination. Cursors should always use
# named prepared statements.
async with self.con.transaction():
with self.assertRaises(asyncio.TimeoutError):
async for _ in self.con.cursor( # NOQA
'select pg_sleep(10)', timeout=0.1):
pass
# Check that we can run queries after a failed cursor
# operation.
await check_simple()
@tb.with_connection_options(max_cached_statement_lifetime=142)
async def test_prepare_24_max_lifetime(self):
cache = self.con._stmt_cache
self.assertEqual(cache.get_max_lifetime(), 142)
cache.set_max_lifetime(1)
s = await self.con.prepare('SELECT 1')
state = s._state
s = await self.con.prepare('SELECT 1')
self.assertIs(s._state, state)
s = await self.con.prepare('SELECT 1')
self.assertIs(s._state, state)
await asyncio.sleep(1, loop=self.loop)
s = await self.con.prepare('SELECT 1')
self.assertIsNot(s._state, state)
@tb.with_connection_options(max_cached_statement_lifetime=0.5)
async def test_prepare_25_max_lifetime_reset(self):
cache = self.con._stmt_cache
s = await self.con.prepare('SELECT 1')
state = s._state
# Disable max_lifetime
cache.set_max_lifetime(0)
await asyncio.sleep(1, loop=self.loop)
# The statement should still be cached (as we disabled the timeout).
s = await self.con.prepare('SELECT 1')
self.assertIs(s._state, state)
@tb.with_connection_options(max_cached_statement_lifetime=0.5)
async def test_prepare_26_max_lifetime_max_size(self):
cache = self.con._stmt_cache
s = await self.con.prepare('SELECT 1')
state = s._state
# Disable max_lifetime
cache.set_max_size(0)
s = await self.con.prepare('SELECT 1')
self.assertIsNot(s._state, state)
# Check that nothing crashes after the initial timeout
await asyncio.sleep(1, loop=self.loop)
@tb.with_connection_options(max_cacheable_statement_size=50)
async def test_prepare_27_max_cacheable_statement_size(self):
cache = self.con._stmt_cache
await self.con.prepare('SELECT 1')
self.assertEqual(len(cache), 1)
# Test that long and explicitly created prepared statements
# are not cached.
await self.con.prepare("SELECT \'" + "a" * 50 + "\'")
self.assertEqual(len(cache), 1)
# Test that implicitly created long prepared statements
# are not cached.
await self.con.fetchval("SELECT \'" + "a" * 50 + "\'")
self.assertEqual(len(cache), 1)
# Test that short prepared statements can still be cached.
await self.con.prepare('SELECT 2')
self.assertEqual(len(cache), 2)
async def test_prepare_28_max_args(self):
N = 32768
args = ','.join('${}'.format(i) for i in range(1, N + 1))
query = 'SELECT ARRAY[{}]'.format(args)
with self.assertRaisesRegex(
exceptions.InterfaceError,
'the number of query arguments cannot exceed 32767'):
await self.con.fetchval(query, *range(1, N + 1))
async def test_prepare_29_duplicates(self):
# In addition to test_record.py, let's have a full functional
# test for records with duplicate keys.
r = await self.con.fetchrow('SELECT 1 as a, 2 as b, 3 as a')
self.assertEqual(list(r.items()), [('a', 1), ('b', 2), ('a', 3)])
self.assertEqual(list(r.keys()), ['a', 'b', 'a'])
self.assertEqual(list(r.values()), [1, 2, 3])
self.assertEqual(r['a'], 3)
self.assertEqual(r['b'], 2)
self.assertEqual(r[0], 1)
self.assertEqual(r[1], 2)
self.assertEqual(r[2], 3)
async def test_prepare_30_invalid_arg_count(self):
with self.assertRaisesRegex(
exceptions.InterfaceError,
'the server expects 1 argument for this query, 0 were passed'):
await self.con.fetchval('SELECT $1::int')
with self.assertRaisesRegex(
exceptions.InterfaceError,
'the server expects 0 arguments for this query, 1 was passed'):
await self.con.fetchval('SELECT 1', 1)
asyncpg-0.13.0/tests/test_pool.py 0000664 0003720 0003720 00000061673 13172407302 017641 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import asyncpg
import inspect
import os
import platform
import random
import time
import unittest
from asyncpg import _testbase as tb
from asyncpg import connection as pg_connection
from asyncpg import cluster as pg_cluster
from asyncpg import pool as pg_pool
_system = platform.uname().system
if os.environ.get('TRAVIS_OS_NAME') == 'osx':
# Travis' macOS is _slow_.
POOL_NOMINAL_TIMEOUT = 0.5
else:
POOL_NOMINAL_TIMEOUT = 0.1
class SlowResetConnection(pg_connection.Connection):
"""Connection class to simulate races with Connection.reset()."""
async def reset(self):
await asyncio.sleep(0.2, loop=self._loop)
return await super().reset()
class SlowResetConnectionPool(pg_pool.Pool):
async def _connect(self, *args, **kwargs):
return await pg_connection.connect(
*args, connection_class=SlowResetConnection, **kwargs)
class TestPool(tb.ConnectedTestCase):
async def test_pool_01(self):
for n in {1, 5, 10, 20, 100}:
with self.subTest(tasksnum=n):
pool = await self.create_pool(database='postgres',
min_size=5, max_size=10)
async def worker():
con = await pool.acquire()
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await pool.release(con)
tasks = [worker() for _ in range(n)]
await asyncio.gather(*tasks, loop=self.loop)
await pool.close()
async def test_pool_02(self):
for n in {1, 3, 5, 10, 20, 100}:
with self.subTest(tasksnum=n):
async with self.create_pool(database='postgres',
min_size=5, max_size=5) as pool:
async def worker():
con = await pool.acquire(timeout=5)
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await pool.release(con)
tasks = [worker() for _ in range(n)]
await asyncio.gather(*tasks, loop=self.loop)
async def test_pool_03(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool.acquire(timeout=1)
with self.assertRaises(asyncio.TimeoutError):
await pool.acquire(timeout=0.03)
pool.terminate()
del con
async def test_pool_04(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool.acquire(timeout=POOL_NOMINAL_TIMEOUT)
con.terminate()
await pool.release(con)
async with pool.acquire(timeout=POOL_NOMINAL_TIMEOUT) as con:
con.terminate()
con = await pool.acquire(timeout=POOL_NOMINAL_TIMEOUT)
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await pool.close()
async def test_pool_05(self):
for n in {1, 3, 5, 10, 20, 100}:
with self.subTest(tasksnum=n):
pool = await self.create_pool(database='postgres',
min_size=5, max_size=10)
async def worker():
async with pool.acquire() as con:
self.assertEqual(await con.fetchval('SELECT 1'), 1)
tasks = [worker() for _ in range(n)]
await asyncio.gather(*tasks, loop=self.loop)
await pool.close()
async def test_pool_06(self):
fut = asyncio.Future(loop=self.loop)
async def setup(con):
fut.set_result(con)
async with self.create_pool(database='postgres',
min_size=5, max_size=5,
setup=setup) as pool:
con = await pool.acquire()
self.assertIs(con, await fut)
async def test_pool_07(self):
cons = set()
async def setup(con):
if con._con not in cons: # `con` is `PoolConnectionProxy`.
raise RuntimeError('init was not called before setup')
async def init(con):
if con in cons:
raise RuntimeError('init was called more than once')
cons.add(con)
async def user(pool):
async with pool.acquire() as con:
if con._con not in cons: # `con` is `PoolConnectionProxy`.
raise RuntimeError('init was not called')
async with self.create_pool(database='postgres',
min_size=2, max_size=5,
init=init,
setup=setup) as pool:
users = asyncio.gather(*[user(pool) for _ in range(10)],
loop=self.loop)
await users
self.assertEqual(len(cons), 5)
async def test_pool_08(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool.acquire(timeout=POOL_NOMINAL_TIMEOUT)
with self.assertRaisesRegex(asyncpg.InterfaceError, 'is not a member'):
await pool.release(con._con)
async def test_pool_09(self):
pool1 = await self.create_pool(database='postgres',
min_size=1, max_size=1)
pool2 = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool1.acquire(timeout=POOL_NOMINAL_TIMEOUT)
with self.assertRaisesRegex(asyncpg.InterfaceError, 'is not a member'):
await pool2.release(con)
await pool1.close()
await pool2.close()
async def test_pool_10(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool.acquire()
await pool.release(con)
await pool.release(con)
await pool.close()
async def test_pool_11(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
async with pool.acquire() as con:
self.assertIn(repr(con._con), repr(con)) # Test __repr__.
ps = await con.prepare('SELECT 1')
async with con.transaction():
cur = await con.cursor('SELECT 1')
ps_cur = await ps.cursor()
self.assertIn('[released]', repr(con))
with self.assertRaisesRegex(
asyncpg.InterfaceError,
r'cannot call Connection\.execute.*released back to the pool'):
con.execute('select 1')
for meth in ('fetchval', 'fetchrow', 'fetch', 'explain',
'get_query', 'get_statusmsg', 'get_parameters',
'get_attributes'):
with self.assertRaisesRegex(
asyncpg.InterfaceError,
r'cannot call PreparedStatement\.{meth}.*released '
r'back to the pool'.format(meth=meth)):
getattr(ps, meth)()
for c in (cur, ps_cur):
for meth in ('fetch', 'fetchrow'):
with self.assertRaisesRegex(
asyncpg.InterfaceError,
r'cannot call Cursor\.{meth}.*released '
r'back to the pool'.format(meth=meth)):
getattr(c, meth)()
with self.assertRaisesRegex(
asyncpg.InterfaceError,
r'cannot call Cursor\.forward.*released '
r'back to the pool'.format(meth=meth)):
c.forward(1)
await pool.close()
async def test_pool_12(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
async with pool.acquire() as con:
self.assertTrue(isinstance(con, pg_connection.Connection))
self.assertFalse(isinstance(con, list))
await pool.close()
async def test_pool_13(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
async with pool.acquire() as con:
self.assertIn('Execute an SQL command', con.execute.__doc__)
self.assertEqual(con.execute.__name__, 'execute')
self.assertIn(
str(inspect.signature(con.execute))[1:],
str(inspect.signature(pg_connection.Connection.execute)))
await pool.close()
def test_pool_init_run_until_complete(self):
pool_init = self.create_pool(database='postgres')
pool = self.loop.run_until_complete(pool_init)
self.assertIsInstance(pool, asyncpg.pool.Pool)
async def test_pool_exception_in_setup_and_init(self):
class Error(Exception):
pass
async def setup(con):
nonlocal setup_calls
setup_calls += 1
if setup_calls > 1:
cons.append(con)
else:
cons.append('error')
raise Error
with self.subTest(method='setup'):
setup_calls = 0
cons = []
async with self.create_pool(database='postgres',
min_size=1, max_size=1,
setup=setup) as pool:
with self.assertRaises(Error):
await pool.acquire()
con = await pool.acquire()
self.assertEqual(cons, ['error', con])
with self.subTest(method='init'):
setup_calls = 0
cons = []
async with self.create_pool(database='postgres',
min_size=0, max_size=1,
init=setup) as pool:
with self.assertRaises(Error):
await pool.acquire()
con = await pool.acquire()
self.assertEqual(await con.fetchval('select 1::int'), 1)
self.assertEqual(cons, ['error', con._con])
async def test_pool_auth(self):
if not self.cluster.is_managed():
self.skipTest('unmanaged cluster')
self.cluster.reset_hba()
if _system != 'Windows':
self.cluster.add_hba_entry(
type='local',
database='postgres', user='pooluser',
auth_method='md5')
self.cluster.add_hba_entry(
type='host', address='127.0.0.1/32',
database='postgres', user='pooluser',
auth_method='md5')
self.cluster.add_hba_entry(
type='host', address='::1/128',
database='postgres', user='pooluser',
auth_method='md5')
self.cluster.reload()
try:
await self.con.execute('''
CREATE ROLE pooluser WITH LOGIN PASSWORD 'poolpassword'
''')
pool = await self.create_pool(database='postgres',
user='pooluser',
password='poolpassword',
min_size=5, max_size=10)
async def worker():
con = await pool.acquire()
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await pool.release(con)
tasks = [worker() for _ in range(5)]
await asyncio.gather(*tasks, loop=self.loop)
await pool.close()
finally:
await self.con.execute('DROP ROLE pooluser')
# Reset cluster's pg_hba.conf since we've meddled with it
self.cluster.trust_local_connections()
self.cluster.reload()
async def test_pool_handles_cancel_in_release(self):
# Use SlowResetConnectionPool to simulate
# the Task.cancel() and __aexit__ race.
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1,
pool_class=SlowResetConnectionPool)
async def worker():
async with pool.acquire():
pass
task = self.loop.create_task(worker())
# Let the worker() run.
await asyncio.sleep(0.1, loop=self.loop)
# Cancel the worker.
task.cancel()
# Wait to make sure the cleanup has completed.
await asyncio.sleep(0.4, loop=self.loop)
# Check that the connection has been returned to the pool.
self.assertEqual(pool._queue.qsize(), 1)
async def test_pool_no_acquire_deadlock(self):
async with self.create_pool(database='postgres',
min_size=1, max_size=1,
max_queries=1) as pool:
async def sleep_and_release():
async with pool.acquire() as con:
await con.execute('SELECT pg_sleep(1)')
asyncio.ensure_future(sleep_and_release(), loop=self.loop)
await asyncio.sleep(0.5, loop=self.loop)
async with pool.acquire() as con:
await con.fetchval('SELECT 1')
async def test_pool_config_persistence(self):
N = 100
cons = set()
class MyConnection(asyncpg.Connection):
async def foo(self):
return 42
async def fetchval(self, query):
res = await super().fetchval(query)
return res + 1
async def test(pool):
async with pool.acquire() as con:
self.assertEqual(await con.fetchval('SELECT 1'), 2)
self.assertEqual(await con.foo(), 42)
self.assertTrue(isinstance(con, MyConnection))
self.assertEqual(con._con._config.statement_cache_size, 3)
cons.add(con)
async with self.create_pool(
database='postgres', min_size=10, max_size=10,
max_queries=1, connection_class=MyConnection,
statement_cache_size=3) as pool:
await asyncio.gather(*[test(pool) for _ in range(N)],
loop=self.loop)
self.assertEqual(len(cons), N)
async def test_pool_release_in_xact(self):
"""Test that Connection.reset() closes any open transaction."""
async with self.create_pool(database='postgres',
min_size=1, max_size=1) as pool:
async def get_xact_id(con):
return await con.fetchval('select txid_current()')
with self.assertLoopErrorHandlerCalled('an active transaction'):
async with pool.acquire() as con:
real_con = con._con # unwrap PoolConnectionProxy
id1 = await get_xact_id(con)
tr = con.transaction()
self.assertIsNone(con._con._top_xact)
await tr.start()
self.assertIs(real_con._top_xact, tr)
id2 = await get_xact_id(con)
self.assertNotEqual(id1, id2)
self.assertIsNone(real_con._top_xact)
async with pool.acquire() as con:
self.assertIs(con._con, real_con)
self.assertIsNone(con._con._top_xact)
id3 = await get_xact_id(con)
self.assertNotEqual(id2, id3)
async def test_pool_connection_methods(self):
async def test_fetch(pool):
i = random.randint(0, 20)
await asyncio.sleep(random.random() / 100, loop=self.loop)
r = await pool.fetch('SELECT {}::int'.format(i))
self.assertEqual(r, [(i,)])
return 1
async def test_fetchrow(pool):
i = random.randint(0, 20)
await asyncio.sleep(random.random() / 100, loop=self.loop)
r = await pool.fetchrow('SELECT {}::int'.format(i))
self.assertEqual(r, (i,))
return 1
async def test_fetchval(pool):
i = random.randint(0, 20)
await asyncio.sleep(random.random() / 100, loop=self.loop)
r = await pool.fetchval('SELECT {}::int'.format(i))
self.assertEqual(r, i)
return 1
async def test_execute(pool):
await asyncio.sleep(random.random() / 100, loop=self.loop)
r = await pool.execute('SELECT generate_series(0, 10)')
self.assertEqual(r, 'SELECT {}'.format(11))
return 1
async def test_execute_with_arg(pool):
i = random.randint(0, 20)
await asyncio.sleep(random.random() / 100, loop=self.loop)
r = await pool.execute('SELECT generate_series(0, $1)', i)
self.assertEqual(r, 'SELECT {}'.format(i + 1))
return 1
async def run(N, meth):
async with self.create_pool(database='postgres',
min_size=5, max_size=10) as pool:
coros = [meth(pool) for _ in range(N)]
res = await asyncio.gather(*coros, loop=self.loop)
self.assertEqual(res, [1] * N)
methods = [test_fetch, test_fetchrow, test_fetchval,
test_execute, test_execute_with_arg]
for method in methods:
with self.subTest(method=method.__name__):
await run(200, method)
async def test_pool_connection_execute_many(self):
async def worker(pool):
await asyncio.sleep(random.random() / 100, loop=self.loop)
await pool.executemany('''
INSERT INTO exmany VALUES($1, $2)
''', [
('a', 1), ('b', 2), ('c', 3), ('d', 4)
])
return 1
N = 200
async with self.create_pool(database='postgres',
min_size=5, max_size=10) as pool:
await pool.execute('CREATE TABLE exmany (a text, b int)')
try:
coros = [worker(pool) for _ in range(N)]
res = await asyncio.gather(*coros, loop=self.loop)
self.assertEqual(res, [1] * N)
n_rows = await pool.fetchval('SELECT count(*) FROM exmany')
self.assertEqual(n_rows, N * 4)
finally:
await pool.execute('DROP TABLE exmany')
async def test_pool_max_inactive_time_01(self):
async with self.create_pool(
database='postgres', min_size=1, max_size=1,
max_inactive_connection_lifetime=0.1) as pool:
# Test that it's OK if a query takes longer time to execute
# than `max_inactive_connection_lifetime`.
con = pool._holders[0]._con
for _ in range(3):
await pool.execute('SELECT pg_sleep(0.5)')
self.assertIs(pool._holders[0]._con, con)
self.assertEqual(
await pool.execute('SELECT 1::int'),
'SELECT 1')
self.assertIs(pool._holders[0]._con, con)
async def test_pool_max_inactive_time_02(self):
async with self.create_pool(
database='postgres', min_size=1, max_size=1,
max_inactive_connection_lifetime=0.5) as pool:
# Test that we have a new connection after pool not
# being used longer than `max_inactive_connection_lifetime`.
con = pool._holders[0]._con
self.assertEqual(
await pool.execute('SELECT 1::int'),
'SELECT 1')
self.assertIs(pool._holders[0]._con, con)
await asyncio.sleep(1, loop=self.loop)
self.assertIs(pool._holders[0]._con, None)
self.assertEqual(
await pool.execute('SELECT 1::int'),
'SELECT 1')
self.assertIsNot(pool._holders[0]._con, con)
async def test_pool_max_inactive_time_03(self):
async with self.create_pool(
database='postgres', min_size=1, max_size=1,
max_inactive_connection_lifetime=1) as pool:
# Test that we start counting inactive time *after*
# the connection is being released back to the pool.
con = pool._holders[0]._con
await pool.execute('SELECT pg_sleep(0.5)')
await asyncio.sleep(0.6, loop=self.loop)
self.assertIs(pool._holders[0]._con, con)
self.assertEqual(
await pool.execute('SELECT 1::int'),
'SELECT 1')
self.assertIs(pool._holders[0]._con, con)
async def test_pool_max_inactive_time_04(self):
# Chaos test for max_inactive_connection_lifetime.
DURATION = 2.0
START = time.monotonic()
N = 0
async def worker(pool):
nonlocal N
await asyncio.sleep(random.random() / 10 + 0.1, loop=self.loop)
async with pool.acquire() as con:
if random.random() > 0.5:
await con.execute('SELECT pg_sleep({:.2f})'.format(
random.random() / 10))
self.assertEqual(
await con.fetchval('SELECT 42::int'),
42)
if time.monotonic() - START < DURATION:
await worker(pool)
N += 1
async with self.create_pool(
database='postgres', min_size=10, max_size=30,
max_inactive_connection_lifetime=0.1) as pool:
workers = [worker(pool) for _ in range(50)]
await asyncio.gather(*workers, loop=self.loop)
self.assertGreaterEqual(N, 50)
async def test_pool_handles_inactive_connection_errors(self):
pool = await self.create_pool(database='postgres',
min_size=1, max_size=1)
con = await pool.acquire(timeout=POOL_NOMINAL_TIMEOUT)
true_con = con._con
await pool.release(con)
# we simulate network error by terminating the connection
true_con.terminate()
# now pool should reopen terminated connection
con = await pool.acquire(timeout=POOL_NOMINAL_TIMEOUT)
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await con.close()
await pool.close()
@unittest.skipIf(os.environ.get('PGHOST'), 'using remote cluster for testing')
class TestHotStandby(tb.ConnectedTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.master_cluster = cls.start_cluster(
pg_cluster.TempCluster,
server_settings={
'max_wal_senders': 10,
'wal_level': 'hot_standby'
})
con = None
try:
con = cls.loop.run_until_complete(
cls.master_cluster.connect(database='postgres', loop=cls.loop))
cls.loop.run_until_complete(
con.execute('''
CREATE ROLE replication WITH LOGIN REPLICATION
'''))
cls.master_cluster.trust_local_replication_by('replication')
conn_spec = cls.master_cluster.get_connection_spec()
cls.standby_cluster = cls.start_cluster(
pg_cluster.HotStandbyCluster,
cluster_kwargs={
'master': conn_spec,
'replication_user': 'replication'
},
server_settings={
'hot_standby': True
})
finally:
if con is not None:
cls.loop.run_until_complete(con.close())
@classmethod
def tearDownMethod(cls):
cls.standby_cluster.stop()
cls.standby_cluster.destroy()
cls.master_cluster.stop()
cls.master_cluster.destroy()
def create_pool(self, **kwargs):
conn_spec = self.standby_cluster.get_connection_spec()
conn_spec.update(kwargs)
return pg_pool.create_pool(loop=self.loop, **conn_spec)
async def test_standby_pool_01(self):
for n in {1, 3, 5, 10, 20, 100}:
with self.subTest(tasksnum=n):
pool = await self.create_pool(database='postgres',
min_size=5, max_size=10)
async def worker():
con = await pool.acquire()
self.assertEqual(await con.fetchval('SELECT 1'), 1)
await pool.release(con)
tasks = [worker() for _ in range(n)]
await asyncio.gather(*tasks, loop=self.loop)
await pool.close()
async def test_standby_cursors(self):
con = await self.standby_cluster.connect(
database='postgres', loop=self.loop)
try:
async with con.transaction():
cursor = await con.cursor('SELECT 1')
self.assertEqual(await cursor.fetchrow(), (1,))
finally:
await con.close()
asyncpg-0.13.0/tests/__init__.py 0000664 0003720 0003720 00000001024 13172407302 017350 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import sys
import unittest
def suite():
test_loader = unittest.TestLoader()
test_suite = test_loader.discover('.', pattern='test_*.py')
return test_suite
if __name__ == '__main__':
runner = unittest.runner.TextTestRunner()
result = runner.run(suite())
sys.exit(not result.wasSuccessful())
asyncpg-0.13.0/tests/test_codecs.py 0000664 0003720 0003720 00000135434 13172407302 020125 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import datetime
import decimal
import ipaddress
import math
import random
import struct
import uuid
import asyncpg
from asyncpg import _testbase as tb
def _timezone(offset):
minutes = offset // 60
return datetime.timezone(datetime.timedelta(minutes=minutes))
infinity_datetime = datetime.datetime(
datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999)
negative_infinity_datetime = datetime.datetime(
datetime.MINYEAR, 1, 1, 0, 0, 0, 0)
infinity_date = datetime.date(datetime.MAXYEAR, 12, 31)
negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1)
type_samples = [
('bool', 'bool', (
True, False,
)),
('smallint', 'int2', (
-2 ** 15, 2 ** 15 - 1,
-1, 0, 1,
)),
('int', 'int4', (
-2 ** 31, 2 ** 31 - 1,
-1, 0, 1,
)),
('bigint', 'int8', (
-2 ** 63, 2 ** 63 - 1,
-1, 0, 1,
)),
('numeric', 'numeric', (
-(2 ** 64),
2 ** 64,
-(2 ** 128),
2 ** 128,
-1, 0, 1,
decimal.Decimal("0.00000000000000"),
decimal.Decimal("1.00000000000000"),
decimal.Decimal("-1.00000000000000"),
decimal.Decimal("-2.00000000000000"),
decimal.Decimal("1000000000000000.00000000000000"),
decimal.Decimal("-0.00000000000000"),
decimal.Decimal(1234),
decimal.Decimal(-1234),
decimal.Decimal("1234000000.00088883231"),
decimal.Decimal(str(1234.00088883231)),
decimal.Decimal("3123.23111"),
decimal.Decimal("-3123000000.23111"),
decimal.Decimal("3123.2311100000"),
decimal.Decimal("-03123.0023111"),
decimal.Decimal("3123.23111"),
decimal.Decimal("3123.23111"),
decimal.Decimal("10000.23111"),
decimal.Decimal("100000.23111"),
decimal.Decimal("1000000.23111"),
decimal.Decimal("10000000.23111"),
decimal.Decimal("100000000.23111"),
decimal.Decimal("1000000000.23111"),
decimal.Decimal("1000000000.3111"),
decimal.Decimal("1000000000.111"),
decimal.Decimal("1000000000.11"),
decimal.Decimal("100000000.0"),
decimal.Decimal("10000000.0"),
decimal.Decimal("1000000.0"),
decimal.Decimal("100000.0"),
decimal.Decimal("10000.0"),
decimal.Decimal("1000.0"),
decimal.Decimal("100.0"),
decimal.Decimal("100"),
decimal.Decimal("100.1"),
decimal.Decimal("100.12"),
decimal.Decimal("100.123"),
decimal.Decimal("100.1234"),
decimal.Decimal("100.12345"),
decimal.Decimal("100.123456"),
decimal.Decimal("100.1234567"),
decimal.Decimal("100.12345679"),
decimal.Decimal("100.123456790"),
decimal.Decimal("100.123456790000000000000000"),
decimal.Decimal("1.0"),
decimal.Decimal("0.0"),
decimal.Decimal("-1.0"),
decimal.Decimal("1.0E-1000"),
decimal.Decimal("1.0E1000"),
decimal.Decimal("0.000000000000000000000000001"),
decimal.Decimal("0.000000000000010000000000001"),
decimal.Decimal("0.00000000000000000000000001"),
decimal.Decimal("0.00000000100000000000000001"),
decimal.Decimal("0.0000000000000000000000001"),
decimal.Decimal("0.000000000000000000000001"),
decimal.Decimal("0.00000000000000000000001"),
decimal.Decimal("0.0000000000000000000001"),
decimal.Decimal("0.000000000000000000001"),
decimal.Decimal("0.00000000000000000001"),
decimal.Decimal("0.0000000000000000001"),
decimal.Decimal("0.000000000000000001"),
decimal.Decimal("0.00000000000000001"),
decimal.Decimal("0.0000000000000001"),
decimal.Decimal("0.000000000000001"),
decimal.Decimal("0.00000000000001"),
decimal.Decimal("0.0000000000001"),
decimal.Decimal("0.000000000001"),
decimal.Decimal("0.00000000001"),
decimal.Decimal("0.0000000001"),
decimal.Decimal("0.000000001"),
decimal.Decimal("0.00000001"),
decimal.Decimal("0.0000001"),
decimal.Decimal("0.000001"),
decimal.Decimal("0.00001"),
decimal.Decimal("0.0001"),
decimal.Decimal("0.001"),
decimal.Decimal("0.01"),
decimal.Decimal("0.1"),
)),
('bytea', 'bytea', (
bytes(range(256)),
bytes(range(255, -1, -1)),
b'\x00\x00',
b'foo',
b'f' * 1024 * 1024,
dict(input=bytearray(b'\x02\x01'), output=b'\x02\x01'),
)),
('text', 'text', (
'',
'A' * (1024 * 1024 + 11)
)),
('"char"', 'char', (
b'a',
b'b',
b'\x00'
)),
('timestamp', 'timestamp', [
datetime.datetime(3000, 5, 20, 5, 30, 10),
datetime.datetime(2000, 1, 1, 5, 25, 10),
datetime.datetime(500, 1, 1, 5, 25, 10),
datetime.datetime(250, 1, 1, 5, 25, 10),
infinity_datetime,
negative_infinity_datetime,
{'textinput': 'infinity', 'output': infinity_datetime},
{'textinput': '-infinity', 'output': negative_infinity_datetime},
]),
('date', 'date', [
datetime.date(3000, 5, 20),
datetime.date(2000, 1, 1),
datetime.date(500, 1, 1),
infinity_date,
negative_infinity_date,
{'textinput': 'infinity', 'output': infinity_date},
{'textinput': '-infinity', 'output': negative_infinity_date},
]),
('time', 'time', [
datetime.time(12, 15, 20),
datetime.time(0, 1, 1),
datetime.time(23, 59, 59),
]),
('timestamptz', 'timestamptz', [
# It's converted to UTC. When it comes back out, it will be in UTC
# again. The datetime comparison will take the tzinfo into account.
datetime.datetime(1990, 5, 12, 10, 10, 0, tzinfo=_timezone(4000)),
datetime.datetime(1982, 5, 18, 10, 10, 0, tzinfo=_timezone(6000)),
datetime.datetime(1950, 1, 1, 10, 10, 0, tzinfo=_timezone(7000)),
datetime.datetime(1800, 1, 1, 10, 10, 0, tzinfo=_timezone(2000)),
datetime.datetime(2400, 1, 1, 10, 10, 0, tzinfo=_timezone(2000)),
infinity_datetime,
negative_infinity_datetime,
]),
('timetz', 'timetz', [
# timetz retains the offset
datetime.time(10, 10, 0, tzinfo=_timezone(4000)),
datetime.time(10, 10, 0, tzinfo=_timezone(6000)),
datetime.time(10, 10, 0, tzinfo=_timezone(7000)),
datetime.time(10, 10, 0, tzinfo=_timezone(2000)),
datetime.time(22, 30, 0, tzinfo=_timezone(0)),
]),
('interval', 'interval', [
# no months :(
datetime.timedelta(40, 10, 1234),
datetime.timedelta(0, 0, 4321),
datetime.timedelta(0, 0),
datetime.timedelta(-100, 0),
datetime.timedelta(-100, -400),
]),
('uuid', 'uuid', [
uuid.UUID('38a4ff5a-3a56-11e6-a6c2-c8f73323c6d4'),
uuid.UUID('00000000-0000-0000-0000-000000000000'),
{'input': '00000000-0000-0000-0000-000000000000',
'output': uuid.UUID('00000000-0000-0000-0000-000000000000')}
]),
('uuid[]', 'uuid[]', [
[uuid.UUID('38a4ff5a-3a56-11e6-a6c2-c8f73323c6d4'),
uuid.UUID('00000000-0000-0000-0000-000000000000')],
[]
]),
('json', 'json', [
'[1, 2, 3, 4]',
'{"a": [1, 2], "b": 0}'
]),
('jsonb', 'jsonb', [
'[1, 2, 3, 4]',
'{"a": [1, 2], "b": 0}'
], (9, 4)),
('oid[]', 'oid[]', [
[1, 2, 3, 4],
[]
]),
('smallint[]', 'int2[]', [
[1, 2, 3, 4],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0],
[]
]),
('bigint[]', 'int8[]', [
[2 ** 42, -2 ** 54, 0],
[]
]),
('int[]', 'int4[]', [
[2 ** 22, -2 ** 24, 0],
[]
]),
('time[]', 'time[]', [
[datetime.time(12, 15, 20), datetime.time(0, 1, 1)],
[]
]),
('text[]', 'text[]', [
['ABCDE', 'EDCBA'],
[],
['A' * 1024 * 1024] * 10
]),
('float8', 'float8', [
1.1,
-1.1,
0,
2,
1e-4,
-1e-20,
122.2e-100,
2e5,
math.pi,
math.e,
math.inf,
-math.inf,
math.nan,
{'textinput': 'infinity', 'output': math.inf},
{'textinput': '-infinity', 'output': -math.inf},
{'textinput': 'NaN', 'output': math.nan},
]),
('float4', 'float4', [
1.1,
-1.1,
0,
2,
1e-4,
-1e-20,
2e5,
math.pi,
math.e,
math.inf,
-math.inf,
math.nan,
{'textinput': 'infinity', 'output': math.inf},
{'textinput': '-infinity', 'output': -math.inf},
{'textinput': 'NaN', 'output': math.nan},
]),
('cidr', 'cidr', [
ipaddress.IPv4Network('255.255.255.255/32'),
ipaddress.IPv4Network('127.0.0.0/8'),
ipaddress.IPv4Network('127.1.0.0/16'),
ipaddress.IPv4Network('127.1.0.0/18'),
ipaddress.IPv4Network('10.0.0.0/32'),
ipaddress.IPv4Network('0.0.0.0/0'),
ipaddress.IPv6Network('ffff' + ':ffff' * 7 + '/128'),
ipaddress.IPv6Network('::1/128'),
ipaddress.IPv6Network('::/0'),
]),
('inet', 'inet', [
ipaddress.IPv4Address('255.255.255.255'),
ipaddress.IPv4Address('127.0.0.1'),
ipaddress.IPv4Address('0.0.0.0'),
ipaddress.IPv6Address('ffff' + ':ffff' * 7),
ipaddress.IPv6Address('::1'),
ipaddress.IPv6Address('::'),
dict(
input='127.0.0.0/8',
output=ipaddress.IPv4Network('127.0.0.0/8')),
dict(
input='127.0.0.1/32',
output=ipaddress.IPv4Address('127.0.0.1')),
# Postgres appends /32 when casting to text explicitly, but
# *not* in inet_out.
dict(
input='10.11.12.13',
textoutput='10.11.12.13/32'
),
dict(
input=ipaddress.IPv4Address('10.11.12.13'),
textoutput='10.11.12.13/32'
),
dict(
input=ipaddress.IPv4Network('10.11.12.13'),
textoutput='10.11.12.13/32'
),
dict(
textinput='10.11.12.13',
output=ipaddress.IPv4Address('10.11.12.13'),
),
dict(
# Non-zero address bits after the network prefix are permitted
# by postgres, but are invalid in Python
# (and zeroed out by supernet()).
textinput='10.11.12.13/0',
output=ipaddress.IPv4Network('0.0.0.0/0'),
),
]),
('macaddr', 'macaddr', [
'00:00:00:00:00:00',
'ff:ff:ff:ff:ff:ff'
]),
('txid_snapshot', 'txid_snapshot', [
(100, 1000, (100, 200, 300, 400))
]),
('varbit', 'varbit', [
asyncpg.BitString('0000 0001'),
asyncpg.BitString('00010001'),
asyncpg.BitString(''),
asyncpg.BitString(),
asyncpg.BitString.frombytes(b'\x00', bitlength=3),
asyncpg.BitString('0000 0000 1'),
dict(input=b'\x01', output=asyncpg.BitString('0000 0001')),
dict(input=bytearray(b'\x02'), output=asyncpg.BitString('0000 0010')),
]),
('path', 'path', [
asyncpg.Path(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 1.0)),
asyncpg.Path(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 1.0),
is_closed=True),
dict(input=((0.0, 0.0), (1.0, 1.0)),
output=asyncpg.Path(asyncpg.Point(0.0, 0.0),
asyncpg.Point(1.0, 1.0),
is_closed=True)),
dict(input=[(0.0, 0.0), (1.0, 1.0)],
output=asyncpg.Path(asyncpg.Point(0.0, 0.0),
asyncpg.Point(1.0, 1.0),
is_closed=False)),
]),
('point', 'point', [
asyncpg.Point(0.0, 0.0),
asyncpg.Point(1.0, 2.0),
]),
('box', 'box', [
asyncpg.Box((1.0, 2.0), (0.0, 0.0)),
]),
('line', 'line', [
asyncpg.Line(1, 2, 3),
], (9, 4)),
('lseg', 'lseg', [
asyncpg.LineSegment((1, 2), (2, 2)),
]),
('polygon', 'polygon', [
asyncpg.Polygon(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 0.0),
asyncpg.Point(1.0, 1.0), asyncpg.Point(0.0, 1.0)),
]),
('circle', 'circle', [
asyncpg.Circle((0.0, 0.0), 100),
]),
]
class TestCodecs(tb.ConnectedTestCase):
async def test_standard_codecs(self):
"""Test encoding/decoding of standard data types and arrays thereof."""
for (typname, intname, sample_data, *metadata) in type_samples:
if metadata and self.server_version < metadata[0]:
continue
st = await self.con.prepare(
"SELECT $1::" + typname
)
text_in = await self.con.prepare(
"SELECT $1::text::" + typname
)
text_out = await self.con.prepare(
"SELECT $1::" + typname + "::text"
)
for sample in sample_data:
with self.subTest(sample=sample, typname=typname):
stmt = st
if isinstance(sample, dict):
if 'textinput' in sample:
inputval = sample['textinput']
stmt = text_in
else:
inputval = sample['input']
if 'textoutput' in sample:
outputval = sample['textoutput']
if stmt is text_in:
raise ValueError(
'cannot test "textin" and'
' "textout" simultaneously')
stmt = text_out
else:
outputval = sample['output']
else:
inputval = outputval = sample
result = await stmt.fetchval(inputval)
err_msg = (
"unexpected result for {} when passing {!r}: "
"received {!r}, expected {!r}".format(
typname, inputval, result, outputval))
if typname.startswith('float'):
if math.isnan(outputval):
if not math.isnan(result):
self.fail(err_msg)
else:
self.assertTrue(
math.isclose(result, outputval, rel_tol=1e-6),
err_msg)
else:
self.assertEqual(result, outputval, err_msg)
with self.subTest(sample=None, typname=typname):
# Test that None is handled for all types.
rsample = await st.fetchval(None)
self.assertIsNone(rsample)
at = st.get_attributes()
self.assertEqual(at[0].type.name, intname)
async def test_all_builtin_types_handled(self):
from asyncpg.protocol.protocol import TYPEMAP
for oid, typename in TYPEMAP.items():
codec = self.con.get_settings().get_data_codec(oid)
self.assertIsNotNone(
codec,
'core type {} ({}) is unhandled'.format(typename, oid))
async def test_void(self):
res = await self.con.fetchval('select pg_sleep(0)')
self.assertIsNone(res)
await self.con.fetchval('select now($1::void)', '')
def test_bitstring(self):
bitlen = random.randint(0, 1000)
bs = ''.join(random.choice(('1', '0', ' ')) for _ in range(bitlen))
bits = asyncpg.BitString(bs)
sanitized_bs = bs.replace(' ', '')
self.assertEqual(sanitized_bs,
bits.as_string().replace(' ', ''))
expected_bytelen = \
len(sanitized_bs) // 8 + (1 if len(sanitized_bs) % 8 else 0)
self.assertEqual(len(bits.bytes), expected_bytelen)
async def test_interval(self):
res = await self.con.fetchval("SELECT '5 years'::interval")
self.assertEqual(res, datetime.timedelta(days=1825))
res = await self.con.fetchval("SELECT '5 years 1 month'::interval")
self.assertEqual(res, datetime.timedelta(days=1855))
res = await self.con.fetchval("SELECT '-5 years'::interval")
self.assertEqual(res, datetime.timedelta(days=-1825))
res = await self.con.fetchval("SELECT '-5 years -1 month'::interval")
self.assertEqual(res, datetime.timedelta(days=-1855))
async def test_numeric(self):
# Test that we handle dscale correctly.
cases = [
'0.001',
'0.001000',
'1',
'1.00000'
]
for case in cases:
res = await self.con.fetchval(
"SELECT $1::numeric", case)
self.assertEqual(str(res), case)
res = await self.con.fetchval(
"SELECT $1::numeric", decimal.Decimal('NaN'))
self.assertTrue(res.is_nan())
res = await self.con.fetchval(
"SELECT $1::numeric", decimal.Decimal('sNaN'))
self.assertTrue(res.is_nan())
with self.assertRaisesRegex(ValueError, 'numeric type does not '
'support infinite values'):
await self.con.fetchval(
"SELECT $1::numeric", decimal.Decimal('-Inf'))
with self.assertRaisesRegex(ValueError, 'numeric type does not '
'support infinite values'):
await self.con.fetchval(
"SELECT $1::numeric", decimal.Decimal('+Inf'))
with self.assertRaises(decimal.InvalidOperation):
await self.con.fetchval(
"SELECT $1::numeric", 'invalid')
async def test_unhandled_type_fallback(self):
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS isn
''')
try:
input_val = '1436-4522'
res = await self.con.fetchrow('''
SELECT $1::issn AS issn, 42 AS int
''', input_val)
self.assertEqual(res['issn'], input_val)
self.assertEqual(res['int'], 42)
finally:
await self.con.execute('''
DROP EXTENSION isn
''')
async def test_invalid_input(self):
cases = [
('bytea', TypeError, 'a bytes-like object is required', [
1,
'aaa'
]),
('bool', TypeError, 'a boolean is required', [
1,
]),
('int2', TypeError, 'an integer is required', [
'2',
'aa',
]),
('smallint', OverflowError, 'int too big to be encoded as INT2', [
2**256, # check for the same exception for any big numbers
decimal.Decimal("2000000000000000000000000000000"),
0xffff,
0xffffffff,
32768,
-32769
]),
('float4', ValueError, 'float value too large', [
4.1 * 10 ** 40,
-4.1 * 10 ** 40,
]),
('int4', TypeError, 'an integer is required', [
'2',
'aa',
]),
('int', OverflowError, 'int too big to be encoded as INT4', [
2**256, # check for the same exception for any big numbers
decimal.Decimal("2000000000000000000000000000000"),
0xffffffff,
2**31,
-2**31 - 1,
]),
('int8', TypeError, 'an integer is required', [
'2',
'aa',
]),
('bigint', OverflowError, 'int too big to be encoded as INT8', [
2**256, # check for the same exception for any big numbers
decimal.Decimal("2000000000000000000000000000000"),
0xffffffffffffffff,
2**63,
-2**63 - 1,
]),
('text', TypeError, 'expected str, got bytes', [
b'foo'
]),
('text', TypeError, 'expected str, got list', [
[1]
])
]
for typname, errcls, errmsg, data in cases:
stmt = await self.con.prepare("SELECT $1::" + typname)
for sample in data:
with self.subTest(sample=sample, typname=typname):
with self.assertRaisesRegex(errcls, errmsg):
await stmt.fetchval(sample)
async def test_arrays(self):
"""Test encoding/decoding of arrays (particularly multidimensional)."""
cases = [
(
r"SELECT '[1:3][-1:0]={{1,2},{4,5},{6,7}}'::int[]",
[[1, 2], [4, 5], [6, 7]]
),
(
r"SELECT '{{{{{{1}}}}}}'::int[]",
[[[[[[1]]]]]]
),
(
r"SELECT '{1, 2, NULL}'::int[]::anyarray",
[1, 2, None]
),
(
r"SELECT '{}'::int[]",
[]
),
]
for sql, expected in cases:
with self.subTest(sql=sql):
res = await self.con.fetchval(sql)
self.assertEqual(res, expected)
with self.assertRaises(asyncpg.ProgramLimitExceededError):
await self.con.fetchval("SELECT '{{{{{{{1}}}}}}}'::int[]")
cases = [
[None],
[1, 2, 3, 4, 5, 6],
[[1, 2], [4, 5], [6, 7]],
[[[1], [2]], [[4], [5]], [[None], [7]]],
[[[[[[1]]]]]],
[[[[[[None]]]]]]
]
st = await self.con.prepare(
"SELECT $1::int[]"
)
for case in cases:
with self.subTest(case=case):
result = await st.fetchval(case)
err_msg = (
"failed to return array data as-is; "
"gave {!r}, received {!r}".format(
case, result))
self.assertEqual(result, case, err_msg)
with self.assertRaisesRegex(ValueError, 'dimensions'):
await self.con.fetchval(
"SELECT $1::int[]",
[[[[[[[1]]]]]]])
with self.assertRaisesRegex(ValueError, 'non-homogeneous'):
await self.con.fetchval(
"SELECT $1::int[]",
[1, [1]])
with self.assertRaisesRegex(ValueError, 'non-homogeneous'):
await self.con.fetchval(
"SELECT $1::int[]",
[[1], 1, [2]])
with self.assertRaisesRegex(ValueError, 'invalid array element'):
await self.con.fetchval(
"SELECT $1::int[]",
[1, 't', 2])
with self.assertRaisesRegex(ValueError, 'invalid array element'):
await self.con.fetchval(
"SELECT $1::int[]",
[[1], ['t'], [2]])
with self.assertRaisesRegex(TypeError,
'non-trivial iterable expected'):
await self.con.fetchval(
"SELECT $1::int[]",
1)
async def test_composites(self):
"""Test encoding/decoding of composite types."""
await self.con.execute('''
CREATE TYPE test_composite AS (
a int,
b text,
c int[]
)
''')
st = await self.con.prepare('''
SELECT ROW(NULL, 1234, '5678', ROW(42, '42'))
''')
res = await st.fetchval()
self.assertEqual(res, (None, 1234, '5678', (42, '42')))
try:
st = await self.con.prepare('''
SELECT ROW(
NULL,
'5678',
ARRAY[9, NULL, 11]::int[]
)::test_composite AS test
''')
res = await st.fetch()
res = res[0]['test']
self.assertIsNone(res['a'])
self.assertEqual(res['b'], '5678')
self.assertEqual(res['c'], [9, None, 11])
self.assertIsNone(res[0])
self.assertEqual(res[1], '5678')
self.assertEqual(res[2], [9, None, 11])
at = st.get_attributes()
self.assertEqual(len(at), 1)
self.assertEqual(at[0].name, 'test')
self.assertEqual(at[0].type.name, 'test_composite')
self.assertEqual(at[0].type.kind, 'composite')
res = await self.con.fetchval('''
SELECT $1::test_composite
''', res)
finally:
await self.con.execute('DROP TYPE test_composite')
async def test_domains(self):
"""Test encoding/decoding of composite types."""
await self.con.execute('''
CREATE DOMAIN my_dom AS int
''')
await self.con.execute('''
CREATE DOMAIN my_dom2 AS my_dom
''')
try:
st = await self.con.prepare('''
SELECT 3::my_dom2
''')
res = await st.fetchval()
self.assertEqual(res, 3)
st = await self.con.prepare('''
SELECT NULL::my_dom2
''')
res = await st.fetchval()
self.assertIsNone(res)
at = st.get_attributes()
self.assertEqual(len(at), 1)
self.assertEqual(at[0].name, 'my_dom2')
self.assertEqual(at[0].type.name, 'int4')
self.assertEqual(at[0].type.kind, 'scalar')
finally:
await self.con.execute('DROP DOMAIN my_dom2')
await self.con.execute('DROP DOMAIN my_dom')
async def test_range_types(self):
"""Test encoding/decoding of range types."""
cases = [
('int4range', [
[(1, 9), asyncpg.Range(1, 10)],
[asyncpg.Range(0, 9, lower_inc=False, upper_inc=True),
asyncpg.Range(1, 10)],
[(), asyncpg.Range(empty=True)],
[asyncpg.Range(empty=True), asyncpg.Range(empty=True)],
[(None, 2), asyncpg.Range(None, 3)],
[asyncpg.Range(None, 2, upper_inc=True),
asyncpg.Range(None, 3)],
[(2,), asyncpg.Range(2, None)],
[(2, None), asyncpg.Range(2, None)],
[asyncpg.Range(2, None), asyncpg.Range(2, None)],
[(None, None), asyncpg.Range(None, None)],
[asyncpg.Range(None, None), asyncpg.Range(None, None)]
])
]
for (typname, sample_data) in cases:
st = await self.con.prepare(
"SELECT $1::" + typname
)
for sample, expected in sample_data:
with self.subTest(sample=sample, typname=typname):
result = await st.fetchval(sample)
self.assertEqual(result, expected)
with self.assertRaisesRegex(
TypeError, 'list, tuple or Range object expected'):
await self.con.fetch("SELECT $1::int4range", 'aa')
with self.assertRaisesRegex(
ValueError, 'expected 0, 1 or 2 elements'):
await self.con.fetch("SELECT $1::int4range", (0, 2, 3))
async def test_extra_codec_alias(self):
"""Test encoding/decoding of a builtin non-pg_catalog codec."""
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS hstore
''')
try:
await self.con.set_builtin_type_codec(
'hstore', codec_name='pg_contrib.hstore')
cases = [
{'ham': 'spam', 'nada': None},
{}
]
st = await self.con.prepare('''
SELECT $1::hstore AS result
''')
for case in cases:
res = await st.fetchval(case)
self.assertEqual(res, case)
res = await self.con.fetchval('''
SELECT $1::hstore AS result
''', (('foo', '2'), ('bar', '3')))
self.assertEqual(res, {'foo': '2', 'bar': '3'})
with self.assertRaisesRegex(ValueError, 'null value not allowed'):
await self.con.fetchval('''
SELECT $1::hstore AS result
''', {None: '1'})
finally:
await self.con.execute('''
DROP EXTENSION hstore
''')
async def test_custom_codec_text(self):
"""Test encoding/decoding using a custom codec in text mode."""
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS hstore
''')
def hstore_decoder(data):
result = {}
items = data.split(',')
for item in items:
k, _, v = item.partition('=>')
result[k.strip('"')] = v.strip('"')
return result
def hstore_encoder(obj):
return ','.join('{}=>{}'.format(k, v) for k, v in obj.items())
try:
await self.con.set_type_codec('hstore', encoder=hstore_encoder,
decoder=hstore_decoder)
st = await self.con.prepare('''
SELECT $1::hstore AS result
''')
res = await st.fetchrow({'ham': 'spam'})
res = res['result']
self.assertEqual(res, {'ham': 'spam'})
pt = st.get_parameters()
self.assertTrue(isinstance(pt, tuple))
self.assertEqual(len(pt), 1)
self.assertEqual(pt[0].name, 'hstore')
self.assertEqual(pt[0].kind, 'scalar')
self.assertEqual(pt[0].schema, 'public')
at = st.get_attributes()
self.assertTrue(isinstance(at, tuple))
self.assertEqual(len(at), 1)
self.assertEqual(at[0].name, 'result')
self.assertEqual(at[0].type, pt[0])
err = 'cannot use custom codec on non-scalar type public._hstore'
with self.assertRaisesRegex(ValueError, err):
await self.con.set_type_codec('_hstore',
encoder=hstore_encoder,
decoder=hstore_decoder)
await self.con.execute('''
CREATE TYPE mytype AS (a int);
''')
try:
err = 'cannot use custom codec on non-scalar type ' + \
'public.mytype'
with self.assertRaisesRegex(ValueError, err):
await self.con.set_type_codec(
'mytype', encoder=hstore_encoder,
decoder=hstore_decoder)
finally:
await self.con.execute('''
DROP TYPE mytype;
''')
finally:
await self.con.execute('''
DROP EXTENSION hstore
''')
async def test_custom_codec_binary(self):
"""Test encoding/decoding using a custom codec in binary mode."""
await self.con.execute('''
CREATE EXTENSION IF NOT EXISTS hstore
''')
longstruct = struct.Struct('!L')
ulong_unpack = lambda b: longstruct.unpack_from(b)[0]
ulong_pack = longstruct.pack
def hstore_decoder(data):
result = {}
n = ulong_unpack(data)
view = memoryview(data)
ptr = 4
for i in range(n):
klen = ulong_unpack(view[ptr:ptr + 4])
ptr += 4
k = bytes(view[ptr:ptr + klen]).decode()
ptr += klen
vlen = ulong_unpack(view[ptr:ptr + 4])
ptr += 4
if vlen == -1:
v = None
else:
v = bytes(view[ptr:ptr + vlen]).decode()
ptr += vlen
result[k] = v
return result
def hstore_encoder(obj):
buffer = bytearray(ulong_pack(len(obj)))
for k, v in obj.items():
kenc = k.encode()
buffer += ulong_pack(len(kenc)) + kenc
if v is None:
buffer += b'\xFF\xFF\xFF\xFF' # -1
else:
venc = v.encode()
buffer += ulong_pack(len(venc)) + venc
return buffer
try:
await self.con.set_type_codec('hstore', encoder=hstore_encoder,
decoder=hstore_decoder,
format='binary')
st = await self.con.prepare('''
SELECT $1::hstore AS result
''')
res = await st.fetchrow({'ham': 'spam'})
res = res['result']
self.assertEqual(res, {'ham': 'spam'})
pt = st.get_parameters()
self.assertTrue(isinstance(pt, tuple))
self.assertEqual(len(pt), 1)
self.assertEqual(pt[0].name, 'hstore')
self.assertEqual(pt[0].kind, 'scalar')
self.assertEqual(pt[0].schema, 'public')
at = st.get_attributes()
self.assertTrue(isinstance(at, tuple))
self.assertEqual(len(at), 1)
self.assertEqual(at[0].name, 'result')
self.assertEqual(at[0].type, pt[0])
finally:
await self.con.execute('''
DROP EXTENSION hstore
''')
async def test_custom_codec_override_binary(self):
"""Test overriding core codecs."""
import json
conn = await self.cluster.connect(database='postgres', loop=self.loop)
try:
def _encoder(value):
return json.dumps(value).encode('utf-8')
def _decoder(value):
return json.loads(value.decode('utf-8'))
await conn.set_type_codec(
'json', encoder=_encoder, decoder=_decoder,
schema='pg_catalog', format='binary'
)
data = {'foo': 'bar', 'spam': 1}
res = await conn.fetchval('SELECT $1::json', data)
self.assertEqual(data, res)
finally:
await conn.close()
async def test_custom_codec_override_text(self):
"""Test overriding core codecs."""
import json
conn = await self.cluster.connect(database='postgres', loop=self.loop)
try:
def _encoder(value):
return json.dumps(value)
def _decoder(value):
return json.loads(value)
await conn.set_type_codec(
'json', encoder=_encoder, decoder=_decoder,
schema='pg_catalog', format='text'
)
data = {'foo': 'bar', 'spam': 1}
res = await conn.fetchval('SELECT $1::json', data)
self.assertEqual(data, res)
def _encoder(value):
return value
def _decoder(value):
return value
await conn.set_type_codec(
'uuid', encoder=_encoder, decoder=_decoder,
schema='pg_catalog', format='text'
)
data = '14058ad9-0118-4b7e-ac15-01bc13e2ccd1'
res = await conn.fetchval('SELECT $1::uuid', data)
self.assertEqual(res, data)
finally:
await conn.close()
async def test_custom_codec_override_tuple(self):
"""Test overriding core codecs."""
cases = [
('date', (3,), '2000-01-04'),
('date', (2**31 - 1,), 'infinity'),
('date', (-2**31,), '-infinity'),
('time', (60 * 10**6,), '00:01:00'),
('timetz', (60 * 10**6, 12600), '00:01:00-03:30'),
('timestamp', (60 * 10**6,), '2000-01-01 00:01:00'),
('timestamp', (2**63 - 1,), 'infinity'),
('timestamp', (-2**63,), '-infinity'),
('timestamptz', (60 * 10**6,), '1999-12-31 19:01:00',
"tab.v AT TIME ZONE 'EST'"),
('timestamptz', (2**63 - 1,), 'infinity'),
('timestamptz', (-2**63,), '-infinity'),
('interval', (2, 3, 1), '2 mons 3 days 00:00:00.000001')
]
conn = await self.cluster.connect(database='postgres', loop=self.loop)
def _encoder(value):
return tuple(value)
def _decoder(value):
return tuple(value)
try:
for (typename, data, expected_result, *extra) in cases:
with self.subTest(type=typename):
await self.con.execute(
'CREATE TABLE tab (v {})'.format(typename))
try:
await conn.set_type_codec(
typename, encoder=_encoder, decoder=_decoder,
schema='pg_catalog', format='tuple'
)
await conn.execute(
'INSERT INTO tab VALUES ($1)', data)
res = await conn.fetchval('SELECT tab.v FROM tab')
self.assertEqual(res, data)
await conn.reset_type_codec(
typename, schema='pg_catalog')
if extra:
val = extra[0]
else:
val = 'tab.v'
res = await conn.fetchval(
'SELECT ({val})::text FROM tab'.format(val=val))
self.assertEqual(res, expected_result)
finally:
await self.con.execute('DROP TABLE tab')
finally:
await conn.close()
async def test_composites_in_arrays(self):
await self.con.execute('''
CREATE TYPE t AS (a text, b int);
CREATE TABLE tab (d t[]);
''')
try:
await self.con.execute(
'INSERT INTO tab (d) VALUES ($1)',
[('a', 1)])
r = await self.con.fetchval('''
SELECT d FROM tab
''')
self.assertEqual(r, [('a', 1)])
finally:
await self.con.execute('''
DROP TABLE tab;
DROP TYPE t;
''')
async def test_table_as_composite(self):
await self.con.execute('''
CREATE TABLE tab (a text, b int);
INSERT INTO tab VALUES ('1', 1);
''')
try:
r = await self.con.fetchrow('''
SELECT tab FROM tab
''')
self.assertEqual(r, (('1', 1),))
finally:
await self.con.execute('''
DROP TABLE tab;
''')
async def test_relacl_array_type(self):
await self.con.execute(r'''
CREATE USER """u1'";
CREATE USER "{u2";
CREATE USER ",u3";
CREATE USER "u4}";
CREATE USER "u5""";
CREATE USER "u6\""";
CREATE USER "u7\";
CREATE USER norm1;
CREATE USER norm2;
CREATE TABLE t0 (); GRANT SELECT ON t0 TO norm1;
CREATE TABLE t1 (); GRANT SELECT ON t1 TO """u1'";
CREATE TABLE t2 (); GRANT SELECT ON t2 TO "{u2";
CREATE TABLE t3 (); GRANT SELECT ON t3 TO ",u3";
CREATE TABLE t4 (); GRANT SELECT ON t4 TO "u4}";
CREATE TABLE t5 (); GRANT SELECT ON t5 TO "u5""";
CREATE TABLE t6 (); GRANT SELECT ON t6 TO "u6\""";
CREATE TABLE t7 (); GRANT SELECT ON t7 TO "u7\";
CREATE TABLE a1 ();
GRANT SELECT ON a1 TO """u1'";
GRANT SELECT ON a1 TO "{u2";
GRANT SELECT ON a1 TO ",u3";
GRANT SELECT ON a1 TO "norm1";
GRANT SELECT ON a1 TO "u4}";
GRANT SELECT ON a1 TO "u5""";
GRANT SELECT ON a1 TO "u6\""";
GRANT SELECT ON a1 TO "u7\";
GRANT SELECT ON a1 TO "norm2";
CREATE TABLE a2 ();
GRANT SELECT ON a2 TO """u1'" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "{u2" WITH GRANT OPTION;
GRANT SELECT ON a2 TO ",u3" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "norm1" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "u4}" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "u5""" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "u6\""" WITH GRANT OPTION;
GRANT SELECT ON a2 TO "u7\" WITH GRANT OPTION;
SET SESSION AUTHORIZATION """u1'"; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION "{u2"; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION ",u3"; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION "u4}"; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION "u5"""; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION "u6\"""; GRANT SELECT ON a2 TO "norm2";
SET SESSION AUTHORIZATION "u7\"; GRANT SELECT ON a2 TO "norm2";
RESET SESSION AUTHORIZATION;
''')
try:
rows = await self.con.fetch('''
SELECT
relacl,
relacl::text[] AS chk,
relacl::text[]::text AS text_
FROM
pg_catalog.pg_class
WHERE
relacl IS NOT NULL
''')
for row in rows:
self.assertEqual(row['relacl'], row['chk'],)
finally:
await self.con.execute(r'''
DROP TABLE t0;
DROP TABLE t1;
DROP TABLE t2;
DROP TABLE t3;
DROP TABLE t4;
DROP TABLE t5;
DROP TABLE t6;
DROP TABLE t7;
DROP TABLE a1;
DROP TABLE a2;
DROP USER """u1'";
DROP USER "{u2";
DROP USER ",u3";
DROP USER "u4}";
DROP USER "u5""";
DROP USER "u6\""";
DROP USER "u7\";
DROP USER norm1;
DROP USER norm2;
''')
async def test_enum(self):
await self.con.execute('''
CREATE TYPE enum_t AS ENUM ('abc', 'def', 'ghi');
CREATE TABLE tab (
a text,
b enum_t
);
INSERT INTO tab (a, b) VALUES ('foo', 'abc');
INSERT INTO tab (a, b) VALUES ('bar', 'def');
''')
try:
for i in range(10):
r = await self.con.fetch('''
SELECT a, b FROM tab ORDER BY b
''')
self.assertEqual(r, [('foo', 'abc'), ('bar', 'def')])
finally:
await self.con.execute('''
DROP TABLE tab;
DROP TYPE enum_t;
''')
async def test_unknown_type_text_fallback(self):
await self.con.execute(r'CREATE EXTENSION citext')
await self.con.execute(r'''
CREATE DOMAIN citext_dom AS citext
''')
await self.con.execute(r'''
CREATE TYPE citext_range AS RANGE (SUBTYPE = citext)
''')
await self.con.execute(r'''
CREATE TYPE citext_comp AS (t citext)
''')
try:
# Check that plain fallback works.
result = await self.con.fetchval('''
SELECT $1::citext
''', 'citext')
self.assertEqual(result, 'citext')
# Check that domain fallback works.
result = await self.con.fetchval('''
SELECT $1::citext_dom
''', 'citext')
self.assertEqual(result, 'citext')
# Check that array fallback works.
cases = [
['a', 'b'],
[None, 'b'],
[],
[' a', ' b'],
['"a', r'\""'],
[['"a', r'\""'], [',', '",']],
]
for case in cases:
result = await self.con.fetchval('''
SELECT
$1::citext[]
''', case)
self.assertEqual(result, case)
# Text encoding of ranges and composite types
# is not supported yet.
with self.assertRaisesRegex(
RuntimeError,
'text encoding of range types is not supported'):
await self.con.fetchval('''
SELECT
$1::citext_range
''', ['a', 'z'])
with self.assertRaisesRegex(
RuntimeError,
'text encoding of composite types is not supported'):
await self.con.fetchval('''
SELECT
$1::citext_comp
''', ('a',))
# Check that setting a custom codec clears the codec
# cache properly and that subsequent queries work
# as expected.
await self.con.set_type_codec(
'citext', encoder=lambda d: d, decoder=lambda d: 'CI: ' + d)
result = await self.con.fetchval('''
SELECT
$1::citext[]
''', ['a', 'b'])
self.assertEqual(result, ['CI: a', 'CI: b'])
finally:
await self.con.execute(r'DROP TYPE citext_comp')
await self.con.execute(r'DROP TYPE citext_range')
await self.con.execute(r'DROP TYPE citext_dom')
await self.con.execute(r'DROP EXTENSION citext')
async def test_enum_in_array(self):
await self.con.execute('''
CREATE TYPE enum_t AS ENUM ('abc', 'def', 'ghi');
''')
try:
result = await self.con.fetchrow('''SELECT $1::enum_t[];''',
['abc'])
self.assertEqual(result, (['abc'],))
result = await self.con.fetchrow('''SELECT ARRAY[$1::enum_t];''',
'abc')
self.assertEqual(result, (['abc'],))
finally:
await self.con.execute('''
DROP TYPE enum_t;
''')
async def test_enum_and_range(self):
await self.con.execute('''
CREATE TYPE enum_t AS ENUM ('abc', 'def', 'ghi');
CREATE TABLE testtab (
a int4range,
b enum_t
);
INSERT INTO testtab VALUES (
'[10, 20)', 'abc'
);
''')
try:
result = await self.con.fetchrow('''
SELECT testtab.a FROM testtab WHERE testtab.b = $1
''', 'abc')
self.assertEqual(result, (asyncpg.Range(10, 20),))
finally:
await self.con.execute('''
DROP TABLE testtab;
DROP TYPE enum_t;
''')
async def test_no_result(self):
st = await self.con.prepare('rollback')
self.assertTupleEqual(st.get_attributes(), ())
asyncpg-0.13.0/tests/test_connect.py 0000664 0003720 0003720 00000050631 13172407302 020311 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import contextlib
import ipaddress
import os
import platform
import ssl
import unittest
import asyncpg
from asyncpg import _testbase as tb
from asyncpg import connection
from asyncpg import connect_utils
from asyncpg import cluster as pg_cluster
from asyncpg.serverversion import split_server_version_string
_system = platform.uname().system
CERTS = os.path.join(os.path.dirname(__file__), 'certs')
SSL_CA_CERT_FILE = os.path.join(CERTS, 'ca.cert.pem')
SSL_CERT_FILE = os.path.join(CERTS, 'server.cert.pem')
SSL_KEY_FILE = os.path.join(CERTS, 'server.key.pem')
class TestSettings(tb.ConnectedTestCase):
async def test_get_settings_01(self):
self.assertEqual(
self.con.get_settings().client_encoding,
'UTF8')
async def test_server_version_01(self):
version = self.con.get_server_version()
version_num = await self.con.fetchval("SELECT current_setting($1)",
'server_version_num', column=0)
ver_maj = int(version_num[:-4])
ver_min = int(version_num[-4:-2])
ver_fix = int(version_num[-2:])
self.assertEqual(version[:3], (ver_maj, ver_min, ver_fix))
def test_server_version_02(self):
versions = [
("9.2", (9, 2, 0, 'final', 0),),
("9.2.1", (9, 2, 1, 'final', 0),),
("9.4beta1", (9, 4, 0, 'beta', 1),),
("10devel", (10, 0, 0, 'devel', 0),),
("10beta2", (10, 0, 0, 'beta', 2),),
# Despite the fact after version 10 Postgre's second number
# means "micro", it is parsed "as is" to be
# less confusing in comparisons.
("10.1", (10, 1, 0, 'final', 0),),
]
for version, expected in versions:
result = split_server_version_string(version)
self.assertEqual(expected, result)
class TestAuthentication(tb.ConnectedTestCase):
def setUp(self):
super().setUp()
if not self.cluster.is_managed():
self.skipTest('unmanaged cluster')
methods = [
('trust', None),
('reject', None),
('md5', 'correctpassword'),
('password', 'correctpassword'),
]
self.cluster.reset_hba()
create_script = []
for method, password in methods:
create_script.append(
'CREATE ROLE {}_user WITH LOGIN{};'.format(
method,
' PASSWORD {!r}'.format(password) if password else ''
)
)
if _system != 'Windows':
self.cluster.add_hba_entry(
type='local',
database='postgres', user='{}_user'.format(method),
auth_method=method)
self.cluster.add_hba_entry(
type='host', address=ipaddress.ip_network('127.0.0.0/24'),
database='postgres', user='{}_user'.format(method),
auth_method=method)
self.cluster.add_hba_entry(
type='host', address=ipaddress.ip_network('::1/128'),
database='postgres', user='{}_user'.format(method),
auth_method=method)
# Put hba changes into effect
self.cluster.reload()
create_script = '\n'.join(create_script)
self.loop.run_until_complete(self.con.execute(create_script))
def tearDown(self):
# Reset cluster's pg_hba.conf since we've meddled with it
self.cluster.trust_local_connections()
methods = [
'trust',
'reject',
'md5',
'password',
]
drop_script = []
for method in methods:
drop_script.append('DROP ROLE {}_user;'.format(method))
drop_script = '\n'.join(drop_script)
self.loop.run_until_complete(self.con.execute(drop_script))
super().tearDown()
async def _try_connect(self, **kwargs):
# On Windows the server sometimes just closes
# the connection sooner than we receive the
# actual error.
if _system == 'Windows':
for tried in range(3):
try:
return await self.cluster.connect(**kwargs)
except asyncpg.ConnectionDoesNotExistError:
pass
return await self.cluster.connect(**kwargs)
async def test_auth_bad_user(self):
with self.assertRaises(
asyncpg.InvalidAuthorizationSpecificationError):
await self._try_connect(user='__nonexistent__',
database='postgres',
loop=self.loop)
async def test_auth_trust(self):
conn = await self.cluster.connect(
user='trust_user', database='postgres', loop=self.loop)
await conn.close()
async def test_auth_reject(self):
with self.assertRaisesRegex(
asyncpg.InvalidAuthorizationSpecificationError,
'pg_hba.conf rejects connection'):
await self._try_connect(
user='reject_user', database='postgres',
loop=self.loop)
async def test_auth_password_cleartext(self):
conn = await self.cluster.connect(
user='password_user', database='postgres',
password='correctpassword', loop=self.loop)
await conn.close()
with self.assertRaisesRegex(
asyncpg.InvalidPasswordError,
'password authentication failed for user "password_user"'):
await self._try_connect(
user='password_user', database='postgres',
password='wrongpassword', loop=self.loop)
async def test_auth_password_md5(self):
conn = await self.cluster.connect(
user='md5_user', database='postgres', password='correctpassword',
loop=self.loop)
await conn.close()
with self.assertRaisesRegex(
asyncpg.InvalidPasswordError,
'password authentication failed for user "md5_user"'):
await self._try_connect(
user='md5_user', database='postgres', password='wrongpassword',
loop=self.loop)
async def test_auth_unsupported(self):
pass
class TestConnectParams(tb.TestCase):
TESTS = [
{
'env': {
'PGUSER': 'user',
'PGDATABASE': 'testdb',
'PGPASSWORD': 'passw',
'PGHOST': 'host',
'PGPORT': '123'
},
'result': ([('host', 123)], {
'user': 'user',
'password': 'passw',
'database': 'testdb'})
},
{
'env': {
'PGUSER': 'user',
'PGDATABASE': 'testdb',
'PGPASSWORD': 'passw',
'PGHOST': 'host',
'PGPORT': '123'
},
'host': 'host2',
'port': '456',
'user': 'user2',
'password': 'passw2',
'database': 'db2',
'result': ([('host2', 456)], {
'user': 'user2',
'password': 'passw2',
'database': 'db2'})
},
{
'env': {
'PGUSER': 'user',
'PGDATABASE': 'testdb',
'PGPASSWORD': 'passw',
'PGHOST': 'host',
'PGPORT': '123'
},
'dsn': 'postgres://user3:123123@localhost/abcdef',
'host': 'host2',
'port': '456',
'user': 'user2',
'password': 'passw2',
'database': 'db2',
'result': ([('host2', 456)], {
'user': 'user2',
'password': 'passw2',
'database': 'db2'})
},
{
'env': {
'PGUSER': 'user',
'PGDATABASE': 'testdb',
'PGPASSWORD': 'passw',
'PGHOST': 'host',
'PGPORT': '123'
},
'dsn': 'postgres://user3:123123@localhost:5555/abcdef',
'result': ([('localhost', 5555)], {
'user': 'user3',
'password': '123123',
'database': 'abcdef'})
},
{
'dsn': 'postgres://user3:123123@localhost:5555/abcdef',
'result': ([('localhost', 5555)], {
'user': 'user3',
'password': '123123',
'database': 'abcdef'})
},
{
'dsn': 'postgresql://user3:123123@localhost:5555/'
'abcdef?param=sss¶m=123&host=testhost&user=testuser'
'&port=2222&database=testdb',
'host': '127.0.0.1',
'port': '888',
'user': 'me',
'password': 'ask',
'database': 'db',
'result': ([('127.0.0.1', 888)], {
'server_settings': {'param': '123'},
'user': 'me',
'password': 'ask',
'database': 'db'})
},
{
'dsn': 'postgresql://user3:123123@localhost:5555/'
'abcdef?param=sss¶m=123&host=testhost&user=testuser'
'&port=2222&database=testdb',
'host': '127.0.0.1',
'port': '888',
'user': 'me',
'password': 'ask',
'database': 'db',
'server_settings': {'aa': 'bb'},
'result': ([('127.0.0.1', 888)], {
'server_settings': {'aa': 'bb', 'param': '123'},
'user': 'me',
'password': 'ask',
'database': 'db'})
},
{
'dsn': 'postgresql:///dbname?host=/unix_sock/test&user=spam',
'result': ([os.path.join('/unix_sock/test', '.s.PGSQL.5432')], {
'user': 'spam',
'database': 'dbname'})
},
{
'dsn': 'pq:///dbname?host=/unix_sock/test&user=spam',
'error': (ValueError, 'invalid DSN')
},
]
@contextlib.contextmanager
def environ(self, **kwargs):
old_vals = {}
for key in kwargs:
if key in os.environ:
old_vals[key] = os.environ[key]
for key, val in kwargs.items():
if val is None:
if key in os.environ:
del os.environ[key]
else:
os.environ[key] = val
try:
yield
finally:
for key in kwargs:
if key in os.environ:
del os.environ[key]
for key, val in old_vals.items():
os.environ[key] = val
def run_testcase(self, testcase):
env = testcase.get('env', {})
test_env = {'PGHOST': None, 'PGPORT': None,
'PGUSER': None, 'PGPASSWORD': None,
'PGDATABASE': None}
test_env.update(env)
dsn = testcase.get('dsn')
user = testcase.get('user')
port = testcase.get('port')
host = testcase.get('host')
password = testcase.get('password')
database = testcase.get('database')
server_settings = testcase.get('server_settings')
expected = testcase.get('result')
expected_error = testcase.get('error')
if expected is None and expected_error is None:
raise RuntimeError(
'invalid test case: either "result" or "error" key '
'has to be specified')
if expected is not None and expected_error is not None:
raise RuntimeError(
'invalid test case: either "result" or "error" key '
'has to be specified, got both')
with contextlib.ExitStack() as es:
es.enter_context(self.subTest(dsn=dsn, env=env))
es.enter_context(self.environ(**test_env))
if expected_error:
es.enter_context(self.assertRaisesRegex(*expected_error))
addrs, params = connect_utils._parse_connect_dsn_and_args(
dsn=dsn, host=host, port=port, user=user, password=password,
database=database, ssl=None, connect_timeout=None,
server_settings=server_settings)
params = {k: v for k, v in params._asdict().items()
if v is not None}
result = (addrs, params)
if expected is not None:
self.assertEqual(expected, result)
def test_test_connect_params_environ(self):
self.assertNotIn('AAAAAAAAAA123', os.environ)
self.assertNotIn('AAAAAAAAAA456', os.environ)
self.assertNotIn('AAAAAAAAAA789', os.environ)
try:
os.environ['AAAAAAAAAA456'] = '123'
os.environ['AAAAAAAAAA789'] = '123'
with self.environ(AAAAAAAAAA123='1',
AAAAAAAAAA456='2',
AAAAAAAAAA789=None):
self.assertEqual(os.environ['AAAAAAAAAA123'], '1')
self.assertEqual(os.environ['AAAAAAAAAA456'], '2')
self.assertNotIn('AAAAAAAAAA789', os.environ)
self.assertNotIn('AAAAAAAAAA123', os.environ)
self.assertEqual(os.environ['AAAAAAAAAA456'], '123')
self.assertEqual(os.environ['AAAAAAAAAA789'], '123')
finally:
for key in {'AAAAAAAAAA123', 'AAAAAAAAAA456', 'AAAAAAAAAA789'}:
if key in os.environ:
del os.environ[key]
def test_test_connect_params_run_testcase(self):
with self.environ(PGPORT='777'):
self.run_testcase({
'env': {
'PGUSER': '__test__'
},
'host': 'abc',
'result': (
[('abc', 5432)],
{'user': '__test__', 'database': '__test__'}
)
})
def test_connect_params(self):
for testcase in self.TESTS:
self.run_testcase(testcase)
async def test_connect_args_validation(self):
for val in {-1, 'a', True, False, 0}:
with self.assertRaisesRegex(ValueError, 'greater than 0'):
await asyncpg.connect(command_timeout=val, loop=self.loop)
for arg in {'max_cacheable_statement_size',
'max_cached_statement_lifetime',
'statement_cache_size'}:
for val in {None, -1, True, False}:
with self.assertRaisesRegex(ValueError, 'greater or equal'):
await asyncpg.connect(**{arg: val}, loop=self.loop)
class TestConnection(tb.ConnectedTestCase):
async def test_connection_isinstance(self):
self.assertTrue(isinstance(self.con, connection.Connection))
self.assertTrue(isinstance(self.con, object))
self.assertFalse(isinstance(self.con, list))
async def test_connection_use_after_close(self):
def check():
return self.assertRaisesRegex(asyncpg.InterfaceError,
'connection is closed')
await self.con.close()
with check():
await self.con.add_listener('aaa', lambda: None)
with check():
self.con.transaction()
with check():
await self.con.executemany('SELECT 1', [])
with check():
await self.con.set_type_codec('aaa', encoder=None, decoder=None)
with check():
await self.con.set_builtin_type_codec('aaa', codec_name='aaa')
for meth in ('execute', 'fetch', 'fetchval', 'fetchrow',
'prepare', 'cursor'):
with check():
await getattr(self.con, meth)('SELECT 1')
with check():
await self.con.reset()
@unittest.skipIf(os.environ.get('PGHOST'), 'unmanaged cluster')
async def test_connection_ssl_to_no_ssl_server(self):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
with self.assertRaisesRegex(ConnectionError, 'rejected SSL'):
await self.cluster.connect(
host='localhost',
user='ssl_user',
database='postgres',
loop=self.loop,
ssl=ssl_context)
async def test_connection_ssl_unix(self):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
with self.assertRaisesRegex(asyncpg.InterfaceError,
'can only be enabled for TCP addresses'):
await self.cluster.connect(
host='/tmp',
loop=self.loop,
ssl=ssl_context)
async def test_connection_implicit_host(self):
conn_spec = self.cluster.get_connection_spec()
con = await asyncpg.connect(
port=conn_spec.get('port'), database='postgres', loop=self.loop)
await con.close()
@unittest.skipIf(os.environ.get('PGHOST'), 'unmanaged cluster')
class TestSSLConnection(tb.ConnectedTestCase):
@classmethod
def get_server_settings(cls):
conf = super().get_server_settings()
conf.update({
'ssl': 'on',
'ssl_cert_file': SSL_CERT_FILE,
'ssl_key_file': SSL_KEY_FILE,
})
return conf
@classmethod
def setup_cluster(cls):
cls.cluster = cls.start_cluster(
pg_cluster.TempCluster, server_settings=cls.get_server_settings())
def setUp(self):
super().setUp()
self.cluster.reset_hba()
create_script = []
create_script.append('CREATE ROLE ssl_user WITH LOGIN;')
self.cluster.add_hba_entry(
type='hostssl', address=ipaddress.ip_network('127.0.0.0/24'),
database='postgres', user='ssl_user',
auth_method='trust')
self.cluster.add_hba_entry(
type='hostssl', address=ipaddress.ip_network('::1/128'),
database='postgres', user='ssl_user',
auth_method='trust')
# Put hba changes into effect
self.cluster.reload()
create_script = '\n'.join(create_script)
self.loop.run_until_complete(self.con.execute(create_script))
def tearDown(self):
# Reset cluster's pg_hba.conf since we've meddled with it
self.cluster.trust_local_connections()
drop_script = []
drop_script.append('DROP ROLE ssl_user;')
drop_script = '\n'.join(drop_script)
self.loop.run_until_complete(self.con.execute(drop_script))
super().tearDown()
async def test_ssl_connection_custom_context(self):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
con = await self.cluster.connect(
host='localhost',
user='ssl_user',
database='postgres',
loop=self.loop,
ssl=ssl_context)
try:
self.assertEqual(await con.fetchval('SELECT 42'), 42)
with self.assertRaises(asyncio.TimeoutError):
await con.execute('SELECT pg_sleep(5)', timeout=0.5)
self.assertEqual(await con.fetchval('SELECT 43'), 43)
finally:
await con.close()
async def test_ssl_connection_default_context(self):
with self.assertRaisesRegex(ssl.SSLError, 'verify failed'):
await self.cluster.connect(
host='localhost',
user='ssl_user',
database='postgres',
loop=self.loop,
ssl=True)
async def test_ssl_connection_pool(self):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
pool = await self.create_pool(
host='localhost',
user='ssl_user',
database='postgres',
min_size=5,
max_size=10,
ssl=ssl_context)
async def worker():
async with pool.acquire() as con:
self.assertEqual(await con.fetchval('SELECT 42'), 42)
with self.assertRaises(asyncio.TimeoutError):
await con.execute('SELECT pg_sleep(5)', timeout=0.5)
self.assertEqual(await con.fetchval('SELECT 43'), 43)
tasks = [worker() for _ in range(100)]
await asyncio.gather(*tasks, loop=self.loop)
await pool.close()
asyncpg-0.13.0/tests/test_listeners.py 0000664 0003720 0003720 00000020764 13172407302 020674 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
from asyncpg import _testbase as tb
from asyncpg import exceptions
class TestListeners(tb.ClusterTestCase):
async def test_listen_01(self):
async with self.create_pool(database='postgres') as pool:
async with pool.acquire() as con:
q1 = asyncio.Queue(loop=self.loop)
q2 = asyncio.Queue(loop=self.loop)
def listener1(*args):
q1.put_nowait(args)
def listener2(*args):
q2.put_nowait(args)
await con.add_listener('test', listener1)
await con.add_listener('test', listener2)
await con.execute("NOTIFY test, 'aaaa'")
self.assertEqual(
await q1.get(),
(con, con.get_server_pid(), 'test', 'aaaa'))
self.assertEqual(
await q2.get(),
(con, con.get_server_pid(), 'test', 'aaaa'))
await con.remove_listener('test', listener2)
await con.execute("NOTIFY test, 'aaaa'")
self.assertEqual(
await q1.get(),
(con, con.get_server_pid(), 'test', 'aaaa'))
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(q2.get(),
timeout=0.05, loop=self.loop)
await con.reset()
await con.remove_listener('test', listener1)
await con.execute("NOTIFY test, 'aaaa'")
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(q1.get(),
timeout=0.05, loop=self.loop)
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(q2.get(),
timeout=0.05, loop=self.loop)
async def test_listen_02(self):
async with self.create_pool(database='postgres') as pool:
async with pool.acquire() as con1, pool.acquire() as con2:
q1 = asyncio.Queue(loop=self.loop)
def listener1(*args):
q1.put_nowait(args)
await con1.add_listener('ipc', listener1)
await con2.execute("NOTIFY ipc, 'hello'")
self.assertEqual(
await q1.get(),
(con1, con2.get_server_pid(), 'ipc', 'hello'))
await con1.remove_listener('ipc', listener1)
async def test_dangling_listener_warns(self):
async with self.create_pool(database='postgres') as pool:
with self.assertWarnsRegex(
exceptions.InterfaceWarning,
'.*Connection.*is being released to the pool but '
'has 1 active notification listener'):
async with pool.acquire() as con:
def listener1(*args):
pass
await con.add_listener('ipc', listener1)
class TestLogListeners(tb.ConnectedTestCase):
@tb.with_connection_options(server_settings={
'client_min_messages': 'notice'
})
async def test_log_listener_01(self):
q1 = asyncio.Queue(loop=self.loop)
def notice_callb(con, message):
# Message fields depend on PG version, hide some values.
dct = message.as_dict()
del dct['server_source_line']
q1.put_nowait((con, type(message), dct))
async def raise_notice():
await self.con.execute(
"""DO $$
BEGIN RAISE NOTICE 'catch me!'; END;
$$ LANGUAGE plpgsql"""
)
async def raise_warning():
await self.con.execute(
"""DO $$
BEGIN RAISE WARNING 'catch me!'; END;
$$ LANGUAGE plpgsql"""
)
con = self.con
con.add_log_listener(notice_callb)
expected_msg = {
'context': 'PL/pgSQL function inline_code_block line 2 at RAISE',
'message': 'catch me!',
'server_source_filename': 'pl_exec.c',
'server_source_function': 'exec_stmt_raise',
}
expected_msg_notice = {
**expected_msg,
'severity': 'NOTICE',
'severity_en': 'NOTICE',
'sqlstate': '00000',
}
expected_msg_warn = {
**expected_msg,
'severity': 'WARNING',
'severity_en': 'WARNING',
'sqlstate': '01000',
}
if con.get_server_version() < (9, 6):
del expected_msg_notice['context']
del expected_msg_notice['severity_en']
del expected_msg_warn['context']
del expected_msg_warn['severity_en']
await raise_notice()
await raise_warning()
self.assertEqual(
await q1.get(),
(con, exceptions.PostgresLogMessage, expected_msg_notice))
self.assertEqual(
await q1.get(),
(con, exceptions.PostgresWarning, expected_msg_warn))
con.remove_log_listener(notice_callb)
await raise_notice()
self.assertTrue(q1.empty())
con.add_log_listener(notice_callb)
await raise_notice()
await q1.get()
self.assertTrue(q1.empty())
await con.reset()
await raise_notice()
self.assertTrue(q1.empty())
@tb.with_connection_options(server_settings={
'client_min_messages': 'notice'
})
async def test_log_listener_02(self):
q1 = asyncio.Queue(loop=self.loop)
cur_id = None
def notice_callb(con, message):
q1.put_nowait((con, cur_id, message.message))
con = self.con
await con.execute(
"CREATE FUNCTION _test(i INT) RETURNS int LANGUAGE plpgsql AS $$"
" BEGIN"
" RAISE NOTICE '1_%', i;"
" PERFORM pg_sleep(0.1);"
" RAISE NOTICE '2_%', i;"
" RETURN i;"
" END"
"$$"
)
try:
con.add_log_listener(notice_callb)
for cur_id in range(10):
await con.execute("SELECT _test($1)", cur_id)
for cur_id in range(10):
self.assertEqual(
q1.get_nowait(),
(con, cur_id, '1_%s' % cur_id))
self.assertEqual(
q1.get_nowait(),
(con, cur_id, '2_%s' % cur_id))
con.remove_log_listener(notice_callb)
self.assertTrue(q1.empty())
finally:
await con.execute('DROP FUNCTION _test(i INT)')
@tb.with_connection_options(server_settings={
'client_min_messages': 'notice'
})
async def test_log_listener_03(self):
q1 = asyncio.Queue(loop=self.loop)
async def raise_message(level, code):
await self.con.execute("""
DO $$ BEGIN
RAISE {} 'catch me!' USING ERRCODE = '{}';
END; $$ LANGUAGE plpgsql;
""".format(level, code))
def notice_callb(con, message):
# Message fields depend on PG version, hide some values.
q1.put_nowait(message)
self.con.add_log_listener(notice_callb)
await raise_message('WARNING', '99999')
msg = await q1.get()
self.assertIsInstance(msg, exceptions.PostgresWarning)
self.assertEqual(msg.sqlstate, '99999')
await raise_message('WARNING', '01004')
msg = await q1.get()
self.assertIsInstance(msg, exceptions.StringDataRightTruncation)
self.assertEqual(msg.sqlstate, '01004')
with self.assertRaises(exceptions.InvalidCharacterValueForCastError):
await raise_message('', '22018')
self.assertTrue(q1.empty())
async def test_dangling_log_listener_warns(self):
async with self.create_pool(database='postgres') as pool:
with self.assertWarnsRegex(
exceptions.InterfaceWarning,
'.*Connection.*is being released to the pool but '
'has 1 active log listener'):
async with pool.acquire() as con:
def listener1(*args):
pass
con.add_log_listener(listener1)
asyncpg-0.13.0/docs/ 0000775 0003720 0003720 00000000000 13172407445 015040 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/docs/installation.rst 0000664 0003720 0003720 00000002504 13172407302 020264 0 ustar travis travis 0000000 0000000 .. _asyncpg-installation:
Installation
============
**asyncpg** has no external dependencies and the recommended way to
install it is to use **pip**:
.. code-block:: bash
$ pip install asyncpg
.. note::
It is recommended to use **pip** version **8.1** or later to take
advantage of the precompiled wheel packages. Older versions of pip
will ignore the wheel packages and install asyncpg from the source
package. In that case a working C compiler is required.
Building from source
--------------------
If you want to build **asyncpg** from a Git checkout you will need:
* A working C compiler.
* CPython header files. These can usually be obtained by installing
the relevant Python development package: **python3-dev** on Debian/Ubuntu,
**python3-devel** on RHEL/Fedora.
* Cython version 0.24 or later. The easiest way to install it to use
virtualenv and pip, however a system package should also suffice.
* GNU make
Once the above requirements are satisfied, run:
.. code-block:: bash
$ make
At this point you can run the usual ``setup.py`` commands or
``pip install -e .`` to install the newly built version.
.. note::
A debug build can be created by running ``make debug``.
Running tests
-------------
To execute the testsuite simply run:
.. code-block:: bash
$ make test
asyncpg-0.13.0/docs/faq.rst 0000664 0003720 0003720 00000003475 13172407302 016342 0 ustar travis travis 0000000 0000000 .. _asyncpg-faq:
Frequently Asked Questions
==========================
Does asyncpg support DB-API?
No. DB-API is a synchronous API, while asyncpg is based
around an asynchronous I/O model. Thus, full drop-in compatibility
with DB-API is not possible and we decided to design asyncpg API
in a way that is better aligned with PostgreSQL architecture and
terminology. We will release a synchronous DB-API-compatible version
of asyncpg at some point in the future.
Can I use asyncpg with SQLAlchemy ORM?
Short answer: no. asyncpg uses asynchronous execution model
and API, which is fundamentally incompatible with SQLAlchemy.
However, it is possible to use asyncpg and SQLAlchemy Core
with the help of a third-party adapter, such as asyncpgsa_.
Can I use dot-notation with :class:`asyncpg.Record`? It looks cleaner.
We decided against making :class:`asyncpg.Record` a named tuple
because we want to keep the ``Record`` method namespace separate
from the column namespace.
Why can't I use a :ref:`cursor ` outside of a transaction?
Cursors created by a call to
:meth:`Connection.cursor() ` or
:meth:`PreparedStatement.cursor() \
`
cannot be used outside of a transaction. Any such attempt will result in
``InterfaceError``.
To create a cursor usable outside of a transaction, use the
``DECLARE ... CURSOR WITH HOLD`` SQL statement directly.
Why do I get ``PostgresSyntaxError`` when using ``expression IN $1``?
``expression IN $1`` is not a valid PostgreSQL syntax. To check
a value against a sequence use ``expression = any($1::mytype[])``,
where ``mytype`` is the array element type.
.. _asyncpgsa: https://github.com/CanopyTax/asyncpgsa
asyncpg-0.13.0/docs/usage.rst 0000664 0003720 0003720 00000030651 13172407302 016673 0 ustar travis travis 0000000 0000000 .. _asyncpg-examples:
asyncpg Usage
=============
The interaction with the database normally starts with a call to
:func:`connect() `, which establishes
a new database session and returns a new
:class:`Connection ` instance,
which provides methods to run queries and manage transactions.
.. code-block:: python
import asyncio
import asyncpg
import datetime
async def main():
# Establish a connection to an existing database named "test"
# as a "postgres" user.
conn = await asyncpg.connect('postgresql://postgres@localhost/test')
# Execute a statement to create a new table.
await conn.execute('''
CREATE TABLE users(
id serial PRIMARY KEY,
name text,
dob date
)
''')
# Insert a record into the created table.
await conn.execute('''
INSERT INTO users(name, dob) VALUES($1, $2)
''', 'Bob', datetime.date(1984, 3, 1))
# Select a row from the table.
row = await conn.fetchrow(
'SELECT * FROM users WHERE name = $1', 'Bob')
# *row* now contains
# asyncpg.Record(id=1, name='Bob', dob=datetime.date(1984, 3, 1))
# Close the connection.
await conn.close()
asyncio.get_event_loop().run_until_complete(main())
.. note::
asyncpg uses the native PostgreSQL syntax for query arguments: ``$n``.
Type Conversion
---------------
asyncpg automatically converts PostgreSQL types to the corresponding Python
types and vice versa. All standard data types are supported out of the box,
including arrays, composite types, range types, enumerations and any
combination of them. It is possible to supply codecs for non-standard
types or override standard codecs. See :ref:`asyncpg-custom-codecs` for
more information.
The table below shows the correspondence between PostgreSQL and Python types.
+----------------------+-----------------------------------------------------+
| PostgreSQL Type | Python Type |
+======================+=====================================================+
| ``anyarray`` | :class:`list ` |
+----------------------+-----------------------------------------------------+
| ``anyenum`` | :class:`str ` |
+----------------------+-----------------------------------------------------+
| ``anyrange`` | :class:`asyncpg.Range ` |
+----------------------+-----------------------------------------------------+
| ``record`` | :class:`asyncpg.Record`, |
| | :class:`tuple ` |
+----------------------+-----------------------------------------------------+
| ``bit``, ``varbit`` | :class:`asyncpg.BitString `|
+----------------------+-----------------------------------------------------+
| ``bool`` | :class:`bool ` |
+----------------------+-----------------------------------------------------+
| ``box`` | :class:`asyncpg.Box ` |
+----------------------+-----------------------------------------------------+
| ``bytea`` | :class:`bytes ` |
+----------------------+-----------------------------------------------------+
| ``char``, ``name``, | :class:`str ` |
| ``varchar``, | |
| ``text``, | |
| ``xml`` | |
+----------------------+-----------------------------------------------------+
| ``cidr`` | :class:`ipaddress.IPv4Network\ |
| | `, |
| | :class:`ipaddress.IPv6Network\ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``inet`` | :class:`ipaddress.IPv4Network\ |
| | `, |
| | :class:`ipaddress.IPv6Network\ |
| | `, |
| | :class:`ipaddress.IPv4Address\ |
| | `, |
| | :class:`ipaddress.IPv6Address\ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``macaddr`` | :class:`str ` |
+----------------------+-----------------------------------------------------+
| ``circle`` | :class:`asyncpg.Circle ` |
+----------------------+-----------------------------------------------------+
| ``date`` | :class:`datetime.date ` |
+----------------------+-----------------------------------------------------+
| ``time`` | offset-naïve :class:`datetime.time \ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``time with | offset-aware :class:`datetime.time \ |
| timezone`` | ` |
+----------------------+-----------------------------------------------------+
| ``timestamp`` | offset-naïve :class:`datetime.datetime \ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``timestamp with | offset-aware :class:`datetime.datetime \ |
| timezone`` | ` |
+----------------------+-----------------------------------------------------+
| ``interval`` | :class:`datetime.timedelta \ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``float``, | :class:`float ` |
| ``double precision`` | |
+----------------------+-----------------------------------------------------+
| ``smallint``, | :class:`int ` |
| ``integer``, | |
| ``bigint`` | |
+----------------------+-----------------------------------------------------+
| ``numeric`` | :class:`Decimal ` |
+----------------------+-----------------------------------------------------+
| ``json``, ``jsonb`` | :class:`str ` |
+----------------------+-----------------------------------------------------+
| ``line`` | :class:`asyncpg.Line ` |
+----------------------+-----------------------------------------------------+
| ``lseg`` | :class:`asyncpg.LineSegment \ |
| | ` |
+----------------------+-----------------------------------------------------+
| ``money`` | :class:`str ` |
+----------------------+-----------------------------------------------------+
| ``path`` | :class:`asyncpg.Path ` |
+----------------------+-----------------------------------------------------+
| ``point`` | :class:`asyncpg.Point ` |
+----------------------+-----------------------------------------------------+
| ``polygon`` | :class:`asyncpg.Polygon ` |
+----------------------+-----------------------------------------------------+
| ``uuid`` | :class:`uuid.UUID ` |
+----------------------+-----------------------------------------------------+
All other types are encoded and decoded as text by default.
.. _asyncpg-custom-codecs:
Custom Type Conversions
-----------------------
asyncpg allows defining custom type conversion functions both for standard
and user-defined types using the :meth:`Connection.set_type_codec() \
` and
:meth:`Connection.set_builtin_type_codec() \
` methods.
The example below shows how to configure asyncpg to encode and decode
JSON values using the :mod:`json ` module.
.. code-block:: python
import asyncio
import asyncpg
import json
async def main():
conn = await asyncpg.connect('postgresql://postgres@localhost/test')
try:
def _encoder(value):
return json.dumps(value).encode('utf-8')
def _decoder(value):
return json.loads(value.decode('utf-8'))
await conn.set_type_codec(
'json', encoder=_encoder, decoder=_decoder,
schema='pg_catalog', binary=True
)
data = {'foo': 'bar', 'spam': 1}
res = await conn.fetchval('SELECT $1::json', data)
finally:
await conn.close()
asyncio.get_event_loop().run_until_complete(main())
Transactions
------------
To create transactions, the
:meth:`Connection.transaction() ` method
should be used.
The most common way to use transactions is through an ``async with`` statement:
.. code-block:: python
async with connection.transaction():
await connection.execute("INSERT INTO mytable VALUES(1, 2, 3)")
.. note::
When not in an explicit transaction block, any changes to the database
will be applied immediately. This is also known as *auto-commit*.
See the :ref:`asyncpg-api-transaction` API documentation for more information.
Connection Pools
----------------
For server-type type applications, that handle frequent requests and need
the database connection for a short period time while handling a request,
the use of a connection pool is recommended. asyncpg provides an advanced
pool implementation, which eliminates the need to use an external connection
pooler such as PgBouncer.
To create a connection pool, use the
:func:`asyncpg.create_pool ` function.
The resulting :class:`Pool ` object can then be used
to borrow connections from the pool.
Below is an example of how **asyncpg** can be used to implement a simple
Web service that computes the requested power of two.
.. code-block:: python
import asyncio
import asyncpg
from aiohttp import web
async def handle(request):
"""Handle incoming requests."""
pool = request.app['pool']
power = int(request.match_info.get('power', 10))
# Take a connection from the pool.
async with pool.acquire() as connection:
# Open a transaction.
async with connection.transaction():
# Run the query passing the request argument.
result = await connection.fetchval('select 2 ^ $1', power)
return web.Response(
text="2 ^ {} is {}".format(power, result))
async def init_app():
"""Initialize the application server."""
app = web.Application()
# Create a database connection pool
app['pool'] = await asyncpg.create_pool(database='postgres',
user='postgres')
# Configure service routes
app.router.add_route('GET', '/{power:\d+}', handle)
app.router.add_route('GET', '/', handle)
return app
loop = asyncio.get_event_loop()
app = loop.run_until_complete(init_app())
web.run_app(app)
See :ref:`asyncpg-api-pool` API documentation for more information.
asyncpg-0.13.0/docs/api/ 0000775 0003720 0003720 00000000000 13172407445 015611 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/docs/api/index.rst 0000664 0003720 0003720 00000021355 13172407302 017450 0 ustar travis travis 0000000 0000000 .. _asyncpg-api-reference:
=============
API Reference
=============
.. module:: asyncpg
:synopsis: A fast PostgreSQL Database Client Library for Python/asyncio
.. currentmodule:: asyncpg
.. _asyncpg-api-connection:
Connection
==========
.. autofunction:: asyncpg.connection.connect
.. autoclass:: asyncpg.connection.Connection
:members:
.. _asyncpg-api-prepared-stmt:
Prepared Statements
===================
Prepared statements are a PostgreSQL feature that can be used to optimize the
performance of queries that are executed more than once. When a query
is *prepared* by a call to :meth:`Connection.prepare`, the server parses,
analyzes and compiles the query allowing to reuse that work once there is
a need to run the same query again.
.. code-block:: pycon
>>> import asyncpg, asyncio
>>> loop = asyncio.get_event_loop()
>>> async def run():
... conn = await asyncpg.connect()
... stmt = await conn.prepare('''SELECT 2 ^ $1''')
... print(await stmt.fetchval(10))
... print(await stmt.fetchval(20))
...
>>> loop.run_until_complete(run())
1024.0
1048576.0
.. note::
asyncpg automatically maintains a small LRU cache for queries executed
during calls to the :meth:`~Connection.fetch`, :meth:`~Connection.fetchrow`,
or :meth:`~Connection.fetchval` methods.
.. autoclass:: asyncpg.prepared_stmt.PreparedStatement()
:members:
.. _asyncpg-api-transaction:
Transactions
============
The most common way to use transactions is through an ``async with`` statement:
.. code-block:: python
async with connection.transaction():
await connection.execute("INSERT INTO mytable VALUES(1, 2, 3)")
asyncpg supports nested transactions (a nested transaction context will create
a `savepoint`_.):
.. code-block:: python
async with connection.transaction():
await connection.execute('CREATE TABLE mytab (a int)')
try:
# Create a nested transaction:
async with connection.transaction():
await connection.execute('INSERT INTO mytab (a) VALUES (1), (2)')
# This nested transaction will be automatically rolled back:
raise Exception
except:
# Ignore exception
pass
# Because the nested transaction was rolled back, there
# will be nothing in `mytab`.
assert await connection.fetch('SELECT a FROM mytab') == []
Alternatively, transactions can be used without an ``async with`` block:
.. code-block:: python
tr = connection.transaction()
await tr.start()
try:
...
except:
await tr.rollback()
raise
finally:
await tr.commit()
See also the
:meth:`Connection.transaction() `
function.
.. _savepoint: https://www.postgresql.org/docs/current/static/sql-savepoint.html
.. autoclass:: asyncpg.transaction.Transaction()
:members:
.. describe:: async with c:
start and commit/rollback the transaction or savepoint block
automatically when entering and exiting the code inside the
context manager block.
.. _asyncpg-api-cursor:
Cursors
=======
Cursors are useful when there is a need to iterate over the results of
a large query without fetching all rows at once. The cursor interface
provided by asyncpg supports *asynchronous iteration* via the ``async for``
statement, and also a way to read row chunks and skip forward over the
result set.
To iterate over a cursor using a connection object use
:meth:`Connection.cursor() `.
To make the iteration efficient, the cursor will prefetch records to
reduce the number of queries sent to the server:
.. code-block:: python
async def iterate(con: Connection):
async with con.transaction():
# Postgres requires non-scrollable cursors to be created
# and used in a transaction.
async for record in con.cursor('SELECT generate_series(0, 100)'):
print(record)
Or, alternatively, you can iterate over the cursor manually (cursor
won't be prefetching any rows):
.. code-block:: python
async def iterate(con: Connection):
async with con.transaction():
# Postgres requires non-scrollable cursors to be created
# and used in a transaction.
async with con.transaction():
# Create a Cursor object
cur = await con.cursor('SELECT generate_series(0, 100)')
# Move the cursor 10 rows forward
await cur.forward(10)
# Fetch one row and print it
print(await cur.fetchrow())
# Fetch a list of 5 rows and print it
print(await cur.fetch(5))
It's also possible to create cursors from prepared statements:
.. code-block:: python
async def iterate(con: Connection):
# Create a prepared statement that will accept one argument
stmt = await con.prepare('SELECT generate_series(0, $1)')
async with con.transaction():
# Postgres requires non-scrollable cursors to be created
# and used in a transaction.
# Execute the prepared statement passing `10` as the
# argument -- that will generate a series or records
# from 0..10. Iterate over all of them and print every
# record.
async for record in stmt.cursor(10):
print(record)
.. note::
Cursors created by a call to
:meth:`Connection.cursor() ` or
:meth:`PreparedStatement.cursor() `
are *non-scrollable*: they can only be read forwards. To create a scrollable
cursor, use the ``DECLARE ... SCROLL CURSOR`` SQL statement directly.
.. warning::
Cursors created by a call to
:meth:`Connection.cursor() ` or
:meth:`PreparedStatement.cursor() `
cannot be used outside of a transaction. Any such attempt will result in
:exc:`~asyncpg.exceptions.InterfaceError`.
To create a cursor usable outside of a transaction, use the
``DECLARE ... CURSOR WITH HOLD`` SQL statement directly.
.. autoclass:: asyncpg.cursor.CursorFactory()
:members:
.. describe:: async for row in c
Execute the statement and iterate over the results asynchronously.
.. describe:: await c
Execute the statement and return an instance of
:class:`~asyncpg.cursor.Cursor` which can be used to navigate over and
fetch subsets of the query results.
.. autoclass:: asyncpg.cursor.Cursor()
:members:
.. _asyncpg-api-pool:
Connection Pools
================
.. autofunction:: asyncpg.pool.create_pool
.. autoclass:: asyncpg.pool.Pool()
:members:
.. _asyncpg-api-record:
Record Objects
==============
Each row (or composite type value) returned by calls to ``fetch*`` methods
is represented by an instance of the :class:`~asyncpg.Record` object.
``Record`` objects are a tuple-/dict-like hybrid, and allow addressing of
items either by a numeric index or by a field name:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> loop = asyncio.get_event_loop()
>>> conn = loop.run_until_complete(asyncpg.connect())
>>> r = loop.run_until_complete(conn.fetchrow('''
... SELECT oid, rolname, rolsuper FROM pg_roles WHERE rolname = user'''))
>>> r
>>> r['oid']
16388
>>> r[0]
16388
>>> dict(r)
{'oid': 16388, 'rolname': 'elvis', 'rolsuper': True}
>>> tuple(r)
(16388, 'elvis', True)
.. note::
``Record`` objects currently cannot be created from Python code.
.. class:: Record()
A read-only representation of PostgreSQL row.
.. describe:: len(r)
Return the number of fields in record *r*.
.. describe:: r[field]
Return the field of *r* with field name or index *field*.
.. describe:: name in r
Return ``True`` if record *r* has a field named *name*.
.. describe:: iter(r)
Return an iterator over the *values* of the record *r*.
.. method:: values()
Return an iterator over the record values.
.. method:: keys()
Return an iterator over the record field names.
.. method:: items()
Return an iterator over ``(field, value)`` pairs.
.. class:: ConnectionSettings()
A read-only collection of Connection settings.
.. describe:: settings.setting_name
Return the value of the "setting_name" setting. Raises an
``AttributeError`` if the setting is not defined.
Example:
.. code-block:: pycon
>>> connection.get_settings().client_encoding
'UTF8'
Data Types
==========
.. automodule:: asyncpg.types
:members:
asyncpg-0.13.0/docs/conf.py 0000664 0003720 0003720 00000005242 13172407302 016332 0 ustar travis travis 0000000 0000000 #!/usr/bin/env python3
import alabaster
import os
import sys
sys.path.insert(0, os.path.abspath('..'))
version_file = os.path.join(os.path.dirname(os.path.dirname(__file__)),
'asyncpg', '__init__.py')
with open(version_file, 'r') as f:
for line in f:
if line.startswith('__version__ ='):
_, _, version = line.partition('=')
version = version.strip(" \n'\"")
break
else:
raise RuntimeError(
'unable to read the version from asyncpg/__init__.py')
# -- General configuration ------------------------------------------------
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.viewcode',
'sphinx.ext.githubpages',
'sphinx.ext.intersphinx',
'sphinxcontrib.asyncio',
]
add_module_names = False
templates_path = ['_templates']
source_suffix = '.rst'
master_doc = 'index'
project = 'asyncpg'
copyright = '2016-present, the asyncpg authors and contributors'
author = ''
release = version
language = None
exclude_patterns = ['_build']
pygments_style = 'sphinx'
todo_include_todos = False
suppress_warnings = ['image.nonlocal_uri']
# -- Options for HTML output ----------------------------------------------
html_theme = 'sphinx_rtd_theme'
# html_theme_options = {
# 'description': 'asyncpg is a fast PostgreSQL client library for the '
# 'Python asyncio framework',
# 'show_powered_by': False,
# }
html_theme_path = [alabaster.get_path()]
html_title = 'asyncpg Documentation'
html_short_title = 'asyncpg'
html_static_path = ['_static']
html_sidebars = {
'**': [
'about.html',
'navigation.html',
]
}
html_show_sourcelink = False
html_show_sphinx = False
html_show_copyright = True
html_context = {
'css_files': [
'_static/theme_overrides.css',
],
}
htmlhelp_basename = 'asyncpgdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {}
latex_documents = [
(master_doc, 'asyncpg.tex', 'asyncpg Documentation',
author, 'manual'),
]
# -- Options for manual page output ---------------------------------------
man_pages = [
(master_doc, 'asyncpg', 'asyncpg Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
texinfo_documents = [
(master_doc, 'asyncpg', 'asyncpg Documentation',
author, 'asyncpg',
'asyncpg is a fast PostgreSQL client library for the '
'Python asyncio framework',
'Miscellaneous'),
]
# -- Options for intersphinx ----------------------------------------------
intersphinx_mapping = {'python': ('https://docs.python.org/3', None)}
asyncpg-0.13.0/docs/index.rst 0000664 0003720 0003720 00000001304 13172407302 016667 0 ustar travis travis 0000000 0000000 .. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master
:target: https://travis-ci.org/MagicStack/asyncpg
.. image:: https://img.shields.io/pypi/status/asyncpg.svg?maxAge=2592000?style=plastic
:target: https://pypi.python.org/pypi/asyncpg
=======
asyncpg
=======
**asyncpg** is a database interface library designed specifically for
PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python's ``asyncio``
framework.
**asyncpg** requires Python 3.5 or later and is supported for PostgreSQL
versions 9.2 to 10.
Contents
--------
.. toctree::
:maxdepth: 2
installation
usage
api/index
faq
asyncpg-0.13.0/performance.png 0000664 0003720 0003720 00000044001 13172407302 017106 0 ustar travis travis 0000000 0000000 ‰PNG
IHDR æ ì (ñ… tEXtSoftware Adobe ImageReadyqÉe< &iTXtXML:com.adobe.xmp Qšª 0PLTElllåçêVVV†††ÕÖׯºÎ¶¶¶ÇÇÇÛÞæïðò¦¦¦–––ùùù»ÄÖž«Äþþþ-C^ D5IDATxÚìÝ‹b£:¶hQ^Íû\ÿÿß^#ÄK¶³³w¥LÆìsº²‡¶,ÁôÊn \–ÌG 9 h š €æ 9 h @s Ð 4 Í @s Ð 4 9 h š €æ 9 h @s Ð 4 Í @s Ð 4 ¹ c[åã¾ «ªî£øUù˜ ”Æ |·æÚ¬¸“õ«šPPV¯âWå]? ¨{ ðíš«‹H9&õóøácy—Å8ëžÆ |»æÚÉSyW•E1„‚*äõ]RÕ³xá¡ü~„²éšáþÏÓx.LÐ: €¿©¹»ŒÚ˶š¨§4^š”/ÿŽåü‹4¦9 øqÆêýøçÁ4—/IÜ+Š~NÒbÁ=
ë ã]2w,¿Û,_Ù?‰ÿ…æª>üAÝWº$ |%Ýÿ{?ò?ÒÜÝVÍšžM/ìׂ:ÜuKã…‡ò¢ÈJãg™äSÍMé_ÿ'J·õ €æþ@sõ6¢˜Åœ„ûD/WE%åÕ–³
S —ÆŸ×ÜýÈóÿPmú
ÐÜŸi®Ùgs“¶Ôk IUß R´¹¼ÞÔOwùÒøÓš«¶5
í° ï ÐÜ¿Õ\»Šäž”M6ÚÆoA_i¼ÇòÖÂiüiÍõE6î‚B¯ šûÏš›r¸y\p+¬)Û”°¥ñíIjÊûmô3h-7³ýÔr?4Ú ¦½ hî_j®º§eu›7“åŠ|òÊA_Ý Í=”ÛÈdÐZÿ7ÍÝ’Åz šûWš»õ˳J†0©d§¯8hyŒŸáÇcöV=ÄŸÖ\¿Ÿ—™Ëæ €æþHs·é(wÉåC¸öãSPšý¼¾°½ ÐÜ inJšÆ ®ò ¯y¡@?jn]P°¬ª ëÅÓøÓš›îös¥:3-€æ¾@s¡î³R¶EnsZ•Æ·Í]‡òƒÓøóšËçICÈ2uJ ¹ÿ®¹<˶ÚYZ±`^ žÆ åÙ² ®QHãOk.î 4ËÎ9 ¹?Éæ–ncXVäÛ£›ñØuã³òzIßâ Ë4þ¼æî-'Óe¥Y– @s¦¹rÎʺu?:<…d¬²h§4 b—–OG¨»p?|ÿÍ}Jä €æþXs“²pl™120ÈvÛ¥&ñ¢¹‡×åY,ˆÏ¡Lã©9 Í}Á”¶œ—Ím»ôIÁ1 þÛ¿.ÞS[痢ñç5×ÕCYŽ·fÔ%€æþLs·[ÕôõÁ(cU÷û‚c<®‹½Ó×ݺû‘ÚâÏinç,¦;Ù~ç Íý'ÍýKª/{0Éëýæf͇•z šûûšËË/;ÞsÍÝs¹¡ÃóÒ#-€æ¾WsC–Õ¡žj..SËî‰I* @sßšÍ}Ý¡^<Ó2¼ßyU^ûrÍ €æþ†æ¾;”›æn¯vd ÐÜ›jn˜ýŸµBs @sÒ\½ ´ìÖD hî
šËçåç³ææ=ð 4wÍMjëÇ ¹|{â
€æ®¡¹1> 3ìRPzÞ ÐÜ¥4·<ìkb°M ÐÜÅ4w»UCÈè@ š» æB[èŽ @s×Õ €æ®©¹1 V6C9X 4w5ÍÕá (õ<E§ š»”æ&¿·qšƒ’Y7 4w-ÍåEQ6AvÍ´T<³p hîBš«‹lšdY†G[¶ži 4w)Í;ÄÌB š»æÊ°yxýVº9 4w%Í
!ë×mU= hîBš ûÍÙ¼ëœ{s @s×Ò\^Y]Î+ ªÌLK ¹Kin¯œÖÌu÷7^˜ 4w1Í…õáY{ š3 hîbš»ÝòvÎëjÛ Í]Os š£9 ÍÑ €æh hŽæh hŽæh hŽæh hŽæ 4wÍe½í €æ.«¹é!_CåYÍ @s—Ô\3Lk.††é €æ®xon¬ú`º²ñ4K ¹KNAi£é<· hî¢;ÔÁtYmëp ¹?ÖÜØ6íávXWµÝGñ«ò1¯òñƒø³š›=í >™N¯ šû͵Á'E¹ ¨™
«Wñ«ònÞ÷» _ÄÿJsÓß7÷w–é• @s ¹¦Xˆ¾ª—¸~ /¤å]ã¬{ÿkÍMé`Óë• @sÿ]sù]Fu>¶Ã¢£jWÞNwǪgñÂCy&H6÷•Oãÿ¢9 Íý‘æú¢h– BZ¶h«‰zJãõ¨IùôïõV=‰i hîû5w—PLëŠb˜“´a.¸§aÝc¼KæŽå÷Ío¥-ŠþILs @s߯¹l™ä5·fwÓ½·ú1~Ècù¸Í¹ r|ˆi hî4wÏÅÚ½ÅîIظ÷^ï²ÀCyµål!½Kcš šû͵÷¬«š-r®5»›ò±ò1~Ècy½fwS¢W=Ä4 4÷
ªì.¸l]8·[©ô•Æ[p,ßiN4WÓ ÐÜOi®âò¶°Œ{Ÿ²M [ßž¤v¡|—²…áÏ4ÞÌv@Ÿ šûÛëæ²¾Ÿ¶À™ÖÍu‰¾ºš{(_ïñÅÄ.ÿ‹æ<» hîgZÎSEÆaža²ÓW ´<ÆO‚eÐr—½Uñ3^i®™Ëé
ƒç €æþ@sÕ¦«,Lˆüš)(íCüyÍY˜Ä9|ü 0 Íý³æv÷Íæ»i›¾æ…iü¨¹¹¼Ù¤ñç57ù- 5«ûÃÿ$ €æþ¥æŽ3Eš ™xÄæi¼“Ñ¡|'Á`À4þ´æªy2̜֯ ¹Oh®9dsù¾`^ žÆËËe€q}Ø×1þ¬æêYŠeø§{5Þ ¹Oh./–'qusÒ5ÝËãoÊ'ñmìºñYy½Ø,αLãÏjnÖÅ¿Îö$ €æþæÂv9“…¦ÍU먫i§ÔiÕxû, ^¼nÚ^®îÂ2¼òYüYÍ•ÁoU L¥9 ¹?ÑÜ”•Ùü”¹dÚó;Ûm—šÄ‹æ ^×f±`¬LâOj®ïcˆ#¤/7ñ ÐÜ'4wûtsð¹ {ÿí_×ÎÛ…—Ý‹øsš«§ÁÐÝH¨)( @s ¹{›º¯«ýB쪯›—ñ¸%Xé뺦¯ÛâÏhnZ¿WaöfÕ¿ ð ÐÜç4÷/©¾,Áz®¹jÎgá¹^ 4÷šë²/K°^<ì+ ²,‚¾Òx Žå;Õ‰æêÏjn·†ÁÌ ¹¯ÓÜš›íS¶©0o·ç¯Û§láf]of;ðJs²9 ¹/Ó\µ¦^]¢¯î…æ ʇívZHäÒø_jN6 4÷eš+ŸŽLÆAËòɯ ËëCöV=Ä4 4÷CšÛÍŠü¢)(íCüÔ®4 4÷÷5Wîfüoúš
¤ñ«×m“Xæiü/5çÞ ÐÜinŸmrR«¹÷“ÀÿhŽæ €æhŽæ €æhŽæ Ð ÍÑ Í 9š£9š@s4Gs @s4Gs @s4Gs @s4Gs hŽæ.¢¹1¯šÃaºªê>Š_•ß” Ä4€æhîÛ5×dÅD= Ⲻ½ˆ_•wýg}÷"¦9 4Gs߯¹ £ ¬9®—¸~ /¤å]ã¬{Ó š£¹ï×ÜÝVY5ÞÚ»”š)®&qåy}«gñÂCyyeÓ5ÃâË4¦9 4Gsß®¹1+²pˆ.êhÑVó"^š”/ÿŽåü‹4¦9 4Gs߯¹:&q!ûš“´aŽïiX÷ï’¹cùýÏç·’Eÿ$¦9 4Gs߯¹²È–©'ãôC¿j¯wÝÒx᡼(²5ÏËžÄ4€æhîû5—-IÙª½"j/ùZ¿z]µålÔǥ1Í 9šû~Í…ÅzÈŠ2ÎûßR¯1Ü\KãÛCŠ6—oƒŸS¢×>Ä4€æhîû5wOº¦¹ ¥m¬ñô•Æ[p,ßi-ü˜Æ4€æhîû5×ÜuUd}Ý—E˜¹OÙ¦„-oOR»PÞoó)ƒÖÒx3Û' š£¹¿«¹¢Ì£Œ²mYÁ¢¯î…æ ʇmd2h-i ÍÑÜ÷knz”I<¼`§¯8hY¾´<– ³·ê!6h €æhîGîÍ•‡¤Ë 4Gs—ši9lÆ«÷úš•Æš[,«êÂzñ4¦9 4Gs߯¹]ŠÖ„ük[äö<¾mî:”ï$ ˜Æ4€æhîG–‡gÛØb ¤³°yxß6) ˳åq*í¼0î‹E{u¸ë–Ư^w+Šlgö$¦9 4Gs߯¹¶(Æ{Åwc˜E\‡|-_½®Úr¶aÊãÒ˜æ Ð Íý€æš"«Êlš÷?&©×n®¥ñí!E›Ëë5»›½ö!¦9 4Gs? ¹m=Á¼lnk¼}¥ñ ËwZ ?¦1Í 9šûÍ
wÁ
M5 ˜f’ìS¶)aKãÛ“Ô.”÷Û|Ê µ4ÞÌvÀI€æhîoj®,²vIëÊ0#å ¯î…æ ʇmd2h-i ÍÑÜhnìâL’1 éÜN_qв|1hy,?foÕCLs hŽæ~bÝÜÊ,&SP Ð Í]Rs³˜6}Í ÒøQsë‚‚eU]X/žÆ4€æhîû5×µíítm‹Üš ½4¾mî:”ï$ ˜Æ4€æhîû5·[œ|7kö<^x(¿Ëlþu;/ Ocš@s4÷íšË×nËC*³8Ęon>Äc7OZIËë%}‹s,Ó˜æ Ð ÍýÄ‚‚b˜ÖËݳ³y²;¥ŽUí”ÆCLãÒòi{¹º»uËÆ;iLs hŽæ¾_saóÓ,ì€G/§ç¢d»íR“xÑÜÃëò,ÄmTÓ˜æ Ð Í}ÿLË)Ý
ÏúZ4?ÿ+«ŸÇÃÁû×µóváe÷"¦9 4Gs?° kêºÚ»h¬ê¾_ÅãºØ;}ÝýH}Ý~Ó š£¹ŸZ7÷Yª¢û¢#Ñ š£¹³i./¿ìx4€æhîlš²ü«Es hŽæN—Í}Ý¡h ÍÑÜéîÍÑ š£9š£9 4Gs4àèþ÷~ü»©á4Gs4üfÍ]òIs4Gs hŽæhŽæ š£9š£9šhŽæhŽæ Ð ÍÑ Í 9š£9š@s4Gs4€æhŽæh 9š£9š£9€æhŽæh ÍÑ ÍÑ š£9š£9 4Gs4Gs hŽæhŽæ Ð ÍÑ Í4Gs4Gs4Ð ÍÑ Í 9š£9š@s4Gs4€æhŽæh ÍÑ ÍÑ @s4Gs4Gs ÍÑ ÍÑ Í4Gs4Gs hŽæhŽæ Ð ÍÑ Í 9š£9š@s4Gs4Ð ÍÑ ÍÑ @s4Gs4€æhŽæh ÍÑ ÍÑ š£9š£9 4Gs¿FsmSí>‡ªíŸK¿* ó* ?ˆi 9š£¹ Ñ\^«rš¬¸SV¯âWå]?ÅE?¾ˆi 9š£¹ŸÑÜXnš«‹Hý<¾½x]—Å8ëžÆ4Ð ÍÑÜinÊ»¢rªI\y[ß%U=‹ Ê'S6]3,GJcšhŽæhîg4W›æm5±$×£&åÓ¿cÔ[õ$¦9€æhŽæ~Fs]VôY”ØÝxÃ\zOúÇxgÆcùÝfó[i‹¢Ó @s4Gs?£¹òžw-šë‹¢™Këp×-wÃœ‡ò±(²5ÏËƇ˜æ š£9šûÍÕSÞ•mwÔ¢“ò¯¥ñ¦Æcyµål!½KcšhŽæhîG4—‡¼lÑ\¶&ac¸é–Æ·-E;”×kv7%zÕCLs ÍÑ Íý„æÆ,$i‹æ¶±Æ[ÐWoÁ±|§µ:Ñ\Ms ÍÑ Íý”æúy][ÔÜ>e›¶4¾=IíBù.e 7ëÒx3Û—
€æhŽæþ¦æš¨£¨¹.ÑW÷BsåCQ´›Öš‡˜æ š£9šû~ÍMk n·Ã e™ Z–/-ËtвJ-+ƒ– ÍÑ Íý¬æÊ"kwWµmþUSPÚ‡˜æ š£9šû ÍíöúÊŸÆš›Ë›í\X@Æ4Ð ÍÑÜOk® NŠGlB>–Æ·Í]‡òƒÓ˜æ š£9šû~ÍÝ8“åý¿÷YÙ¼ < ÊËe'‚õa_Ç˜æ š£9šûkÊ5+çî»9M‹;Ð¥ñ]ŒÝø¬¼^lçX¦1Í4Gs4÷óš›ô4í”ZeÑNi<Ä4.-Ÿ¶—«»[·l¼“Æ4Ð ÍÑÜ 4öžËvÛ¥&ñ¢¹‡×µY,X+“˜æ š£9š;æ‚¿îrªŸÇÃÁû×µóváe÷"¦9€æhŽæ~Jsª¾nÆWñ¸-öN_×5}Ý~Ó @s4Gs'ÐÜÇ,º/:Í4Gs4w6ÍuÙ—¹‰æ š£9š;›æ†,ÿªCÑ @s4Gs§Ëæ¾îP4Ð ÍÑÜéîÍÑ @s4Gs4Gs ÍÑ ÍÑ š£9š£9 4Gs4Gs hŽæhŽæ Ð ÍÑ Í 9š£9šhŽæhŽæh 9š£9š@s4Gs4€æhŽæh ÍÑ ÍÑ š£9š£9 4Gs4Gs ÍÑ ÍÑ Í4Gs4Gs hŽæhŽæ Ð ÍÑ Í 9š£9š@s4Gs4Ð ÍÑ ÍÑ @s4Gs4€æhŽæh ÍÑ ÍÑ š£9š£9 4Gs4Gs hŽæhŽæ š£9š£9šhŽæhŽæ Ð ÍÑ Í 9š£9š@s4Gs4€æhŽæh 9š£9š£9€æhŽæhŽæ š£9š£9 4Gs4÷'šk«|<|UÕ}¿* óãÒ˜æ š£9šûnÍ5e11¬j²).«Wñ«ò®Ÿâ¬ï^Ä4Ð ÍÑÜ·k®)¢¯ê%®ŸÇ iy—Å8ëžÆ4Ð ÍÑÜ·kn²\Óví°è¨šÄ•çu½—Æ å÷¤°lºæ~ òiLs ÍÑ Í}»æÊ"kÃw 5áÕQ[MÔS¯GMÊ—ÇrþEÓ @s4Gsß®¹n•W[ýœ¤
·Å{Ýc¼KæŽåw›Ío%Ÿ”Æ4Ð ÍÑÜ·k®ZoEõ1© ÷ÞêÇx᡼(²5ÏËžÄ4Ð ÍÑÜ÷gsuÐÌÞº'aãê½á1Þ;åÕ–³
S —Æ4Ð ÍÑÜ,(XÇ,³ñza<3o)Ú\^¯ÙÝ”èµ1Í4Gs4÷CšËû!+âT”m¬ñô•Æ[p,ßi-ü˜Æ4Ð ÍÑÜin^:–qïS¶)aKãÛ“Ô.”÷Û|Ê µ4ÞÌvÀe 9š£¹¿žÍ
å´”;Ë÷3/g}u/4÷P>l#“AkiLs ÍÑ Íýཹ®œÅµÓW ´,_ Z ËÙ[õ´hŽæhî5w³0!Ò 4Gs×Ñ\[šWÂmúš
¤ñ£æÖ˪º°^‹3i4Gs4Gs߯¹ÕVS^×Ün}øï×ñÂCù=ÜÌù$¦9Ð ÍÑ Í}»æÆ,ëâº'a1»ËƒÓxUTR^m9Û0åqiLs 9š£9šûln'¼0ø¸¥^c¸¹–Æ·‡m.¯×ìnòeûÓ hŽæhŽæ~RsÃœ¬mc· ¯4Þ‚cùNkáÇ4¦9Ð ÍÑ Íýœæºr^߶OÙ¦„-oOR»PÞoó)ƒÖÒx3Û×EÐ ÍÑ ÍýuÍÓRïl:R—è«{¡¹‡òa™ ZKcšÍÑ ÍÑÜi®šžWÒéÈd ´,_ Z ËÙ[õ´ÍÑ ÍÑÜhn ¦}å)›)( ÍÑ Í½¿æ¦§}eÕ}Í ÒøÕëªmU]X/žÆ4š£9š£¹ ÐÜô,®~·YÎ¶È ùX¿zÝN‚Á€iLs 9š£9šûÍõÉÎÍÏ ÀÓøÕ붧†µóÂð4¦9Ð ÍÑ Í}¿æ²tÿ€,1æÛ£›ñØuã³òzIßâ Ë4¦9Ð ÍÑ Í}»æ¦'0×+ù¬§²ºÓìËöö$ b—–O÷øêîÖ-ï¤1ÍæhŽæhîÛ5·îhâ0f‘í¶KMâEs¯ û³fÛ6ªiLs 9š£9šûnÍõš‹eY}|Íÿí_×ÎÛ…—Ý‹˜æ@s4Gs4÷Ý÷æž1Vuߌ¯âq]ì¾îÖ5}Ý~Ó hŽæhŽæ~^s SÝ ‰æ@s4Gs4w6Íåå— æ@s4Gs4w6Í
YNs ÍÑ Í]6›ûºCÑ hŽæhŽæNwoŽæ š£9š£9šÍÑ ÍÑ Í4Gs4Gs4Ð ÍÑ ÍÑ @s4Gs4Gs ÍÑ ÍÑ Í4Gs4Gs4Ð ÍÑ ÍÑ hŽæhŽæh 9š£9š£9€æhŽæhŽæ š£9š£9šhŽæhŽæh 9š£9š£9Ð ÍÑ ÍÑ ÍæhŽæhŽæ š£9š£9šhŽæhŽæh 9š£9š£9€æhŽæhŽæ š£9š£9šÍÑ ÍÑ Í4Gs4Gs4Ð ÍÑ ÍÑ @s4Gs4Gs ÍÑ ÍÑ Í4Gs4Gs4Ð ÍÑ ÍÑ hŽæhŽæh 9š£9š£9€æhŽæhŽæ š£9š£9šhŽæhŽæh 9š£9š£9Ð ÍÑ ÍÑ Íý2ºÿ½ ÍÑ ÍÑ Íásäox‚Ñ ÍÑÜ%47¶‡ÃtUÛ}¿* ó* ?ˆiŽæhŽæhŽæ~Bs}±N“wÊêUüª¼ë§¸èÇ1ÍÑ ÍÑ ÍÑÜÏh.+¶ÕE¤~ ¿z]—Å8ëžÆ4š£9š£¹ ÑÜ8[6WMâÊÛú.©êYüêu·ò~¦kÖc¥1ÍæhŽæhîû5Wõå”v•[b7k«‰eiüêuÓ¿cÔ[õ$¦9Ð ÍÑ Íý€æÊ8²¸%iÃüÓ=
ë ãÛ‹×MÇ™ßJ[ý“˜æ@s4Gs4÷š«‡¡Ü
,öEѬ÷ÞêÇøöâuãfʬÈƇ˜æ@s4Gs4÷C÷æn·Ms÷$,:)ùZß^¼®Úr¶Þ¥1ÍæhŽæhîšÛæ\Ž¡0o/^W¯ÙÝ”èU1ÍæhŽæhî5—=ü4»/o/^·ÓZh®¦9Ð ÍÑ Í#›s.³‡øv{þº}ÊnÖ¥ñf¶®ü4Gs4Gs4÷šë}u/4÷P>E»iyˆi4Gs4Gs'¸7·ÓW ´,_ Z–é e• ZV-As4Gs4w²{s_3¥}ˆi4Gs4Gs'Èæ6}Í ÒøöâuÍv., Hcšûÿ»ú5’æhŽæhîÇ57,/™DÕ<Æ·¯ÛI00iŽæhŽæhŽæN ¹- ›€§ñíÅëîÿÄÖ‡} cš£9š£9š£¹Ÿ¿77f1MËgõ¥ñmìºñYy½Ø,αLcš£9š£9š£¹ŸÏæ&=M;¥VY´S1K˧íåêîÖ-ÏÇLcš£9š£9š£¹hnšYd»íR“xÑÜÃëÚ,,ƒ•ILs4Gs4Gs4wÍÝåT?‡ƒÿö¯kçíÂËîELs4Gs4Gs4÷3šK¨úº_Åã¶Ø;}]×ôuûALs4Gs4Gs4wÍ}ìÀ¢û¢#Ñ ÍÑ ÍÑ ÍMs]öen¢9š£9š£9š;›æ†,§9š£9š£9š»l6÷u‡¢9š£9š£9š;›æn4Gs4Gs4Gs4Gs4Gs4Gs4Gs 9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š£9š»šæÆ6Ïó7ûÿ‘æhŽæhŽæhÎ5’æhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæhŽæ4!ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑœk$ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑ ÍÑÜeÌ«|¤9š£9š£9š»¢æº¾˜èGš£9š£9š£¹Ëi®ËŠ™¬£9š£9š£9š»šæÊ¢(›®îÿÐ ÍÑ ÍÑ Í]LsÍ]ocÔ]Es4Gs4Gs4w-ÍÝí6¿µ¶(zš£9š£9š£¹Kin,Šå7+²‘æhŽæhŽæhîJš«¶ n(ŠŽæhŽæhŽæhîJš«‹¢‰?ö¯nÎÑ ÍÑ ÍÑ Í½¿æjš£9š£9š£¹‹in—ÂÝ5WïÌvÀ5’æhŽæhŽæÞQsCQ´‰Ý i®kÿÃ0üCÿί†ëÈÿî
2jBM¨ 5ῦ;§æêC6W}…æþÞÚ‡“¼¿YÃËWPjBMø‹›ðSPZãÓ„šPjÂ+i®ÙnȽ\P uœ`šPjBMø¦šË‹bXþ÷‹Lë8Á4¡&Ô„šðRš»•Ëί ö¥uœ`šPjBMø®š«»
g¿5çs‚iBM¨ iî_3m7Ww·îƒx´ŽLjBM¨ ßUs·vÚV5ûh[UãÓ„šPj·ÕÜì¹{.×i '˜&Ô„šP^Os·[×ôu«uœ`šPjBMxMÍi '˜&Ô„šPÒœÌ ¦ 5¡&Ô„4çs‚iBM¨ 5!Í9Áœ`šPjBš à"Ð €æ 9 h š €æ ¹ÿDŸý‚¨Í²öiÝËkװ˲æ•Ë¯QgteV_ûÜ«Ëßqþá )Í=e¬çÇJÅ/ø€ª¢¨ž_¨îÏk˜Å[_D«º¾B5>ÒÜu«¶\þ‹Â…”æ~êr<¿hŽæNË0_"¯¹þÚçÞpqÍäBJsÿÐ:Åõ+ûBs]ž_»†cžwï\«ëkn¼¼æú_£¹ 'ÍÉæ^hN
iN6Gs²¹7>ºnº¹ÑWó÷ù{ë›æîõëë想.=Ìykx裛æÚ{C7íë&»ŸšSt¶&ô¤Òߪ¹¬ºûe¢ˆ_6êíqVdmøÅÔ0÷Ö‡9ˆíÑdsXÝ–/)õ\p¶ñ¯ûկ鲊÷^4פ–®>€¬^%?‘]ݦ¿êç¿*O7À÷øá çI
›¹.ý¸ÿ¦YÍUœm¾âýͶóÎÂÉ_¬ßˆ§î:·Õ½S5bšg
ýØÎTÇlî[e1³¹Pïa:ËŠüÕ¹zò½¥Û3wÒ“^H¯æîŸo7¨š;ÒtáXºe{¸s.‰SZÐÌ—ÄpµŸÚ¯]®›í´ët—<~û ë˜Ü«Psv6Äxè¢Ü¦Ëçë0Tk6WÅ~اû¢œ~øiã<Ô°ŽÙ¯ßmêùUáÒ²v]A—Ý.¶àÒÓÕ¿¼íïÍaå\ó¼¡ :Ây¨¦w>ÎI÷ðäG͵ñ{I›(mø‡Ãœ·†i š‹—— çnŸÇÁˆüÔôœÒ_¬¹ù[G;}X“í,4Ö®u²åeþÛõJ“ß]Χ¹fýî¿»HNoºÙ½ã6J _’…|þͬ¹~©qyºÙ8釟6NZÃû)4“œþ2_y «ÎöM¥)–™[lê›cüEsÔ\³¼ìIC§ áD”ËE»\[ìðÖcÛ4ËËš5Mþp˜×0í£QsÙrõÈ–/`é¹»õäüÔôœÒ_¬¹ö¶ûÖ1ƤZ¿N-ljÂïÛmæ×ÜNëïÇÓ`ÛðÁ\Ãí7×q‹c%¶Ü5î4oܵíÉÚ0ùð 'áZ•ø ÌÜ-Ã(·¶=]6Ïøn½&V[ûì4÷aC§¿?[‹¥¿øÖc6×Á¯ßD^6|{¶/›é[{v™‚ºoo»/“OštL´yÖNzÎ é/Ö\ü©^OnîVù±uòÝ׬f›±7_r†µÿe'Ô\¿Ö°Ú¿Á¹'mq³Œª×·ý ÌgàômmhOنɇÿÐ8i
wkwÂ'k<Ýiθ€®Ù®óWãxqèÖ[TÅ.ù~ÙÐiG8U«ÛþôIßúqAAWeë¹ú¢áÏv¦oí¡ Œy_,š{qîÖg¼7w褧¼þ^Í-5¯æ†h–k^y»=[Õ~Ño£>óë“ߟSssŸÚ}Ñ*?nñ<qº³“•á?óÕ$δ ó£²²>ߊ‚hœ‡†‰ óÂÕd™‚2ß'ïO7ß¾ÙFQËel+Û];7Í ®‰IC?t„ó°k±yÔ.}ëë€r[»é°¯>;Y6—¾µ‡ È¢¹±™' ¤š[ÎÝ~û«üÜô”Ò_<Óò¶æÚSCŒYL¦ëcëdû?ØåUlìÄš«w§J¾ûb<Œì†
òp*ÕÅžMsËÌßó(ø‡Æy¨a¶¯à¦¹[ /¡g{r³}s_ƶB=Êx‹îayxý¬¡ÓŽpÊï)·ò˜wÆ· ³¹uMË°hîUßm¦eúÖ . QsqAÈ4õ0{íN˜Í}Ü8i
·%9ýnnév½<_6[dnÝ…ç`Ô j.mèójn\æqkúÖÍåÙSÍ= æ¼5|裋沵cf »ÓMÊöìô„Òßü”:>!#_½°}Œã$é§ßÄÅûÓ2ÍîöN÷æB•Ã\›!ö¼l7Ñ°šÿ ì± ž‚Ò/÷’O·¶ø 硆Ãö„¥í)(c|°ÔØœíqøM|2ÄÔbÃ6hµ¶CÌmþ©¡Ï{o.´X{ëÂ$§áöøÖ·AËéch²â©æ sÞ>^@â åô˜Õ|(Šg÷æŠîW«ª?éSPŽô„Ò_|onyh\½WßòU©\ž8š ‡òr¹n¾Ó½¹`ôùÏ£tU˜¼6@±2õZ·Ýpúþj8ãÿ©q jž†;?1q÷LË:Ìá‹
~²+H™>ç¯)¶„¥gÍ=̉k˜ôÑ~‚:j9¥sõósw^örÂlî¡“žïBú‹gZÆçŠn7œöÏü«Ök'Ÿ~œwŸåOŠ3k.$dÛcÞãó`ï¿ë–«ß¼‚¬(Û}Ý–¿:ÛtûnœÇÆ™éY}Ø¡ Ž×ádÙêÔnó.óÝ(Øöu£\w(8fkdž>³ænM9ŸƒË ›ã[?.(¸
ÓÏ>=̉kxì£qAÁ²v3|ëŸ4Ù8„/ ys¯>tÒó]Hõ‚‚®©÷¿h÷“,ƼzÞŸ¦m’š÷ÜuzÌ×}¡bëúpÝÛº¯ÛÔ"mÓ÷'ݬì 'á½É׬“©ð„;êÅ°ë.dQmÙ~²üs
}êN9ŸýGo}Úz›ûbû©Ãœ¹†O/ U=?€a¬^\wnaûÇz›‰ÞNz¾ ©usýÙºÐY’¥‹röm·Ÿ%_ã•öÓ »|ü‚¦ø¢Ãœ¸†]—Ÿõ¤|ÖIÏw!¥¹Ûn<¨¿aŸ7\»‚íj®>ÝD ?‘À~–s÷Ó‡9q
·ÍC²Î±©Î!¥¹ø})ÏO·òòG©šìÚšëªá|³j>¾‚´ÓdÃáBm7 [·@üÙÃœ·†Õü¨½1?ݲ¹‡NzÎ )ÍU\ê
òç_COžëü)ý w|ÿÍeç›OþgäëÄÊá‡9q
×¹¦E{òNzÎ )ÍmÓ»3·×\viË…ÅsçVÆ3ÍeÕ¥¡-ã<ùñ ‡9o
Ç8¸¬ÎÞIÏy!ýšÇcSŒy{Ã~ðáêÎ »7è¤I›´ÝõúYUWÝisÞŽmÓ´oÐIÏy!ýš ü
h @s Ð 4 Í @s_J—eO§¦ÏÊ Öª.³í,3ÞÍý%ò‹?û`ÛœëRòµŠ'àù6ŽÍÑ @s^«Usž¼šû[t]çCÀ©/ÙGã£ó Hs 9 —Ô\¼.Ñ hî+¿7u_7ãšÍÅŸ¦Ím×=³ÃWÌ{Áþátm3m8=¾á³ ¯U›çéÎxo×Ã6ÔӣǷᡓn#y³m{þî•^³¹qÑ\»m/ý¬ËvM}ÿõØæã¥N¿6_0ÏO\µãe3T(^.óµÓÓ£Xóp9m¶'¥ß£¡®¾¯ÛÒ\_ÌÌ3»Ö{sÍüHðøDøûY×Í_îÜÍ¿/ï¥ï÷µóZµyBSm3·_<µº!„Mûž;Ù ;éronœ+U ã*Ü›+»ù œ wÿØe—°}²ùì[Ÿ~ò‘Mu梎=òVÍ6׫·Š…=+§ Ïë¹cvëù¹^\¿¥ÛþzÍõÓFNe¹l’´h.lð4dK;ÞϺi”).·V{I½á”°kÕæ¹æúXÁù8mûU„]¿Î·c׿ï¤Qsó^fårx÷J'3-§Š„ÚÊñY—ÝW®ºÔé7fq+ÖìÄ5Kzd.—ålî|Ý2½*fogKÇœµ=ïž—Íýö[ºío×\;ï˾vÛYÖÆo ÓGÞÞæ
-û{A»àôEëž°wå[nÆzÚ<×\øªØÝ¿D† ~¯YŸÇo‘ùÛwÒ¨¹{TÛÎÔï^éDss —Ç.švÙP¹iðk½:^çô«æ‹O¿¦Jçï‘åÜÃò9Œ…¡
mè®E6
^îêÛÎY_ùMÝö·k®Y>ʸ=`>÷µ¡Úù›I¶|Aiço$åògeñ–ÙÜ•jóBsÕ2Ö,ß*ã·Îüí;鬹j½ Ε|÷J¯šëç.:W®›»hÚe×ÊWo©¹O¿ð½¥ŠWýwè‘ã®5šÝ¨e³œºc¶Kî¦j¶ËñMÝö·k®ªëÛ®â—Évû"5 /[óçðeû}û¦ÙÜ…jóü,Œõè•ãÞˆãÚœùÛwÒYsëW±xÍ÷J'÷æ–ÛRóÐUÒe§Òn\u±Ó/ Wfgn´¤Gvqhù^…içß1ê:~Y‡•çòÕc÷ {Ïê¾¥Ûš‚2ÂU¶×Ünç÷>ü˜“ëéu»ßgï™Í]¨6Ï5ׯ5ÊöÕªßòÞ\ÒIg!l•—ÑŸ·®ô‹§ 4¡ÎI—Ýý¾GÍýÃéW &¨¼Aœî³5ÝþK77M>Gã®~Íq0ö[º-͵õ°›%4Ÿeýú]qj…zɾc¬÷¿ÏÞ2›»Rmžk®Ù²ñÛm;“š÷œiy줳æv™whÐw¯tÿü)(í³pWùú
5÷§__œýöÁ±G¶áç¬ °šÃw•í¡=¡ ßúé·«¿]scœ[«æúÃÓ”ªx–-®›âÝïßt¦å…jó\sín(¬ÛNê ³¹´“†Ëw_ŠË¨¹·®tronyósAÒe•«.wúU'OæÒ yË£ôæß¡Šm¬Ã°j=G{}K·ýíš›æ²öM> ïÍõkš ‡¶ž^·ûý{fsWªÍsÍU;ŒÛ©S¿c6—vÒpaÜUjÍæÞºÒ/žiY%ƒ”! ‹ýÐVuµÓoÌN>;6í‘¡2}¹$wó¨å’¦&šë 4÷÷»í/×\·®ÀlöšÛ
ϲ3„Lzû}÷ž3-¯T›çš«÷WŽíÂ2¼¡æ :é“{sÃûWúõ½¹ê¡Ëîâþ-_~÷:•ë¬Žwè‘KG¬·É'ÍÚ†É åö½¤kêî{ºí/×\µ~Æý^sÕþ£/æùÌÝúÙ»ß7o:ÓòBµy®¹~?äU®óö²7ÔÜC']gZŽ{«¿{¥ÓusÛ|»Çðøûêb§_3É¢<ñ°eÚ#ë² ·„,
] ˜ds‡…0Ý÷t[š›Û+Ïö÷æÆly.Mµ.ã–¦˜ T0·Ež½éº¹ Õæ¹æâ2Of^òL·Ú·ï¤³æ¶g*Í&x÷J§ëæ†Ýµ/í²Såúµ©«k~]XqÐeçmµ´Gn9]¹å£Ãâ«Dsëŵ[—‡ÿõnkÐrZ?†‡ÊmÙÜôÙ‡¦˜–(Îû‚ÜË»ùÑmñÁJ÷¿ëŸ½çSP®S›š íŸ8Ýë¸W¸êßò)(4Žes_*Ù_ ÒÃÃSPò¹‹>;CåÆ÷}
ÊG§ßÖžg}¤eÚ#Çø¼¹±Ù=x½–$š[.®]¹ Büýnk
Jx”ܽ±²0¾<Ó²\ »6ŸCó#öƒ×ê圜Ÿ\úžëæ®T›çš+OÑ[ž,›õï8Ó2í¤QsU¶ôÑ0dôî•NïÍ-]´yÚeƒßÊùÿ«K~ÍòÐò¼OûJ{d f]†‹æÎåíþû˦¹ù¯©K·µ `ž›‡Ï~·CA]쟚}oŸ|^²>T¼œ£7iy¡Ú<×\µ6ìÜÎCpBÞl‹”Þ·“.×¼Ü?%þÝ+h®k±ª]6V¾iÞq¦å§_·>±¹;o¢šöÈ[ Ý4, ÞŒ—fsËY=~W·µ<zéJ_YsW<ýŠO×å[º-Í}Šq|hµ®ŠSÔæŒ5|(i›¦½z'½n¥ŸtÙ×ÕvúýpóödÝ–æ †æ 4 Í @s Ð 4ü#]–5×®a]:—šÃÃÓpß÷©¸±ÿH¿îê€æð{ˆ{³½¯æ†Oêk 9€æð{5wëºî½+ ›h¸`’Cs ÍáÓµyØè}·oñØÔ}ÝÌÊËó²(ò¼›²¹ñ6¶ùò²1ocv7ïA}VÖ
Üß{·«òm Úm ¾ÓܱJysØÖ 9àrìVÏÏwïÖË} ìê8?ú½¨ç{s÷ÿZú{ïÕ5ñÅg}üïZv½¹8ïË|ãíüæ³ü˜õ «4ÆÏ£ìtÐ ð–š»_dziëŽlŒÈʲŒ^
áE§ ”ëNå¼QóPÄ?>«Ö
<ÑÜRñy#“%›Kª4…å´™YÆs 9à 5w¿€·Óº¸y æ6^Þ»è±ãLË&&y·±{~Õó«»¾x¹Ùjx›+–j®Èî~ë꘢FÍ%Uªb›ËìÙ Ð ~›ææ.\Í×ñfÉ×–Ý7ÍõÁnÙòÛ&¸± —Ãäçá+ÍUË šUsi•úhû{úêTÍo©¹jŸŸ‹©«ù⟬›[t6_ôûuãâ%éy+ÍÅô¬›k>¿.Òwm«·€æ€wÔ\œ=’íÇ »*{ª¹¨³nþg7Wÿ¼£–¯5·ˆ9[œý¤JSÒ7 hxcÍÝŽškë0m£xª¹¨„º(ÚY9ÿ§8í˜ÞkÍ-é,—<îY•†0³¬( Íï©¹ì ¹uþüð ¹>:"_oTE μŸæÚÃ+VÍ%Uj2+
@sÀe47M²ï›||qonþ·ÛR»j¥=m
Í
‹æª5›ËÖ×=«Rׄü¶ uÐ ð~š; ZvËò¹uP/}ts9¯'ï柋·©á¦¹rÑ\½Ö|X³¹WUj³M‹ ÍïšÍUû¡½§š»+./ã$Å~ øëʲ>m
£®Ó”Òã”ø›~ºÜWi\ëõ¾[4 4š{Ô\ž=¿7&Y.³7ªuR~Þ\gÉW—)6ê¹b}ÊWµj.R¶|>•l4¼¿æºù™(c˜wÑ첺|?æ·þÍ°ML9íSP)—á1•y˜b³<eªêÅu˜T©_îI.O…hx/Í ôaúüä¸lžtÑÎK 6Í5Ŷ⬠S3ÊâÌO|Œ˜ŸÈ<XgZ–éÃ<ŸTi + †Õú ÍïœÍ-
Ê<oÉÞêæ¦ ÿ:«2¾<«O< q®@v 5«×™–k]wšK«”Ç=2–Í— oê*¤fm3Û¬«>ZÝ5ußœ{8o@ÞlûÆÍ
ªºiÿ©JmÓ÷ue5hÀјRÐ @s h 9€æ Ð @s h 9 Èhî$@s šó h š €æ 9 h š Ð 4 Í @s Ð 4 Í h š €æ 9 h š Ð 4 Í @s Ð 4 Í ~ÿ_€
A&CŽÁ IEND®B`‚ asyncpg-0.13.0/setup.cfg 0000664 0003720 0003720 00000000046 13172407445 015731 0 ustar travis travis 0000000 0000000 [egg_info]
tag_build =
tag_date = 0
asyncpg-0.13.0/asyncpg/ 0000775 0003720 0003720 00000000000 13172407445 015554 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/asyncpg/connresource.py 0000664 0003720 0003720 00000002162 13172407302 020624 0 ustar travis travis 0000000 0000000
# Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import functools
from . import exceptions
def guarded(meth):
"""A decorator to add a sanity check to ConnectionResource methods."""
@functools.wraps(meth)
def _check(self, *args, **kwargs):
self._check_conn_validity(meth.__name__)
return meth(self, *args, **kwargs)
return _check
class ConnectionResource:
__slots__ = ('_connection', '_con_release_ctr')
def __init__(self, connection):
self._connection = connection
self._con_release_ctr = connection._pool_release_ctr
def _check_conn_validity(self, meth_name):
con_release_ctr = self._connection._pool_release_ctr
if con_release_ctr != self._con_release_ctr:
raise exceptions.InterfaceError(
'cannot call {}.{}(): '
'the underlying connection has been released back '
'to the pool'.format(self.__class__.__name__, meth_name))
asyncpg-0.13.0/asyncpg/introspection.py 0000664 0003720 0003720 00000011401 13172407302 021013 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
_TYPEINFO = '''\
(
SELECT
t.oid AS oid,
ns.nspname AS ns,
t.typname AS name,
t.typtype AS kind,
(CASE WHEN t.typtype = 'd' THEN
(WITH RECURSIVE typebases(oid, depth) AS (
SELECT
t2.typbasetype AS oid,
0 AS depth
FROM
pg_type t2
WHERE
t2.oid = t.oid
UNION ALL
SELECT
t2.typbasetype AS oid,
tb.depth + 1 AS depth
FROM
pg_type t2,
typebases tb
WHERE
tb.oid = t2.oid
AND t2.typbasetype != 0
) SELECT oid FROM typebases ORDER BY depth DESC LIMIT 1)
ELSE NULL
END) AS basetype,
t.typreceive::oid != 0 AND t.typsend::oid != 0
AS has_bin_io,
t.typelem AS elemtype,
elem_t.typdelim AS elemdelim,
range_t.rngsubtype AS range_subtype,
(CASE WHEN t.typtype = 'r' THEN
(SELECT
range_elem_t.typreceive::oid != 0 AND
range_elem_t.typsend::oid != 0
FROM
pg_catalog.pg_type AS range_elem_t
WHERE
range_elem_t.oid = range_t.rngsubtype)
ELSE
elem_t.typreceive::oid != 0 AND
elem_t.typsend::oid != 0
END) AS elem_has_bin_io,
(CASE WHEN t.typtype = 'c' THEN
(SELECT
array_agg(ia.atttypid ORDER BY ia.attnum)
FROM
pg_attribute ia
INNER JOIN pg_class c
ON (ia.attrelid = c.oid)
WHERE
ia.attnum > 0 AND NOT ia.attisdropped
AND c.reltype = t.oid)
ELSE NULL
END) AS attrtypoids,
(CASE WHEN t.typtype = 'c' THEN
(SELECT
array_agg(ia.attname::text ORDER BY ia.attnum)
FROM
pg_attribute ia
INNER JOIN pg_class c
ON (ia.attrelid = c.oid)
WHERE
ia.attnum > 0 AND NOT ia.attisdropped
AND c.reltype = t.oid)
ELSE NULL
END) AS attrnames
FROM
pg_catalog.pg_type AS t
INNER JOIN pg_catalog.pg_namespace ns ON (
ns.oid = t.typnamespace)
LEFT JOIN pg_type elem_t ON (
t.typlen = -1 AND
t.typelem != 0 AND
t.typelem = elem_t.oid
)
LEFT JOIN pg_range range_t ON (
t.oid = range_t.rngtypid
)
)
'''
INTRO_LOOKUP_TYPES = '''\
WITH RECURSIVE typeinfo_tree(
oid, ns, name, kind, basetype, has_bin_io, elemtype, elemdelim,
range_subtype, elem_has_bin_io, attrtypoids, attrnames, depth)
AS (
SELECT
ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io,
ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io,
ti.attrtypoids, ti.attrnames, 0
FROM
{typeinfo} AS ti
WHERE
ti.oid = any($1::oid[])
UNION ALL
SELECT
ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io,
ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io,
ti.attrtypoids, ti.attrnames, tt.depth + 1
FROM
{typeinfo} ti,
typeinfo_tree tt
WHERE
(tt.elemtype IS NOT NULL AND ti.oid = tt.elemtype)
OR (tt.attrtypoids IS NOT NULL AND ti.oid = any(tt.attrtypoids))
OR (tt.range_subtype IS NOT NULL AND ti.oid = tt.range_subtype)
)
SELECT DISTINCT
*
FROM
typeinfo_tree
ORDER BY
depth DESC
'''.format(typeinfo=_TYPEINFO)
TYPE_BY_NAME = '''\
SELECT
t.oid,
t.typelem AS elemtype,
t.typtype AS kind
FROM
pg_catalog.pg_type AS t
INNER JOIN pg_catalog.pg_namespace ns ON (ns.oid = t.typnamespace)
WHERE
t.typname = $1 AND ns.nspname = $2
'''
asyncpg-0.13.0/asyncpg/types.py 0000664 0003720 0003720 00000023757 13172407302 017300 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import collections
__all__ = (
'Type', 'Attribute', 'Range', 'BitString', 'Point', 'Path', 'Polygon',
'Box', 'Line', 'LineSegment', 'Circle', 'ServerVersion',
)
Type = collections.namedtuple('Type', ['oid', 'name', 'kind', 'schema'])
Type.__doc__ = 'Database data type.'
Type.oid.__doc__ = 'OID of the type.'
Type.name.__doc__ = 'Type name. For example "int2".'
Type.kind.__doc__ = \
'Type kind. Can be "scalar", "array", "composite" or "range".'
Type.schema.__doc__ = 'Name of the database schema that defines the type.'
Attribute = collections.namedtuple('Attribute', ['name', 'type'])
Attribute.__doc__ = 'Database relation attribute.'
Attribute.name.__doc__ = 'Attribute name.'
Attribute.type.__doc__ = 'Attribute data type :class:`asyncpg.types.Type`.'
ServerVersion = collections.namedtuple(
'ServerVersion', ['major', 'minor', 'micro', 'releaselevel', 'serial'])
ServerVersion.__doc__ = 'PostgreSQL server version tuple.'
class Range:
"""Immutable representation of PostgreSQL `range` type."""
__slots__ = '_lower', '_upper', '_lower_inc', '_upper_inc', '_empty'
def __init__(self, lower=None, upper=None, *,
lower_inc=True, upper_inc=False,
empty=False):
self._empty = empty
if empty:
self._lower = self._upper = None
self._lower_inc = self._upper_inc = False
else:
self._lower = lower
self._upper = upper
self._lower_inc = lower is not None and lower_inc
self._upper_inc = upper is not None and upper_inc
@property
def lower(self):
return self._lower
@property
def lower_inc(self):
return self._lower_inc
@property
def lower_inf(self):
return self._lower is None and not self._empty
@property
def upper(self):
return self._upper
@property
def upper_inc(self):
return self._upper_inc
@property
def upper_inf(self):
return self._upper is None and not self._empty
@property
def isempty(self):
return self._empty
def __bool__(self):
return not self._empty
def __eq__(self, other):
if not isinstance(other, Range):
return NotImplemented
return (
self._lower,
self._upper,
self._lower_inc,
self._upper_inc,
self._empty
) == (
other._lower,
other._upper,
other._lower_inc,
other._upper_inc,
other._empty
)
def __hash__(self, other):
return hash((
self._lower,
self._upper,
self._lower_inc,
self._upper_inc,
self._empty
))
def __repr__(self):
if self._empty:
desc = 'empty'
else:
if self._lower is None or not self._lower_inc:
lb = '('
else:
lb = '['
if self._lower is not None:
lb += repr(self._lower)
if self._upper is not None:
ub = repr(self._upper)
else:
ub = ''
if self._upper is None or not self._upper_inc:
ub += ')'
else:
ub += ']'
desc = '{}, {}'.format(lb, ub)
return ''.format(desc)
__str__ = __repr__
class BitString:
"""Immutable representation of PostgreSQL `bit` and `varbit` types."""
__slots__ = '_bytes', '_bitlength'
def __init__(self, bitstring=None):
if not bitstring:
self._bytes = bytes()
self._bitlength = 0
else:
bytelen = len(bitstring) // 8 + 1
bytes_ = bytearray(bytelen)
byte = 0
byte_pos = 0
bit_pos = 0
for i, bit in enumerate(bitstring):
if bit == ' ':
continue
bit = int(bit)
if bit != 0 and bit != 1:
raise ValueError(
'invalid bit value at position {}'.format(i))
byte |= bit << (8 - bit_pos - 1)
bit_pos += 1
if bit_pos == 8:
bytes_[byte_pos] = byte
byte = 0
byte_pos += 1
bit_pos = 0
if bit_pos != 0:
bytes_[byte_pos] = byte
bitlen = byte_pos * 8 + bit_pos
bytelen = byte_pos + (1 if bit_pos else 0)
self._bytes = bytes(bytes_[:bytelen])
self._bitlength = bitlen
@classmethod
def frombytes(cls, bytes_=None, bitlength=None):
if bitlength is None and bytes_ is None:
bytes_ = bytes()
bitlength = 0
elif bitlength is None:
bitlength = len(bytes_) * 8
else:
if bytes_ is None:
bytes_ = bytes(bitlength // 8 + 1)
bitlength = bitlength
else:
bytes_len = len(bytes_) * 8
if bytes_len == 0 and bitlength != 0:
raise ValueError('invalid bit length specified')
if bytes_len != 0 and bitlength == 0:
raise ValueError('invalid bit length specified')
if bitlength < bytes_len - 8:
raise ValueError('invalid bit length specified')
if bitlength > bytes_len:
raise ValueError('invalid bit length specified')
result = cls()
result._bytes = bytes_
result._bitlength = bitlength
return result
@property
def bytes(self):
return self._bytes
def as_string(self):
s = ''
for i in range(self._bitlength):
s += str(self._getitem(i))
if i % 4 == 3:
s += ' '
return s.strip()
def __repr__(self):
return ''.format(self.as_string())
__str__ = __repr__
def __eq__(self, other):
if not isinstance(other, BitString):
return NotImplemented
return (self._bytes == other._bytes and
self._bitlength == other._bitlength)
def __hash__(self):
return hash((self._bytes, self._bitlength))
def _getitem(self, i):
byte = self._bytes[i // 8]
shift = 8 - i % 8 - 1
return (byte >> shift) & 0x1
def __getitem__(self, i):
if isinstance(i, slice):
raise NotImplementedError('BitString does not support slices')
if i >= self._bitlength:
raise IndexError('index out of range')
return self._getitem(i)
def __len__(self):
return self._bitlength
class Point(tuple):
"""Immutable representation of PostgreSQL `point` type."""
__slots__ = ()
def __new__(cls, x, y):
return super().__new__(cls, (float(x), float(y)))
def __repr__(self):
return '{}.{}({})'.format(
type(self).__module__,
type(self).__name__,
tuple.__repr__(self)
)
@property
def x(self):
return self[0]
@property
def y(self):
return self[1]
class Box(tuple):
"""Immutable representation of PostgreSQL `box` type."""
__slots__ = ()
def __new__(cls, high, low):
return super().__new__(cls, (Point(*high), Point(*low)))
def __repr__(self):
return '{}.{}({})'.format(
type(self).__module__,
type(self).__name__,
tuple.__repr__(self)
)
@property
def high(self):
return self[0]
@property
def low(self):
return self[1]
class Line(tuple):
"""Immutable representation of PostgreSQL `line` type."""
__slots__ = ()
def __new__(cls, A, B, C):
return super().__new__(cls, (A, B, C))
@property
def A(self):
return self[0]
@property
def B(self):
return self[1]
@property
def C(self):
return self[2]
class LineSegment(tuple):
"""Immutable representation of PostgreSQL `lseg` type."""
__slots__ = ()
def __new__(cls, p1, p2):
return super().__new__(cls, (Point(*p1), Point(*p2)))
def __repr__(self):
return '{}.{}({})'.format(
type(self).__module__,
type(self).__name__,
tuple.__repr__(self)
)
@property
def p1(self):
return self[0]
@property
def p2(self):
return self[1]
class Path:
"""Immutable representation of PostgreSQL `path` type."""
__slots__ = '_is_closed', 'points'
def __init__(self, *points, is_closed=False):
self.points = tuple(Point(*p) for p in points)
self._is_closed = is_closed
@property
def is_closed(self):
return self._is_closed
def __eq__(self, other):
if not isinstance(other, Path):
return NotImplemented
return (self.points == other.points and
self._is_closed == other._is_closed)
def __hash__(self):
return hash((self.points, self.is_closed))
def __iter__(self):
return iter(self.points)
def __len__(self):
return len(self.points)
def __getitem__(self, i):
return self.points[i]
def __contains__(self, point):
return point in self.points
class Polygon(Path):
"""Immutable representation of PostgreSQL `polygon` type."""
__slots__ = ()
def __init__(self, *points):
# polygon is always closed
super().__init__(*points, is_closed=True)
class Circle(tuple):
"""Immutable representation of PostgreSQL `circle` type."""
__slots__ = ()
def __new__(cls, center, radius):
return super().__new__(cls, (center, radius))
@property
def center(self):
return self[0]
@property
def radius(self):
return self[1]
asyncpg-0.13.0/asyncpg/pool.py 0000664 0003720 0003720 00000054712 13172407302 017100 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import functools
import inspect
from . import connection
from . import connect_utils
from . import exceptions
class PoolConnectionProxyMeta(type):
def __new__(mcls, name, bases, dct, *, wrap=False):
if wrap:
for attrname in dir(connection.Connection):
if attrname.startswith('_') or attrname in dct:
continue
meth = getattr(connection.Connection, attrname)
if not inspect.isfunction(meth):
continue
wrapper = mcls._wrap_connection_method(attrname)
wrapper = functools.update_wrapper(wrapper, meth)
dct[attrname] = wrapper
if '__doc__' not in dct:
dct['__doc__'] = connection.Connection.__doc__
return super().__new__(mcls, name, bases, dct)
def __init__(cls, name, bases, dct, *, wrap=False):
# Needed for Python 3.5 to handle `wrap` class keyword argument.
super().__init__(name, bases, dct)
@staticmethod
def _wrap_connection_method(meth_name):
def call_con_method(self, *args, **kwargs):
# This method will be owned by PoolConnectionProxy class.
if self._con is None:
raise exceptions.InterfaceError(
'cannot call Connection.{}(): '
'connection has been released back to the pool'.format(
meth_name))
meth = getattr(self._con.__class__, meth_name)
return meth(self._con, *args, **kwargs)
return call_con_method
class PoolConnectionProxy(connection._ConnectionProxy,
metaclass=PoolConnectionProxyMeta,
wrap=True):
__slots__ = ('_con', '_holder')
def __init__(self, holder: 'PoolConnectionHolder',
con: connection.Connection):
self._con = con
self._holder = holder
con._set_proxy(self)
def __getattr__(self, attr):
# Proxy all unresolved attributes to the wrapped Connection object.
return getattr(self._con, attr)
def _detach(self):
if self._con is None:
raise exceptions.InterfaceError(
'cannot detach PoolConnectionProxy: already detached')
con, self._con = self._con, None
con._set_proxy(None)
def __repr__(self):
if self._con is None:
return '<{classname} [released] {id:#x}>'.format(
classname=self.__class__.__name__, id=id(self))
else:
return '<{classname} {con!r} {id:#x}>'.format(
classname=self.__class__.__name__, con=self._con, id=id(self))
class PoolConnectionHolder:
__slots__ = ('_con', '_pool', '_loop',
'_connect_args', '_connect_kwargs',
'_max_queries', '_setup', '_init',
'_max_inactive_time', '_in_use',
'_inactive_callback')
def __init__(self, pool, *, connect_args, connect_kwargs,
max_queries, setup, init, max_inactive_time):
self._pool = pool
self._con = None
self._connect_args = connect_args
self._connect_kwargs = connect_kwargs
self._max_queries = max_queries
self._max_inactive_time = max_inactive_time
self._setup = setup
self._init = init
self._inactive_callback = None
self._in_use = False
async def connect(self):
assert self._con is None
if self._pool._working_addr is None:
# First connection attempt on this pool.
con = await connection.connect(
*self._connect_args,
loop=self._pool._loop,
connection_class=self._pool._connection_class,
**self._connect_kwargs)
self._pool._working_addr = con._addr
self._pool._working_config = con._config
self._pool._working_params = con._params
else:
# We've connected before and have a resolved address,
# and parsed options and config.
con = await connect_utils._connect_addr(
loop=self._pool._loop,
addr=self._pool._working_addr,
timeout=self._pool._working_params.connect_timeout,
config=self._pool._working_config,
params=self._pool._working_params,
connection_class=self._pool._connection_class)
if self._init is not None:
await self._init(con)
self._con = con
async def acquire(self) -> PoolConnectionProxy:
if self._con is None or self._con.is_closed():
self._con = None
await self.connect()
self._maybe_cancel_inactive_callback()
proxy = PoolConnectionProxy(self, self._con)
if self._setup is not None:
try:
await self._setup(proxy)
except Exception as ex:
# If a user-defined `setup` function fails, we don't
# know if the connection is safe for re-use, hence
# we close it. A new connection will be created
# when `acquire` is called again.
try:
proxy._detach()
# Use `close` to close the connection gracefully.
# An exception in `setup` isn't necessarily caused
# by an IO or a protocol error.
await self._con.close()
finally:
self._con = None
raise ex
self._in_use = True
return proxy
async def release(self):
assert self._in_use
self._in_use = False
self._con._on_release()
if self._con.is_closed():
self._con = None
elif self._con._protocol.queries_count >= self._max_queries:
try:
await self._con.close()
finally:
self._con = None
else:
try:
await self._con.reset()
except Exception as ex:
# If the `reset` call failed, terminate the connection.
# A new one will be created when `acquire` is called
# again.
try:
# An exception in `reset` is most likely caused by
# an IO error, so terminate the connection.
self._con.terminate()
finally:
self._con = None
raise ex
assert self._inactive_callback is None
if self._max_inactive_time and self._con is not None:
self._inactive_callback = self._pool._loop.call_later(
self._max_inactive_time, self._deactivate_connection)
async def close(self):
self._maybe_cancel_inactive_callback()
if self._con is None:
return
if self._con.is_closed():
self._con = None
return
try:
await self._con.close()
finally:
self._con = None
def terminate(self):
self._maybe_cancel_inactive_callback()
if self._con is None:
return
if self._con.is_closed():
self._con = None
return
try:
self._con.terminate()
finally:
self._con = None
def _maybe_cancel_inactive_callback(self):
if self._inactive_callback is not None:
self._inactive_callback.cancel()
self._inactive_callback = None
def _deactivate_connection(self):
assert not self._in_use
if self._con is None or self._con.is_closed():
return
self._con.terminate()
self._con = None
class Pool:
"""A connection pool.
Connection pool can be used to manage a set of connections to the database.
Connections are first acquired from the pool, then used, and then released
back to the pool. Once a connection is released, it's reset to close all
open cursors and other resources *except* prepared statements.
Pools are created by calling :func:`~asyncpg.pool.create_pool`.
"""
__slots__ = ('_queue', '_loop', '_minsize', '_maxsize',
'_working_addr', '_working_config', '_working_params',
'_holders', '_initialized', '_closed',
'_connection_class')
def __init__(self, *connect_args,
min_size,
max_size,
max_queries,
max_inactive_connection_lifetime,
setup,
init,
loop,
connection_class,
**connect_kwargs):
if loop is None:
loop = asyncio.get_event_loop()
self._loop = loop
if max_size <= 0:
raise ValueError('max_size is expected to be greater than zero')
if min_size < 0:
raise ValueError(
'min_size is expected to be greater or equal to zero')
if min_size > max_size:
raise ValueError('min_size is greater than max_size')
if max_queries <= 0:
raise ValueError('max_queries is expected to be greater than zero')
if max_inactive_connection_lifetime < 0:
raise ValueError(
'max_inactive_connection_lifetime is expected to be greater '
'or equal to zero')
self._minsize = min_size
self._maxsize = max_size
self._holders = []
self._initialized = False
self._queue = asyncio.LifoQueue(maxsize=self._maxsize, loop=self._loop)
self._working_addr = None
self._working_config = None
self._working_params = None
self._connection_class = connection_class
self._closed = False
for _ in range(max_size):
ch = PoolConnectionHolder(
self,
connect_args=connect_args,
connect_kwargs=connect_kwargs,
max_queries=max_queries,
max_inactive_time=max_inactive_connection_lifetime,
setup=setup,
init=init)
self._holders.append(ch)
self._queue.put_nowait(ch)
async def _async__init__(self):
if self._initialized:
return
if self._closed:
raise exceptions.InterfaceError('pool is closed')
if self._minsize:
# Since we use a LIFO queue, the first items in the queue will be
# the last ones in `self._holders`. We want to pre-connect the
# first few connections in the queue, therefore we want to walk
# `self._holders` in reverse.
# Connect the first connection holder in the queue so that it
# can record `_working_addr` and `_working_opts`, which will
# speed up successive connection attempts.
first_ch = self._holders[-1] # type: PoolConnectionHolder
await first_ch.connect()
if self._minsize > 1:
connect_tasks = []
for i, ch in enumerate(reversed(self._holders[:-1])):
# `minsize - 1` because we already have first_ch
if i >= self._minsize - 1:
break
connect_tasks.append(ch.connect())
await asyncio.gather(*connect_tasks, loop=self._loop)
self._initialized = True
return self
async def execute(self, query: str, *args, timeout: float=None) -> str:
"""Execute an SQL command (or commands).
Pool performs this operation using one of its connections. Other than
that, it behaves identically to
:meth:`Connection.execute() `.
.. versionadded:: 0.10.0
"""
async with self.acquire() as con:
return await con.execute(query, *args, timeout=timeout)
async def executemany(self, command: str, args, *, timeout: float=None):
"""Execute an SQL *command* for each sequence of arguments in *args*.
Pool performs this operation using one of its connections. Other than
that, it behaves identically to
:meth:`Connection.executemany() `.
.. versionadded:: 0.10.0
"""
async with self.acquire() as con:
return await con.executemany(command, args, timeout=timeout)
async def fetch(self, query, *args, timeout=None) -> list:
"""Run a query and return the results as a list of :class:`Record`.
Pool performs this operation using one of its connections. Other than
that, it behaves identically to
:meth:`Connection.fetch() `.
.. versionadded:: 0.10.0
"""
async with self.acquire() as con:
return await con.fetch(query, *args, timeout=timeout)
async def fetchval(self, query, *args, column=0, timeout=None):
"""Run a query and return a value in the first row.
Pool performs this operation using one of its connections. Other than
that, it behaves identically to
:meth:`Connection.fetchval() `.
.. versionadded:: 0.10.0
"""
async with self.acquire() as con:
return await con.fetchval(
query, *args, column=column, timeout=timeout)
async def fetchrow(self, query, *args, timeout=None):
"""Run a query and return the first row.
Pool performs this operation using one of its connections. Other than
that, it behaves identically to
:meth:`Connection.fetchrow() `.
.. versionadded:: 0.10.0
"""
async with self.acquire() as con:
return await con.fetchrow(query, *args, timeout=timeout)
def acquire(self, *, timeout=None):
"""Acquire a database connection from the pool.
:param float timeout: A timeout for acquiring a Connection.
:return: An instance of :class:`~asyncpg.connection.Connection`.
Can be used in an ``await`` expression or with an ``async with`` block.
.. code-block:: python
async with pool.acquire() as con:
await con.execute(...)
Or:
.. code-block:: python
con = await pool.acquire()
try:
await con.execute(...)
finally:
await pool.release(con)
"""
return PoolAcquireContext(self, timeout)
async def _acquire(self, timeout):
async def _acquire_impl():
ch = await self._queue.get() # type: PoolConnectionHolder
try:
proxy = await ch.acquire() # type: PoolConnectionProxy
except Exception:
self._queue.put_nowait(ch)
raise
else:
return proxy
self._check_init()
if timeout is None:
return await _acquire_impl()
else:
return await asyncio.wait_for(
_acquire_impl(), timeout=timeout, loop=self._loop)
async def release(self, connection):
"""Release a database connection back to the pool."""
async def _release_impl(ch: PoolConnectionHolder):
try:
await ch.release()
finally:
self._queue.put_nowait(ch)
self._check_init()
if (type(connection) is not PoolConnectionProxy or
connection._holder._pool is not self):
raise exceptions.InterfaceError(
'Pool.release() received invalid connection: '
'{connection!r} is not a member of this pool'.format(
connection=connection))
if connection._con is None:
# Already released, do nothing.
return
connection._detach()
# Use asyncio.shield() to guarantee that task cancellation
# does not prevent the connection from being returned to the
# pool properly.
return await asyncio.shield(_release_impl(connection._holder),
loop=self._loop)
async def close(self):
"""Gracefully close all connections in the pool."""
if self._closed:
return
self._check_init()
self._closed = True
coros = [ch.close() for ch in self._holders]
await asyncio.gather(*coros, loop=self._loop)
def terminate(self):
"""Terminate all connections in the pool."""
if self._closed:
return
self._check_init()
self._closed = True
for ch in self._holders:
ch.terminate()
def _check_init(self):
if not self._initialized:
raise exceptions.InterfaceError('pool is not initialized')
if self._closed:
raise exceptions.InterfaceError('pool is closed')
def _drop_statement_cache(self):
# Drop statement cache for all connections in the pool.
for ch in self._holders:
if ch._con is not None:
ch._con._drop_local_statement_cache()
def __await__(self):
return self._async__init__().__await__()
async def __aenter__(self):
await self._async__init__()
return self
async def __aexit__(self, *exc):
await self.close()
class PoolAcquireContext:
__slots__ = ('timeout', 'connection', 'done', 'pool')
def __init__(self, pool, timeout):
self.pool = pool
self.timeout = timeout
self.connection = None
self.done = False
async def __aenter__(self):
if self.connection is not None or self.done:
raise exceptions.InterfaceError('a connection is already acquired')
self.connection = await self.pool._acquire(self.timeout)
return self.connection
async def __aexit__(self, *exc):
self.done = True
con = self.connection
self.connection = None
await self.pool.release(con)
def __await__(self):
self.done = True
return self.pool._acquire(self.timeout).__await__()
def create_pool(dsn=None, *,
min_size=10,
max_size=10,
max_queries=50000,
max_inactive_connection_lifetime=300.0,
setup=None,
init=None,
loop=None,
connection_class=connection.Connection,
**connect_kwargs):
r"""Create a connection pool.
Can be used either with an ``async with`` block:
.. code-block:: python
async with asyncpg.create_pool(user='postgres',
command_timeout=60) as pool:
async with pool.acquire() as con:
await con.fetch('SELECT 1')
Or directly with ``await``:
.. code-block:: python
pool = await asyncpg.create_pool(user='postgres', command_timeout=60)
con = await pool.acquire()
try:
await con.fetch('SELECT 1')
finally:
await pool.release(con)
.. warning::
Prepared statements and cursors returned by
:meth:`Connection.prepare() ` and
:meth:`Connection.cursor() ` become
invalid once the connection is released. Likewise, all notification
and log listeners are removed, and ``asyncpg`` will issue a warning
if there are any listener callbacks registered on a connection that
is being released to the pool.
:param str dsn:
Connection arguments specified using as a single string in
the following format:
``postgres://user:pass@host:port/database?option=value``.
:param \*\*connect_kwargs:
Keyword arguments for the :func:`~asyncpg.connection.connect`
function.
:param int min_size:
Number of connection the pool will be initialized with.
:param int max_size:
Max number of connections in the pool.
:param int max_queries:
Number of queries after a connection is closed and replaced
with a new connection.
:param float max_inactive_connection_lifetime:
Number of seconds after which inactive connections in the
pool will be closed. Pass ``0`` to disable this mechanism.
:param coroutine setup:
A coroutine to prepare a connection right before it is returned
from :meth:`Pool.acquire() `. An example use
case would be to automatically set up notifications listeners for
all connections of a pool.
:param coroutine init:
A coroutine to initialize a connection when it is created.
An example use case would be to setup type codecs with
:meth:`Connection.set_builtin_type_codec() <\
asyncpg.connection.Connection.set_builtin_type_codec>`
or :meth:`Connection.set_type_codec() <\
asyncpg.connection.Connection.set_type_codec>`.
:param loop:
An asyncio event loop instance. If ``None``, the default
event loop will be used.
:return: An instance of :class:`~asyncpg.pool.Pool`.
.. versionchanged:: 0.10.0
An :exc:`~asyncpg.exceptions.InterfaceError` will be raised on any
attempted operation on a released connection.
.. versionchanged:: 0.13.0
An :exc:`~asyncpg.exceptions.InterfaceError` will be raised on any
attempted operation on a prepared statement or a cursor created
on a connection that has been released to the pool.
.. versionchanged:: 0.13.0
An :exc:`~asyncpg.exceptions.InterfaceWarning` will be produced
if there are any active listeners (added via
:meth:`Connection.add_listener() `
or :meth:`Connection.add_log_listener()
`) present on the connection
at the moment of its release to the pool.
"""
if not issubclass(connection_class, connection.Connection):
raise TypeError(
'connection_class is expected to be a subclass of '
'asyncpg.Connection, got {!r}'.format(connection_class))
return Pool(
dsn,
connection_class=connection_class,
min_size=min_size, max_size=max_size,
max_queries=max_queries, loop=loop, setup=setup, init=init,
max_inactive_connection_lifetime=max_inactive_connection_lifetime,
**connect_kwargs)
asyncpg-0.13.0/asyncpg/exceptions/ 0000775 0003720 0003720 00000000000 13172407445 017735 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/asyncpg/exceptions/__init__.py 0000664 0003720 0003720 00000063776 13172407302 022061 0 ustar travis travis 0000000 0000000 # GENERATED FROM postgresql/src/backend/utils/errcodes.txt
# DO NOT MODIFY, use tools/generate_exceptions.py to update
from ._base import * # NOQA
from . import _base
class PostgresWarning(_base.PostgresLogMessage, Warning):
sqlstate = '01000'
class DynamicResultSetsReturned(PostgresWarning):
sqlstate = '0100C'
class ImplicitZeroBitPadding(PostgresWarning):
sqlstate = '01008'
class NullValueEliminatedInSetFunction(PostgresWarning):
sqlstate = '01003'
class PrivilegeNotGranted(PostgresWarning):
sqlstate = '01007'
class PrivilegeNotRevoked(PostgresWarning):
sqlstate = '01006'
class StringDataRightTruncation(PostgresWarning):
sqlstate = '01004'
class DeprecatedFeature(PostgresWarning):
sqlstate = '01P01'
class NoData(PostgresWarning):
sqlstate = '02000'
class NoAdditionalDynamicResultSetsReturned(NoData):
sqlstate = '02001'
class SQLStatementNotYetCompleteError(_base.PostgresError):
sqlstate = '03000'
class PostgresConnectionError(_base.PostgresError):
sqlstate = '08000'
class ConnectionDoesNotExistError(PostgresConnectionError):
sqlstate = '08003'
class ConnectionFailureError(PostgresConnectionError):
sqlstate = '08006'
class ClientCannotConnectError(PostgresConnectionError):
sqlstate = '08001'
class ConnectionRejectionError(PostgresConnectionError):
sqlstate = '08004'
class TransactionResolutionUnknownError(PostgresConnectionError):
sqlstate = '08007'
class ProtocolViolationError(PostgresConnectionError):
sqlstate = '08P01'
class TriggeredActionError(_base.PostgresError):
sqlstate = '09000'
class FeatureNotSupportedError(_base.PostgresError):
sqlstate = '0A000'
class InvalidCachedStatementError(FeatureNotSupportedError):
pass
class InvalidTransactionInitiationError(_base.PostgresError):
sqlstate = '0B000'
class LocatorError(_base.PostgresError):
sqlstate = '0F000'
class InvalidLocatorSpecificationError(LocatorError):
sqlstate = '0F001'
class InvalidGrantorError(_base.PostgresError):
sqlstate = '0L000'
class InvalidGrantOperationError(InvalidGrantorError):
sqlstate = '0LP01'
class InvalidRoleSpecificationError(_base.PostgresError):
sqlstate = '0P000'
class DiagnosticsError(_base.PostgresError):
sqlstate = '0Z000'
class StackedDiagnosticsAccessedWithoutActiveHandlerError(DiagnosticsError):
sqlstate = '0Z002'
class CaseNotFoundError(_base.PostgresError):
sqlstate = '20000'
class CardinalityViolationError(_base.PostgresError):
sqlstate = '21000'
class DataError(_base.PostgresError):
sqlstate = '22000'
class ArraySubscriptError(DataError):
sqlstate = '2202E'
class CharacterNotInRepertoireError(DataError):
sqlstate = '22021'
class DatetimeFieldOverflowError(DataError):
sqlstate = '22008'
class DivisionByZeroError(DataError):
sqlstate = '22012'
class ErrorInAssignmentError(DataError):
sqlstate = '22005'
class EscapeCharacterConflictError(DataError):
sqlstate = '2200B'
class IndicatorOverflowError(DataError):
sqlstate = '22022'
class IntervalFieldOverflowError(DataError):
sqlstate = '22015'
class InvalidArgumentForLogarithmError(DataError):
sqlstate = '2201E'
class InvalidArgumentForNtileFunctionError(DataError):
sqlstate = '22014'
class InvalidArgumentForNthValueFunctionError(DataError):
sqlstate = '22016'
class InvalidArgumentForPowerFunctionError(DataError):
sqlstate = '2201F'
class InvalidArgumentForWidthBucketFunctionError(DataError):
sqlstate = '2201G'
class InvalidCharacterValueForCastError(DataError):
sqlstate = '22018'
class InvalidDatetimeFormatError(DataError):
sqlstate = '22007'
class InvalidEscapeCharacterError(DataError):
sqlstate = '22019'
class InvalidEscapeOctetError(DataError):
sqlstate = '2200D'
class InvalidEscapeSequenceError(DataError):
sqlstate = '22025'
class NonstandardUseOfEscapeCharacterError(DataError):
sqlstate = '22P06'
class InvalidIndicatorParameterValueError(DataError):
sqlstate = '22010'
class InvalidParameterValueError(DataError):
sqlstate = '22023'
class InvalidRegularExpressionError(DataError):
sqlstate = '2201B'
class InvalidRowCountInLimitClauseError(DataError):
sqlstate = '2201W'
class InvalidRowCountInResultOffsetClauseError(DataError):
sqlstate = '2201X'
class InvalidTablesampleArgumentError(DataError):
sqlstate = '2202H'
class InvalidTablesampleRepeatError(DataError):
sqlstate = '2202G'
class InvalidTimeZoneDisplacementValueError(DataError):
sqlstate = '22009'
class InvalidUseOfEscapeCharacterError(DataError):
sqlstate = '2200C'
class MostSpecificTypeMismatchError(DataError):
sqlstate = '2200G'
class NullValueNotAllowedError(DataError):
sqlstate = '22004'
class NullValueNoIndicatorParameterError(DataError):
sqlstate = '22002'
class NumericValueOutOfRangeError(DataError):
sqlstate = '22003'
class SequenceGeneratorLimitExceededError(DataError):
sqlstate = '2200H'
class StringDataLengthMismatchError(DataError):
sqlstate = '22026'
class StringDataRightTruncationError(DataError):
sqlstate = '22001'
class SubstringError(DataError):
sqlstate = '22011'
class TrimError(DataError):
sqlstate = '22027'
class UnterminatedCStringError(DataError):
sqlstate = '22024'
class ZeroLengthCharacterStringError(DataError):
sqlstate = '2200F'
class PostgresFloatingPointError(DataError):
sqlstate = '22P01'
class InvalidTextRepresentationError(DataError):
sqlstate = '22P02'
class InvalidBinaryRepresentationError(DataError):
sqlstate = '22P03'
class BadCopyFileFormatError(DataError):
sqlstate = '22P04'
class UntranslatableCharacterError(DataError):
sqlstate = '22P05'
class NotAnXmlDocumentError(DataError):
sqlstate = '2200L'
class InvalidXmlDocumentError(DataError):
sqlstate = '2200M'
class InvalidXmlContentError(DataError):
sqlstate = '2200N'
class InvalidXmlCommentError(DataError):
sqlstate = '2200S'
class InvalidXmlProcessingInstructionError(DataError):
sqlstate = '2200T'
class IntegrityConstraintViolationError(_base.PostgresError):
sqlstate = '23000'
class RestrictViolationError(IntegrityConstraintViolationError):
sqlstate = '23001'
class NotNullViolationError(IntegrityConstraintViolationError):
sqlstate = '23502'
class ForeignKeyViolationError(IntegrityConstraintViolationError):
sqlstate = '23503'
class UniqueViolationError(IntegrityConstraintViolationError):
sqlstate = '23505'
class CheckViolationError(IntegrityConstraintViolationError):
sqlstate = '23514'
class ExclusionViolationError(IntegrityConstraintViolationError):
sqlstate = '23P01'
class InvalidCursorStateError(_base.PostgresError):
sqlstate = '24000'
class InvalidTransactionStateError(_base.PostgresError):
sqlstate = '25000'
class ActiveSQLTransactionError(InvalidTransactionStateError):
sqlstate = '25001'
class BranchTransactionAlreadyActiveError(InvalidTransactionStateError):
sqlstate = '25002'
class HeldCursorRequiresSameIsolationLevelError(InvalidTransactionStateError):
sqlstate = '25008'
class InappropriateAccessModeForBranchTransactionError(
InvalidTransactionStateError):
sqlstate = '25003'
class InappropriateIsolationLevelForBranchTransactionError(
InvalidTransactionStateError):
sqlstate = '25004'
class NoActiveSQLTransactionForBranchTransactionError(
InvalidTransactionStateError):
sqlstate = '25005'
class ReadOnlySQLTransactionError(InvalidTransactionStateError):
sqlstate = '25006'
class SchemaAndDataStatementMixingNotSupportedError(
InvalidTransactionStateError):
sqlstate = '25007'
class NoActiveSQLTransactionError(InvalidTransactionStateError):
sqlstate = '25P01'
class InFailedSQLTransactionError(InvalidTransactionStateError):
sqlstate = '25P02'
class IdleInTransactionSessionTimeoutError(InvalidTransactionStateError):
sqlstate = '25P03'
class InvalidSQLStatementNameError(_base.PostgresError):
sqlstate = '26000'
class TriggeredDataChangeViolationError(_base.PostgresError):
sqlstate = '27000'
class InvalidAuthorizationSpecificationError(_base.PostgresError):
sqlstate = '28000'
class InvalidPasswordError(InvalidAuthorizationSpecificationError):
sqlstate = '28P01'
class DependentPrivilegeDescriptorsStillExistError(_base.PostgresError):
sqlstate = '2B000'
class DependentObjectsStillExistError(
DependentPrivilegeDescriptorsStillExistError):
sqlstate = '2BP01'
class InvalidTransactionTerminationError(_base.PostgresError):
sqlstate = '2D000'
class SQLRoutineError(_base.PostgresError):
sqlstate = '2F000'
class FunctionExecutedNoReturnStatementError(SQLRoutineError):
sqlstate = '2F005'
class ModifyingSQLDataNotPermittedError(SQLRoutineError):
sqlstate = '2F002'
class ProhibitedSQLStatementAttemptedError(SQLRoutineError):
sqlstate = '2F003'
class ReadingSQLDataNotPermittedError(SQLRoutineError):
sqlstate = '2F004'
class InvalidCursorNameError(_base.PostgresError):
sqlstate = '34000'
class ExternalRoutineError(_base.PostgresError):
sqlstate = '38000'
class ContainingSQLNotPermittedError(ExternalRoutineError):
sqlstate = '38001'
class ModifyingExternalRoutineSQLDataNotPermittedError(ExternalRoutineError):
sqlstate = '38002'
class ProhibitedExternalRoutineSQLStatementAttemptedError(
ExternalRoutineError):
sqlstate = '38003'
class ReadingExternalRoutineSQLDataNotPermittedError(ExternalRoutineError):
sqlstate = '38004'
class ExternalRoutineInvocationError(_base.PostgresError):
sqlstate = '39000'
class InvalidSqlstateReturnedError(ExternalRoutineInvocationError):
sqlstate = '39001'
class NullValueInExternalRoutineNotAllowedError(
ExternalRoutineInvocationError):
sqlstate = '39004'
class TriggerProtocolViolatedError(ExternalRoutineInvocationError):
sqlstate = '39P01'
class SrfProtocolViolatedError(ExternalRoutineInvocationError):
sqlstate = '39P02'
class EventTriggerProtocolViolatedError(ExternalRoutineInvocationError):
sqlstate = '39P03'
class SavepointError(_base.PostgresError):
sqlstate = '3B000'
class InvalidSavepointSpecificationError(SavepointError):
sqlstate = '3B001'
class InvalidCatalogNameError(_base.PostgresError):
sqlstate = '3D000'
class InvalidSchemaNameError(_base.PostgresError):
sqlstate = '3F000'
class TransactionRollbackError(_base.PostgresError):
sqlstate = '40000'
class TransactionIntegrityConstraintViolationError(TransactionRollbackError):
sqlstate = '40002'
class SerializationError(TransactionRollbackError):
sqlstate = '40001'
class StatementCompletionUnknownError(TransactionRollbackError):
sqlstate = '40003'
class DeadlockDetectedError(TransactionRollbackError):
sqlstate = '40P01'
class SyntaxOrAccessError(_base.PostgresError):
sqlstate = '42000'
class PostgresSyntaxError(SyntaxOrAccessError):
sqlstate = '42601'
class InsufficientPrivilegeError(SyntaxOrAccessError):
sqlstate = '42501'
class CannotCoerceError(SyntaxOrAccessError):
sqlstate = '42846'
class GroupingError(SyntaxOrAccessError):
sqlstate = '42803'
class WindowingError(SyntaxOrAccessError):
sqlstate = '42P20'
class InvalidRecursionError(SyntaxOrAccessError):
sqlstate = '42P19'
class InvalidForeignKeyError(SyntaxOrAccessError):
sqlstate = '42830'
class InvalidNameError(SyntaxOrAccessError):
sqlstate = '42602'
class NameTooLongError(SyntaxOrAccessError):
sqlstate = '42622'
class ReservedNameError(SyntaxOrAccessError):
sqlstate = '42939'
class DatatypeMismatchError(SyntaxOrAccessError):
sqlstate = '42804'
class IndeterminateDatatypeError(SyntaxOrAccessError):
sqlstate = '42P18'
class CollationMismatchError(SyntaxOrAccessError):
sqlstate = '42P21'
class IndeterminateCollationError(SyntaxOrAccessError):
sqlstate = '42P22'
class WrongObjectTypeError(SyntaxOrAccessError):
sqlstate = '42809'
class GeneratedAlwaysError(SyntaxOrAccessError):
sqlstate = '428C9'
class UndefinedColumnError(SyntaxOrAccessError):
sqlstate = '42703'
class UndefinedFunctionError(SyntaxOrAccessError):
sqlstate = '42883'
class UndefinedTableError(SyntaxOrAccessError):
sqlstate = '42P01'
class UndefinedParameterError(SyntaxOrAccessError):
sqlstate = '42P02'
class UndefinedObjectError(SyntaxOrAccessError):
sqlstate = '42704'
class DuplicateColumnError(SyntaxOrAccessError):
sqlstate = '42701'
class DuplicateCursorError(SyntaxOrAccessError):
sqlstate = '42P03'
class DuplicateDatabaseError(SyntaxOrAccessError):
sqlstate = '42P04'
class DuplicateFunctionError(SyntaxOrAccessError):
sqlstate = '42723'
class DuplicatePreparedStatementError(SyntaxOrAccessError):
sqlstate = '42P05'
class DuplicateSchemaError(SyntaxOrAccessError):
sqlstate = '42P06'
class DuplicateTableError(SyntaxOrAccessError):
sqlstate = '42P07'
class DuplicateAliasError(SyntaxOrAccessError):
sqlstate = '42712'
class DuplicateObjectError(SyntaxOrAccessError):
sqlstate = '42710'
class AmbiguousColumnError(SyntaxOrAccessError):
sqlstate = '42702'
class AmbiguousFunctionError(SyntaxOrAccessError):
sqlstate = '42725'
class AmbiguousParameterError(SyntaxOrAccessError):
sqlstate = '42P08'
class AmbiguousAliasError(SyntaxOrAccessError):
sqlstate = '42P09'
class InvalidColumnReferenceError(SyntaxOrAccessError):
sqlstate = '42P10'
class InvalidColumnDefinitionError(SyntaxOrAccessError):
sqlstate = '42611'
class InvalidCursorDefinitionError(SyntaxOrAccessError):
sqlstate = '42P11'
class InvalidDatabaseDefinitionError(SyntaxOrAccessError):
sqlstate = '42P12'
class InvalidFunctionDefinitionError(SyntaxOrAccessError):
sqlstate = '42P13'
class InvalidPreparedStatementDefinitionError(SyntaxOrAccessError):
sqlstate = '42P14'
class InvalidSchemaDefinitionError(SyntaxOrAccessError):
sqlstate = '42P15'
class InvalidTableDefinitionError(SyntaxOrAccessError):
sqlstate = '42P16'
class InvalidObjectDefinitionError(SyntaxOrAccessError):
sqlstate = '42P17'
class WithCheckOptionViolationError(_base.PostgresError):
sqlstate = '44000'
class InsufficientResourcesError(_base.PostgresError):
sqlstate = '53000'
class DiskFullError(InsufficientResourcesError):
sqlstate = '53100'
class OutOfMemoryError(InsufficientResourcesError):
sqlstate = '53200'
class TooManyConnectionsError(InsufficientResourcesError):
sqlstate = '53300'
class ConfigurationLimitExceededError(InsufficientResourcesError):
sqlstate = '53400'
class ProgramLimitExceededError(_base.PostgresError):
sqlstate = '54000'
class StatementTooComplexError(ProgramLimitExceededError):
sqlstate = '54001'
class TooManyColumnsError(ProgramLimitExceededError):
sqlstate = '54011'
class TooManyArgumentsError(ProgramLimitExceededError):
sqlstate = '54023'
class ObjectNotInPrerequisiteStateError(_base.PostgresError):
sqlstate = '55000'
class ObjectInUseError(ObjectNotInPrerequisiteStateError):
sqlstate = '55006'
class CantChangeRuntimeParamError(ObjectNotInPrerequisiteStateError):
sqlstate = '55P02'
class LockNotAvailableError(ObjectNotInPrerequisiteStateError):
sqlstate = '55P03'
class OperatorInterventionError(_base.PostgresError):
sqlstate = '57000'
class QueryCanceledError(OperatorInterventionError):
sqlstate = '57014'
class AdminShutdownError(OperatorInterventionError):
sqlstate = '57P01'
class CrashShutdownError(OperatorInterventionError):
sqlstate = '57P02'
class CannotConnectNowError(OperatorInterventionError):
sqlstate = '57P03'
class DatabaseDroppedError(OperatorInterventionError):
sqlstate = '57P04'
class PostgresSystemError(_base.PostgresError):
sqlstate = '58000'
class PostgresIOError(PostgresSystemError):
sqlstate = '58030'
class UndefinedFileError(PostgresSystemError):
sqlstate = '58P01'
class DuplicateFileError(PostgresSystemError):
sqlstate = '58P02'
class SnapshotTooOldError(_base.PostgresError):
sqlstate = '72000'
class ConfigFileError(_base.PostgresError):
sqlstate = 'F0000'
class LockFileExistsError(ConfigFileError):
sqlstate = 'F0001'
class FDWError(_base.PostgresError):
sqlstate = 'HV000'
class FDWColumnNameNotFoundError(FDWError):
sqlstate = 'HV005'
class FDWDynamicParameterValueNeededError(FDWError):
sqlstate = 'HV002'
class FDWFunctionSequenceError(FDWError):
sqlstate = 'HV010'
class FDWInconsistentDescriptorInformationError(FDWError):
sqlstate = 'HV021'
class FDWInvalidAttributeValueError(FDWError):
sqlstate = 'HV024'
class FDWInvalidColumnNameError(FDWError):
sqlstate = 'HV007'
class FDWInvalidColumnNumberError(FDWError):
sqlstate = 'HV008'
class FDWInvalidDataTypeError(FDWError):
sqlstate = 'HV004'
class FDWInvalidDataTypeDescriptorsError(FDWError):
sqlstate = 'HV006'
class FDWInvalidDescriptorFieldIdentifierError(FDWError):
sqlstate = 'HV091'
class FDWInvalidHandleError(FDWError):
sqlstate = 'HV00B'
class FDWInvalidOptionIndexError(FDWError):
sqlstate = 'HV00C'
class FDWInvalidOptionNameError(FDWError):
sqlstate = 'HV00D'
class FDWInvalidStringLengthOrBufferLengthError(FDWError):
sqlstate = 'HV090'
class FDWInvalidStringFormatError(FDWError):
sqlstate = 'HV00A'
class FDWInvalidUseOfNullPointerError(FDWError):
sqlstate = 'HV009'
class FDWTooManyHandlesError(FDWError):
sqlstate = 'HV014'
class FDWOutOfMemoryError(FDWError):
sqlstate = 'HV001'
class FDWNoSchemasError(FDWError):
sqlstate = 'HV00P'
class FDWOptionNameNotFoundError(FDWError):
sqlstate = 'HV00J'
class FDWReplyHandleError(FDWError):
sqlstate = 'HV00K'
class FDWSchemaNotFoundError(FDWError):
sqlstate = 'HV00Q'
class FDWTableNotFoundError(FDWError):
sqlstate = 'HV00R'
class FDWUnableToCreateExecutionError(FDWError):
sqlstate = 'HV00L'
class FDWUnableToCreateReplyError(FDWError):
sqlstate = 'HV00M'
class FDWUnableToEstablishConnectionError(FDWError):
sqlstate = 'HV00N'
class PLPGSQLError(_base.PostgresError):
sqlstate = 'P0000'
class RaiseError(PLPGSQLError):
sqlstate = 'P0001'
class NoDataFoundError(PLPGSQLError):
sqlstate = 'P0002'
class TooManyRowsError(PLPGSQLError):
sqlstate = 'P0003'
class AssertError(PLPGSQLError):
sqlstate = 'P0004'
class InternalServerError(_base.PostgresError):
sqlstate = 'XX000'
class DataCorruptedError(InternalServerError):
sqlstate = 'XX001'
class IndexCorruptedError(InternalServerError):
sqlstate = 'XX002'
__all__ = _base.__all__ + (
'ActiveSQLTransactionError', 'AdminShutdownError',
'AmbiguousAliasError', 'AmbiguousColumnError',
'AmbiguousFunctionError', 'AmbiguousParameterError',
'ArraySubscriptError', 'AssertError', 'BadCopyFileFormatError',
'BranchTransactionAlreadyActiveError', 'CannotCoerceError',
'CannotConnectNowError', 'CantChangeRuntimeParamError',
'CardinalityViolationError', 'CaseNotFoundError',
'CharacterNotInRepertoireError', 'CheckViolationError',
'ClientCannotConnectError', 'CollationMismatchError',
'ConfigFileError', 'ConfigurationLimitExceededError',
'ConnectionDoesNotExistError', 'ConnectionFailureError',
'ConnectionRejectionError', 'ContainingSQLNotPermittedError',
'CrashShutdownError', 'DataCorruptedError', 'DataError',
'DatabaseDroppedError', 'DatatypeMismatchError',
'DatetimeFieldOverflowError', 'DeadlockDetectedError',
'DependentObjectsStillExistError',
'DependentPrivilegeDescriptorsStillExistError', 'DeprecatedFeature',
'DiagnosticsError', 'DiskFullError', 'DivisionByZeroError',
'DuplicateAliasError', 'DuplicateColumnError', 'DuplicateCursorError',
'DuplicateDatabaseError', 'DuplicateFileError',
'DuplicateFunctionError', 'DuplicateObjectError',
'DuplicatePreparedStatementError', 'DuplicateSchemaError',
'DuplicateTableError', 'DynamicResultSetsReturned',
'ErrorInAssignmentError', 'EscapeCharacterConflictError',
'EventTriggerProtocolViolatedError', 'ExclusionViolationError',
'ExternalRoutineError', 'ExternalRoutineInvocationError',
'FDWColumnNameNotFoundError', 'FDWDynamicParameterValueNeededError',
'FDWError', 'FDWFunctionSequenceError',
'FDWInconsistentDescriptorInformationError',
'FDWInvalidAttributeValueError', 'FDWInvalidColumnNameError',
'FDWInvalidColumnNumberError', 'FDWInvalidDataTypeDescriptorsError',
'FDWInvalidDataTypeError', 'FDWInvalidDescriptorFieldIdentifierError',
'FDWInvalidHandleError', 'FDWInvalidOptionIndexError',
'FDWInvalidOptionNameError', 'FDWInvalidStringFormatError',
'FDWInvalidStringLengthOrBufferLengthError',
'FDWInvalidUseOfNullPointerError', 'FDWNoSchemasError',
'FDWOptionNameNotFoundError', 'FDWOutOfMemoryError',
'FDWReplyHandleError', 'FDWSchemaNotFoundError',
'FDWTableNotFoundError', 'FDWTooManyHandlesError',
'FDWUnableToCreateExecutionError', 'FDWUnableToCreateReplyError',
'FDWUnableToEstablishConnectionError', 'FeatureNotSupportedError',
'ForeignKeyViolationError', 'FunctionExecutedNoReturnStatementError',
'GeneratedAlwaysError', 'GroupingError',
'HeldCursorRequiresSameIsolationLevelError',
'IdleInTransactionSessionTimeoutError', 'ImplicitZeroBitPadding',
'InFailedSQLTransactionError',
'InappropriateAccessModeForBranchTransactionError',
'InappropriateIsolationLevelForBranchTransactionError',
'IndeterminateCollationError', 'IndeterminateDatatypeError',
'IndexCorruptedError', 'IndicatorOverflowError',
'InsufficientPrivilegeError', 'InsufficientResourcesError',
'IntegrityConstraintViolationError', 'InternalServerError',
'IntervalFieldOverflowError', 'InvalidArgumentForLogarithmError',
'InvalidArgumentForNthValueFunctionError',
'InvalidArgumentForNtileFunctionError',
'InvalidArgumentForPowerFunctionError',
'InvalidArgumentForWidthBucketFunctionError',
'InvalidAuthorizationSpecificationError',
'InvalidBinaryRepresentationError', 'InvalidCachedStatementError',
'InvalidCatalogNameError', 'InvalidCharacterValueForCastError',
'InvalidColumnDefinitionError', 'InvalidColumnReferenceError',
'InvalidCursorDefinitionError', 'InvalidCursorNameError',
'InvalidCursorStateError', 'InvalidDatabaseDefinitionError',
'InvalidDatetimeFormatError', 'InvalidEscapeCharacterError',
'InvalidEscapeOctetError', 'InvalidEscapeSequenceError',
'InvalidForeignKeyError', 'InvalidFunctionDefinitionError',
'InvalidGrantOperationError', 'InvalidGrantorError',
'InvalidIndicatorParameterValueError',
'InvalidLocatorSpecificationError', 'InvalidNameError',
'InvalidObjectDefinitionError', 'InvalidParameterValueError',
'InvalidPasswordError', 'InvalidPreparedStatementDefinitionError',
'InvalidRecursionError', 'InvalidRegularExpressionError',
'InvalidRoleSpecificationError', 'InvalidRowCountInLimitClauseError',
'InvalidRowCountInResultOffsetClauseError',
'InvalidSQLStatementNameError', 'InvalidSavepointSpecificationError',
'InvalidSchemaDefinitionError', 'InvalidSchemaNameError',
'InvalidSqlstateReturnedError', 'InvalidTableDefinitionError',
'InvalidTablesampleArgumentError', 'InvalidTablesampleRepeatError',
'InvalidTextRepresentationError',
'InvalidTimeZoneDisplacementValueError',
'InvalidTransactionInitiationError', 'InvalidTransactionStateError',
'InvalidTransactionTerminationError',
'InvalidUseOfEscapeCharacterError', 'InvalidXmlCommentError',
'InvalidXmlContentError', 'InvalidXmlDocumentError',
'InvalidXmlProcessingInstructionError', 'LocatorError',
'LockFileExistsError', 'LockNotAvailableError',
'ModifyingExternalRoutineSQLDataNotPermittedError',
'ModifyingSQLDataNotPermittedError', 'MostSpecificTypeMismatchError',
'NameTooLongError', 'NoActiveSQLTransactionError',
'NoActiveSQLTransactionForBranchTransactionError',
'NoAdditionalDynamicResultSetsReturned', 'NoData', 'NoDataFoundError',
'NonstandardUseOfEscapeCharacterError', 'NotAnXmlDocumentError',
'NotNullViolationError', 'NullValueEliminatedInSetFunction',
'NullValueInExternalRoutineNotAllowedError',
'NullValueNoIndicatorParameterError', 'NullValueNotAllowedError',
'NumericValueOutOfRangeError', 'ObjectInUseError',
'ObjectNotInPrerequisiteStateError', 'OperatorInterventionError',
'OutOfMemoryError', 'PLPGSQLError', 'PostgresConnectionError',
'PostgresFloatingPointError', 'PostgresIOError',
'PostgresSyntaxError', 'PostgresSystemError', 'PostgresWarning',
'PrivilegeNotGranted', 'PrivilegeNotRevoked',
'ProgramLimitExceededError',
'ProhibitedExternalRoutineSQLStatementAttemptedError',
'ProhibitedSQLStatementAttemptedError', 'ProtocolViolationError',
'QueryCanceledError', 'RaiseError', 'ReadOnlySQLTransactionError',
'ReadingExternalRoutineSQLDataNotPermittedError',
'ReadingSQLDataNotPermittedError', 'ReservedNameError',
'RestrictViolationError', 'SQLRoutineError',
'SQLStatementNotYetCompleteError', 'SavepointError',
'SchemaAndDataStatementMixingNotSupportedError',
'SequenceGeneratorLimitExceededError', 'SerializationError',
'SnapshotTooOldError', 'SrfProtocolViolatedError',
'StackedDiagnosticsAccessedWithoutActiveHandlerError',
'StatementCompletionUnknownError', 'StatementTooComplexError',
'StringDataLengthMismatchError', 'StringDataRightTruncation',
'StringDataRightTruncationError', 'SubstringError',
'SyntaxOrAccessError', 'TooManyArgumentsError', 'TooManyColumnsError',
'TooManyConnectionsError', 'TooManyRowsError',
'TransactionIntegrityConstraintViolationError',
'TransactionResolutionUnknownError', 'TransactionRollbackError',
'TriggerProtocolViolatedError', 'TriggeredActionError',
'TriggeredDataChangeViolationError', 'TrimError',
'UndefinedColumnError', 'UndefinedFileError',
'UndefinedFunctionError', 'UndefinedObjectError',
'UndefinedParameterError', 'UndefinedTableError',
'UniqueViolationError', 'UnterminatedCStringError',
'UntranslatableCharacterError', 'WindowingError',
'WithCheckOptionViolationError', 'WrongObjectTypeError',
'ZeroLengthCharacterStringError'
)
asyncpg-0.13.0/asyncpg/exceptions/_base.py 0000664 0003720 0003720 00000015061 13172407302 021353 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncpg
import sys
__all__ = ('PostgresError', 'FatalPostgresError', 'UnknownPostgresError',
'InterfaceError', 'InterfaceWarning', 'PostgresLogMessage',
'InternalClientError')
def _is_asyncpg_class(cls):
modname = cls.__module__
return modname == 'asyncpg' or modname.startswith('asyncpg.')
class PostgresMessageMeta(type):
_message_map = {}
_field_map = {
'S': 'severity',
'V': 'severity_en',
'C': 'sqlstate',
'M': 'message',
'D': 'detail',
'H': 'hint',
'P': 'position',
'p': 'internal_position',
'q': 'internal_query',
'W': 'context',
's': 'schema_name',
't': 'table_name',
'c': 'column_name',
'd': 'data_type_name',
'n': 'constraint_name',
'F': 'server_source_filename',
'L': 'server_source_line',
'R': 'server_source_function'
}
def __new__(mcls, name, bases, dct):
cls = super().__new__(mcls, name, bases, dct)
if cls.__module__ == mcls.__module__ and name == 'PostgresMessage':
for f in mcls._field_map.values():
setattr(cls, f, None)
if _is_asyncpg_class(cls):
mod = sys.modules[cls.__module__]
if hasattr(mod, name):
raise RuntimeError('exception class redefinition: {}'.format(
name))
code = dct.get('sqlstate')
if code is not None:
existing = mcls._message_map.get(code)
if existing is not None:
raise TypeError('{} has duplicate SQLSTATE code, which is'
'already defined by {}'.format(
name, existing.__name__))
mcls._message_map[code] = cls
return cls
@classmethod
def get_message_class_for_sqlstate(mcls, code):
return mcls._message_map.get(code, UnknownPostgresError)
class PostgresMessage(metaclass=PostgresMessageMeta):
@classmethod
def _get_error_class(cls, fields):
sqlstate = fields.get('C')
return type(cls).get_message_class_for_sqlstate(sqlstate)
@classmethod
def _get_error_dict(cls, fields, query):
dct = {
'query': query
}
field_map = type(cls)._field_map
for k, v in fields.items():
field = field_map.get(k)
if field:
dct[field] = v
return dct
@classmethod
def _make_constructor(cls, fields, query=None):
dct = cls._get_error_dict(fields, query)
exccls = cls._get_error_class(fields)
message = dct.get('message', '')
# PostgreSQL will raise an exception when it detects
# that the result type of the query has changed from
# when the statement was prepared.
#
# The original error is somewhat cryptic and unspecific,
# so we raise a custom subclass that is easier to handle
# and identify.
#
# Note that we specifically do not rely on the error
# message, as it is localizable.
is_icse = (
exccls.__name__ == 'FeatureNotSupportedError' and
_is_asyncpg_class(exccls) and
dct.get('server_source_function') == 'RevalidateCachedQuery'
)
if is_icse:
exceptions = sys.modules[exccls.__module__]
exccls = exceptions.InvalidCachedStatementError
message = ('cached statement plan is invalid due to a database '
'schema or configuration change')
return exccls, message, dct
def as_dict(self):
dct = {}
for f in type(self)._field_map.values():
val = getattr(self, f)
if val is not None:
dct[f] = val
return dct
class PostgresError(PostgresMessage, Exception):
"""Base class for all Postgres errors."""
def __str__(self):
msg = self.args[0]
if self.detail:
msg += '\nDETAIL: {}'.format(self.detail)
if self.hint:
msg += '\nHINT: {}'.format(self.hint)
return msg
@classmethod
def new(cls, fields, query=None):
exccls, message, dct = cls._make_constructor(fields, query)
ex = exccls(message)
ex.__dict__.update(dct)
return ex
class FatalPostgresError(PostgresError):
"""A fatal error that should result in server disconnection."""
class UnknownPostgresError(FatalPostgresError):
"""An error with an unknown SQLSTATE code."""
class InterfaceMessage:
def __init__(self, *, detail=None, hint=None):
self.detail = detail
self.hint = hint
def __str__(self):
msg = self.args[0]
if self.detail:
msg += '\nDETAIL: {}'.format(self.detail)
if self.hint:
msg += '\nHINT: {}'.format(self.hint)
return msg
class InterfaceError(InterfaceMessage, Exception):
"""An error caused by improper use of asyncpg API."""
def __init__(self, msg, *, detail=None, hint=None):
InterfaceMessage.__init__(self, detail=detail, hint=hint)
Exception.__init__(self, msg)
class InterfaceWarning(InterfaceMessage, UserWarning):
"""A warning caused by an improper use of asyncpg API."""
def __init__(self, msg, *, detail=None, hint=None):
InterfaceMessage.__init__(self, detail=detail, hint=hint)
UserWarning.__init__(self, msg)
class InternalClientError(Exception):
pass
class PostgresLogMessage(PostgresMessage):
"""A base class for non-error server messages."""
def __str__(self):
return '{}: {}'.format(type(self).__name__, self.message)
def __setattr__(self, name, val):
raise TypeError('instances of {} are immutable'.format(
type(self).__name__))
@classmethod
def new(cls, fields, query=None):
exccls, message_text, dct = cls._make_constructor(fields, query)
if exccls is UnknownPostgresError:
exccls = PostgresLogMessage
if exccls is PostgresLogMessage:
severity = dct.get('severity_en') or dct.get('severity')
if severity and severity.upper() == 'WARNING':
exccls = asyncpg.PostgresWarning
if issubclass(exccls, (BaseException, Warning)):
msg = exccls(message_text)
else:
msg = exccls()
msg.__dict__.update(dct)
return msg
asyncpg-0.13.0/asyncpg/utils.py 0000664 0003720 0003720 00000002527 13172407302 017264 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the ayncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import re
def _quote_ident(ident):
return '"{}"'.format(ident.replace('"', '""'))
def _quote_literal(string):
return "'{}'".format(string.replace("'", "''"))
async def _mogrify(conn, query, args):
"""Safely inline arguments to query text."""
# Introspect the target query for argument types and
# build a list of safely-quoted fully-qualified type names.
ps = await conn.prepare(query)
paramtypes = []
for t in ps.get_parameters():
if t.name.endswith('[]'):
pname = '_' + t.name[:-2]
else:
pname = t.name
paramtypes.append('{}.{}'.format(
_quote_ident(t.schema), _quote_ident(pname)))
del ps
# Use Postgres to convert arguments to text representation
# by casting each value to text.
cols = ['quote_literal(${}::{}::text)'.format(i, t)
for i, t in enumerate(paramtypes, start=1)]
textified = await conn.fetchrow(
'SELECT {cols}'.format(cols=', '.join(cols)), *args)
# Finally, replace $n references with text values.
return re.sub(
r'\$(\d+)\b', lambda m: textified[int(m.group(1)) - 1], query)
asyncpg-0.13.0/asyncpg/connection.py 0000664 0003720 0003720 00000161700 13172407302 020262 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import collections
import collections.abc
import itertools
import struct
import time
import warnings
from . import compat
from . import connect_utils
from . import cursor
from . import exceptions
from . import introspection
from . import prepared_stmt
from . import protocol
from . import serverversion
from . import transaction
from . import utils
class ConnectionMeta(type):
def __instancecheck__(cls, instance):
mro = type(instance).__mro__
return Connection in mro or _ConnectionProxy in mro
class Connection(metaclass=ConnectionMeta):
"""A representation of a database session.
Connections are created by calling :func:`~asyncpg.connection.connect`.
"""
__slots__ = ('_protocol', '_transport', '_loop',
'_top_xact', '_uid', '_aborted',
'_pool_release_ctr', '_stmt_cache', '_stmts_to_close',
'_listeners', '_server_version', '_server_caps',
'_intro_query', '_reset_query', '_proxy',
'_stmt_exclusive_section', '_config', '_params', '_addr',
'_log_listeners')
def __init__(self, protocol, transport, loop,
addr: (str, int) or str,
config: connect_utils._ClientConfiguration,
params: connect_utils._ConnectionParameters):
self._protocol = protocol
self._transport = transport
self._loop = loop
self._top_xact = None
self._uid = 0
self._aborted = False
# Incremented very time the connection is released back to a pool.
# Used to catch invalid references to connection-related resources
# post-release (e.g. explicit prepared statements).
self._pool_release_ctr = 0
self._addr = addr
self._config = config
self._params = params
self._stmt_cache = _StatementCache(
loop=loop,
max_size=config.statement_cache_size,
on_remove=self._maybe_gc_stmt,
max_lifetime=config.max_cached_statement_lifetime)
self._stmts_to_close = set()
self._listeners = {}
self._log_listeners = set()
settings = self._protocol.get_settings()
ver_string = settings.server_version
self._server_version = \
serverversion.split_server_version_string(ver_string)
self._server_caps = _detect_server_capabilities(
self._server_version, settings)
self._intro_query = introspection.INTRO_LOOKUP_TYPES
self._reset_query = None
self._proxy = None
# Used to serialize operations that might involve anonymous
# statements. Specifically, we want to make the following
# operation atomic:
# ("prepare an anonymous statement", "use the statement")
#
# Used for `con.fetchval()`, `con.fetch()`, `con.fetchrow()`,
# `con.execute()`, and `con.executemany()`.
self._stmt_exclusive_section = _Atomic()
async def add_listener(self, channel, callback):
"""Add a listener for Postgres notifications.
:param str channel: Channel to listen on.
:param callable callback:
A callable receiving the following arguments:
**connection**: a Connection the callback is registered with;
**pid**: PID of the Postgres server that sent the notification;
**channel**: name of the channel the notification was sent to;
**payload**: the payload.
"""
self._check_open()
if channel not in self._listeners:
await self.fetch('LISTEN {}'.format(channel))
self._listeners[channel] = set()
self._listeners[channel].add(callback)
async def remove_listener(self, channel, callback):
"""Remove a listening callback on the specified channel."""
if self.is_closed():
return
if channel not in self._listeners:
return
if callback not in self._listeners[channel]:
return
self._listeners[channel].remove(callback)
if not self._listeners[channel]:
del self._listeners[channel]
await self.fetch('UNLISTEN {}'.format(channel))
def add_log_listener(self, callback):
"""Add a listener for Postgres log messages.
It will be called when asyncronous NoticeResponse is received
from the connection. Possible message types are: WARNING, NOTICE,
DEBUG, INFO, or LOG.
:param callable callback:
A callable receiving the following arguments:
**connection**: a Connection the callback is registered with;
**message**: the `exceptions.PostgresLogMessage` message.
.. versionadded:: 0.12.0
"""
if self.is_closed():
raise exceptions.InterfaceError('connection is closed')
self._log_listeners.add(callback)
def remove_log_listener(self, callback):
"""Remove a listening callback for log messages.
.. versionadded:: 0.12.0
"""
self._log_listeners.discard(callback)
def get_server_pid(self):
"""Return the PID of the Postgres server the connection is bound to."""
return self._protocol.get_server_pid()
def get_server_version(self):
"""Return the version of the connected PostgreSQL server.
The returned value is a named tuple similar to that in
``sys.version_info``:
.. code-block:: pycon
>>> con.get_server_version()
ServerVersion(major=9, minor=6, micro=1,
releaselevel='final', serial=0)
.. versionadded:: 0.8.0
"""
return self._server_version
def get_settings(self):
"""Return connection settings.
:return: :class:`~asyncpg.ConnectionSettings`.
"""
return self._protocol.get_settings()
def transaction(self, *, isolation='read_committed', readonly=False,
deferrable=False):
"""Create a :class:`~transaction.Transaction` object.
Refer to `PostgreSQL documentation`_ on the meaning of transaction
parameters.
:param isolation: Transaction isolation mode, can be one of:
`'serializable'`, `'repeatable_read'`,
`'read_committed'`.
:param readonly: Specifies whether or not this transaction is
read-only.
:param deferrable: Specifies whether or not this transaction is
deferrable.
.. _`PostgreSQL documentation`: https://www.postgresql.org/docs/\
current/static/sql-set-transaction.html
"""
self._check_open()
return transaction.Transaction(self, isolation, readonly, deferrable)
async def execute(self, query: str, *args, timeout: float=None) -> str:
"""Execute an SQL command (or commands).
This method can execute many SQL commands at once, when no arguments
are provided.
Example:
.. code-block:: pycon
>>> await con.execute('''
... CREATE TABLE mytab (a int);
... INSERT INTO mytab (a) VALUES (100), (200), (300);
... ''')
INSERT 0 3
>>> await con.execute('''
... INSERT INTO mytab (a) VALUES ($1), ($2)
... ''', 10, 20)
INSERT 0 2
:param args: Query arguments.
:param float timeout: Optional timeout value in seconds.
:return str: Status of the last SQL command.
.. versionchanged:: 0.5.4
Made it possible to pass query arguments.
"""
self._check_open()
if not args:
return await self._protocol.query(query, timeout)
_, status, _ = await self._execute(query, args, 0, timeout, True)
return status.decode()
async def executemany(self, command: str, args, *, timeout: float=None):
"""Execute an SQL *command* for each sequence of arguments in *args*.
Example:
.. code-block:: pycon
>>> await con.executemany('''
... INSERT INTO mytab (a) VALUES ($1, $2, $3);
... ''', [(1, 2, 3), (4, 5, 6)])
:param command: Command to execute.
:param args: An iterable containing sequences of arguments.
:param float timeout: Optional timeout value in seconds.
:return None: This method discards the results of the operations.
.. versionadded:: 0.7.0
.. versionchanged:: 0.11.0
`timeout` became a keyword-only parameter.
"""
self._check_open()
return await self._executemany(command, args, timeout)
async def _get_statement(self, query, timeout, *, named: bool=False):
statement = self._stmt_cache.get(query)
if statement is not None:
return statement
# Only use the cache when:
# * `statement_cache_size` is greater than 0;
# * query size is less than `max_cacheable_statement_size`.
use_cache = self._stmt_cache.get_max_size() > 0
if (use_cache and
self._config.max_cacheable_statement_size and
len(query) > self._config.max_cacheable_statement_size):
use_cache = False
if use_cache or named:
stmt_name = self._get_unique_id('stmt')
else:
stmt_name = ''
statement = await self._protocol.prepare(stmt_name, query, timeout)
ready = statement._init_types()
if ready is not True:
types, intro_stmt = await self.__execute(
self._intro_query, (list(ready),), 0, timeout)
self._protocol.get_settings().register_data_types(types)
if not intro_stmt.name and not statement.name:
# The introspection query has used an anonymous statement,
# which has blown away the anonymous statement we've prepared
# for the query, so we need to re-prepare it.
statement = await self._protocol.prepare(
stmt_name, query, timeout)
if use_cache:
self._stmt_cache.put(query, statement)
# If we've just created a new statement object, check if there
# are any statements for GC.
if self._stmts_to_close:
await self._cleanup_stmts()
return statement
def cursor(self, query, *args, prefetch=None, timeout=None):
"""Return a *cursor factory* for the specified query.
:param args: Query arguments.
:param int prefetch: The number of rows the *cursor iterator*
will prefetch (defaults to ``50``.)
:param float timeout: Optional timeout in seconds.
:return: A :class:`~cursor.CursorFactory` object.
"""
self._check_open()
return cursor.CursorFactory(self, query, None, args,
prefetch, timeout)
async def prepare(self, query, *, timeout=None):
"""Create a *prepared statement* for the specified query.
:param str query: Text of the query to create a prepared statement for.
:param float timeout: Optional timeout value in seconds.
:return: A :class:`~prepared_stmt.PreparedStatement` instance.
"""
self._check_open()
stmt = await self._get_statement(query, timeout, named=True)
return prepared_stmt.PreparedStatement(self, query, stmt)
async def fetch(self, query, *args, timeout=None) -> list:
"""Run a query and return the results as a list of :class:`Record`.
:param str query: Query text.
:param args: Query arguments.
:param float timeout: Optional timeout value in seconds.
:return list: A list of :class:`Record` instances.
"""
self._check_open()
return await self._execute(query, args, 0, timeout)
async def fetchval(self, query, *args, column=0, timeout=None):
"""Run a query and return a value in the first row.
:param str query: Query text.
:param args: Query arguments.
:param int column: Numeric index within the record of the value to
return (defaults to 0).
:param float timeout: Optional timeout value in seconds.
If not specified, defaults to the value of
``command_timeout`` argument to the ``Connection``
instance constructor.
:return: The value of the specified column of the first record, or
None if no records were returned by the query.
"""
self._check_open()
data = await self._execute(query, args, 1, timeout)
if not data:
return None
return data[0][column]
async def fetchrow(self, query, *args, timeout=None):
"""Run a query and return the first row.
:param str query: Query text
:param args: Query arguments
:param float timeout: Optional timeout value in seconds.
:return: The first row as a :class:`Record` instance, or None if
no records were returned by the query.
"""
self._check_open()
data = await self._execute(query, args, 1, timeout)
if not data:
return None
return data[0]
async def copy_from_table(self, table_name, *, output,
columns=None, schema_name=None, timeout=None,
format=None, oids=None, delimiter=None,
null=None, header=None, quote=None,
escape=None, force_quote=None, encoding=None):
"""Copy table contents to a file or file-like object.
:param str table_name:
The name of the table to copy data from.
:param output:
A :term:`path-like object `,
or a :term:`file-like object `, or
a :term:`coroutine function `
that takes a ``bytes`` instance as a sole argument.
:param list columns:
An optional list of column names to copy.
:param str schema_name:
An optional schema name to qualify the table.
:param float timeout:
Optional timeout value in seconds.
The remaining keyword arguments are ``COPY`` statement options,
see `COPY statement documentation`_ for details.
:return: The status string of the COPY command.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... result = await con.copy_from_table(
... 'mytable', columns=('foo', 'bar'),
... output='file.csv', format='csv')
... print(result)
>>> asyncio.get_event_loop().run_until_complete(run())
'COPY 100'
.. _`COPY statement documentation`: https://www.postgresql.org/docs/\
current/static/sql-copy.html
.. versionadded:: 0.11.0
"""
tabname = utils._quote_ident(table_name)
if schema_name:
tabname = utils._quote_ident(schema_name) + '.' + tabname
if columns:
cols = '({})'.format(
', '.join(utils._quote_ident(c) for c in columns))
else:
cols = ''
opts = self._format_copy_opts(
format=format, oids=oids, delimiter=delimiter,
null=null, header=header, quote=quote, escape=escape,
force_quote=force_quote, encoding=encoding
)
copy_stmt = 'COPY {tab}{cols} TO STDOUT {opts}'.format(
tab=tabname, cols=cols, opts=opts)
return await self._copy_out(copy_stmt, output, timeout)
async def copy_from_query(self, query, *args, output,
timeout=None, format=None, oids=None,
delimiter=None, null=None, header=None,
quote=None, escape=None, force_quote=None,
encoding=None):
"""Copy the results of a query to a file or file-like object.
:param str query:
The query to copy the results of.
:param \*args:
Query arguments.
:param output:
A :term:`path-like object `,
or a :term:`file-like object `, or
a :term:`coroutine function `
that takes a ``bytes`` instance as a sole argument.
:param float timeout:
Optional timeout value in seconds.
The remaining keyword arguments are ``COPY`` statement options,
see `COPY statement documentation`_ for details.
:return: The status string of the COPY command.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... result = await con.copy_from_query(
... 'SELECT foo, bar FROM mytable WHERE foo > $1', 10,
... output='file.csv', format='csv')
... print(result)
>>> asyncio.get_event_loop().run_until_complete(run())
'COPY 10'
.. _`COPY statement documentation`: https://www.postgresql.org/docs/\
current/static/sql-copy.html
.. versionadded:: 0.11.0
"""
opts = self._format_copy_opts(
format=format, oids=oids, delimiter=delimiter,
null=null, header=header, quote=quote, escape=escape,
force_quote=force_quote, encoding=encoding
)
if args:
query = await utils._mogrify(self, query, args)
copy_stmt = 'COPY ({query}) TO STDOUT {opts}'.format(
query=query, opts=opts)
return await self._copy_out(copy_stmt, output, timeout)
async def copy_to_table(self, table_name, *, source,
columns=None, schema_name=None, timeout=None,
format=None, oids=None, freeze=None,
delimiter=None, null=None, header=None,
quote=None, escape=None, force_quote=None,
force_not_null=None, force_null=None,
encoding=None):
"""Copy data to the specified table.
:param str table_name:
The name of the table to copy data to.
:param source:
A :term:`path-like object `,
or a :term:`file-like object `, or
an :term:`asynchronous iterable `
that returns ``bytes``, or an object supporting the
:ref:`buffer protocol `.
:param list columns:
An optional list of column names to copy.
:param str schema_name:
An optional schema name to qualify the table.
:param float timeout:
Optional timeout value in seconds.
The remaining keyword arguments are ``COPY`` statement options,
see `COPY statement documentation`_ for details.
:return: The status string of the COPY command.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... result = await con.copy_to_table(
... 'mytable', source='datafile.tbl')
.... print(result)
>>> asyncio.get_event_loop().run_until_complete(run())
'COPY 140000'
.. _`COPY statement documentation`: https://www.postgresql.org/docs/\
current/static/sql-copy.html
.. versionadded:: 0.11.0
"""
tabname = utils._quote_ident(table_name)
if schema_name:
tabname = utils._quote_ident(schema_name) + '.' + tabname
if columns:
cols = '({})'.format(
', '.join(utils._quote_ident(c) for c in columns))
else:
cols = ''
opts = self._format_copy_opts(
format=format, oids=oids, freeze=freeze, delimiter=delimiter,
null=null, header=header, quote=quote, escape=escape,
force_not_null=force_not_null, force_null=force_null,
encoding=encoding
)
copy_stmt = 'COPY {tab}{cols} FROM STDIN {opts}'.format(
tab=tabname, cols=cols, opts=opts)
return await self._copy_in(copy_stmt, source, timeout)
async def copy_records_to_table(self, table_name, *, records,
columns=None, schema_name=None,
timeout=None):
"""Copy a list of records to the specified table using binary COPY.
:param str table_name:
The name of the table to copy data to.
:param records:
An iterable returning row tuples to copy into the table.
:param list columns:
An optional list of column names to copy.
:param str schema_name:
An optional schema name to qualify the table.
:param float timeout:
Optional timeout value in seconds.
:return: The status string of the COPY command.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... result = await con.copy_records_to_table(
... 'mytable', records=[
... (1, 'foo', 'bar'),
... (2, 'ham', 'spam')])
.... print(result)
>>> asyncio.get_event_loop().run_until_complete(run())
'COPY 2'
.. versionadded:: 0.11.0
"""
tabname = utils._quote_ident(table_name)
if schema_name:
tabname = utils._quote_ident(schema_name) + '.' + tabname
if columns:
col_list = ', '.join(utils._quote_ident(c) for c in columns)
cols = '({})'.format(col_list)
else:
col_list = '*'
cols = ''
intro_query = 'SELECT {cols} FROM {tab} LIMIT 1'.format(
tab=tabname, cols=col_list)
intro_ps = await self.prepare(intro_query)
opts = '(FORMAT binary)'
copy_stmt = 'COPY {tab}{cols} FROM STDIN {opts}'.format(
tab=tabname, cols=cols, opts=opts)
return await self._copy_in_records(
copy_stmt, records, intro_ps._state, timeout)
def _format_copy_opts(self, *, format=None, oids=None, freeze=None,
delimiter=None, null=None, header=None, quote=None,
escape=None, force_quote=None, force_not_null=None,
force_null=None, encoding=None):
kwargs = dict(locals())
kwargs.pop('self')
opts = []
if force_quote is not None and isinstance(force_quote, bool):
kwargs.pop('force_quote')
if force_quote:
opts.append('FORCE_QUOTE *')
for k, v in kwargs.items():
if v is not None:
if k in ('force_not_null', 'force_null', 'force_quote'):
v = '(' + ', '.join(utils._quote_ident(c) for c in v) + ')'
elif k in ('oids', 'freeze', 'header'):
v = str(v)
else:
v = utils._quote_literal(v)
opts.append('{} {}'.format(k.upper(), v))
if opts:
return '(' + ', '.join(opts) + ')'
else:
return ''
async def _copy_out(self, copy_stmt, output, timeout):
try:
path = compat.fspath(output)
except TypeError:
# output is not a path-like object
path = None
writer = None
opened_by_us = False
run_in_executor = self._loop.run_in_executor
if path is not None:
# a path
f = await run_in_executor(None, open, path, 'wb')
opened_by_us = True
elif hasattr(output, 'write'):
# file-like
f = output
elif callable(output):
# assuming calling output returns an awaitable.
writer = output
else:
raise TypeError(
'output is expected to be a file-like object, '
'a path-like object or a coroutine function, '
'not {}'.format(type(output).__name__)
)
if writer is None:
async def _writer(data):
await run_in_executor(None, f.write, data)
writer = _writer
try:
return await self._protocol.copy_out(copy_stmt, writer, timeout)
finally:
if opened_by_us:
f.close()
async def _copy_in(self, copy_stmt, source, timeout):
try:
path = compat.fspath(source)
except TypeError:
# source is not a path-like object
path = None
f = None
reader = None
data = None
opened_by_us = False
run_in_executor = self._loop.run_in_executor
if path is not None:
# a path
f = await run_in_executor(None, open, path, 'wb')
opened_by_us = True
elif hasattr(source, 'read'):
# file-like
f = source
elif isinstance(source, collections.abc.AsyncIterable):
# assuming calling output returns an awaitable.
reader = source
else:
# assuming source is an instance supporting the buffer protocol.
data = source
if f is not None:
# Copying from a file-like object.
class _Reader:
@compat.aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
data = await run_in_executor(None, f.read, 524288)
if len(data) == 0:
raise StopAsyncIteration
else:
return data
reader = _Reader()
try:
return await self._protocol.copy_in(
copy_stmt, reader, data, None, None, timeout)
finally:
if opened_by_us:
await run_in_executor(None, f.close)
async def _copy_in_records(self, copy_stmt, records, intro_stmt, timeout):
return await self._protocol.copy_in(
copy_stmt, None, None, records, intro_stmt, timeout)
async def set_type_codec(self, typename, *,
schema='public', encoder, decoder,
binary=None, format='text'):
"""Set an encoder/decoder pair for the specified data type.
:param typename:
Name of the data type the codec is for.
:param schema:
Schema name of the data type the codec is for
(defaults to ``'public'``)
:param format:
The type of the argument received by the *decoder* callback,
and the type of the *encoder* callback return value.
If *format* is ``'text'`` (the default), the exchange datum is a
``str`` instance containing valid text representation of the
data type.
If *format* is ``'binary'``, the exchange datum is a ``bytes``
instance containing valid _binary_ representation of the
data type.
If *format* is ``'tuple'``, the exchange datum is a type-specific
``tuple`` of values. The table below lists supported data
types and their format for this mode.
+-----------------+---------------------------------------------+
| Type | Tuple layout |
+=================+=============================================+
| ``interval`` | (``months``, ``days``, ``microseconds``) |
+-----------------+---------------------------------------------+
| ``date`` | (``date ordinal relative to Jan 1 2000``,) |
| | ``-2^31`` for negative infinity timestamp |
| | ``2^31-1`` for positive infinity timestamp. |
+-----------------+---------------------------------------------+
| ``timestamp`` | (``microseconds relative to Jan 1 2000``,) |
| | ``-2^63`` for negative infinity timestamp |
| | ``2^63-1`` for positive infinity timestamp. |
+-----------------+---------------------------------------------+
| ``timestamp | (``microseconds relative to Jan 1 2000 |
| with time zone``| UTC``,) |
| | ``-2^63`` for negative infinity timestamp |
| | ``2^63-1`` for positive infinity timestamp. |
+-----------------+---------------------------------------------+
| ``time`` | (``microseconds``,) |
+-----------------+---------------------------------------------+
| ``time with | (``microseconds``, |
| time zone`` | ``time zone offset in seconds``) |
+-----------------+---------------------------------------------+
:param encoder:
Callable accepting a Python object as a single argument and
returning a value encoded according to *format*.
:param decoder:
Callable accepting a single argument encoded according to *format*
and returning a decoded Python object.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> import datetime
>>> from dateutil.relativedelta import relativedelta
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... def encoder(delta):
... ndelta = delta.normalized()
... return (ndelta.years * 12 + ndelta.months,
... ndelta.days,
... ((ndelta.hours * 3600 +
... ndelta.minutes * 60 +
... ndelta.seconds) * 1000000 +
... ndelta.microseconds))
... def decoder(tup):
... return relativedelta(months=tup[0], days=tup[1],
... microseconds=tup[2])
... await con.set_type_codec(
... 'interval', schema='pg_catalog', encoder=encoder,
... decoder=decoder, format='tuple')
... result = await con.fetchval(
... "SELECT '2 years 3 mons 1 day'::interval")
... print(result)
... print(datetime.datetime(2002, 1, 1) + result)
>>> asyncio.get_event_loop().run_until_complete(run())
relativedelta(years=+2, months=+3, days=+1)
2004-04-02 00:00:00
.. versionadded:: 0.12.0
Added the ``format`` keyword argument and support for 'tuple'
format.
.. versionchanged:: 0.12.0
The ``binary`` keyword argument is deprecated in favor of
``format``.
.. versionchanged:: 0.13.0
The ``binary`` keyword argument was removed in favor of
``format``.
"""
self._check_open()
typeinfo = await self.fetchrow(
introspection.TYPE_BY_NAME, typename, schema)
if not typeinfo:
raise ValueError('unknown type: {}.{}'.format(schema, typename))
oid = typeinfo['oid']
if typeinfo['kind'] != b'b' or typeinfo['elemtype']:
raise ValueError(
'cannot use custom codec on non-scalar type {}.{}'.format(
schema, typename))
self._protocol.get_settings().add_python_codec(
oid, typename, schema, 'scalar',
encoder, decoder, format)
# Statement cache is no longer valid due to codec changes.
self._drop_local_statement_cache()
async def reset_type_codec(self, typename, *, schema='public'):
"""Reset *typename* codec to the default implementation.
:param typename:
Name of the data type the codec is for.
:param schema:
Schema name of the data type the codec is for
(defaults to ``'public'``)
.. versionadded:: 0.12.0
"""
typeinfo = await self.fetchrow(
introspection.TYPE_BY_NAME, typename, schema)
if not typeinfo:
raise ValueError('unknown type: {}.{}'.format(schema, typename))
oid = typeinfo['oid']
self._protocol.get_settings().remove_python_codec(
oid, typename, schema)
# Statement cache is no longer valid due to codec changes.
self._drop_local_statement_cache()
async def set_builtin_type_codec(self, typename, *,
schema='public', codec_name):
"""Set a builtin codec for the specified data type.
:param typename: Name of the data type the codec is for.
:param schema: Schema name of the data type the codec is for
(defaults to 'public')
:param codec_name: The name of the builtin codec.
"""
self._check_open()
typeinfo = await self.fetchrow(
introspection.TYPE_BY_NAME, typename, schema)
if not typeinfo:
raise ValueError('unknown type: {}.{}'.format(schema, typename))
oid = typeinfo['oid']
if typeinfo['kind'] != b'b' or typeinfo['elemtype']:
raise ValueError(
'cannot alias non-scalar type {}.{}'.format(
schema, typename))
self._protocol.get_settings().set_builtin_type_codec(
oid, typename, schema, 'scalar', codec_name)
# Statement cache is no longer valid due to codec changes.
self._drop_local_statement_cache()
def is_closed(self):
"""Return ``True`` if the connection is closed, ``False`` otherwise.
:return bool: ``True`` if the connection is closed, ``False``
otherwise.
"""
return not self._protocol.is_connected() or self._aborted
async def close(self):
"""Close the connection gracefully."""
if self.is_closed():
return
self._mark_stmts_as_closed()
self._listeners.clear()
self._log_listeners.clear()
self._aborted = True
await self._protocol.close()
def terminate(self):
"""Terminate the connection without waiting for pending data."""
self._mark_stmts_as_closed()
self._listeners.clear()
self._log_listeners.clear()
self._aborted = True
self._protocol.abort()
async def reset(self):
self._check_open()
self._listeners.clear()
self._log_listeners.clear()
reset_query = self._get_reset_query()
if reset_query:
await self.execute(reset_query)
def _check_open(self):
if self.is_closed():
raise exceptions.InterfaceError('connection is closed')
def _get_unique_id(self, prefix):
self._uid += 1
return '__asyncpg_{}_{}__'.format(prefix, self._uid)
def _mark_stmts_as_closed(self):
for stmt in self._stmt_cache.iter_statements():
stmt.mark_closed()
for stmt in self._stmts_to_close:
stmt.mark_closed()
self._stmt_cache.clear()
self._stmts_to_close.clear()
def _maybe_gc_stmt(self, stmt):
if stmt.refs == 0 and not self._stmt_cache.has(stmt.query):
# If low-level `stmt` isn't referenced from any high-level
# `PreparedStatement` object and is not in the `_stmt_cache`:
#
# * mark it as closed, which will make it non-usable
# for any `PreparedStatement` or for methods like
# `Connection.fetch()`.
#
# * schedule it to be formally closed on the server.
stmt.mark_closed()
self._stmts_to_close.add(stmt)
async def _cleanup_stmts(self):
# Called whenever we create a new prepared statement in
# `Connection._get_statement()` and `_stmts_to_close` is
# not empty.
to_close = self._stmts_to_close
self._stmts_to_close = set()
for stmt in to_close:
# It is imperative that statements are cleaned properly,
# so we ignore the timeout.
await self._protocol.close_statement(stmt, protocol.NO_TIMEOUT)
def _cancel_current_command(self, waiter):
async def cancel():
try:
# Open new connection to the server
r, w = await connect_utils._open_connection(
loop=self._loop, addr=self._addr, params=self._params)
except Exception as ex:
waiter.set_exception(ex)
return
try:
# Pack CancelRequest message
msg = struct.pack('!llll', 16, 80877102,
self._protocol.backend_pid,
self._protocol.backend_secret)
w.write(msg)
await r.read() # Wait until EOF
except ConnectionResetError:
# On some systems Postgres will reset the connection
# after processing the cancellation command.
pass
except Exception as ex:
waiter.set_exception(ex)
finally:
if not waiter.done(): # Ensure set_exception wasn't called.
waiter.set_result(None)
w.close()
self._loop.create_task(cancel())
def _process_log_message(self, fields, last_query):
if not self._log_listeners:
return
message = exceptions.PostgresLogMessage.new(fields, query=last_query)
con_ref = self._unwrap()
for cb in self._log_listeners:
self._loop.call_soon(
self._call_log_listener, cb, con_ref, message)
def _call_log_listener(self, cb, con_ref, message):
try:
cb(con_ref, message)
except Exception as ex:
self._loop.call_exception_handler({
'message': 'Unhandled exception in asyncpg log message '
'listener callback {!r}'.format(cb),
'exception': ex
})
def _process_notification(self, pid, channel, payload):
if channel not in self._listeners:
return
con_ref = self._unwrap()
for cb in self._listeners[channel]:
self._loop.call_soon(
self._call_listener, cb, con_ref, pid, channel, payload)
def _call_listener(self, cb, con_ref, pid, channel, payload):
try:
cb(con_ref, pid, channel, payload)
except Exception as ex:
self._loop.call_exception_handler({
'message': 'Unhandled exception in asyncpg notification '
'listener callback {!r}'.format(cb),
'exception': ex
})
def _unwrap(self):
if self._proxy is None:
con_ref = self
else:
# `_proxy` is not None when the connection is a member
# of a connection pool. Which means that the user is working
# with a `PoolConnectionProxy` instance, and expects to see it
# (and not the actual Connection) in their event callbacks.
con_ref = self._proxy
return con_ref
def _get_reset_query(self):
if self._reset_query is not None:
return self._reset_query
caps = self._server_caps
_reset_query = []
if self._protocol.is_in_transaction() or self._top_xact is not None:
self._loop.call_exception_handler({
'message': 'Resetting connection with an '
'active transaction {!r}'.format(self)
})
self._top_xact = None
_reset_query.append('ROLLBACK;')
if caps.advisory_locks:
_reset_query.append('SELECT pg_advisory_unlock_all();')
if caps.sql_close_all:
_reset_query.append('CLOSE ALL;')
if caps.notifications and caps.plpgsql:
_reset_query.append('''
DO $$
BEGIN
PERFORM * FROM pg_listening_channels() LIMIT 1;
IF FOUND THEN
UNLISTEN *;
END IF;
END;
$$;
''')
if caps.sql_reset:
_reset_query.append('RESET ALL;')
_reset_query = '\n'.join(_reset_query)
self._reset_query = _reset_query
return _reset_query
def _set_proxy(self, proxy):
if self._proxy is not None and proxy is not None:
# Should not happen unless there is a bug in `Pool`.
raise exceptions.InterfaceError(
'internal asyncpg error: connection is already proxied')
self._proxy = proxy
def _check_listeners(self, listeners, listener_type):
if listeners:
count = len(listeners)
w = exceptions.InterfaceWarning(
'{conn!r} is being released to the pool but has {c} active '
'{type} listener{s}'.format(
conn=self, c=count, type=listener_type,
s='s' if count > 1 else ''))
warnings.warn(w)
def _on_release(self, stacklevel=1):
# Invalidate external references to the connection.
self._pool_release_ctr += 1
# Called when the connection is about to be released to the pool.
# Let's check that the user has not left any listeners on it.
self._check_listeners(
list(itertools.chain.from_iterable(self._listeners.values())),
'notification')
self._check_listeners(
self._log_listeners, 'log')
def _drop_local_statement_cache(self):
self._stmt_cache.clear()
def _drop_global_statement_cache(self):
if self._proxy is not None:
# This connection is a member of a pool, so we delegate
# the cache drop to the pool.
pool = self._proxy._holder._pool
pool._drop_statement_cache()
else:
self._drop_local_statement_cache()
async def _execute(self, query, args, limit, timeout, return_status=False):
with self._stmt_exclusive_section:
result, _ = await self.__execute(
query, args, limit, timeout, return_status=return_status)
return result
async def __execute(self, query, args, limit, timeout,
return_status=False):
executor = lambda stmt, timeout: self._protocol.bind_execute(
stmt, args, '', limit, return_status, timeout)
timeout = self._protocol._get_timeout(timeout)
return await self._do_execute(query, executor, timeout)
async def _executemany(self, query, args, timeout):
executor = lambda stmt, timeout: self._protocol.bind_execute_many(
stmt, args, '', timeout)
timeout = self._protocol._get_timeout(timeout)
with self._stmt_exclusive_section:
result, _ = await self._do_execute(query, executor, timeout)
return result
async def _do_execute(self, query, executor, timeout, retry=True):
if timeout is None:
stmt = await self._get_statement(query, None)
else:
before = time.monotonic()
stmt = await self._get_statement(query, timeout)
after = time.monotonic()
timeout -= after - before
before = after
try:
if timeout is None:
result = await executor(stmt, None)
else:
try:
result = await executor(stmt, timeout)
finally:
after = time.monotonic()
timeout -= after - before
except exceptions.InvalidCachedStatementError:
# PostgreSQL will raise an exception when it detects
# that the result type of the query has changed from
# when the statement was prepared. This may happen,
# for example, after an ALTER TABLE or SET search_path.
#
# When this happens, and there is no transaction running,
# we can simply re-prepare the statement and try once
# again. We deliberately retry only once as this is
# supposed to be a rare occurrence.
#
# If the transaction _is_ running, this error will put it
# into an error state, and we have no choice but to
# re-raise the exception.
#
# In either case we clear the statement cache for this
# connection and all other connections of the pool this
# connection belongs to (if any).
#
# See https://github.com/MagicStack/asyncpg/issues/72
# and https://github.com/MagicStack/asyncpg/issues/76
# for discussion.
#
self._drop_global_statement_cache()
if self._protocol.is_in_transaction() or not retry:
raise
else:
return await self._do_execute(
query, executor, timeout, retry=False)
return result, stmt
async def connect(dsn=None, *,
host=None, port=None,
user=None, password=None,
database=None,
loop=None,
timeout=60,
statement_cache_size=100,
max_cached_statement_lifetime=300,
max_cacheable_statement_size=1024 * 15,
command_timeout=None,
ssl=None,
connection_class=Connection,
server_settings=None):
r"""A coroutine to establish a connection to a PostgreSQL server.
Returns a new :class:`~asyncpg.connection.Connection` object.
:param dsn:
Connection arguments specified using as a single string in the
following format:
``postgres://user:pass@host:port/database?option=value``
:param host:
database host address or a path to the directory containing
database server UNIX socket (defaults to the default UNIX socket,
or the value of the ``PGHOST`` environment variable, if set).
:param port:
connection port number (defaults to ``5432``, or the value of
the ``PGPORT`` environment variable, if set)
:param user:
the name of the database role used for authentication
(defaults to the name of the effective user of the process
making the connection, or the value of ``PGUSER`` environment
variable, if set)
:param database:
the name of the database (defaults to the value of ``PGDATABASE``
environment variable, if set.)
:param password:
password used for authentication
:param loop:
An asyncio event loop instance. If ``None``, the default
event loop will be used.
:param float timeout:
connection timeout in seconds.
:param int statement_cache_size:
the size of prepared statement LRU cache. Pass ``0`` to
disable the cache.
:param int max_cached_statement_lifetime:
the maximum time in seconds a prepared statement will stay
in the cache. Pass ``0`` to allow statements be cached
indefinitely.
:param int max_cacheable_statement_size:
the maximum size of a statement that can be cached (15KiB by
default). Pass ``0`` to allow all statements to be cached
regardless of their size.
:param float command_timeout:
the default timeout for operations on this connection
(the default is ``None``: no timeout).
:param ssl:
pass ``True`` or an `ssl.SSLContext `_ instance to
require an SSL connection. If ``True``, a default SSL context
returned by `ssl.create_default_context() `_
will be used.
:param dict server_settings:
an optional dict of server parameters.
:param Connection connection_class:
class of the returned connection object. Must be a subclass of
:class:`~asyncpg.connection.Connection`.
:return: A :class:`~asyncpg.connection.Connection` instance.
Example:
.. code-block:: pycon
>>> import asyncpg
>>> import asyncio
>>> async def run():
... con = await asyncpg.connect(user='postgres')
... types = await con.fetch('SELECT * FROM pg_type')
... print(types)
>>> asyncio.get_event_loop().run_until_complete(run())
[= 0
self._max_size = new_size
self._maybe_cleanup()
def get_max_lifetime(self):
return self._max_lifetime
def set_max_lifetime(self, new_lifetime):
assert new_lifetime >= 0
self._max_lifetime = new_lifetime
for entry in self._entries.values():
# For every entry cancel the existing callback
# and setup a new one if necessary.
self._set_entry_timeout(entry)
def get(self, query, *, promote=True):
if not self._max_size:
# The cache is disabled.
return
entry = self._entries.get(query) # type: _StatementCacheEntry
if entry is None:
return
if entry._statement.closed:
# Happens in unittests when we call `stmt._state.mark_closed()`
# manually.
self._entries.pop(query)
self._clear_entry_callback(entry)
return
if promote:
# `promote` is `False` when `get()` is called by `has()`.
self._entries.move_to_end(query, last=True)
return entry._statement
def has(self, query):
return self.get(query, promote=False) is not None
def put(self, query, statement):
if not self._max_size:
# The cache is disabled.
return
self._entries[query] = self._new_entry(query, statement)
# Check if the cache is bigger than max_size and trim it
# if necessary.
self._maybe_cleanup()
def iter_statements(self):
return (e._statement for e in self._entries.values())
def clear(self):
# First, make sure that we cancel all scheduled callbacks.
for entry in self._entries.values():
self._clear_entry_callback(entry)
# Clear the entries dict.
self._entries.clear()
def _set_entry_timeout(self, entry):
# Clear the existing timeout.
self._clear_entry_callback(entry)
# Set the new timeout if it's not 0.
if self._max_lifetime:
entry._cleanup_cb = self._loop.call_later(
self._max_lifetime, self._on_entry_expired, entry)
def _new_entry(self, query, statement):
entry = _StatementCacheEntry(self, query, statement)
self._set_entry_timeout(entry)
return entry
def _on_entry_expired(self, entry):
# `call_later` callback, called when an entry stayed longer
# than `self._max_lifetime`.
if self._entries.get(entry._query) is entry:
self._entries.pop(entry._query)
self._on_remove(entry._statement)
def _clear_entry_callback(self, entry):
if entry._cleanup_cb is not None:
entry._cleanup_cb.cancel()
def _maybe_cleanup(self):
# Delete cache entries until the size of the cache is `max_size`.
while len(self._entries) > self._max_size:
old_query, old_entry = self._entries.popitem(last=False)
self._clear_entry_callback(old_entry)
# Let the connection know that the statement was removed
# from the cache.
self._on_remove(old_entry._statement)
class _Atomic:
__slots__ = ('_acquired',)
def __init__(self):
self._acquired = 0
def __enter__(self):
if self._acquired:
raise exceptions.InterfaceError(
'cannot perform operation: another operation is in progress')
self._acquired = 1
def __exit__(self, t, e, tb):
self._acquired = 0
class _ConnectionProxy:
# Base class to enable `isinstance(Connection)` check.
__slots__ = ()
ServerCapabilities = collections.namedtuple(
'ServerCapabilities',
['advisory_locks', 'notifications', 'plpgsql', 'sql_reset',
'sql_close_all'])
ServerCapabilities.__doc__ = 'PostgreSQL server capabilities.'
def _detect_server_capabilities(server_version, connection_settings):
if hasattr(connection_settings, 'padb_revision'):
# Amazon Redshift detected.
advisory_locks = False
notifications = False
plpgsql = False
sql_reset = True
sql_close_all = False
elif hasattr(connection_settings, 'crdb_version'):
# CockroachDB detected.
advisory_locks = False
notifications = False
plpgsql = False
sql_reset = False
sql_close_all = False
else:
# Standard PostgreSQL server assumed.
advisory_locks = True
notifications = True
plpgsql = True
sql_reset = True
sql_close_all = True
return ServerCapabilities(
advisory_locks=advisory_locks,
notifications=notifications,
plpgsql=plpgsql,
sql_reset=sql_reset,
sql_close_all=sql_close_all
)
asyncpg-0.13.0/asyncpg/transaction.py 0000664 0003720 0003720 00000016042 13172407302 020446 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import enum
from . import exceptions as apg_errors
class TransactionState(enum.Enum):
NEW = 0
STARTED = 1
COMMITTED = 2
ROLLEDBACK = 3
FAILED = 4
ISOLATION_LEVELS = {'read_committed', 'serializable', 'repeatable_read'}
class Transaction:
"""Represents a transaction or savepoint block.
Transactions are created by calling the
:meth:`Connection.transaction() `
function.
"""
__slots__ = ('_connection', '_isolation', '_readonly', '_deferrable',
'_state', '_nested', '_id', '_managed')
def __init__(self, connection, isolation, readonly, deferrable):
if isolation not in ISOLATION_LEVELS:
raise ValueError(
'isolation is expected to be either of {}, '
'got {!r}'.format(ISOLATION_LEVELS, isolation))
if isolation != 'serializable':
if readonly:
raise ValueError(
'"readonly" is only supported for '
'serializable transactions')
if deferrable and not readonly:
raise ValueError(
'"deferrable" is only supported for '
'serializable readonly transactions')
self._connection = connection
self._isolation = isolation
self._readonly = readonly
self._deferrable = deferrable
self._state = TransactionState.NEW
self._nested = False
self._id = None
self._managed = False
async def __aenter__(self):
if self._managed:
raise apg_errors.InterfaceError(
'cannot enter context: already in an `async with` block')
self._managed = True
await self.start()
async def __aexit__(self, extype, ex, tb):
try:
if extype is not None:
await self.__rollback()
else:
await self.__commit()
finally:
self._managed = False
async def start(self):
"""Enter the transaction or savepoint block."""
self.__check_state_base('start')
if self._state is TransactionState.STARTED:
raise apg_errors.InterfaceError(
'cannot start; the transaction is already started')
con = self._connection
if con._top_xact is None:
if con._protocol.is_in_transaction():
raise apg_errors.InterfaceError(
'cannot use Connection.transaction() in '
'a manually started transaction')
con._top_xact = self
else:
# Nested transaction block
top_xact = con._top_xact
if self._isolation != top_xact._isolation:
raise apg_errors.InterfaceError(
'nested transaction has a different isolation level: '
'current {!r} != outer {!r}'.format(
self._isolation, top_xact._isolation))
self._nested = True
if self._nested:
self._id = con._get_unique_id('savepoint')
query = 'SAVEPOINT {};'.format(self._id)
else:
if self._isolation == 'read_committed':
query = 'BEGIN;'
elif self._isolation == 'repeatable_read':
query = 'BEGIN ISOLATION LEVEL REPEATABLE READ;'
else:
query = 'BEGIN ISOLATION LEVEL SERIALIZABLE'
if self._readonly:
query += ' READ ONLY'
if self._deferrable:
query += ' DEFERRABLE'
query += ';'
try:
await self._connection.execute(query)
except:
self._state = TransactionState.FAILED
raise
else:
self._state = TransactionState.STARTED
def __check_state_base(self, opname):
if self._state is TransactionState.COMMITTED:
raise apg_errors.InterfaceError(
'cannot {}; the transaction is already committed'.format(
opname))
if self._state is TransactionState.ROLLEDBACK:
raise apg_errors.InterfaceError(
'cannot {}; the transaction is already rolled back'.format(
opname))
if self._state is TransactionState.FAILED:
raise apg_errors.InterfaceError(
'cannot {}; the transaction is in error state'.format(
opname))
def __check_state(self, opname):
if self._state is not TransactionState.STARTED:
if self._state is TransactionState.NEW:
raise apg_errors.InterfaceError(
'cannot {}; the transaction is not yet started'.format(
opname))
self.__check_state_base(opname)
async def __commit(self):
self.__check_state('commit')
if self._connection._top_xact is self:
self._connection._top_xact = None
if self._nested:
query = 'RELEASE SAVEPOINT {};'.format(self._id)
else:
query = 'COMMIT;'
try:
await self._connection.execute(query)
except:
self._state = TransactionState.FAILED
raise
else:
self._state = TransactionState.COMMITTED
async def __rollback(self):
self.__check_state('rollback')
if self._connection._top_xact is self:
self._connection._top_xact = None
if self._nested:
query = 'ROLLBACK TO {};'.format(self._id)
else:
query = 'ROLLBACK;'
try:
await self._connection.execute(query)
except:
self._state = TransactionState.FAILED
raise
else:
self._state = TransactionState.ROLLEDBACK
async def commit(self):
"""Exit the transaction or savepoint block and commit changes."""
if self._managed:
raise apg_errors.InterfaceError(
'cannot manually commit from within an `async with` block')
await self.__commit()
async def rollback(self):
"""Exit the transaction or savepoint block and rollback changes."""
if self._managed:
raise apg_errors.InterfaceError(
'cannot manually rollback from within an `async with` block')
await self.__rollback()
def __repr__(self):
attrs = []
attrs.append('state:{}'.format(self._state.name.lower()))
attrs.append(self._isolation)
if self._readonly:
attrs.append('readonly')
if self._deferrable:
attrs.append('deferrable')
if self.__class__.__module__.startswith('asyncpg.'):
mod = 'asyncpg'
else:
mod = self.__class__.__module__
return '<{}.{} {} {:#x}>'.format(
mod, self.__class__.__name__, ' '.join(attrs), id(self))
asyncpg-0.13.0/asyncpg/prepared_stmt.py 0000664 0003720 0003720 00000016630 13172407302 020775 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import json
from . import connresource
from . import cursor
from . import exceptions
class PreparedStatement(connresource.ConnectionResource):
"""A representation of a prepared statement."""
__slots__ = ('_state', '_query', '_last_status')
def __init__(self, connection, query, state):
super().__init__(connection)
self._state = state
self._query = query
state.attach()
self._last_status = None
@connresource.guarded
def get_query(self) -> str:
"""Return the text of the query for this prepared statement.
Example::
stmt = await connection.prepare('SELECT $1::int')
assert stmt.get_query() == "SELECT $1::int"
"""
return self._query
@connresource.guarded
def get_statusmsg(self) -> str:
"""Return the status of the executed command.
Example::
stmt = await connection.prepare('CREATE TABLE mytab (a int)')
await stmt.fetch()
assert stmt.get_statusmsg() == "CREATE TABLE"
"""
if self._last_status is None:
return self._last_status
return self._last_status.decode()
@connresource.guarded
def get_parameters(self):
"""Return a description of statement parameters types.
:return: A tuple of :class:`asyncpg.types.Type`.
Example::
stmt = await connection.prepare('SELECT ($1::int, $2::text)')
print(stmt.get_parameters())
# Will print:
# (Type(oid=23, name='int4', kind='scalar', schema='pg_catalog'),
# Type(oid=25, name='text', kind='scalar', schema='pg_catalog'))
"""
return self._state._get_parameters()
@connresource.guarded
def get_attributes(self):
"""Return a description of relation attributes (columns).
:return: A tuple of :class:`asyncpg.types.Attribute`.
Example::
st = await self.con.prepare('''
SELECT typname, typnamespace FROM pg_type
''')
print(st.get_attributes())
# Will print:
# (Attribute(
# name='typname',
# type=Type(oid=19, name='name', kind='scalar',
# schema='pg_catalog')),
# Attribute(
# name='typnamespace',
# type=Type(oid=26, name='oid', kind='scalar',
# schema='pg_catalog')))
"""
return self._state._get_attributes()
@connresource.guarded
def cursor(self, *args, prefetch=None,
timeout=None) -> cursor.CursorFactory:
"""Return a *cursor factory* for the prepared statement.
:param args: Query arguments.
:param int prefetch: The number of rows the *cursor iterator*
will prefetch (defaults to ``50``.)
:param float timeout: Optional timeout in seconds.
:return: A :class:`~cursor.CursorFactory` object.
"""
return cursor.CursorFactory(self._connection, self._query,
self._state, args, prefetch,
timeout)
@connresource.guarded
async def explain(self, *args, analyze=False):
"""Return the execution plan of the statement.
:param args: Query arguments.
:param analyze: If ``True``, the statement will be executed and
the run time statitics added to the return value.
:return: An object representing the execution plan. This value
is actually a deserialized JSON output of the SQL
``EXPLAIN`` command.
"""
query = 'EXPLAIN (FORMAT JSON, VERBOSE'
if analyze:
query += ', ANALYZE) '
else:
query += ') '
query += self._state.query
if analyze:
# From PostgreSQL docs:
# Important: Keep in mind that the statement is actually
# executed when the ANALYZE option is used. Although EXPLAIN
# will discard any output that a SELECT would return, other
# side effects of the statement will happen as usual. If you
# wish to use EXPLAIN ANALYZE on an INSERT, UPDATE, DELETE,
# CREATE TABLE AS, or EXECUTE statement without letting the
# command affect your data, use this approach:
# BEGIN;
# EXPLAIN ANALYZE ...;
# ROLLBACK;
tr = self._connection.transaction()
await tr.start()
try:
data = await self._connection.fetchval(query, *args)
finally:
await tr.rollback()
else:
data = await self._connection.fetchval(query, *args)
return json.loads(data)
@connresource.guarded
async def fetch(self, *args, timeout=None):
r"""Execute the statement and return a list of :class:`Record` objects.
:param str query: Query text
:param args: Query arguments
:param float timeout: Optional timeout value in seconds.
:return: A list of :class:`Record` instances.
"""
data = await self.__bind_execute(args, 0, timeout)
return data
@connresource.guarded
async def fetchval(self, *args, column=0, timeout=None):
"""Execute the statement and return a value in the first row.
:param args: Query arguments.
:param int column: Numeric index within the record of the value to
return (defaults to 0).
:param float timeout: Optional timeout value in seconds.
If not specified, defaults to the value of
``command_timeout`` argument to the ``Connection``
instance constructor.
:return: The value of the specified column of the first record.
"""
data = await self.__bind_execute(args, 1, timeout)
if not data:
return None
return data[0][column]
@connresource.guarded
async def fetchrow(self, *args, timeout=None):
"""Execute the statement and return the first row.
:param str query: Query text
:param args: Query arguments
:param float timeout: Optional timeout value in seconds.
:return: The first row as a :class:`Record` instance.
"""
data = await self.__bind_execute(args, 1, timeout)
if not data:
return None
return data[0]
async def __bind_execute(self, args, limit, timeout):
protocol = self._connection._protocol
data, status, _ = await protocol.bind_execute(
self._state, args, '', limit, True, timeout)
self._last_status = status
return data
def _check_open(self, meth_name):
if self._state.closed:
raise exceptions.InterfaceError(
'cannot call PreparedStmt.{}(): '
'the prepared statement is closed'.format(meth_name))
def _check_conn_validity(self, meth_name):
self._check_open(meth_name)
super()._check_conn_validity(meth_name)
def __del__(self):
self._state.detach()
self._connection._maybe_gc_stmt(self._state)
asyncpg-0.13.0/asyncpg/_testbase.py 0000664 0003720 0003720 00000015076 13172407302 020100 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import atexit
import contextlib
import functools
import inspect
import logging
import os
import re
import time
import unittest
from asyncpg import cluster as pg_cluster
from asyncpg import connection as pg_connection
from asyncpg import pool as pg_pool
@contextlib.contextmanager
def silence_asyncio_long_exec_warning():
def flt(log_record):
msg = log_record.getMessage()
return not msg.startswith('Executing ')
logger = logging.getLogger('asyncio')
logger.addFilter(flt)
try:
yield
finally:
logger.removeFilter(flt)
class TestCaseMeta(type(unittest.TestCase)):
@staticmethod
def _iter_methods(bases, ns):
for base in bases:
for methname in dir(base):
if not methname.startswith('test_'):
continue
meth = getattr(base, methname)
if not inspect.iscoroutinefunction(meth):
continue
yield methname, meth
for methname, meth in ns.items():
if not methname.startswith('test_'):
continue
if not inspect.iscoroutinefunction(meth):
continue
yield methname, meth
def __new__(mcls, name, bases, ns):
for methname, meth in mcls._iter_methods(bases, ns):
@functools.wraps(meth)
def wrapper(self, *args, __meth__=meth, **kwargs):
self.loop.run_until_complete(__meth__(self, *args, **kwargs))
ns[methname] = wrapper
return super().__new__(mcls, name, bases, ns)
class TestCase(unittest.TestCase, metaclass=TestCaseMeta):
@classmethod
def setUpClass(cls):
if os.environ.get('USE_UVLOOP'):
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
cls.loop = loop
@classmethod
def tearDownClass(cls):
cls.loop.close()
asyncio.set_event_loop(None)
@contextlib.contextmanager
def assertRunUnder(self, delta):
st = time.monotonic()
try:
yield
finally:
elapsed = time.monotonic() - st
if elapsed > delta:
raise AssertionError(
'running block took {:0.3f}s which is longer '
'than the expected maximum of {:0.3f}s'.format(
elapsed, delta))
@contextlib.contextmanager
def assertLoopErrorHandlerCalled(self, msg_re: str):
contexts = []
def handler(loop, ctx):
contexts.append(ctx)
old_handler = self.loop.get_exception_handler()
self.loop.set_exception_handler(handler)
try:
yield
for ctx in contexts:
msg = ctx.get('message')
if msg and re.search(msg_re, msg):
return
raise AssertionError(
'no message matching {!r} was logged with '
'loop.call_exception_handler()'.format(msg_re))
finally:
self.loop.set_exception_handler(old_handler)
_default_cluster = None
def _start_cluster(ClusterCls, cluster_kwargs, server_settings):
cluster = ClusterCls(**cluster_kwargs)
cluster.init()
cluster.trust_local_connections()
cluster.start(port='dynamic', server_settings=server_settings)
atexit.register(_shutdown_cluster, cluster)
return cluster
def _start_default_cluster(server_settings={}):
global _default_cluster
if _default_cluster is None:
pg_host = os.environ.get('PGHOST')
if pg_host:
# Using existing cluster, assuming it is initialized and running
_default_cluster = pg_cluster.RunningCluster()
else:
_default_cluster = _start_cluster(
pg_cluster.TempCluster, {}, server_settings)
return _default_cluster
def _shutdown_cluster(cluster):
cluster.stop()
cluster.destroy()
def create_pool(dsn=None, *,
min_size=10,
max_size=10,
max_queries=50000,
max_inactive_connection_lifetime=60.0,
setup=None,
init=None,
loop=None,
pool_class=pg_pool.Pool,
connection_class=pg_connection.Connection,
**connect_kwargs):
return pool_class(
dsn,
min_size=min_size, max_size=max_size,
max_queries=max_queries, loop=loop, setup=setup, init=init,
max_inactive_connection_lifetime=max_inactive_connection_lifetime,
connection_class=connection_class,
**connect_kwargs)
class ClusterTestCase(TestCase):
@classmethod
def get_server_settings(cls):
return {
'log_connections': 'on'
}
@classmethod
def setup_cluster(cls):
cls.cluster = _start_default_cluster(cls.get_server_settings())
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.setup_cluster()
def create_pool(self, pool_class=pg_pool.Pool, **kwargs):
conn_spec = self.cluster.get_connection_spec()
conn_spec.update(kwargs)
return create_pool(loop=self.loop, pool_class=pool_class, **conn_spec)
@classmethod
def start_cluster(cls, ClusterCls, *,
cluster_kwargs={}, server_settings={}):
return _start_cluster(ClusterCls, cluster_kwargs, server_settings)
def with_connection_options(**options):
if not options:
raise ValueError('no connection options were specified')
def wrap(func):
func.__connect_options__ = options
return func
return wrap
class ConnectedTestCase(ClusterTestCase):
def setUp(self):
super().setUp()
# Extract options set up with `with_connection_options`.
test_func = getattr(self, self._testMethodName).__func__
opts = getattr(test_func, '__connect_options__', {})
if 'database' not in opts:
opts = dict(opts)
opts['database'] = 'postgres'
self.con = self.loop.run_until_complete(
self.cluster.connect(loop=self.loop, **opts))
self.server_version = self.con.get_server_version()
def tearDown(self):
try:
self.loop.run_until_complete(self.con.close())
self.con = None
finally:
super().tearDown()
asyncpg-0.13.0/asyncpg/cluster.py 0000664 0003720 0003720 00000051171 13172407302 017604 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import errno
import os
import os.path
import platform
import random
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import textwrap
import time
import asyncpg
from asyncpg import serverversion
_system = platform.uname().system
if _system == 'Windows':
def platform_exe(name):
if name.endswith('.exe'):
return name
return name + '.exe'
else:
def platform_exe(name):
return name
if _system == 'Linux':
def ensure_dead_with_parent():
import ctypes
import signal
try:
PR_SET_PDEATHSIG = 1
libc = ctypes.CDLL(ctypes.util.find_library('c'))
libc.prctl(PR_SET_PDEATHSIG, signal.SIGKILL)
except Exception as e:
print(e)
else:
ensure_dead_with_parent = None
def find_available_port(port_range=(49152, 65535), max_tries=1000):
low, high = port_range
port = low
try_no = 0
while try_no < max_tries:
try_no += 1
port = random.randint(low, high)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.bind(('127.0.0.1', port))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
continue
finally:
sock.close()
break
else:
port = None
return port
class ClusterError(Exception):
pass
class Cluster:
def __init__(self, data_dir, *, pg_config_path=None):
self._data_dir = data_dir
self._pg_config_path = pg_config_path
self._pg_bin_dir = os.environ.get('PGINSTALLATION')
self._pg_ctl = None
self._daemon_pid = None
self._daemon_process = None
self._connection_addr = None
self._connection_spec_override = None
def is_managed(self):
return True
def get_data_dir(self):
return self._data_dir
def get_status(self):
if self._pg_ctl is None:
self._init_env()
process = subprocess.run(
[self._pg_ctl, 'status', '-D', self._data_dir],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.stdout, process.stderr
if process.returncode == 4 or not os.listdir(self._data_dir):
return 'not-initialized'
elif process.returncode == 3:
return 'stopped'
elif process.returncode == 0:
r = re.match(r'.*PID\s?:\s+(\d+).*', stdout.decode())
if not r:
raise ClusterError(
'could not parse pg_ctl status output: {}'.format(
stdout.decode()))
self._daemon_pid = int(r.group(1))
return self._test_connection(timeout=0)
else:
raise ClusterError(
'pg_ctl status exited with status {:d}: {}'.format(
process.returncode, stderr))
async def connect(self, loop=None, **kwargs):
conn_info = self.get_connection_spec()
conn_info.update(kwargs)
return await asyncpg.connect(loop=loop, **conn_info)
def init(self, **settings):
"""Initialize cluster."""
if self.get_status() != 'not-initialized':
raise ClusterError(
'cluster in {!r} has already been initialized'.format(
self._data_dir))
if settings:
settings_args = ['--{}={}'.format(k, v)
for k, v in settings.items()]
extra_args = ['-o'] + [' '.join(settings_args)]
else:
extra_args = []
process = subprocess.run(
[self._pg_ctl, 'init', '-D', self._data_dir] + extra_args,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = process.stdout
if process.returncode != 0:
raise ClusterError(
'pg_ctl init exited with status {:d}:\n{}'.format(
process.returncode, output.decode()))
return output.decode()
def start(self, wait=60, *, server_settings={}, **opts):
"""Start the cluster."""
status = self.get_status()
if status == 'running':
return
elif status == 'not-initialized':
raise ClusterError(
'cluster in {!r} has not been initialized'.format(
self._data_dir))
port = opts.pop('port', None)
if port == 'dynamic':
port = find_available_port()
extra_args = ['--{}={}'.format(k, v) for k, v in opts.items()]
extra_args.append('--port={}'.format(port))
sockdir = server_settings.get('unix_socket_directories')
if sockdir is None:
sockdir = server_settings.get('unix_socket_directory')
if sockdir is None:
sockdir = '/tmp'
ssl_key = server_settings.get('ssl_key_file')
if ssl_key:
# Make sure server certificate key file has correct permissions.
keyfile = os.path.join(self._data_dir, 'srvkey.pem')
shutil.copy(ssl_key, keyfile)
os.chmod(keyfile, 0o400)
server_settings = server_settings.copy()
server_settings['ssl_key_file'] = keyfile
if self._pg_version < (9, 3):
sockdir_opt = 'unix_socket_directory'
else:
sockdir_opt = 'unix_socket_directories'
server_settings[sockdir_opt] = sockdir
for k, v in server_settings.items():
extra_args.extend(['-c', '{}={}'.format(k, v)])
if _system == 'Windows':
# On Windows we have to use pg_ctl as direct execution
# of postgres daemon under an Administrative account
# is not permitted and there is no easy way to drop
# privileges.
process = subprocess.run(
[self._pg_ctl, 'start', '-D', self._data_dir,
'-o', ' '.join(extra_args)],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
stderr = process.stderr
if process.returncode != 0:
raise ClusterError(
'pg_ctl start exited with status {:d}: {}'.format(
process.returncode, stderr.decode()))
else:
if os.getenv('ASYNCPG_DEBUG_SERVER'):
stdout = sys.stdout
else:
stdout = subprocess.DEVNULL
self._daemon_process = \
subprocess.Popen(
[self._postgres, '-D', self._data_dir, *extra_args],
stdout=stdout, stderr=subprocess.STDOUT,
preexec_fn=ensure_dead_with_parent)
self._daemon_pid = self._daemon_process.pid
self._test_connection(timeout=wait)
def reload(self):
"""Reload server configuration."""
status = self.get_status()
if status != 'running':
raise ClusterError('cannot reload: cluster is not running')
process = subprocess.run(
[self._pg_ctl, 'reload', '-D', self._data_dir],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stderr = process.stderr
if process.returncode != 0:
raise ClusterError(
'pg_ctl stop exited with status {:d}: {}'.format(
process.returncode, stderr.decode()))
def stop(self, wait=60):
process = subprocess.run(
[self._pg_ctl, 'stop', '-D', self._data_dir, '-t', str(wait),
'-m', 'fast'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stderr = process.stderr
if process.returncode != 0:
raise ClusterError(
'pg_ctl stop exited with status {:d}: {}'.format(
process.returncode, stderr.decode()))
if (self._daemon_process is not None and
self._daemon_process.returncode is None):
self._daemon_process.kill()
def destroy(self):
status = self.get_status()
if status == 'stopped' or status == 'not-initialized':
shutil.rmtree(self._data_dir)
else:
raise ClusterError('cannot destroy {} cluster'.format(status))
def _get_connection_spec(self):
if self._connection_addr is None:
self._connection_addr = self._connection_addr_from_pidfile()
if self._connection_addr is not None:
if self._connection_spec_override:
args = self._connection_addr.copy()
args.update(self._connection_spec_override)
return args
else:
return self._connection_addr
def get_connection_spec(self):
status = self.get_status()
if status != 'running':
raise ClusterError('cluster is not running')
return self._get_connection_spec()
def override_connection_spec(self, **kwargs):
self._connection_spec_override = kwargs
def reset_hba(self):
"""Remove all records from pg_hba.conf."""
status = self.get_status()
if status == 'not-initialized':
raise ClusterError(
'cannot modify HBA records: cluster is not initialized')
pg_hba = os.path.join(self._data_dir, 'pg_hba.conf')
try:
with open(pg_hba, 'w'):
pass
except IOError as e:
raise ClusterError(
'cannot modify HBA records: {}'.format(e)) from e
def add_hba_entry(self, *, type='host', database, user, address=None,
auth_method, auth_options=None):
"""Add a record to pg_hba.conf."""
status = self.get_status()
if status == 'not-initialized':
raise ClusterError(
'cannot modify HBA records: cluster is not initialized')
if type not in {'local', 'host', 'hostssl', 'hostnossl'}:
raise ValueError('invalid HBA record type: {!r}'.format(type))
pg_hba = os.path.join(self._data_dir, 'pg_hba.conf')
record = '{} {} {}'.format(type, database, user)
if type != 'local':
if address is None:
raise ValueError(
'{!r} entry requires a valid address'.format(type))
else:
record += ' {}'.format(address)
record += ' {}'.format(auth_method)
if auth_options is not None:
record += ' ' + ' '.join(
'{}={}'.format(k, v) for k, v in auth_options)
try:
with open(pg_hba, 'a') as f:
print(record, file=f)
except IOError as e:
raise ClusterError(
'cannot modify HBA records: {}'.format(e)) from e
def trust_local_connections(self):
self.reset_hba()
if _system != 'Windows':
self.add_hba_entry(type='local', database='all',
user='all', auth_method='trust')
self.add_hba_entry(type='host', address='127.0.0.1/32',
database='all', user='all',
auth_method='trust')
self.add_hba_entry(type='host', address='::1/128',
database='all', user='all',
auth_method='trust')
status = self.get_status()
if status == 'running':
self.reload()
def trust_local_replication_by(self, user):
if _system != 'Windows':
self.add_hba_entry(type='local', database='replication',
user=user, auth_method='trust')
self.add_hba_entry(type='host', address='127.0.0.1/32',
database='replication', user=user,
auth_method='trust')
self.add_hba_entry(type='host', address='::1/128',
database='replication', user=user,
auth_method='trust')
status = self.get_status()
if status == 'running':
self.reload()
def _init_env(self):
if not self._pg_bin_dir:
pg_config = self._find_pg_config(self._pg_config_path)
pg_config_data = self._run_pg_config(pg_config)
self._pg_bin_dir = pg_config_data.get('bindir')
if not self._pg_bin_dir:
raise ClusterError(
'pg_config output did not provide the BINDIR value')
self._pg_ctl = self._find_pg_binary('pg_ctl')
self._postgres = self._find_pg_binary('postgres')
self._pg_version = self._get_pg_version()
def _connection_addr_from_pidfile(self):
pidfile = os.path.join(self._data_dir, 'postmaster.pid')
try:
with open(pidfile, 'rt') as f:
piddata = f.read()
except FileNotFoundError:
return None
lines = piddata.splitlines()
if len(lines) < 6:
# A complete postgres pidfile is at least 6 lines
return None
pmpid = int(lines[0])
if self._daemon_pid and pmpid != self._daemon_pid:
# This might be an old pidfile left from previous postgres
# daemon run.
return None
portnum = lines[3]
sockdir = lines[4]
hostaddr = lines[5]
if sockdir:
if sockdir[0] != '/':
# Relative sockdir
sockdir = os.path.normpath(
os.path.join(self._data_dir, sockdir))
host_str = sockdir
else:
host_str = hostaddr
if host_str == '*':
host_str = 'localhost'
elif host_str == '0.0.0.0':
host_str = '127.0.0.1'
elif host_str == '::':
host_str = '::1'
return {
'host': host_str,
'port': portnum
}
def _test_connection(self, timeout=60):
self._connection_addr = None
loop = asyncio.new_event_loop()
try:
for i in range(timeout):
if self._connection_addr is None:
conn_spec = self._get_connection_spec()
if conn_spec is None:
time.sleep(1)
continue
try:
con = loop.run_until_complete(
asyncpg.connect(database='postgres',
timeout=5, loop=loop,
**self._connection_addr))
except (OSError, asyncio.TimeoutError,
asyncpg.CannotConnectNowError,
asyncpg.PostgresConnectionError):
time.sleep(1)
continue
except asyncpg.PostgresError:
# Any other error other than ServerNotReadyError or
# ConnectionError is interpreted to indicate the server is
# up.
break
else:
loop.run_until_complete(con.close())
break
finally:
loop.close()
return 'running'
def _run_pg_config(self, pg_config_path):
process = subprocess.run(
pg_config_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.stdout, process.stderr
if process.returncode != 0:
raise ClusterError('pg_config exited with status {:d}: {}'.format(
process.returncode, stderr))
else:
config = {}
for line in stdout.splitlines():
k, eq, v = line.decode('utf-8').partition('=')
if eq:
config[k.strip().lower()] = v.strip()
return config
def _find_pg_config(self, pg_config_path):
if pg_config_path is None:
pg_install = os.environ.get('PGINSTALLATION')
if pg_install:
pg_config_path = platform_exe(
os.path.join(pg_install, 'pg_config'))
else:
pathenv = os.environ.get('PATH').split(os.pathsep)
for path in pathenv:
pg_config_path = platform_exe(
os.path.join(path, 'pg_config'))
if os.path.exists(pg_config_path):
break
else:
pg_config_path = None
if not pg_config_path:
raise ClusterError('could not find pg_config executable')
if not os.path.isfile(pg_config_path):
raise ClusterError('{!r} is not an executable')
return pg_config_path
def _find_pg_binary(self, binary):
bpath = platform_exe(os.path.join(self._pg_bin_dir, binary))
if not os.path.isfile(bpath):
raise ClusterError(
'could not find {} executable: '.format(binary) +
'{!r} does not exist or is not a file'.format(bpath))
return bpath
def _get_pg_version(self):
process = subprocess.run(
[self._postgres, '--version'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.stdout, process.stderr
if process.returncode != 0:
raise ClusterError(
'postgres --version exited with status {:d}: {}'.format(
process.returncode, stderr))
version_string = stdout.decode('utf-8').strip(' \n')
prefix = 'postgres (PostgreSQL) '
if not version_string.startswith(prefix):
raise ClusterError(
'could not determine server version from {!r}'.format(
version_string))
version_string = version_string[len(prefix):]
return serverversion.split_server_version_string(version_string)
class TempCluster(Cluster):
def __init__(self, *,
data_dir_suffix=None, data_dir_prefix=None,
data_dir_parent=None, pg_config_path=None):
self._data_dir = tempfile.mkdtemp(suffix=data_dir_suffix,
prefix=data_dir_prefix,
dir=data_dir_parent)
super().__init__(self._data_dir, pg_config_path=pg_config_path)
class HotStandbyCluster(TempCluster):
def __init__(self, *,
master, replication_user,
data_dir_suffix=None, data_dir_prefix=None,
data_dir_parent=None, pg_config_path=None):
self._master = master
self._repl_user = replication_user
super().__init__(
data_dir_suffix=data_dir_suffix,
data_dir_prefix=data_dir_prefix,
data_dir_parent=data_dir_parent,
pg_config_path=pg_config_path)
def _init_env(self):
super()._init_env()
self._pg_basebackup = self._find_pg_binary('pg_basebackup')
def init(self, **settings):
"""Initialize cluster."""
if self.get_status() != 'not-initialized':
raise ClusterError(
'cluster in {!r} has already been initialized'.format(
self._data_dir))
process = subprocess.run(
[self._pg_basebackup, '-h', self._master['host'],
'-p', self._master['port'], '-D', self._data_dir,
'-U', self._repl_user],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = process.stdout
if process.returncode != 0:
raise ClusterError(
'pg_basebackup init exited with status {:d}:\n{}'.format(
process.returncode, output.decode()))
with open(os.path.join(self._data_dir, 'recovery.conf'), 'w') as f:
f.write(textwrap.dedent("""\
standby_mode = 'on'
primary_conninfo = 'host={host} port={port} user={user}'
""".format(
host=self._master['host'],
port=self._master['port'],
user=self._repl_user)))
return output.decode()
class RunningCluster(Cluster):
def __init__(self, **kwargs):
self.conn_spec = kwargs
def is_managed(self):
return False
def get_connection_spec(self):
return dict(self.conn_spec)
def get_status(self):
return 'running'
def init(self, **settings):
pass
def start(self, wait=60, **settings):
pass
def stop(self, wait=60):
pass
def destroy(self):
pass
def reset_hba(self):
raise ClusterError('cannot modify HBA records of unmanaged cluster')
def add_hba_entry(self, *, type='host', database, user, address=None,
auth_method, auth_options=None):
raise ClusterError('cannot modify HBA records of unmanaged cluster')
asyncpg-0.13.0/asyncpg/compat.py 0000664 0003720 0003720 00000002320 13172407302 017376 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import functools
import os
import sys
PY_36 = sys.version_info >= (3, 6)
if sys.version_info < (3, 5, 2):
def aiter_compat(func):
@functools.wraps(func)
async def wrapper(self):
return func(self)
return wrapper
else:
def aiter_compat(func):
return func
if PY_36:
fspath = os.fspath
else:
def fspath(path):
fsp = getattr(path, '__fspath__', None)
if fsp is not None and callable(fsp):
path = fsp()
if not isinstance(path, (str, bytes)):
raise TypeError(
'expected {}() to return str or bytes, not {}'.format(
fsp.__qualname__, type(path).__name__
))
return path
elif isinstance(path, (str, bytes)):
return path
else:
raise TypeError(
'expected str, bytes or path-like object, not {}'.format(
type(path).__name__
)
)
asyncpg-0.13.0/asyncpg/serverversion.py 0000664 0003720 0003720 00000002434 13172407302 021035 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
from . import types
def split_server_version_string(version_string):
version_string = version_string.strip()
if version_string.startswith('PostgreSQL '):
version_string = version_string[len('PostgreSQL '):]
if version_string.startswith('Postgres-XL'):
version_string = version_string[len('Postgre-XL '):]
parts = version_string.strip().split('.')
if not parts[-1].isdigit():
# release level specified
lastitem = parts[-1]
levelpart = lastitem.rstrip('0123456789').lower()
if levelpart != lastitem:
serial = int(lastitem[len(levelpart):])
else:
serial = 0
level = levelpart.lstrip('0123456789')
if level != levelpart:
parts[-1] = levelpart[:-len(level)]
else:
parts[-1] = 0
else:
level = 'final'
serial = 0
versions = [int(p) for p in parts][:3]
if len(versions) < 3:
versions += [0] * (3 - len(versions))
versions.append(level)
versions.append(serial)
return types.ServerVersion(*versions)
asyncpg-0.13.0/asyncpg/connect_utils.py 0000664 0003720 0003720 00000027327 13172407302 021002 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import asyncio
import collections
import getpass
import os
import platform
import socket
import struct
import time
import urllib.parse
from . import exceptions
from . import protocol
_ConnectionParameters = collections.namedtuple(
'ConnectionParameters',
[
'user',
'password',
'database',
'ssl',
'connect_timeout',
'server_settings',
])
_ClientConfiguration = collections.namedtuple(
'ConnectionConfiguration',
[
'command_timeout',
'statement_cache_size',
'max_cached_statement_lifetime',
'max_cacheable_statement_size',
])
_system = platform.uname().system
def _parse_connect_dsn_and_args(*, dsn, host, port, user,
password, database, ssl, connect_timeout,
server_settings):
if host is not None and not isinstance(host, str):
raise TypeError(
'host argument is expected to be str, got {!r}'.format(
type(host)))
if dsn:
parsed = urllib.parse.urlparse(dsn)
if parsed.scheme not in {'postgresql', 'postgres'}:
raise ValueError(
'invalid DSN: scheme is expected to be either of '
'"postgresql" or "postgres", got {!r}'.format(parsed.scheme))
if parsed.port and port is None:
port = int(parsed.port)
if parsed.hostname and host is None:
host = parsed.hostname
if parsed.path and database is None:
database = parsed.path
if database.startswith('/'):
database = database[1:]
if parsed.username and user is None:
user = parsed.username
if parsed.password and password is None:
password = parsed.password
if parsed.query:
query = urllib.parse.parse_qs(parsed.query, strict_parsing=True)
for key, val in query.items():
if isinstance(val, list):
query[key] = val[-1]
if 'host' in query:
val = query.pop('host')
if host is None:
host = val
if 'port' in query:
val = int(query.pop('port'))
if port is None:
port = val
if 'dbname' in query:
val = query.pop('dbname')
if database is None:
database = val
if 'database' in query:
val = query.pop('database')
if database is None:
database = val
if 'user' in query:
val = query.pop('user')
if user is None:
user = val
if 'password' in query:
val = query.pop('password')
if password is None:
password = val
if query:
if server_settings is None:
server_settings = query
else:
server_settings = {**query, **server_settings}
# On env-var -> connection parameter conversion read here:
# https://www.postgresql.org/docs/current/static/libpq-envars.html
# Note that env values may be an empty string in cases when
# the variable is "unset" by setting it to an empty value
#
if host is None:
host = os.getenv('PGHOST')
if not host:
if _system == 'Windows':
host = ['localhost']
else:
host = ['/tmp', '/private/tmp',
'/var/pgsql_socket', '/run/postgresql',
'localhost']
if not isinstance(host, list):
host = [host]
if port is None:
port = os.getenv('PGPORT')
if port:
port = int(port)
else:
port = 5432
else:
port = int(port)
if user is None:
user = os.getenv('PGUSER')
if not user:
user = getpass.getuser()
if password is None:
password = os.getenv('PGPASSWORD')
if database is None:
database = os.getenv('PGDATABASE')
if database is None:
database = user
if user is None:
raise exceptions.InterfaceError(
'could not determine user name to connect with')
if database is None:
raise exceptions.InterfaceError(
'could not determine database name to connect to')
addrs = []
for h in host:
if h.startswith('/'):
# UNIX socket name
if '.s.PGSQL.' not in h:
h = os.path.join(h, '.s.PGSQL.{}'.format(port))
addrs.append(h)
else:
# TCP host/port
addrs.append((h, port))
if not addrs:
raise ValueError(
'could not determine the database address to connect to')
if ssl:
for addr in addrs:
if isinstance(addr, str):
# UNIX socket
raise exceptions.InterfaceError(
'`ssl` parameter can only be enabled for TCP addresses, '
'got a UNIX socket path: {!r}'.format(addr))
if server_settings is not None and (
not isinstance(server_settings, dict) or
not all(isinstance(k, str) for k in server_settings) or
not all(isinstance(v, str) for v in server_settings.values())):
raise ValueError(
'server_settings is expected to be None or '
'a Dict[str, str]')
params = _ConnectionParameters(
user=user, password=password, database=database, ssl=ssl,
connect_timeout=connect_timeout, server_settings=server_settings)
return addrs, params
def _parse_connect_arguments(*, dsn, host, port, user, password, database,
timeout, command_timeout, statement_cache_size,
max_cached_statement_lifetime,
max_cacheable_statement_size,
ssl, server_settings):
local_vars = locals()
for var_name in {'max_cacheable_statement_size',
'max_cached_statement_lifetime',
'statement_cache_size'}:
var_val = local_vars[var_name]
if var_val is None or isinstance(var_val, bool) or var_val < 0:
raise ValueError(
'{} is expected to be greater '
'or equal to 0, got {!r}'.format(var_name, var_val))
if command_timeout is not None:
try:
if isinstance(command_timeout, bool):
raise ValueError
command_timeout = float(command_timeout)
if command_timeout <= 0:
raise ValueError
except ValueError:
raise ValueError(
'invalid command_timeout value: '
'expected greater than 0 float (got {!r})'.format(
command_timeout)) from None
addrs, params = _parse_connect_dsn_and_args(
dsn=dsn, host=host, port=port, user=user,
password=password, ssl=ssl,
database=database, connect_timeout=timeout,
server_settings=server_settings)
config = _ClientConfiguration(
command_timeout=command_timeout,
statement_cache_size=statement_cache_size,
max_cached_statement_lifetime=max_cached_statement_lifetime,
max_cacheable_statement_size=max_cacheable_statement_size,)
return addrs, params, config
async def _connect_addr(*, addr, loop, timeout, params, config,
connection_class):
assert loop is not None
if timeout <= 0:
raise asyncio.TimeoutError
connected = _create_future(loop)
proto_factory = lambda: protocol.Protocol(
addr, connected, params, loop)
if isinstance(addr, str):
# UNIX socket
assert params.ssl is None
connector = loop.create_unix_connection(proto_factory, addr)
elif params.ssl:
connector = _create_ssl_connection(
proto_factory, *addr, loop=loop, ssl_context=params.ssl)
else:
connector = loop.create_connection(proto_factory, *addr)
before = time.monotonic()
tr, pr = await asyncio.wait_for(
connector, timeout=timeout, loop=loop)
timeout -= time.monotonic() - before
try:
if timeout <= 0:
raise asyncio.TimeoutError
await asyncio.wait_for(connected, loop=loop, timeout=timeout)
except Exception:
tr.close()
raise
con = connection_class(pr, tr, loop, addr, config, params)
pr.set_connection(con)
return con
async def _connect(*, loop, timeout, connection_class, **kwargs):
if loop is None:
loop = asyncio.get_event_loop()
addrs, params, config = _parse_connect_arguments(timeout=timeout, **kwargs)
last_error = None
addr = None
for addr in addrs:
before = time.monotonic()
try:
con = await _connect_addr(
addr=addr, loop=loop, timeout=timeout,
params=params, config=config,
connection_class=connection_class)
except (OSError, asyncio.TimeoutError, ConnectionError) as ex:
last_error = ex
else:
return con
finally:
timeout -= time.monotonic() - before
raise last_error
async def _get_ssl_ready_socket(host, port, *, loop):
reader, writer = await asyncio.open_connection(host, port, loop=loop)
tr = writer.transport
try:
sock = _get_socket(tr)
_set_nodelay(sock)
writer.write(struct.pack('!ll', 8, 80877103)) # SSLRequest message.
await writer.drain()
resp = await reader.readexactly(1)
if resp == b'S':
return sock.dup()
else:
raise ConnectionError(
'PostgreSQL server at "{}:{}" rejected SSL upgrade'.format(
host, port))
finally:
tr.close()
async def _create_ssl_connection(protocol_factory, host, port, *,
loop, ssl_context):
sock = await _get_ssl_ready_socket(host, port, loop=loop)
try:
return await loop.create_connection(
protocol_factory, sock=sock, ssl=ssl_context,
server_hostname=host)
except Exception:
sock.close()
raise
async def _open_connection(*, loop, addr, params: _ConnectionParameters):
if isinstance(addr, str):
r, w = await asyncio.open_unix_connection(addr, loop=loop)
else:
if params.ssl:
sock = await _get_ssl_ready_socket(*addr, loop=loop)
try:
r, w = await asyncio.open_connection(
sock=sock,
loop=loop,
ssl=params.ssl,
server_hostname=addr[0])
except Exception:
sock.close()
raise
else:
r, w = await asyncio.open_connection(*addr, loop=loop)
_set_nodelay(_get_socket(w.transport))
return r, w
def _get_socket(transport):
sock = transport.get_extra_info('socket')
if sock is None:
# Shouldn't happen with any asyncio-complaint event loop.
raise ConnectionError(
'could not get the socket for transport {!r}'.format(transport))
return sock
def _set_nodelay(sock):
if not hasattr(socket, 'AF_UNIX') or sock.family != socket.AF_UNIX:
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
def _create_future(loop):
try:
create_future = loop.create_future
except AttributeError:
return asyncio.Future(loop=loop)
else:
return create_future()
asyncpg-0.13.0/asyncpg/__init__.py 0000664 0003720 0003720 00000001025 13172407302 017653 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
from .connection import connect, Connection # NOQA
from .exceptions import * # NOQA
from .pool import create_pool # NOQA
from .protocol import Record # NOQA
from .types import * # NOQA
__all__ = ('connect', 'create_pool', 'Record', 'Connection') + \
exceptions.__all__ # NOQA
__version__ = '0.13.0'
asyncpg-0.13.0/asyncpg/protocol/ 0000775 0003720 0003720 00000000000 13172407445 017415 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/asyncpg/protocol/debug.pxd 0000664 0003720 0003720 00000000065 13172407302 021211 0 ustar travis travis 0000000 0000000 cdef extern from "debug.h":
cdef int ASYNCPG_DEBUG
asyncpg-0.13.0/asyncpg/protocol/codecs/ 0000775 0003720 0003720 00000000000 13172407445 020655 5 ustar travis travis 0000000 0000000 asyncpg-0.13.0/asyncpg/protocol/codecs/money.pyx 0000664 0003720 0003720 00000001015 13172407302 022533 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef init_monetary_codecs():
moneyoids = [
MONEYOID,
]
for oid in moneyoids:
register_core_codec(oid,
&text_encode,
&text_decode,
PG_FORMAT_TEXT)
init_monetary_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/datetime.pyx 0000664 0003720 0003720 00000035400 13172407302 023205 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import datetime
utc = datetime.timezone.utc
date_from_ordinal = datetime.date.fromordinal
timedelta = datetime.timedelta
pg_epoch_datetime = datetime.datetime(2000, 1, 1)
cdef int32_t pg_epoch_datetime_ts = \
cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp()))
pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc)
cdef int32_t pg_epoch_datetime_utc_ts = \
cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp())
pg_epoch_date = datetime.date(2000, 1, 1)
cdef int32_t pg_date_offset_ord = \
cpython.PyLong_AsLong(pg_epoch_date.toordinal())
# Binary representations of infinity for datetimes.
cdef int64_t pg_time64_infinity = 0x7fffffffffffffff
cdef int64_t pg_time64_negative_infinity = 0x8000000000000000
cdef int32_t pg_date_infinity = 0x7fffffff
cdef int32_t pg_date_negative_infinity = 0x80000000
infinity_datetime = datetime.datetime(
datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999)
cdef int32_t infinity_datetime_ord = cpython.PyLong_AsLong(
infinity_datetime.toordinal())
cdef int64_t infinity_datetime_ts = 252455615999999999
negative_infinity_datetime = datetime.datetime(
datetime.MINYEAR, 1, 1, 0, 0, 0, 0)
cdef int32_t negative_infinity_datetime_ord = cpython.PyLong_AsLong(
negative_infinity_datetime.toordinal())
cdef int64_t negative_infinity_datetime_ts = -63082281600000000
infinity_date = datetime.date(datetime.MAXYEAR, 12, 31)
cdef int32_t infinity_date_ord = cpython.PyLong_AsLong(
infinity_date.toordinal())
negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1)
cdef int32_t negative_infinity_date_ord = cpython.PyLong_AsLong(
negative_infinity_date.toordinal())
cdef inline _encode_time(WriteBuffer buf, int64_t seconds,
int32_t microseconds):
# XXX: add support for double timestamps
# int64 timestamps,
cdef int64_t ts = seconds * 1000000 + microseconds
if ts == infinity_datetime_ts:
buf.write_int64(pg_time64_infinity)
elif ts == negative_infinity_datetime_ts:
buf.write_int64(pg_time64_negative_infinity)
else:
buf.write_int64(ts)
cdef inline int32_t _decode_time(FastReadBuffer buf, int64_t *seconds,
uint32_t *microseconds):
# XXX: add support for double timestamps
# int64 timestamps,
cdef int64_t ts = hton.unpack_int64(buf.read(8))
if ts == pg_time64_infinity:
return 1
elif ts == pg_time64_negative_infinity:
return -1
seconds[0] = (ts / 1000000)
microseconds[0] = (ts % 1000000)
return 0
cdef date_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int32_t ordinal = cpython.PyLong_AsLong(obj.toordinal())
int32_t pg_ordinal
if ordinal == infinity_date_ord:
pg_ordinal = pg_date_infinity
elif ordinal == negative_infinity_date_ord:
pg_ordinal = pg_date_negative_infinity
else:
pg_ordinal = ordinal - pg_date_offset_ord
buf.write_int32(4)
buf.write_int32(pg_ordinal)
cdef date_encode_tuple(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int32_t pg_ordinal
if len(obj) != 1:
raise ValueError(
'date tuple encoder: expecting 1 element '
'in tuple, got {}'.format(len(obj)))
pg_ordinal = obj[0]
buf.write_int32(4)
buf.write_int32(pg_ordinal)
cdef date_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4))
if pg_ordinal == pg_date_infinity:
return infinity_date
elif pg_ordinal == pg_date_negative_infinity:
return negative_infinity_date
else:
return date_from_ordinal(pg_ordinal + pg_date_offset_ord)
cdef date_decode_tuple(ConnectionSettings settings, FastReadBuffer buf):
cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4))
return (pg_ordinal,)
cdef timestamp_encode(ConnectionSettings settings, WriteBuffer buf, obj):
delta = obj - pg_epoch_datetime
cdef:
int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \
cpython.PyLong_AsLong(delta.seconds)
int32_t microseconds = cpython.PyLong_AsLong(
delta.microseconds)
buf.write_int32(8)
_encode_time(buf, seconds, microseconds)
cdef timestamp_encode_tuple(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int64_t microseconds
if len(obj) != 1:
raise ValueError(
'timestamp tuple encoder: expecting 1 element '
'in tuple, got {}'.format(len(obj)))
microseconds = obj[0]
buf.write_int32(8)
buf.write_int64(microseconds)
cdef timestamp_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t seconds = 0
uint32_t microseconds = 0
int32_t inf = _decode_time(buf, &seconds, µseconds)
if inf > 0:
# positive infinity
return infinity_datetime
elif inf < 0:
# negative infinity
return negative_infinity_datetime
else:
return pg_epoch_datetime.__add__(
timedelta(0, seconds, microseconds))
cdef timestamp_decode_tuple(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t ts = hton.unpack_int64(buf.read(8))
return (ts,)
cdef timestamptz_encode(ConnectionSettings settings, WriteBuffer buf, obj):
buf.write_int32(8)
if obj == infinity_datetime:
buf.write_int64(pg_time64_infinity)
return
elif obj == negative_infinity_datetime:
buf.write_int64(pg_time64_negative_infinity)
return
delta = obj.astimezone(utc) - pg_epoch_datetime_utc
cdef:
int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \
cpython.PyLong_AsLong(delta.seconds)
int32_t microseconds = cpython.PyLong_AsLong(
delta.microseconds)
_encode_time(buf, seconds, microseconds)
cdef timestamptz_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t seconds = 0
uint32_t microseconds = 0
int32_t inf = _decode_time(buf, &seconds, µseconds)
if inf > 0:
# positive infinity
return infinity_datetime
elif inf < 0:
# negative infinity
return negative_infinity_datetime
else:
return pg_epoch_datetime_utc.__add__(
timedelta(0, seconds, microseconds))
cdef time_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \
cpython.PyLong_AsLong(obj.minute) * 60 + \
cpython.PyLong_AsLong(obj.second)
int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond)
buf.write_int32(8)
_encode_time(buf, seconds, microseconds)
cdef time_encode_tuple(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int64_t microseconds
if len(obj) != 1:
raise ValueError(
'time tuple encoder: expecting 1 element '
'in tuple, got {}'.format(len(obj)))
microseconds = obj[0]
buf.write_int32(8)
buf.write_int64(microseconds)
cdef time_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t seconds = 0
uint32_t microseconds = 0
_decode_time(buf, &seconds, µseconds)
cdef:
int64_t minutes = (seconds / 60)
int64_t sec = seconds % 60
int64_t hours = (minutes / 60)
int64_t min = minutes % 60
return datetime.time(hours, min, sec, microseconds)
cdef time_decode_tuple(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t ts = hton.unpack_int64(buf.read(8))
return (ts,)
cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj):
offset = obj.tzinfo.utcoffset(None)
cdef:
int32_t offset_sec = \
cpython.PyLong_AsLong(offset.days) * 24 * 60 * 60 + \
cpython.PyLong_AsLong(offset.seconds)
int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \
cpython.PyLong_AsLong(obj.minute) * 60 + \
cpython.PyLong_AsLong(obj.second)
int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond)
buf.write_int32(12)
_encode_time(buf, seconds, microseconds)
buf.write_int32(offset_sec)
cdef timetz_encode_tuple(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int64_t microseconds
int32_t offset_sec
if len(obj) != 2:
raise ValueError(
'time tuple encoder: expecting 2 elements2 '
'in tuple, got {}'.format(len(obj)))
microseconds = obj[0]
offset_sec = obj[1]
buf.write_int32(12)
buf.write_int64(microseconds)
buf.write_int32(offset_sec)
cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf):
time = time_decode(settings, buf)
cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60)
return time.replace(tzinfo=datetime.timezone(timedelta(minutes=offset)))
cdef timetz_decode_tuple(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int64_t microseconds = hton.unpack_int64(buf.read(8))
int32_t offset_sec = hton.unpack_int32(buf.read(4))
return (microseconds, offset_sec)
cdef interval_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
int32_t days = cpython.PyLong_AsLong(obj.days)
int64_t seconds = cpython.PyLong_AsLongLong(obj.seconds)
int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds)
buf.write_int32(16)
_encode_time(buf, seconds, microseconds)
buf.write_int32(days)
buf.write_int32(0) # Months
cdef interval_encode_tuple(ConnectionSettings settings, WriteBuffer buf,
tuple obj):
cdef:
int32_t months
int32_t days
int64_t microseconds
if len(obj) != 3:
raise ValueError(
'interval tuple encoder: expecting 3 elements '
'in tuple, got {}'.format(len(obj)))
months = obj[0]
days = obj[1]
microseconds = obj[2]
buf.write_int32(16)
buf.write_int64(microseconds)
buf.write_int32(days)
buf.write_int32(months)
cdef interval_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int32_t days
int32_t months
int32_t years
int64_t seconds = 0
uint32_t microseconds = 0
_decode_time(buf, &seconds, µseconds)
days = hton.unpack_int32(buf.read(4))
months = hton.unpack_int32(buf.read(4))
if months < 0:
years = -(-months // 12)
months = -(-months % 12)
else:
years = (months // 12)
months = (months % 12)
return datetime.timedelta(days=days + months * 30 + years * 365,
seconds=seconds, microseconds=microseconds)
cdef interval_decode_tuple(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int32_t days
int32_t months
int64_t microseconds
microseconds = hton.unpack_int64(buf.read(8))
days = hton.unpack_int32(buf.read(4))
months = hton.unpack_int32(buf.read(4))
return (months, days, microseconds)
cdef init_datetime_codecs():
register_core_codec(DATEOID,
&date_encode,
&date_decode,
PG_FORMAT_BINARY)
register_core_codec(DATEOID,
&date_encode_tuple,
&date_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
register_core_codec(TIMEOID,
&time_encode,
&time_decode,
PG_FORMAT_BINARY)
register_core_codec(TIMEOID,
&time_encode_tuple,
&time_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
register_core_codec(TIMETZOID,
&timetz_encode,
&timetz_decode,
PG_FORMAT_BINARY)
register_core_codec(TIMETZOID,
&timetz_encode_tuple,
&timetz_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
register_core_codec(TIMESTAMPOID,
×tamp_encode,
×tamp_decode,
PG_FORMAT_BINARY)
register_core_codec(TIMESTAMPOID,
×tamp_encode_tuple,
×tamp_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
register_core_codec(TIMESTAMPTZOID,
×tamptz_encode,
×tamptz_decode,
PG_FORMAT_BINARY)
register_core_codec(TIMESTAMPTZOID,
×tamp_encode_tuple,
×tamp_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
register_core_codec(INTERVALOID,
&interval_encode,
&interval_decode,
PG_FORMAT_BINARY)
register_core_codec(INTERVALOID,
&interval_encode_tuple,
&interval_decode_tuple,
PG_FORMAT_BINARY,
PG_XFORMAT_TUPLE)
# For obsolete abstime/reltime/tinterval, we do not bother to
# interpret the value, and simply return and pass it as text.
#
register_core_codec(ABSTIMEOID,
&text_encode,
&text_decode,
PG_FORMAT_TEXT)
register_core_codec(RELTIMEOID,
&text_encode,
&text_decode,
PG_FORMAT_TEXT)
register_core_codec(TINTERVALOID,
&text_encode,
&text_decode,
PG_FORMAT_TEXT)
init_datetime_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/json.pyx 0000664 0003720 0003720 00000002323 13172407302 022360 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef jsonb_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
char *str
ssize_t size
as_pg_string_and_size(settings, obj, &str, &size)
if size > 0x7fffffff - 1:
raise ValueError('string too long')
buf.write_int32(size + 1)
buf.write_byte(1) # JSONB format version
buf.write_cstr(str, size)
cdef jsonb_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef uint8_t format = buf.read(1)[0]
if format != 1:
raise ValueError('unexpected JSONB format: {}'.format(format))
return text_decode(settings, buf)
cdef init_json_codecs():
register_core_codec(JSONOID,
&text_encode,
&text_decode,
PG_FORMAT_BINARY)
register_core_codec(JSONBOID,
&jsonb_encode,
&jsonb_decode,
PG_FORMAT_BINARY)
init_json_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/uuid.pyx 0000664 0003720 0003720 00000001403 13172407302 022353 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
import uuid
_UUID = uuid.UUID
cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj):
if cpython.PyUnicode_Check(obj):
obj = _UUID(obj)
bytea_encode(settings, wbuf, obj.bytes)
cdef uuid_decode(ConnectionSettings settings, FastReadBuffer buf):
return _UUID(bytes=bytea_decode(settings, buf))
cdef init_uuid_codecs():
register_core_codec(UUIDOID,
&uuid_encode,
&uuid_decode,
PG_FORMAT_BINARY)
init_uuid_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/hstore.pyx 0000664 0003720 0003720 00000004322 13172407302 022714 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef hstore_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
char *str
ssize_t size
ssize_t count
object items
WriteBuffer item_buf = WriteBuffer.new()
count = len(obj)
if count > _MAXINT32:
raise ValueError('hstore value is too large')
item_buf.write_int32(count)
if hasattr(obj, 'items'):
items = obj.items()
else:
items = obj
for k, v in items:
if k is None:
raise ValueError('null value not allowed in hstore key')
as_pg_string_and_size(settings, k, &str, &size)
item_buf.write_int32(size)
item_buf.write_cstr(str, size)
if v is None:
item_buf.write_int32(-1)
else:
as_pg_string_and_size(settings, v, &str, &size)
item_buf.write_int32(size)
item_buf.write_cstr(str, size)
buf.write_int32(item_buf.len())
buf.write_buffer(item_buf)
cdef hstore_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
dict result
uint32_t elem_count
int32_t elem_len
uint32_t i
str k
str v
result = {}
elem_count = hton.unpack_int32(buf.read(4))
if elem_count == 0:
return result
for i in range(elem_count):
elem_len = hton.unpack_int32(buf.read(4))
if elem_len < 0:
raise ValueError('null value not allowed in hstore key')
k = decode_pg_string(settings, buf.read(elem_len), elem_len)
elem_len = hton.unpack_int32(buf.read(4))
if elem_len < 0:
v = None
else:
v = decode_pg_string(settings, buf.read(elem_len), elem_len)
result[k] = v
return result
cdef init_hstore_codecs():
register_extra_codec('pg_contrib.hstore',
&hstore_encode,
&hstore_decode,
PG_FORMAT_BINARY)
init_hstore_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/txid.pyx 0000664 0003720 0003720 00000003625 13172407302 022365 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef txid_snapshot_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef:
ssize_t nxip
int64_t xmin
int64_t xmax
int i
WriteBuffer xip_buf = WriteBuffer.new()
if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)):
raise TypeError(
'list or tuple expected (got type {})'.format(type(obj)))
if len(obj) != 3:
raise ValueError(
'invalid number of elements in txid_snapshot tuple, expecting 4')
nxip = len(obj[2])
if nxip > _MAXINT32:
raise ValueError('txid_snapshot value is too long')
xmin = obj[0]
xmax = obj[1]
for i in range(nxip):
xip_buf.write_int64(obj[2][i])
buf.write_int32(20 + xip_buf.len())
buf.write_int32(nxip)
buf.write_int64(obj[0])
buf.write_int64(obj[1])
buf.write_buffer(xip_buf)
cdef txid_snapshot_decode(ConnectionSettings settings, FastReadBuffer buf):
cdef:
int32_t nxip
int64_t xmin
int64_t xmax
tuple xip_tup
int32_t i
object xip
nxip = hton.unpack_int32(buf.read(4))
xmin = hton.unpack_int64(buf.read(8))
xmax = hton.unpack_int64(buf.read(8))
xip_tup = cpython.PyTuple_New(nxip)
for i in range(nxip):
xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8)))
cpython.Py_INCREF(xip)
cpython.PyTuple_SET_ITEM(xip_tup, i, xip)
return (xmin, xmax, xip_tup)
cdef init_txid_codecs():
register_core_codec(TXID_SNAPSHOTOID,
&txid_snapshot_encode,
&txid_snapshot_decode,
PG_FORMAT_BINARY)
init_txid_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/int.pyx 0000664 0003720 0003720 00000006436 13172407302 022212 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj):
if not cpython.PyBool_Check(obj):
raise TypeError('a boolean is required (got type {})'.format(
type(obj).__name__))
buf.write_int32(1)
buf.write_byte(b'\x01' if obj is True else b'\x00')
cdef bool_decode(ConnectionSettings settings, FastReadBuffer buf):
return buf.read(1)[0] is b'\x01'
cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef int overflow = 0
cdef long val
try:
val = cpython.PyLong_AsLong(obj)
except OverflowError:
overflow = 1
if overflow or val < -32768 or val > 32767:
raise OverflowError(
'int too big to be encoded as INT2: {!r}'.format(obj))
buf.write_int32(2)
buf.write_int16(val)
cdef int2_decode(ConnectionSettings settings, FastReadBuffer buf):
return cpython.PyLong_FromLong(hton.unpack_int16(buf.read(2)))
cdef int4_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef int overflow = 0
cdef long val = 0
try:
val = cpython.PyLong_AsLong(obj)
except OverflowError:
overflow = 1
# "long" and "long long" have the same size for x86_64, need an extra check
if overflow or (sizeof(val) > 4 and (val < -2147483648 or
val > 2147483647)):
raise OverflowError(
'int too big to be encoded as INT4: {!r}'.format(obj))
buf.write_int32(4)
buf.write_int32(val)
cdef int4_decode(ConnectionSettings settings, FastReadBuffer buf):
return cpython.PyLong_FromLong(hton.unpack_int32(buf.read(4)))
cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj):
cdef int overflow = 0
cdef long long val
try:
val = cpython.PyLong_AsLongLong(obj)
except OverflowError:
overflow = 1
# Just in case for systems with "long long" bigger than 8 bytes
if overflow or (sizeof(val) > 8 and (val < -9223372036854775808 or
val > 9223372036854775807)):
raise OverflowError(
'int too big to be encoded as INT8: {!r}'.format(obj))
buf.write_int32(8)
buf.write_int64(val)
cdef int8_decode(ConnectionSettings settings, FastReadBuffer buf):
return cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8)))
cdef init_int_codecs():
register_core_codec(BOOLOID,
&bool_encode,
&bool_decode,
PG_FORMAT_BINARY)
register_core_codec(INT2OID,
&int2_encode,
&int2_decode,
PG_FORMAT_BINARY)
register_core_codec(INT4OID,
&int4_encode,
&int4_decode,
PG_FORMAT_BINARY)
register_core_codec(INT8OID,
&int8_encode,
&int8_decode,
PG_FORMAT_BINARY)
init_int_codecs()
asyncpg-0.13.0/asyncpg/protocol/codecs/base.pyx 0000664 0003720 0003720 00000064077 13172407302 022337 0 ustar travis travis 0000000 0000000 # Copyright (C) 2016-present the asyncpg authors and contributors
#
#
# This module is part of asyncpg and is released under
# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
cdef void* binary_codec_map[(MAXSUPPORTEDOID + 1) * 2]
cdef void* text_codec_map[(MAXSUPPORTEDOID + 1) * 2]
cdef dict TYPE_CODECS_CACHE = {}
cdef dict EXTRA_CODECS = {}
@cython.final
cdef class Codec:
def __cinit__(self, uint32_t oid):
self.oid = oid
self.type = CODEC_UNDEFINED
cdef init(self, str name, str schema, str kind,
CodecType type, ServerDataFormat format,
ClientExchangeFormat xformat,
encode_func c_encoder, decode_func c_decoder,
object py_encoder, object py_decoder,
Codec element_codec, tuple element_type_oids,
object element_names, list element_codecs,
Py_UCS4 element_delimiter):
self.name = name
self.schema = schema
self.kind = kind
self.type = type
self.format = format
self.xformat = xformat
self.c_encoder = c_encoder
self.c_decoder = c_decoder
self.py_encoder = py_encoder
self.py_decoder = py_decoder
self.element_codec = element_codec
self.element_type_oids = element_type_oids
self.element_codecs = element_codecs
self.element_delimiter = element_delimiter
if element_names is not None:
self.element_names = record.ApgRecordDesc_New(
element_names, tuple(element_names))
else:
self.element_names = None
if type == CODEC_C:
self.encoder = &self.encode_scalar
self.decoder = &self.decode_scalar
elif type == CODEC_ARRAY:
if format == PG_FORMAT_BINARY:
self.encoder = &self.encode_array
self.decoder = &self.decode_array
else:
self.encoder = &self.encode_array_text
self.decoder = &self.decode_array_text
elif type == CODEC_RANGE:
if format != PG_FORMAT_BINARY:
raise RuntimeError(
'cannot encode type "{}"."{}": text encoding of '
'range types is not supported'.format(schema, name))
self.encoder = &self.encode_range
self.decoder = &self.decode_range
elif type == CODEC_COMPOSITE:
if format != PG_FORMAT_BINARY:
raise RuntimeError(
'cannot encode type "{}"."{}": text encoding of '
'composite types is not supported'.format(schema, name))
self.encoder = &self.encode_composite
self.decoder = &self.decode_composite
elif type == CODEC_PY:
self.encoder = &self.encode_in_python
self.decoder = &self.decode_in_python
else:
raise RuntimeError('unexpected codec type: {}'.format(type))
cdef Codec copy(self):
cdef Codec codec
codec = Codec(self.oid)
codec.init(self.name, self.schema, self.kind,
self.type, self.format, self.xformat,
self.c_encoder, self.c_decoder,
self.py_encoder, self.py_decoder,
self.element_codec,
self.element_type_oids, self.element_names,
self.element_codecs, self.element_delimiter)
return codec
cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
self.c_encoder(settings, buf, obj)
cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
array_encode(settings, buf, obj, self.element_codec.oid,
codec_encode_func_ex,
(self.element_codec))
cdef encode_array_text(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
return textarray_encode(settings, buf, obj,
codec_encode_func_ex,
(self.element_codec),
self.element_delimiter)
cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
range_encode(settings, buf, obj, self.element_codec.oid,
codec_encode_func_ex,
(self.element_codec))
cdef encode_composite(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
cdef:
WriteBuffer elem_data
int i
list elem_codecs = self.element_codecs
ssize_t count
count = len(obj)
if count > _MAXINT32:
raise ValueError('too many elements in composite type record')
elem_data = WriteBuffer.new()
i = 0
for item in obj:
elem_data.write_int32(self.element_type_oids[i])
if item is None:
elem_data.write_int32(-1)
else:
(elem_codecs[i]).encode(settings, elem_data, item)
i += 1
record_encode_frame(settings, buf, elem_data, count)
cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
data = self.py_encoder(obj)
if self.xformat == PG_XFORMAT_OBJECT:
if self.format == PG_FORMAT_BINARY:
bytea_encode(settings, buf, data)
elif self.format == PG_FORMAT_TEXT:
text_encode(settings, buf, data)
else:
raise RuntimeError(
'unexpected data format: {}'.format(self.format))
elif self.xformat == PG_XFORMAT_TUPLE:
self.c_encoder(settings, buf, data)
else:
raise RuntimeError(
'unexpected exchange format: {}'.format(self.xformat))
cdef encode(self, ConnectionSettings settings, WriteBuffer buf,
object obj):
return self.encoder(self, settings, buf, obj)
cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf):
return self.c_decoder(settings, buf)
cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf):
return array_decode(settings, buf, codec_decode_func_ex,
(self.element_codec))
cdef decode_array_text(self, ConnectionSettings settings,
FastReadBuffer buf):
return textarray_decode(settings, buf, codec_decode_func_ex,
(self.element_codec),
self.element_delimiter)
cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf):
return range_decode(settings, buf, codec_decode_func_ex,