async def execute(self, query: ClauseElement, values: dict = None) -> None:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, context = self._compile(query)
cursor = await self._connection.execute(query, args)
await cursor.close()
async def execute(self,
query: ClauseElement,
values: dict = None) -> typing.Any:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
return await self._connection.fetchval(query, *args)
async def execute_many(self, query: ClauseElement, values: list) -> None:
assert self._connection is not None, "Connection is not acquired"
# asyncpg uses prepared statements under the hood, so we just
# loop through multiple executes here, which should all end up
# using the same prepared statement.
for item in values:
single_query = query.values(item)
single_query, args, result_columns = self._compile(single_query)
await self._connection.execute(single_query, *args)
async def execute_many(self, query: ClauseElement, values: list) -> None:
assert self._connection is not None, "Connection is not acquired"
cursor = await self._connection.cursor()
try:
for item in values:
single_query = query.values(item)
single_query, args, context = self._compile(single_query)
await cursor.execute(single_query, args)
finally:
await cursor.close()
async def execute(self, query: ClauseElement, values: dict = None) -> None:
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
conn = await self.acquire_connection()
try:
await conn.execute(query, *args)
finally:
await self.release_connection()
async def execute(self, query: ClauseElement, values: dict = None) -> None:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
cursor = await self._connection.cursor()
try:
await cursor.execute(query, args)
finally:
await cursor.close()
async def executemany(self, query: ClauseElement, values: list) -> None:
conn = await self.acquire_connection()
cursor = await conn.cursor()
try:
for item in values:
single_query = query.values(item)
single_query, args, result_columns = self._compile(single_query)
await cursor.execute(single_query, args)
finally:
await cursor.close()
await self.release_connection()
async def executemany(self, query: ClauseElement, values: list) -> None:
conn = await self.acquire_connection()
try:
# asyncpg uses prepared statements under the hood, so we just
# loop through multiple executes here, which should all end up
# using the same prepared statement.
for item in values:
single_query = query.values(item)
single_query, args = self._compile(single_query)
await conn.execute(single_query, *args)
finally:
await self.release_connection()
async def execute(self,
query: ClauseElement,
values: dict = None) -> typing.Any:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, context = self._compile(query)
cursor = await self._connection.cursor()
try:
await cursor.execute(query, args)
return cursor.lastrowid
finally:
await cursor.close()