def named_cursor(
self,
args: typing.Dict,
prefetch: typing.Optional[int] = None,
timeout: typing.Optional[float] = None,
):
"""Extended version of `cursor` with support of the named
parameters."""
prepared_args = query_module.QueryParamsDictConverter().prepare_asyncpg_args(args, self._params_order_list)
return super().cursor(*prepared_args, prefetch=prefetch, timeout=timeout)
async def named_fetchrow(
self,
args: typing.Dict,
timeout: typing.Optional[float] = None) -> asyncpg.Record:
"""Extended version of `fetchrow` with support of the named parameters.
:param args: Dict with the parameters values.
:param timeout: Optional timeout value in seconds.
"""
prepared_args = query_module.QueryParamsDictConverter(
).prepare_asyncpg_args(args, self._params_order_list)
return await super().fetchrow(*prepared_args, timeout=timeout)
async def named_fetch(
self,
query: str,
args: typing.Dict,
timeout: typing.Optional[float] = None
) -> typing.List[asyncpg.Record]:
"""Extended versions of `fetch` with support of the named
parameters."""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return await super().fetch(converted_query,
*asyncpg_args,
timeout=timeout)
def test_dict_converter_prepare_asyncpg_args():
"""Test `prepare_asyncpg_args` for dict converter."""
converter = query.QueryParamsDictConverter()
asyncpg_args = converter.prepare_asyncpg_args(
{
'some_field_1': '1',
'some_field_2': '2',
'some_field_3': '3'
},
['some_field_1', 'some_field_2', 'some_field_3'],
)
assert asyncpg_args == ['1', '2', '3']
async def named_fetchval(
self,
query: str,
args: typing.Dict,
column: int = 0,
timeout: typing.Optional[float] = None
) -> typing.Optional[typing.Any]:
"""Extended versions of `fetchval` with support of the named
parameters."""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return await super().fetchval(converted_query,
*asyncpg_args,
column=column,
timeout=timeout)
def named_cursor(
self,
query: str,
args: typing.Dict,
prefetch: typing.Optional[int] = None,
timeout: typing.Optional[float] = None,
) -> cursor.CursorFactory:
"""Extended version of `cursor` with support of the named
parameters."""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return super().cursor(converted_query,
*asyncpg_args,
prefetch=prefetch,
timeout=timeout)
async def named_execute(self,
query: str,
args: typing.Dict,
timeout: typing.Optional[float] = None) -> str:
"""Extended versions of `execute` with support of the named parameters.
:param query: SQL query to execute (could include named parameters).
:param args: Dict with the parameters values.
:param timeout: Optional timeout value in seconds.
"""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
query_result: str = await super().execute(converted_query,
*asyncpg_args,
timeout=timeout)
return query_result
async def named_fetchval(
self,
args: typing.Dict,
column: int = 0,
timeout: typing.Optional[float] = None) -> typing.Any:
"""Extended version of `fetchval` with support of the named parameters.
:param args: Dict with the parameters values.
:param column: Numeric index within the record of the value to return.
:param timeout: Optional timeout value in seconds.
"""
prepared_args = query_module.QueryParamsDictConverter(
).prepare_asyncpg_args(args, self._params_order_list)
return await super().fetchval(*prepared_args,
column=column,
timeout=timeout)
def named_cursor(
self,
args: typing.Dict,
prefetch: typing.Optional[int] = None,
timeout: typing.Optional[float] = None,
) -> asyncpg.cursor.CursorFactory:
"""Extended version of `cursor` with support of the named parameters.
:param args: Dict with the parameters values.
:param prefetch: The number of rows the *cursor iterator* will prefetch (defaults to ``50``.)
:param timeout: Optional timeout value in seconds.
"""
prepared_args = query_module.QueryParamsDictConverter(
).prepare_asyncpg_args(args, self._params_order_list)
return super().cursor(*prepared_args,
prefetch=prefetch,
timeout=timeout)
def named_cursor(
self,
query: str,
args: typing.Dict,
prefetch: typing.Optional[int] = None,
timeout: typing.Optional[float] = None,
) -> cursor.CursorFactory:
"""Extended version of `cursor` with support of the named parameters.
:param query: SQL query to execute (could include named parameters).
:param args: Dict with the parameters values.
:param prefetch: The number of rows the *cursor iterator* will prefetch (defaults to ``50``.)
:param timeout: Optional timeout value in seconds.
"""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return super().cursor(converted_query,
*asyncpg_args,
prefetch=prefetch,
timeout=timeout)
async def named_fetchval(
self,
query: str,
args: typing.Dict,
column: int = 0,
timeout: typing.Optional[float] = None
) -> typing.Optional[typing.Any]:
"""Extended versions of `fetchval` with support of the named
parameters.
:param query: SQL query to execute (could include named parameters).
:param args: Dict with the parameters values.
:param column: Numeric index within the record of the value to return.
:param timeout: Optional timeout value in seconds.
"""
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return await super().fetchval(converted_query,
*asyncpg_args,
column=column,
timeout=timeout)
async def named_execute(self,
query: str,
args: typing.Dict,
timeout: typing.Optional[float] = None) -> str:
"""Extended versions of `execute` with support of the named
parameters."""
# Convert the received query in the parameter to all lower-case
query = query.lower()
# Fetch the column string that is passed as part of INTO clause
query_columns = query.split('into')[1].split('values')[0].strip()
# Convert the column into list for further detailed logging
columns = [
column.strip()
for column in query_columns[query_columns.index('(') +
1:-1].split(',')
]
number_of_columns = len(columns)
number_of_values = len(list(args.keys()))
missing_columns = set(columns) - set(args.keys())
# Scenario: When the value passed in parameter do not match the number of columns
if number_of_values < number_of_columns:
raise KeyError(
'Values missing. Columns that are missing values: {0}'.format(
missing_columns))
# Scenario: When the expected column id is not received
if 'id' not in args:
raise KeyError(
'Expected column name-> id :: Provided column name-> {}'.
format(list(args.keys())[0]))
converted_query, asyncpg_args = self._prepare_asyncpg_parameters(
query, args, query_module.QueryParamsDictConverter())
return await super().execute(converted_query,
*asyncpg_args,
timeout=timeout)
async def named_fetchval(self, args: typing.Dict, column: int = 0, timeout: typing.Optional[float] = None):
"""Extended version of `fetchval` with support of the named
parameters."""
prepared_args = query_module.QueryParamsDictConverter().prepare_asyncpg_args(args, self._params_order_list)
return await super().fetchval(*prepared_args, column=column, timeout=timeout)
