)
self._autocommit = value
- def cursor(
+ def _cursor(
self, name: str = "", format: pq.Format = pq.Format.TEXT
) -> cursor.BaseCursor:
if name:
def cursor(
self, name: str = "", format: pq.Format = pq.Format.TEXT
) -> cursor.Cursor:
- cur = super().cursor(name, format=format)
+ cur = self._cursor(name, format=format)
return cast(cursor.Cursor, cur)
def _start_query(self) -> None:
async def close(self) -> None:
self.pgconn.finish()
- def cursor(
+ async def cursor(
self, name: str = "", format: pq.Format = pq.Format.TEXT
) -> cursor.AsyncCursor:
- cur = super().cursor(name, format=format)
+ cur = self._cursor(name, format=format)
return cast(cursor.AsyncCursor, cur)
async def _start_query(self) -> None:
async def fetch_info_async(
conn: "AsyncConnection", name: str
) -> Optional[CompositeTypeInfo]:
- cur = conn.cursor(format=pq.Format.BINARY)
+ cur = await conn.cursor(format=pq.Format.BINARY)
await cur.execute(_type_info_query, {"name": name})
rec = await cur.fetchone()
return CompositeTypeInfo._from_record(rec)
async def runner():
nonlocal stop
- cur = aconn.cursor()
+ cur = await aconn.cursor()
for i in range(1000):
await cur.execute("select %s;", (i,))
await aconn.commit()
async def test_concurrent_execution(dsn):
async def worker():
cnn = await psycopg3.AsyncConnection.connect(dsn)
- cur = cnn.cursor()
+ cur = await cnn.cursor()
await cur.execute("select pg_sleep(0.5)")
await cur.close()
await cnn.close()
errors.append(exc)
async def worker():
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(psycopg3.DatabaseError):
await cur.execute("select pg_sleep(2)")
# still working
await aconn.rollback()
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select 1")
assert await cur.fetchone() == (1,)
assert aconn.closed
assert aconn.status == aconn.ConnStatus.BAD
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await aconn.close()
assert aconn.closed
aconn.pgconn.exec_(b"drop table if exists foo")
aconn.pgconn.exec_(b"create table foo (id int primary key)")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
await cur.execute("insert into foo values (1)")
aconn.pgconn.exec_(b"drop table if exists foo")
aconn.pgconn.exec_(b"create table foo (id int primary key)")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
await cur.execute("insert into foo values (1)")
await aconn.set_autocommit(True)
assert aconn.autocommit
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select 1")
assert await cur.fetchone() == (1,)
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
async def test_autocommit_intrans(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select 1")
assert await cur.fetchone() == (1,)
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
async def test_autocommit_inerror(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(psycopg3.DatabaseError):
await cur.execute("meh")
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INERROR
async def test_get_encoding(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("show client_encoding")
(enc,) = await cur.fetchone()
assert enc == aconn.client_encoding
assert aconn.client_encoding != newenc
await aconn.set_client_encoding(newenc)
assert aconn.client_encoding == newenc
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("show client_encoding")
(enc,) = await cur.fetchone()
assert enc == newenc
async def test_set_encoding_unsupported(aconn):
await aconn.set_client_encoding("EUC_TW")
+ cur = await aconn.cursor()
with pytest.raises(psycopg3.NotSupportedError):
- await aconn.cursor().execute("select 1")
+ await cur.execute("select 1")
async def test_set_encoding_bad(aconn):
async def test_broken_connection(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(psycopg3.DatabaseError):
await cur.execute("select pg_terminate_backend(pg_backend_pid())")
assert aconn.closed
aconn.add_notice_handler(lambda diag: severities.append(diag.severity))
aconn.pgconn.exec_(b"set client_min_messages to notice")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute(
"do $$begin raise notice 'hello notice'; end$$ language plpgsql"
)
aconn.add_notify_handler(lambda n: nots2.append(n))
await aconn.set_autocommit(True)
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("listen foo")
await cur.execute("notify foo, 'n1'")
@pytest.mark.parametrize("format", [Format.TEXT, Format.BINARY])
async def test_copy_out_read(aconn, format):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
copy = await cur.copy(
f"copy ({sample_values}) to stdout (format {format.name})"
)
@pytest.mark.parametrize("format", [Format.TEXT, Format.BINARY])
async def test_copy_out_iter(aconn, format):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
copy = await cur.copy(
f"copy ({sample_values}) to stdout (format {format.name})"
)
[(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")],
)
async def test_copy_in_buffers(aconn, format, buffer):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
copy = await cur.copy(f"copy copy_in from stdin (format {format.name})")
await copy.write(globals()[buffer])
async def test_copy_in_buffers_pg_error(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
copy = await cur.copy("copy copy_in from stdin (format text)")
await copy.write(sample_text)
assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INERROR
-async def test_copy_bad_result(conn):
- conn.autocommit = True
+async def test_copy_bad_result(aconn):
+ await aconn.set_autocommit(True)
- cur = conn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(e.SyntaxError):
await cur.copy("wat")
[(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")],
)
async def test_copy_in_buffers_with(aconn, format, buffer):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
async with (
await cur.copy(f"copy copy_in from stdin (format {format.name})")
async def test_copy_in_str(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
async with (
await cur.copy("copy copy_in from stdin (format text)")
async def test_copy_in_str_binary(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
with pytest.raises(e.QueryCanceled):
async with (
async def test_copy_in_buffers_with_pg_error(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
with pytest.raises(e.UniqueViolation):
async with (
async def test_copy_in_buffers_with_py_error(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
with pytest.raises(e.QueryCanceled) as exc:
async with (
if format == Format.BINARY:
pytest.skip("TODO: implement int binary adapter")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
async with (
if format == Format.TEXT:
pytest.skip("TODO: remove after implementing int binary adapter")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, "col1 serial primary key, col2 int, data text")
async with (
async def test_copy_in_allchars(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await ensure_table(cur, sample_tabledef)
await aconn.set_client_encoding("utf8")
async def test_close(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
assert not cur.closed
await cur.close()
assert cur.closed
async def test_context(aconn):
- async with aconn.cursor() as cur:
+ async with (await aconn.cursor()) as cur:
assert not cur.closed
assert cur.closed
async def test_weakref(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
w = weakref.ref(cur)
await cur.close()
del cur
async def test_status(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
assert cur.status is None
await cur.execute("reset all")
assert cur.status == cur.ExecStatus.COMMAND_OK
async def test_execute_many_results(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
assert cur.nextset() is None
rv = await cur.execute("select 'foo'; select generate_series(1,3)")
async def test_execute_sequence(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
rv = await cur.execute(
"select %s::int, %s::text, %s::text", [1, "foo", None]
)
@pytest.mark.parametrize("query", ["", " ", ";"])
async def test_execute_empty_query(aconn, query):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute(query)
assert cur.status == cur.ExecStatus.EMPTY_QUERY
with pytest.raises(psycopg3.ProgrammingError):
async def test_fetchone(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select %s::int, %s::text, %s::text", [1, "foo", None])
assert cur.pgresult.fformat(0) == 0
async def test_execute_binary_result(aconn):
- cur = aconn.cursor(format=psycopg3.pq.Format.BINARY)
+ cur = await aconn.cursor(format=psycopg3.pq.Format.BINARY)
await cur.execute("select %s::text, %s::text", ["foo", None])
assert cur.pgresult.fformat(0) == 1
@pytest.mark.parametrize("encoding", ["utf8", "latin9"])
async def test_query_encode(aconn, encoding):
await aconn.set_client_encoding(encoding)
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select '\u20ac'")
(res,) = await cur.fetchone()
assert res == "\u20ac"
async def test_query_badenc(aconn):
await aconn.set_client_encoding("latin1")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(UnicodeEncodeError):
await cur.execute("select '\u20ac'")
async def test_executemany(aconn, execmany):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.executemany(
"insert into execmany(num, data) values (%s, %s)",
[(10, "hello"), (20, "world")],
async def test_executemany_name(aconn, execmany):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.executemany(
"insert into execmany(num, data) values (%(num)s, %(data)s)",
[{"num": 11, "data": "hello", "x": 1}, {"num": 21, "data": "world"}],
async def test_executemany_rowcount(aconn, execmany):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.executemany(
"insert into execmany(num, data) values (%s, %s)",
[(10, "hello"), (20, "world")],
],
)
async def test_executemany_badquery(aconn, query):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(psycopg3.DatabaseError):
await cur.executemany(query, [(10, "hello"), (20, "world")])
async def test_callproc_args(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute(
"""
create function testfunc(a int, b text) returns text[] language sql as
async def test_callproc_badparam(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(TypeError):
await cur.callproc("lower", 42)
with pytest.raises(TypeError):
async def test_callproc_dict(aconn):
testfunc = make_testfunc(aconn)
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.callproc(testfunc.name, [2])
assert (await cur.fetchone()) == (4,)
if "_p" in args:
args[testfunc.param] = args.pop("_p")
- cur = aconn.cursor()
+ cur = await aconn.cursor()
with pytest.raises(exc):
await cur.callproc(testfunc.name, args)
async def test_rowcount(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select 1 from generate_series(1, 42)")
assert cur.rowcount == 42
async def test_iter(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select generate_series(1, 3)")
res = []
async for rec in cur:
async def test_iter_stop(aconn):
- cur = aconn.cursor()
+ cur = await aconn.cursor()
await cur.execute("select generate_series(1, 3)")
async for rec in cur:
assert rec == (1,)
projects / thirdparty / psycopg.git / commitdiff
