— ⭐️ —
Databases is BSD licensed code. Designed & built in Brighton, England.
[sqlalchemy-core]: https://docs.sqlalchemy.org/en/latest/core/ [sqlalchemy-core-tutorial]: https://docs.sqlalchemy.org/en/latest/core/tutorial.html [alembic]: https://alembic.sqlalchemy.org/en/latest/ [psycopg2]: https://www.psycopg.org/ [pymysql]: https://github.com/PyMySQL/PyMySQL [asyncpg]: https://github.com/MagicStack/asyncpg [aiopg]: https://github.com/aio-libs/aiopg [aiomysql]: https://github.com/aio-libs/aiomysql [asyncmy]: https://github.com/long2ice/asyncmy [aiosqlite]: https://github.com/omnilib/aiosqlite [starlette]: https://github.com/encode/starlette [sanic]: https://github.com/huge-success/sanic [responder]: https://github.com/kennethreitz/responder [quart]: https://gitlab.com/pgjones/quart [aiohttp]: https://github.com/aio-libs/aiohttp [tornado]: https://github.com/tornadoweb/tornado [fastapi]: https://github.com/tiangolo/fastapi ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/README.md 0000644 0001751 0000177 00000007525 00000000000 015545 0 ustar 00runner docker 0000000 0000000 # Databases
— ⭐️ —
Databases is BSD licensed code. Designed & built in Brighton, England.
[sqlalchemy-core]: https://docs.sqlalchemy.org/en/latest/core/ [sqlalchemy-core-tutorial]: https://docs.sqlalchemy.org/en/latest/core/tutorial.html [alembic]: https://alembic.sqlalchemy.org/en/latest/ [psycopg2]: https://www.psycopg.org/ [pymysql]: https://github.com/PyMySQL/PyMySQL [asyncpg]: https://github.com/MagicStack/asyncpg [aiopg]: https://github.com/aio-libs/aiopg [aiomysql]: https://github.com/aio-libs/aiomysql [asyncmy]: https://github.com/long2ice/asyncmy [aiosqlite]: https://github.com/omnilib/aiosqlite [starlette]: https://github.com/encode/starlette [sanic]: https://github.com/huge-success/sanic [responder]: https://github.com/kennethreitz/responder [quart]: https://gitlab.com/pgjones/quart [aiohttp]: https://github.com/aio-libs/aiohttp [tornado]: https://github.com/tornadoweb/tornado [fastapi]: https://github.com/tiangolo/fastapi ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9480538 databases-0.9.0/databases/ 0000755 0001751 0000177 00000000000 00000000000 016204 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/__init__.py 0000644 0001751 0000177 00000000156 00000000000 020317 0 ustar 00runner docker 0000000 0000000 from databases.core import Database, DatabaseURL __version__ = "0.9.0" __all__ = ["Database", "DatabaseURL"] ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9480538 databases-0.9.0/databases/backends/ 0000755 0001751 0000177 00000000000 00000000000 017756 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/__init__.py 0000644 0001751 0000177 00000000000 00000000000 022055 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/aiopg.py 0000644 0001751 0000177 00000025666 00000000000 021446 0 ustar 00runner docker 0000000 0000000 import getpass import json import logging import typing import uuid import aiopg from sqlalchemy.engine.cursor import CursorResultMetaData from sqlalchemy.engine.interfaces import Dialect, ExecutionContext from sqlalchemy.engine.row import Row from sqlalchemy.sql import ClauseElement from sqlalchemy.sql.ddl import DDLElement from databases.backends.common.records import Record, Row, create_column_maps from databases.backends.compilers.psycopg import PGCompiler_psycopg from databases.backends.dialects.psycopg import PGDialect_psycopg from databases.core import LOG_EXTRA, DatabaseURL from databases.interfaces import ( ConnectionBackend, DatabaseBackend, Record as RecordInterface, TransactionBackend, ) logger = logging.getLogger("databases") class AiopgBackend(DatabaseBackend): def __init__( self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any ) -> None: self._database_url = DatabaseURL(database_url) self._options = options self._dialect = self._get_dialect() self._pool: typing.Union[aiopg.Pool, None] = None def _get_dialect(self) -> Dialect: dialect = PGDialect_psycopg( json_serializer=json.dumps, json_deserializer=lambda x: x ) dialect.statement_compiler = PGCompiler_psycopg dialect.implicit_returning = True dialect.supports_native_enum = True dialect.supports_smallserial = True # 9.2+ dialect._backslash_escapes = False dialect.supports_sane_multi_rowcount = True # psycopg 2.0.9+ dialect._has_native_hstore = True dialect.supports_native_decimal = True return dialect def _get_connection_kwargs(self) -> dict: url_options = self._database_url.options kwargs = {} min_size = url_options.get("min_size") max_size = url_options.get("max_size") ssl = url_options.get("ssl") if min_size is not None: kwargs["minsize"] = int(min_size) if max_size is not None: kwargs["maxsize"] = int(max_size) if ssl is not None: kwargs["ssl"] = {"true": True, "false": False}[ssl.lower()] for key, value in self._options.items(): # Coerce 'min_size' and 'max_size' for consistency. if key == "min_size": key = "minsize" elif key == "max_size": key = "maxsize" kwargs[key] = value return kwargs async def connect(self) -> None: assert self._pool is None, "DatabaseBackend is already running" kwargs = self._get_connection_kwargs() self._pool = await aiopg.create_pool( host=self._database_url.hostname, port=self._database_url.port, user=self._database_url.username or getpass.getuser(), password=self._database_url.password, database=self._database_url.database, **kwargs, ) async def disconnect(self) -> None: assert self._pool is not None, "DatabaseBackend is not running" self._pool.close() await self._pool.wait_closed() self._pool = None def connection(self) -> "AiopgConnection": return AiopgConnection(self, self._dialect) class CompilationContext: def __init__(self, context: ExecutionContext): self.context = context class AiopgConnection(ConnectionBackend): def __init__(self, database: AiopgBackend, dialect: Dialect): self._database = database self._dialect = dialect self._connection: typing.Optional[aiopg.Connection] = None async def acquire(self) -> None: assert self._connection is None, "Connection is already acquired" assert self._database._pool is not None, "DatabaseBackend is not running" self._connection = await self._database._pool.acquire() async def release(self) -> None: assert self._connection is not None, "Connection is not acquired" assert self._database._pool is not None, "DatabaseBackend is not running" await self._database._pool.release(self._connection) self._connection = None async def fetch_all(self, query: ClauseElement) -> typing.List[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) rows = await cursor.fetchall() metadata = CursorResultMetaData(context, cursor.description) rows = [ Row( metadata, metadata._processors, metadata._keymap, row, ) for row in rows ] return [Record(row, result_columns, dialect, column_maps) for row in rows] finally: cursor.close() async def fetch_one(self, query: ClauseElement) -> typing.Optional[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) row = await cursor.fetchone() if row is None: return None metadata = CursorResultMetaData(context, cursor.description) row = Row( metadata, metadata._processors, metadata._keymap, row, ) return Record(row, result_columns, dialect, column_maps) finally: cursor.close() async def execute(self, query: ClauseElement) -> typing.Any: assert self._connection is not None, "Connection is not acquired" query_str, args, _, _ = self._compile(query) cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) return cursor.lastrowid finally: cursor.close() async def execute_many(self, queries: typing.List[ClauseElement]) -> None: assert self._connection is not None, "Connection is not acquired" cursor = await self._connection.cursor() try: for single_query in queries: single_query, args, _, _ = self._compile(single_query) await cursor.execute(single_query, args) finally: cursor.close() async def iterate( self, query: ClauseElement ) -> typing.AsyncGenerator[typing.Any, None]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) metadata = CursorResultMetaData(context, cursor.description) async for row in cursor: record = Row( metadata, metadata._processors, metadata._keymap, row, ) yield Record(record, result_columns, dialect, column_maps) finally: cursor.close() def transaction(self) -> TransactionBackend: return AiopgTransaction(self) def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]: compiled = query.compile( dialect=self._dialect, compile_kwargs={"render_postcompile": True} ) execution_context = self._dialect.execution_ctx_cls() execution_context.dialect = self._dialect if not isinstance(query, DDLElement): compiled_params = sorted(compiled.params.items()) args = compiled.construct_params() for key, val in args.items(): if key in compiled._bind_processors: args[key] = compiled._bind_processors[key](val) execution_context.result_column_struct = ( compiled._result_columns, compiled._ordered_columns, compiled._textual_ordered_columns, compiled._ad_hoc_textual, compiled._loose_column_name_matching, ) mapping = { key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1) } compiled_query = compiled.string % mapping result_map = compiled._result_columns else: args = {} result_map = None compiled_query = compiled.string query_message = compiled_query.replace(" \n", " ").replace("\n", " ") logger.debug( "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA ) return compiled.string, args, result_map, CompilationContext(execution_context) @property def raw_connection(self) -> aiopg.connection.Connection: assert self._connection is not None, "Connection is not acquired" return self._connection class AiopgTransaction(TransactionBackend): def __init__(self, connection: AiopgConnection): self._connection = connection self._is_root = False self._savepoint_name = "" async def start( self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any] ) -> None: assert self._connection._connection is not None, "Connection is not acquired" self._is_root = is_root cursor = await self._connection._connection.cursor() if self._is_root: await cursor.execute("BEGIN") else: id = str(uuid.uuid4()).replace("-", "_") self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}" try: await cursor.execute(f"SAVEPOINT {self._savepoint_name}") finally: cursor.close() async def commit(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" cursor = await self._connection._connection.cursor() if self._is_root: await cursor.execute("COMMIT") else: try: await cursor.execute(f"RELEASE SAVEPOINT {self._savepoint_name}") finally: cursor.close() async def rollback(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" cursor = await self._connection._connection.cursor() if self._is_root: await cursor.execute("ROLLBACK") else: try: await cursor.execute(f"ROLLBACK TO SAVEPOINT {self._savepoint_name}") finally: cursor.close() ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/asyncmy.py 0000644 0001751 0000177 00000026266 00000000000 022027 0 ustar 00runner docker 0000000 0000000 import getpass import logging import typing import uuid import asyncmy from sqlalchemy.dialects.mysql import pymysql from sqlalchemy.engine.cursor import CursorResultMetaData from sqlalchemy.engine.interfaces import Dialect, ExecutionContext from sqlalchemy.sql import ClauseElement from sqlalchemy.sql.ddl import DDLElement from databases.backends.common.records import Record, Row, create_column_maps from databases.core import LOG_EXTRA, DatabaseURL from databases.interfaces import ( ConnectionBackend, DatabaseBackend, Record as RecordInterface, TransactionBackend, ) logger = logging.getLogger("databases") class AsyncMyBackend(DatabaseBackend): def __init__( self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any ) -> None: self._database_url = DatabaseURL(database_url) self._options = options self._dialect = pymysql.dialect(paramstyle="pyformat") self._dialect.supports_native_decimal = True self._pool = None def _get_connection_kwargs(self) -> dict: url_options = self._database_url.options kwargs = {} min_size = url_options.get("min_size") max_size = url_options.get("max_size") pool_recycle = url_options.get("pool_recycle") ssl = url_options.get("ssl") unix_socket = url_options.get("unix_socket") if min_size is not None: kwargs["minsize"] = int(min_size) if max_size is not None: kwargs["maxsize"] = int(max_size) if pool_recycle is not None: kwargs["pool_recycle"] = int(pool_recycle) if ssl is not None: kwargs["ssl"] = {"true": True, "false": False}[ssl.lower()] if unix_socket is not None: kwargs["unix_socket"] = unix_socket for key, value in self._options.items(): # Coerce 'min_size' and 'max_size' for consistency. if key == "min_size": key = "minsize" elif key == "max_size": key = "maxsize" kwargs[key] = value return kwargs async def connect(self) -> None: assert self._pool is None, "DatabaseBackend is already running" kwargs = self._get_connection_kwargs() self._pool = await asyncmy.create_pool( host=self._database_url.hostname, port=self._database_url.port or 3306, user=self._database_url.username or getpass.getuser(), password=self._database_url.password, db=self._database_url.database, autocommit=True, **kwargs, ) async def disconnect(self) -> None: assert self._pool is not None, "DatabaseBackend is not running" self._pool.close() await self._pool.wait_closed() self._pool = None def connection(self) -> "AsyncMyConnection": return AsyncMyConnection(self, self._dialect) class CompilationContext: def __init__(self, context: ExecutionContext): self.context = context class AsyncMyConnection(ConnectionBackend): def __init__(self, database: AsyncMyBackend, dialect: Dialect): self._database = database self._dialect = dialect self._connection: typing.Optional[asyncmy.Connection] = None async def acquire(self) -> None: assert self._connection is None, "Connection is already acquired" assert self._database._pool is not None, "DatabaseBackend is not running" self._connection = await self._database._pool.acquire() async def release(self) -> None: assert self._connection is not None, "Connection is not acquired" assert self._database._pool is not None, "DatabaseBackend is not running" await self._database._pool.release(self._connection) self._connection = None async def fetch_all(self, query: ClauseElement) -> typing.List[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.cursor() as cursor: try: await cursor.execute(query_str, args) rows = await cursor.fetchall() metadata = CursorResultMetaData(context, cursor.description) rows = [ Row( metadata, metadata._processors, metadata._keymap, row, ) for row in rows ] return [ Record(row, result_columns, dialect, column_maps) for row in rows ] finally: await cursor.close() async def fetch_one(self, query: ClauseElement) -> typing.Optional[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.cursor() as cursor: try: await cursor.execute(query_str, args) row = await cursor.fetchone() if row is None: return None metadata = CursorResultMetaData(context, cursor.description) row = Row( metadata, metadata._processors, metadata._keymap, row, ) return Record(row, result_columns, dialect, column_maps) finally: await cursor.close() async def execute(self, query: ClauseElement) -> typing.Any: assert self._connection is not None, "Connection is not acquired" query_str, args, _, _ = self._compile(query) async with self._connection.cursor() as cursor: try: await cursor.execute(query_str, args) if cursor.lastrowid == 0: return cursor.rowcount return cursor.lastrowid finally: await cursor.close() async def execute_many(self, queries: typing.List[ClauseElement]) -> None: assert self._connection is not None, "Connection is not acquired" async with self._connection.cursor() as cursor: try: for single_query in queries: single_query, args, _, _ = self._compile(single_query) await cursor.execute(single_query, args) finally: await cursor.close() async def iterate( self, query: ClauseElement ) -> typing.AsyncGenerator[typing.Any, None]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.cursor() as cursor: try: await cursor.execute(query_str, args) metadata = CursorResultMetaData(context, cursor.description) async for row in cursor: record = Row( metadata, metadata._processors, metadata._keymap, row, ) yield Record(record, result_columns, dialect, column_maps) finally: await cursor.close() def transaction(self) -> TransactionBackend: return AsyncMyTransaction(self) def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]: compiled = query.compile( dialect=self._dialect, compile_kwargs={"render_postcompile": True} ) execution_context = self._dialect.execution_ctx_cls() execution_context.dialect = self._dialect if not isinstance(query, DDLElement): compiled_params = sorted(compiled.params.items()) args = compiled.construct_params() for key, val in args.items(): if key in compiled._bind_processors: args[key] = compiled._bind_processors[key](val) execution_context.result_column_struct = ( compiled._result_columns, compiled._ordered_columns, compiled._textual_ordered_columns, compiled._ad_hoc_textual, compiled._loose_column_name_matching, ) mapping = { key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1) } compiled_query = compiled.string % mapping result_map = compiled._result_columns else: args = {} result_map = None compiled_query = compiled.string query_message = compiled_query.replace(" \n", " ").replace("\n", " ") logger.debug( "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA ) return compiled.string, args, result_map, CompilationContext(execution_context) @property def raw_connection(self) -> asyncmy.connection.Connection: assert self._connection is not None, "Connection is not acquired" return self._connection class AsyncMyTransaction(TransactionBackend): def __init__(self, connection: AsyncMyConnection): self._connection = connection self._is_root = False self._savepoint_name = "" async def start( self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any] ) -> None: assert self._connection._connection is not None, "Connection is not acquired" self._is_root = is_root if self._is_root: await self._connection._connection.begin() else: id = str(uuid.uuid4()).replace("-", "_") self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}" async with self._connection._connection.cursor() as cursor: try: await cursor.execute(f"SAVEPOINT {self._savepoint_name}") finally: await cursor.close() async def commit(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: await self._connection._connection.commit() else: async with self._connection._connection.cursor() as cursor: try: await cursor.execute(f"RELEASE SAVEPOINT {self._savepoint_name}") finally: await cursor.close() async def rollback(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: await self._connection._connection.rollback() else: async with self._connection._connection.cursor() as cursor: try: await cursor.execute( f"ROLLBACK TO SAVEPOINT {self._savepoint_name}" ) finally: await cursor.close() ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9480538 databases-0.9.0/databases/backends/common/ 0000755 0001751 0000177 00000000000 00000000000 021246 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/common/__init__.py 0000644 0001751 0000177 00000000000 00000000000 023345 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/common/records.py 0000644 0001751 0000177 00000010464 00000000000 023266 0 ustar 00runner docker 0000000 0000000 import enum import typing from datetime import date, datetime, time from sqlalchemy.engine.interfaces import Dialect from sqlalchemy.engine.row import Row as SQLRow from sqlalchemy.sql.compiler import _CompileLabel from sqlalchemy.sql.schema import Column from sqlalchemy.sql.sqltypes import JSON from sqlalchemy.types import TypeEngine from databases.interfaces import Record as RecordInterface DIALECT_EXCLUDE = {"postgresql"} class Record(RecordInterface): __slots__ = ( "_row", "_result_columns", "_dialect", "_column_map", "_column_map_int", "_column_map_full", ) def __init__( self, row: typing.Any, result_columns: tuple, dialect: Dialect, column_maps: typing.Tuple[ typing.Mapping[typing.Any, typing.Tuple[int, TypeEngine]], typing.Mapping[int, typing.Tuple[int, TypeEngine]], typing.Mapping[str, typing.Tuple[int, TypeEngine]], ], ) -> None: self._row = row self._result_columns = result_columns self._dialect = dialect self._column_map, self._column_map_int, self._column_map_full = column_maps @property def _mapping(self) -> typing.Mapping: return self._row def keys(self) -> typing.KeysView: return self._mapping.keys() def values(self) -> typing.ValuesView: return self._mapping.values() def __getitem__(self, key: typing.Any) -> typing.Any: if len(self._column_map) == 0: return self._row[key] elif isinstance(key, Column): idx, datatype = self._column_map_full[str(key)] elif isinstance(key, int): idx, datatype = self._column_map_int[key] else: idx, datatype = self._column_map[key] raw = self._row[idx] processor = datatype._cached_result_processor(self._dialect, None) if self._dialect.name in DIALECT_EXCLUDE: if processor is not None and isinstance(raw, (int, str, float)): return processor(raw) return raw def __iter__(self) -> typing.Iterator: return iter(self._row.keys()) def __len__(self) -> int: return len(self._row) def __getattr__(self, name: str) -> typing.Any: try: return self.__getitem__(name) except KeyError as e: raise AttributeError(e.args[0]) from e class Row(SQLRow): def __getitem__(self, key: typing.Any) -> typing.Any: """ An instance of a Row in SQLAlchemy allows the access to the Row._fields as tuple and the Row._mapping for the values. """ if isinstance(key, int): return super().__getitem__(key) idx = self._key_to_index[key][0] return super().__getitem__(idx) def keys(self): return self._mapping.keys() def values(self): return self._mapping.values() def create_column_maps( result_columns: typing.Any, ) -> typing.Tuple[ typing.Mapping[typing.Any, typing.Tuple[int, TypeEngine]], typing.Mapping[int, typing.Tuple[int, TypeEngine]], typing.Mapping[str, typing.Tuple[int, TypeEngine]], ]: """ Generate column -> datatype mappings from the column definitions. These mappings are used throughout PostgresConnection methods to initialize Record-s. The underlying DB driver does not do type conversion for us so we have wrap the returned asyncpg.Record-s. :return: Three mappings from different ways to address a column to \ corresponding column indexes and datatypes: \ 1. by column identifier; \ 2. by column index; \ 3. by column name in Column sqlalchemy objects. """ column_map, column_map_int, column_map_full = {}, {}, {} for idx, (column_name, _, column, datatype) in enumerate(result_columns): column_map[column_name] = (idx, datatype) column_map_int[idx] = (idx, datatype) # Added in SQLA 2.0 and _CompileLabels do not have _annotations # When this happens, the mapping is on the second position if isinstance(column[0], _CompileLabel): column_map_full[str(column[2])] = (idx, datatype) else: column_map_full[str(column[0])] = (idx, datatype) return column_map, column_map_int, column_map_full ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9520538 databases-0.9.0/databases/backends/compilers/ 0000755 0001751 0000177 00000000000 00000000000 021753 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/compilers/__init__.py 0000644 0001751 0000177 00000000000 00000000000 024052 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/compilers/psycopg.py 0000644 0001751 0000177 00000000772 00000000000 024017 0 ustar 00runner docker 0000000 0000000 from sqlalchemy.dialects.postgresql.psycopg import PGCompiler_psycopg class APGCompiler_psycopg2(PGCompiler_psycopg): def construct_params(self, *args, **kwargs): pd = super().construct_params(*args, **kwargs) for column in self.prefetch: pd[column.key] = self._exec_default(column.default) return pd def _exec_default(self, default): if default.is_callable: return default.arg(self.dialect) else: return default.arg ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9520538 databases-0.9.0/databases/backends/dialects/ 0000755 0001751 0000177 00000000000 00000000000 021546 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/dialects/__init__.py 0000644 0001751 0000177 00000000000 00000000000 023645 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/dialects/psycopg.py 0000644 0001751 0000177 00000002216 00000000000 023605 0 ustar 00runner docker 0000000 0000000 """ All the unique changes for the databases package with the custom Numeric as the deprecated pypostgresql for backwards compatibility and to make sure the package can go to SQLAlchemy 2.0+. """ import typing from sqlalchemy import types, util from sqlalchemy.dialects.postgresql.base import PGDialect, PGExecutionContext from sqlalchemy.engine import processors from sqlalchemy.types import Float, Numeric class PGExecutionContext_psycopg(PGExecutionContext): ... class PGNumeric(Numeric): def bind_processor( self, dialect: typing.Any ) -> typing.Union[str, None]: # pragma: no cover return processors.to_str def result_processor( self, dialect: typing.Any, coltype: typing.Any ) -> typing.Union[float, None]: # pragma: no cover if self.asdecimal: return None else: return processors.to_float class PGDialect_psycopg(PGDialect): colspecs = util.update_copy( PGDialect.colspecs, { types.Numeric: PGNumeric, types.Float: Float, }, ) execution_ctx_cls = PGExecutionContext_psycopg dialect = PGDialect_psycopg ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/mysql.py 0000644 0001751 0000177 00000025411 00000000000 021500 0 ustar 00runner docker 0000000 0000000 import getpass import logging import typing import uuid import aiomysql from sqlalchemy.dialects.mysql import pymysql from sqlalchemy.engine.cursor import CursorResultMetaData from sqlalchemy.engine.interfaces import Dialect, ExecutionContext from sqlalchemy.sql import ClauseElement from sqlalchemy.sql.ddl import DDLElement from databases.backends.common.records import Record, Row, create_column_maps from databases.core import LOG_EXTRA, DatabaseURL from databases.interfaces import ( ConnectionBackend, DatabaseBackend, Record as RecordInterface, TransactionBackend, ) logger = logging.getLogger("databases") class MySQLBackend(DatabaseBackend): def __init__( self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any ) -> None: self._database_url = DatabaseURL(database_url) self._options = options self._dialect = pymysql.dialect(paramstyle="pyformat") self._dialect.supports_native_decimal = True self._pool = None def _get_connection_kwargs(self) -> dict: url_options = self._database_url.options kwargs = {} min_size = url_options.get("min_size") max_size = url_options.get("max_size") pool_recycle = url_options.get("pool_recycle") ssl = url_options.get("ssl") unix_socket = url_options.get("unix_socket") if min_size is not None: kwargs["minsize"] = int(min_size) if max_size is not None: kwargs["maxsize"] = int(max_size) if pool_recycle is not None: kwargs["pool_recycle"] = int(pool_recycle) if ssl is not None: kwargs["ssl"] = {"true": True, "false": False}[ssl.lower()] if unix_socket is not None: kwargs["unix_socket"] = unix_socket for key, value in self._options.items(): # Coerce 'min_size' and 'max_size' for consistency. if key == "min_size": key = "minsize" elif key == "max_size": key = "maxsize" kwargs[key] = value return kwargs async def connect(self) -> None: assert self._pool is None, "DatabaseBackend is already running" kwargs = self._get_connection_kwargs() self._pool = await aiomysql.create_pool( host=self._database_url.hostname, port=self._database_url.port or 3306, user=self._database_url.username or getpass.getuser(), password=self._database_url.password, db=self._database_url.database, autocommit=True, **kwargs, ) async def disconnect(self) -> None: assert self._pool is not None, "DatabaseBackend is not running" self._pool.close() await self._pool.wait_closed() self._pool = None def connection(self) -> "MySQLConnection": return MySQLConnection(self, self._dialect) class CompilationContext: def __init__(self, context: ExecutionContext): self.context = context class MySQLConnection(ConnectionBackend): def __init__(self, database: MySQLBackend, dialect: Dialect): self._database = database self._dialect = dialect self._connection: typing.Optional[aiomysql.Connection] = None async def acquire(self) -> None: assert self._connection is None, "Connection is already acquired" assert self._database._pool is not None, "DatabaseBackend is not running" self._connection = await self._database._pool.acquire() async def release(self) -> None: assert self._connection is not None, "Connection is not acquired" assert self._database._pool is not None, "DatabaseBackend is not running" await self._database._pool.release(self._connection) self._connection = None async def fetch_all(self, query: ClauseElement) -> typing.List[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) rows = await cursor.fetchall() metadata = CursorResultMetaData(context, cursor.description) rows = [ Row( metadata, metadata._processors, metadata._keymap, row, ) for row in rows ] return [Record(row, result_columns, dialect, column_maps) for row in rows] finally: await cursor.close() async def fetch_one(self, query: ClauseElement) -> typing.Optional[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) row = await cursor.fetchone() if row is None: return None metadata = CursorResultMetaData(context, cursor.description) row = Row( metadata, metadata._processors, metadata._keymap, row, ) return Record(row, result_columns, dialect, column_maps) finally: await cursor.close() async def execute(self, query: ClauseElement) -> typing.Any: assert self._connection is not None, "Connection is not acquired" query_str, args, _, _ = self._compile(query) cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) if cursor.lastrowid == 0: return cursor.rowcount return cursor.lastrowid finally: await cursor.close() async def execute_many(self, queries: typing.List[ClauseElement]) -> None: assert self._connection is not None, "Connection is not acquired" cursor = await self._connection.cursor() try: for single_query in queries: single_query, args, _, _ = self._compile(single_query) await cursor.execute(single_query, args) finally: await cursor.close() async def iterate( self, query: ClauseElement ) -> typing.AsyncGenerator[typing.Any, None]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect cursor = await self._connection.cursor() try: await cursor.execute(query_str, args) metadata = CursorResultMetaData(context, cursor.description) async for row in cursor: record = Row( metadata, metadata._processors, metadata._keymap, row, ) yield Record(record, result_columns, dialect, column_maps) finally: await cursor.close() def transaction(self) -> TransactionBackend: return MySQLTransaction(self) def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]: compiled = query.compile( dialect=self._dialect, compile_kwargs={"render_postcompile": True} ) execution_context = self._dialect.execution_ctx_cls() execution_context.dialect = self._dialect if not isinstance(query, DDLElement): compiled_params = sorted(compiled.params.items()) args = compiled.construct_params() for key, val in args.items(): if key in compiled._bind_processors: args[key] = compiled._bind_processors[key](val) execution_context.result_column_struct = ( compiled._result_columns, compiled._ordered_columns, compiled._textual_ordered_columns, compiled._ad_hoc_textual, compiled._loose_column_name_matching, ) mapping = { key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1) } compiled_query = compiled.string % mapping result_map = compiled._result_columns else: args = {} result_map = None compiled_query = compiled.string query_message = compiled_query.replace(" \n", " ").replace("\n", " ") logger.debug( "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA ) return compiled.string, args, result_map, CompilationContext(execution_context) @property def raw_connection(self) -> aiomysql.connection.Connection: assert self._connection is not None, "Connection is not acquired" return self._connection class MySQLTransaction(TransactionBackend): def __init__(self, connection: MySQLConnection): self._connection = connection self._is_root = False self._savepoint_name = "" async def start( self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any] ) -> None: assert self._connection._connection is not None, "Connection is not acquired" self._is_root = is_root if self._is_root: await self._connection._connection.begin() else: id = str(uuid.uuid4()).replace("-", "_") self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}" cursor = await self._connection._connection.cursor() try: await cursor.execute(f"SAVEPOINT {self._savepoint_name}") finally: await cursor.close() async def commit(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: await self._connection._connection.commit() else: cursor = await self._connection._connection.cursor() try: await cursor.execute(f"RELEASE SAVEPOINT {self._savepoint_name}") finally: await cursor.close() async def rollback(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: await self._connection._connection.rollback() else: cursor = await self._connection._connection.cursor() try: await cursor.execute(f"ROLLBACK TO SAVEPOINT {self._savepoint_name}") finally: await cursor.close() ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/postgres.py 0000644 0001751 0000177 00000020431 00000000000 022176 0 ustar 00runner docker 0000000 0000000 import logging import typing import asyncpg from sqlalchemy.engine.interfaces import Dialect from sqlalchemy.sql import ClauseElement from sqlalchemy.sql.ddl import DDLElement from databases.backends.common.records import Record, create_column_maps from databases.backends.dialects.psycopg import dialect as psycopg_dialect from databases.core import LOG_EXTRA, DatabaseURL from databases.interfaces import ( ConnectionBackend, DatabaseBackend, Record as RecordInterface, TransactionBackend, ) logger = logging.getLogger("databases") class PostgresBackend(DatabaseBackend): def __init__( self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any ) -> None: self._database_url = DatabaseURL(database_url) self._options = options self._dialect = self._get_dialect() self._pool = None def _get_dialect(self) -> Dialect: dialect = psycopg_dialect(paramstyle="pyformat") dialect.implicit_returning = True dialect.supports_native_enum = True dialect.supports_smallserial = True # 9.2+ dialect._backslash_escapes = False dialect.supports_sane_multi_rowcount = True # psycopg 2.0.9+ dialect._has_native_hstore = True dialect.supports_native_decimal = True return dialect def _get_connection_kwargs(self) -> dict: url_options = self._database_url.options kwargs: typing.Dict[str, typing.Any] = {} min_size = url_options.get("min_size") max_size = url_options.get("max_size") ssl = url_options.get("ssl") if min_size is not None: kwargs["min_size"] = int(min_size) if max_size is not None: kwargs["max_size"] = int(max_size) if ssl is not None: ssl = ssl.lower() kwargs["ssl"] = {"true": True, "false": False}.get(ssl, ssl) kwargs.update(self._options) return kwargs async def connect(self) -> None: assert self._pool is None, "DatabaseBackend is already running" kwargs = dict( host=self._database_url.hostname, port=self._database_url.port, user=self._database_url.username, password=self._database_url.password, database=self._database_url.database, ) kwargs.update(self._get_connection_kwargs()) self._pool = await asyncpg.create_pool(**kwargs) async def disconnect(self) -> None: assert self._pool is not None, "DatabaseBackend is not running" await self._pool.close() self._pool = None def connection(self) -> "PostgresConnection": return PostgresConnection(self, self._dialect) class PostgresConnection(ConnectionBackend): def __init__(self, database: PostgresBackend, dialect: Dialect): self._database = database self._dialect = dialect self._connection: typing.Optional[asyncpg.connection.Connection] = None async def acquire(self) -> None: assert self._connection is None, "Connection is already acquired" assert self._database._pool is not None, "DatabaseBackend is not running" self._connection = await self._database._pool.acquire() async def release(self) -> None: assert self._connection is not None, "Connection is not acquired" assert self._database._pool is not None, "DatabaseBackend is not running" self._connection = await self._database._pool.release(self._connection) self._connection = None async def fetch_all(self, query: ClauseElement) -> typing.List[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns = self._compile(query) rows = await self._connection.fetch(query_str, *args) dialect = self._dialect column_maps = create_column_maps(result_columns) return [Record(row, result_columns, dialect, column_maps) for row in rows] async def fetch_one(self, query: ClauseElement) -> typing.Optional[RecordInterface]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns = self._compile(query) row = await self._connection.fetchrow(query_str, *args) if row is None: return None return Record( row, result_columns, self._dialect, create_column_maps(result_columns), ) async def fetch_val( self, query: ClauseElement, column: typing.Any = 0 ) -> typing.Any: # we are not calling self._connection.fetchval here because # it does not convert all the types, e.g. JSON stays string # instead of an object # see also: # https://github.com/encode/databases/pull/131 # https://github.com/encode/databases/pull/132 # https://github.com/encode/databases/pull/246 row = await self.fetch_one(query) if row is None: return None return row[column] async def execute(self, query: ClauseElement) -> typing.Any: assert self._connection is not None, "Connection is not acquired" query_str, args, _ = self._compile(query) return await self._connection.fetchval(query_str, *args) async def execute_many(self, queries: typing.List[ClauseElement]) -> 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 single_query in queries: single_query, args, _ = self._compile(single_query) await self._connection.execute(single_query, *args) async def iterate( self, query: ClauseElement ) -> typing.AsyncGenerator[typing.Any, None]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns = self._compile(query) column_maps = create_column_maps(result_columns) async for row in self._connection.cursor(query_str, *args): yield Record(row, result_columns, self._dialect, column_maps) def transaction(self) -> TransactionBackend: return PostgresTransaction(connection=self) def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]: compiled = query.compile( dialect=self._dialect, compile_kwargs={"render_postcompile": True} ) if not isinstance(query, DDLElement): compiled_params = sorted(compiled.params.items()) mapping = { key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1) } compiled_query = compiled.string % mapping processors = compiled._bind_processors args = [ processors[key](val) if key in processors else val for key, val in compiled_params ] result_map = compiled._result_columns else: compiled_query = compiled.string args = [] result_map = None query_message = compiled_query.replace(" \n", " ").replace("\n", " ") logger.debug( "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA ) return compiled_query, args, result_map @property def raw_connection(self) -> asyncpg.connection.Connection: assert self._connection is not None, "Connection is not acquired" return self._connection class PostgresTransaction(TransactionBackend): def __init__(self, connection: PostgresConnection): self._connection = connection self._transaction: typing.Optional[asyncpg.transaction.Transaction] = None async def start( self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any] ) -> None: assert self._connection._connection is not None, "Connection is not acquired" self._transaction = self._connection._connection.transaction(**extra_options) await self._transaction.start() async def commit(self) -> None: assert self._transaction is not None await self._transaction.commit() async def rollback(self) -> None: assert self._transaction is not None await self._transaction.rollback() ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/backends/sqlite.py 0000644 0001751 0000177 00000023617 00000000000 021642 0 ustar 00runner docker 0000000 0000000 import logging import sqlite3 import typing import uuid from urllib.parse import urlencode import aiosqlite from sqlalchemy.dialects.sqlite import pysqlite from sqlalchemy.engine.cursor import CursorResultMetaData from sqlalchemy.engine.interfaces import Dialect, ExecutionContext from sqlalchemy.sql import ClauseElement from sqlalchemy.sql.ddl import DDLElement from databases.backends.common.records import Record, Row, create_column_maps from databases.core import LOG_EXTRA, DatabaseURL from databases.interfaces import ConnectionBackend, DatabaseBackend, TransactionBackend logger = logging.getLogger("databases") class SQLiteBackend(DatabaseBackend): def __init__( self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any ) -> None: self._database_url = DatabaseURL(database_url) self._options = options self._dialect = pysqlite.dialect(paramstyle="qmark") # aiosqlite does not support decimals self._dialect.supports_native_decimal = False self._pool = SQLitePool(self._database_url, **self._options) async def connect(self) -> None: ... async def disconnect(self) -> None: # if it extsis, remove reference to connection to cached in-memory database on disconnect if self._pool._memref: self._pool._memref = None # assert self._pool is not None, "DatabaseBackend is not running" # self._pool.close() # await self._pool.wait_closed() # self._pool = None def connection(self) -> "SQLiteConnection": return SQLiteConnection(self._pool, self._dialect) class SQLitePool: def __init__(self, url: DatabaseURL, **options: typing.Any) -> None: self._database = url.database self._memref = None # add query params to database connection string if url.options: self._database += "?" + urlencode(url.options) self._options = options if url.options and "cache" in url.options: # reference to a connection to the cached in-memory database must be held to keep it from being deleted self._memref = sqlite3.connect(self._database, **self._options) async def acquire(self) -> aiosqlite.Connection: connection = aiosqlite.connect( database=self._database, isolation_level=None, **self._options ) await connection.__aenter__() return connection async def release(self, connection: aiosqlite.Connection) -> None: await connection.__aexit__(None, None, None) class CompilationContext: def __init__(self, context: ExecutionContext): self.context = context class SQLiteConnection(ConnectionBackend): def __init__(self, pool: SQLitePool, dialect: Dialect): self._pool = pool self._dialect = dialect self._connection: typing.Optional[aiosqlite.Connection] = None async def acquire(self) -> None: assert self._connection is None, "Connection is already acquired" self._connection = await self._pool.acquire() async def release(self) -> None: assert self._connection is not None, "Connection is not acquired" await self._pool.release(self._connection) self._connection = None async def fetch_all(self, query: ClauseElement) -> typing.List[Record]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.execute(query_str, args) as cursor: rows = await cursor.fetchall() metadata = CursorResultMetaData(context, cursor.description) rows = [ Row( metadata, metadata._processors, metadata._keymap, row, ) for row in rows ] return [Record(row, result_columns, dialect, column_maps) for row in rows] async def fetch_one(self, query: ClauseElement) -> typing.Optional[Record]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.execute(query_str, args) as cursor: row = await cursor.fetchone() if row is None: return None metadata = CursorResultMetaData(context, cursor.description) row = Row( metadata, metadata._processors, metadata._keymap, row, ) return Record(row, result_columns, dialect, column_maps) async def execute(self, query: ClauseElement) -> typing.Any: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) async with self._connection.cursor() as cursor: await cursor.execute(query_str, args) if cursor.lastrowid == 0: return cursor.rowcount return cursor.lastrowid async def execute_many(self, queries: typing.List[ClauseElement]) -> None: assert self._connection is not None, "Connection is not acquired" for single_query in queries: await self.execute(single_query) async def iterate( self, query: ClauseElement ) -> typing.AsyncGenerator[typing.Any, None]: assert self._connection is not None, "Connection is not acquired" query_str, args, result_columns, context = self._compile(query) column_maps = create_column_maps(result_columns) dialect = self._dialect async with self._connection.execute(query_str, args) as cursor: metadata = CursorResultMetaData(context, cursor.description) async for row in cursor: record = Row( metadata, metadata._processors, metadata._keymap, row, ) yield Record(record, result_columns, dialect, column_maps) def transaction(self) -> TransactionBackend: return SQLiteTransaction(self) def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]: compiled = query.compile( dialect=self._dialect, compile_kwargs={"render_postcompile": True} ) execution_context = self._dialect.execution_ctx_cls() execution_context.dialect = self._dialect args = [] result_map = None if not isinstance(query, DDLElement): compiled_params = sorted(compiled.params.items()) params = compiled.construct_params() for key in compiled.positiontup: raw_val = params[key] if key in compiled._bind_processors: val = compiled._bind_processors[key](raw_val) else: val = raw_val args.append(val) execution_context.result_column_struct = ( compiled._result_columns, compiled._ordered_columns, compiled._textual_ordered_columns, compiled._ad_hoc_textual, compiled._loose_column_name_matching, ) mapping = { key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1) } compiled_query = compiled.string % mapping result_map = compiled._result_columns else: compiled_query = compiled.string query_message = compiled_query.replace(" \n", " ").replace("\n", " ") logger.debug( "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA ) return compiled.string, args, result_map, CompilationContext(execution_context) @property def raw_connection(self) -> aiosqlite.core.Connection: assert self._connection is not None, "Connection is not acquired" return self._connection class SQLiteTransaction(TransactionBackend): def __init__(self, connection: SQLiteConnection): self._connection = connection self._is_root = False self._savepoint_name = "" async def start( self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any] ) -> None: assert self._connection._connection is not None, "Connection is not acquired" self._is_root = is_root if self._is_root: async with self._connection._connection.execute("BEGIN") as cursor: await cursor.close() else: id = str(uuid.uuid4()).replace("-", "_") self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}" async with self._connection._connection.execute( f"SAVEPOINT {self._savepoint_name}" ) as cursor: await cursor.close() async def commit(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: async with self._connection._connection.execute("COMMIT") as cursor: await cursor.close() else: async with self._connection._connection.execute( f"RELEASE SAVEPOINT {self._savepoint_name}" ) as cursor: await cursor.close() async def rollback(self) -> None: assert self._connection._connection is not None, "Connection is not acquired" if self._is_root: async with self._connection._connection.execute("ROLLBACK") as cursor: await cursor.close() else: async with self._connection._connection.execute( f"ROLLBACK TO SAVEPOINT {self._savepoint_name}" ) as cursor: await cursor.close() ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/core.py 0000644 0001751 0000177 00000047460 00000000000 017521 0 ustar 00runner docker 0000000 0000000 import asyncio import contextlib import functools import logging import typing import weakref from contextvars import ContextVar from types import TracebackType from urllib.parse import SplitResult, parse_qsl, unquote, urlsplit from sqlalchemy import text from sqlalchemy.sql import ClauseElement from databases.importer import import_from_string from databases.interfaces import DatabaseBackend, Record, TransactionBackend try: # pragma: no cover import click # Extra log info for optional coloured terminal outputs. LOG_EXTRA = { "color_message": "Query: " + click.style("%s", bold=True) + " Args: %s" } CONNECT_EXTRA = { "color_message": "Connected to database " + click.style("%s", bold=True) } DISCONNECT_EXTRA = { "color_message": "Disconnected from database " + click.style("%s", bold=True) } except ImportError: # pragma: no cover LOG_EXTRA = {} CONNECT_EXTRA = {} DISCONNECT_EXTRA = {} logger = logging.getLogger("databases") _ACTIVE_TRANSACTIONS: ContextVar[ typing.Optional["weakref.WeakKeyDictionary['Transaction', 'TransactionBackend']"] ] = ContextVar("databases:active_transactions", default=None) class Database: SUPPORTED_BACKENDS = { "postgresql": "databases.backends.postgres:PostgresBackend", "postgresql+aiopg": "databases.backends.aiopg:AiopgBackend", "postgres": "databases.backends.postgres:PostgresBackend", "mysql": "databases.backends.mysql:MySQLBackend", "mysql+asyncmy": "databases.backends.asyncmy:AsyncMyBackend", "sqlite": "databases.backends.sqlite:SQLiteBackend", } _connection_map: "weakref.WeakKeyDictionary[asyncio.Task, 'Connection']" def __init__( self, url: typing.Union[str, "DatabaseURL"], *, force_rollback: bool = False, **options: typing.Any, ): self.url = DatabaseURL(url) self.options = options self.is_connected = False self._connection_map = weakref.WeakKeyDictionary() self._force_rollback = force_rollback backend_str = self._get_backend() backend_cls = import_from_string(backend_str) assert issubclass(backend_cls, DatabaseBackend) self._backend = backend_cls(self.url, **self.options) # When `force_rollback=True` is used, we use a single global # connection, within a transaction that always rolls back. self._global_connection: typing.Optional[Connection] = None self._global_transaction: typing.Optional[Transaction] = None @property def _current_task(self) -> asyncio.Task: task = asyncio.current_task() if not task: raise RuntimeError("No currently active asyncio.Task found") return task @property def _connection(self) -> typing.Optional["Connection"]: return self._connection_map.get(self._current_task) @_connection.setter def _connection( self, connection: typing.Optional["Connection"] ) -> typing.Optional["Connection"]: task = self._current_task if connection is None: self._connection_map.pop(task, None) else: self._connection_map[task] = connection return self._connection async def connect(self) -> None: """ Establish the connection pool. """ if self.is_connected: logger.debug("Already connected, skipping connection") return None await self._backend.connect() logger.info( "Connected to database %s", self.url.obscure_password, extra=CONNECT_EXTRA ) self.is_connected = True if self._force_rollback: assert self._global_connection is None assert self._global_transaction is None self._global_connection = Connection(self, self._backend) self._global_transaction = self._global_connection.transaction( force_rollback=True ) await self._global_transaction.__aenter__() async def disconnect(self) -> None: """ Close all connections in the connection pool. """ if not self.is_connected: logger.debug("Already disconnected, skipping disconnection") return None if self._force_rollback: assert self._global_connection is not None assert self._global_transaction is not None await self._global_transaction.__aexit__() self._global_transaction = None self._global_connection = None else: self._connection = None await self._backend.disconnect() logger.info( "Disconnected from database %s", self.url.obscure_password, extra=DISCONNECT_EXTRA, ) self.is_connected = False async def __aenter__(self) -> "Database": await self.connect() return self async def __aexit__( self, exc_type: typing.Optional[typing.Type[BaseException]] = None, exc_value: typing.Optional[BaseException] = None, traceback: typing.Optional[TracebackType] = None, ) -> None: await self.disconnect() async def fetch_all( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.List[Record]: async with self.connection() as connection: return await connection.fetch_all(query, values) async def fetch_one( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.Optional[Record]: async with self.connection() as connection: return await connection.fetch_one(query, values) async def fetch_val( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, column: typing.Any = 0, ) -> typing.Any: async with self.connection() as connection: return await connection.fetch_val(query, values, column=column) async def execute( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.Any: async with self.connection() as connection: return await connection.execute(query, values) async def execute_many( self, query: typing.Union[ClauseElement, str], values: list ) -> None: async with self.connection() as connection: return await connection.execute_many(query, values) async def iterate( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.AsyncGenerator[typing.Mapping, None]: async with self.connection() as connection: async for record in connection.iterate(query, values): yield record def connection(self) -> "Connection": if self._global_connection is not None: return self._global_connection if not self._connection: self._connection = Connection(self, self._backend) return self._connection def transaction( self, *, force_rollback: bool = False, **kwargs: typing.Any ) -> "Transaction": return Transaction(self.connection, force_rollback=force_rollback, **kwargs) @contextlib.contextmanager def force_rollback(self) -> typing.Iterator[None]: initial = self._force_rollback self._force_rollback = True try: yield finally: self._force_rollback = initial def _get_backend(self) -> str: return self.SUPPORTED_BACKENDS.get( self.url.scheme, self.SUPPORTED_BACKENDS[self.url.dialect] ) class Connection: def __init__(self, database: Database, backend: DatabaseBackend) -> None: self._database = database self._backend = backend self._connection_lock = asyncio.Lock() self._connection = self._backend.connection() self._connection_counter = 0 self._transaction_lock = asyncio.Lock() self._transaction_stack: typing.List[Transaction] = [] self._query_lock = asyncio.Lock() async def __aenter__(self) -> "Connection": async with self._connection_lock: self._connection_counter += 1 try: if self._connection_counter == 1: await self._connection.acquire() except BaseException as e: self._connection_counter -= 1 raise e return self async def __aexit__( self, exc_type: typing.Optional[typing.Type[BaseException]] = None, exc_value: typing.Optional[BaseException] = None, traceback: typing.Optional[TracebackType] = None, ) -> None: async with self._connection_lock: assert self._connection is not None self._connection_counter -= 1 if self._connection_counter == 0: await self._connection.release() self._database._connection = None async def fetch_all( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.List[Record]: built_query = self._build_query(query, values) async with self._query_lock: return await self._connection.fetch_all(built_query) async def fetch_one( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.Optional[Record]: built_query = self._build_query(query, values) async with self._query_lock: return await self._connection.fetch_one(built_query) async def fetch_val( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, column: typing.Any = 0, ) -> typing.Any: built_query = self._build_query(query, values) async with self._query_lock: return await self._connection.fetch_val(built_query, column) async def execute( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.Any: built_query = self._build_query(query, values) async with self._query_lock: return await self._connection.execute(built_query) async def execute_many( self, query: typing.Union[ClauseElement, str], values: list ) -> None: queries = [self._build_query(query, values_set) for values_set in values] async with self._query_lock: await self._connection.execute_many(queries) async def iterate( self, query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None, ) -> typing.AsyncGenerator[typing.Any, None]: built_query = self._build_query(query, values) async with self.transaction(): async with self._query_lock: async for record in self._connection.iterate(built_query): yield record def transaction( self, *, force_rollback: bool = False, **kwargs: typing.Any ) -> "Transaction": def connection_callable() -> Connection: return self return Transaction(connection_callable, force_rollback, **kwargs) @property def raw_connection(self) -> typing.Any: return self._connection.raw_connection @staticmethod def _build_query( query: typing.Union[ClauseElement, str], values: typing.Optional[dict] = None ) -> ClauseElement: if isinstance(query, str): query = text(query) return query.bindparams(**values) if values is not None else query elif values: return query.values(**values) # type: ignore return query _CallableType = typing.TypeVar("_CallableType", bound=typing.Callable) class Transaction: def __init__( self, connection_callable: typing.Callable[[], Connection], force_rollback: bool, **kwargs: typing.Any, ) -> None: self._connection_callable = connection_callable self._force_rollback = force_rollback self._extra_options = kwargs @property def _connection(self) -> "Connection": # Returns the same connection if called multiple times return self._connection_callable() @property def _transaction(self) -> typing.Optional["TransactionBackend"]: transactions = _ACTIVE_TRANSACTIONS.get() if transactions is None: return None return transactions.get(self, None) @_transaction.setter def _transaction( self, transaction: typing.Optional["TransactionBackend"] ) -> typing.Optional["TransactionBackend"]: transactions = _ACTIVE_TRANSACTIONS.get() if transactions is None: transactions = weakref.WeakKeyDictionary() else: transactions = transactions.copy() if transaction is None: transactions.pop(self, None) else: transactions[self] = transaction _ACTIVE_TRANSACTIONS.set(transactions) return transactions.get(self, None) async def __aenter__(self) -> "Transaction": """ Called when entering `async with database.transaction()` """ await self.start() return self async def __aexit__( self, exc_type: typing.Optional[typing.Type[BaseException]] = None, exc_value: typing.Optional[BaseException] = None, traceback: typing.Optional[TracebackType] = None, ) -> None: """ Called when exiting `async with database.transaction()` """ if exc_type is not None or self._force_rollback: await self.rollback() else: await self.commit() def __await__(self) -> typing.Generator[None, None, "Transaction"]: """ Called if using the low-level `transaction = await database.transaction()` """ return self.start().__await__() def __call__(self, func: _CallableType) -> _CallableType: """ Called if using `@database.transaction()` as a decorator. """ @functools.wraps(func) async def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any: async with self: return await func(*args, **kwargs) return wrapper # type: ignore async def start(self) -> "Transaction": self._transaction = self._connection._connection.transaction() async with self._connection._transaction_lock: is_root = not self._connection._transaction_stack await self._connection.__aenter__() await self._transaction.start( is_root=is_root, extra_options=self._extra_options ) self._connection._transaction_stack.append(self) return self async def commit(self) -> None: async with self._connection._transaction_lock: assert self._connection._transaction_stack[-1] is self self._connection._transaction_stack.pop() assert self._transaction is not None await self._transaction.commit() await self._connection.__aexit__() self._transaction = None async def rollback(self) -> None: async with self._connection._transaction_lock: assert self._connection._transaction_stack[-1] is self self._connection._transaction_stack.pop() assert self._transaction is not None await self._transaction.rollback() await self._connection.__aexit__() self._transaction = None class _EmptyNetloc(str): def __bool__(self) -> bool: return True class DatabaseURL: def __init__(self, url: typing.Union[str, "DatabaseURL"]): if isinstance(url, DatabaseURL): self._url: str = url._url elif isinstance(url, str): self._url = url else: raise TypeError( f"Invalid type for DatabaseURL. Expected str or DatabaseURL, got {type(url)}" ) @property def components(self) -> SplitResult: if not hasattr(self, "_components"): self._components = urlsplit(self._url) return self._components @property def scheme(self) -> str: return self.components.scheme @property def dialect(self) -> str: return self.components.scheme.split("+")[0] @property def driver(self) -> str: if "+" not in self.components.scheme: return "" return self.components.scheme.split("+", 1)[1] @property def userinfo(self) -> typing.Optional[bytes]: if self.components.username: info = self.components.username if self.components.password: info += ":" + self.components.password return info.encode("utf-8") return None @property def username(self) -> typing.Optional[str]: if self.components.username is None: return None return unquote(self.components.username) @property def password(self) -> typing.Optional[str]: if self.components.password is None: return None return unquote(self.components.password) @property def hostname(self) -> typing.Optional[str]: return ( self.components.hostname or self.options.get("host") or self.options.get("unix_sock") ) @property def port(self) -> typing.Optional[int]: return self.components.port @property def netloc(self) -> typing.Optional[str]: return self.components.netloc @property def database(self) -> str: path = self.components.path if path.startswith("/"): path = path[1:] return unquote(path) @property def options(self) -> dict: if not hasattr(self, "_options"): self._options = dict(parse_qsl(self.components.query)) return self._options def replace(self, **kwargs: typing.Any) -> "DatabaseURL": if ( "username" in kwargs or "password" in kwargs or "hostname" in kwargs or "port" in kwargs ): hostname = kwargs.pop("hostname", self.hostname) port = kwargs.pop("port", self.port) username = kwargs.pop("username", self.components.username) password = kwargs.pop("password", self.components.password) netloc = hostname if port is not None: netloc += f":{port}" if username is not None: userpass = username if password is not None: userpass += f":{password}" netloc = f"{userpass}@{netloc}" kwargs["netloc"] = netloc if "database" in kwargs: kwargs["path"] = "/" + kwargs.pop("database") if "dialect" in kwargs or "driver" in kwargs: dialect = kwargs.pop("dialect", self.dialect) driver = kwargs.pop("driver", self.driver) kwargs["scheme"] = f"{dialect}+{driver}" if driver else dialect if not kwargs.get("netloc", self.netloc): # Using an empty string that evaluates as True means we end up # with URLs like `sqlite:///database` instead of `sqlite:/database` kwargs["netloc"] = _EmptyNetloc() components = self.components._replace(**kwargs) return self.__class__(components.geturl()) @property def obscure_password(self) -> str: if self.password: return self.replace(password="********")._url return self._url def __str__(self) -> str: return self._url def __repr__(self) -> str: return f"{self.__class__.__name__}({repr(self.obscure_password)})" def __eq__(self, other: typing.Any) -> bool: return str(self) == str(other) ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/databases/importer.py 0000644 0001751 0000177 00000002120 00000000000 020412 0 ustar 00runner docker 0000000 0000000 import importlib import typing class ImportFromStringError(Exception): pass def import_from_string(import_str: str) -> typing.Any: module_str, _, attrs_str = import_str.partition(":") if not module_str or not attrs_str: message = ( 'Import string "{import_str}" must be in format "
— ⭐️ —
Databases is BSD licensed code. Designed & built in Brighton, England.
[sqlalchemy-core]: https://docs.sqlalchemy.org/en/latest/core/ [sqlalchemy-core-tutorial]: https://docs.sqlalchemy.org/en/latest/core/tutorial.html [alembic]: https://alembic.sqlalchemy.org/en/latest/ [psycopg2]: https://www.psycopg.org/ [pymysql]: https://github.com/PyMySQL/PyMySQL [asyncpg]: https://github.com/MagicStack/asyncpg [aiopg]: https://github.com/aio-libs/aiopg [aiomysql]: https://github.com/aio-libs/aiomysql [asyncmy]: https://github.com/long2ice/asyncmy [aiosqlite]: https://github.com/omnilib/aiosqlite [starlette]: https://github.com/encode/starlette [sanic]: https://github.com/huge-success/sanic [responder]: https://github.com/kennethreitz/responder [quart]: https://gitlab.com/pgjones/quart [aiohttp]: https://github.com/aio-libs/aiohttp [tornado]: https://github.com/tornadoweb/tornado [fastapi]: https://github.com/tiangolo/fastapi ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314764.0 databases-0.9.0/databases.egg-info/SOURCES.txt 0000644 0001751 0000177 00000001565 00000000000 021571 0 ustar 00runner docker 0000000 0000000 LICENSE.md README.md setup.cfg setup.py databases/__init__.py databases/core.py databases/importer.py databases/interfaces.py databases/py.typed databases.egg-info/PKG-INFO databases.egg-info/SOURCES.txt databases.egg-info/dependency_links.txt databases.egg-info/not-zip-safe databases.egg-info/requires.txt databases.egg-info/top_level.txt databases/backends/__init__.py databases/backends/aiopg.py databases/backends/asyncmy.py databases/backends/mysql.py databases/backends/postgres.py databases/backends/sqlite.py databases/backends/common/__init__.py databases/backends/common/records.py databases/backends/compilers/__init__.py databases/backends/compilers/psycopg.py databases/backends/dialects/__init__.py databases/backends/dialects/psycopg.py tests/test_connection_options.py tests/test_database_url.py tests/test_databases.py tests/test_importer.py tests/test_integration.py ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314764.0 databases-0.9.0/databases.egg-info/dependency_links.txt 0000644 0001751 0000177 00000000001 00000000000 023744 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314740.0 databases-0.9.0/databases.egg-info/not-zip-safe 0000644 0001751 0000177 00000000001 00000000000 022124 0 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314764.0 databases-0.9.0/databases.egg-info/requires.txt 0000644 0001751 0000177 00000000257 00000000000 022302 0 ustar 00runner docker 0000000 0000000 sqlalchemy>=2.0.7 [aiomysql] aiomysql [aiopg] aiopg [aiosqlite] aiosqlite [asyncmy] asyncmy [asyncpg] asyncpg [mysql] aiomysql [postgresql] asyncpg [sqlite] aiosqlite ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314764.0 databases-0.9.0/databases.egg-info/top_level.txt 0000644 0001751 0000177 00000000160 00000000000 022425 0 ustar 00runner docker 0000000 0000000 databases databases/backends databases/backends/common databases/backends/compilers databases/backends/dialects ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9520538 databases-0.9.0/setup.cfg 0000644 0001751 0000177 00000000576 00000000000 016106 0 ustar 00runner docker 0000000 0000000 [mypy] disallow_untyped_defs = True ignore_missing_imports = True no_implicit_optional = True disallow_any_generics = false disallow_untyped_decorators = true implicit_reexport = true disallow_incomplete_defs = true exclude = databases/backends [tool:isort] profile = black combine_as_imports = True [coverage:run] source = databases, tests [egg_info] tag_build = tag_date = 0 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/setup.py 0000644 0001751 0000177 00000004234 00000000000 015772 0 ustar 00runner docker 0000000 0000000 #!/usr/bin/env python # -*- coding: utf-8 -*- import os import re from setuptools import setup def get_version(package): """ Return package version as listed in `__version__` in `init.py`. """ with open(os.path.join(package, "__init__.py")) as f: return re.search("__version__ = ['\"]([^'\"]+)['\"]", f.read()).group(1) def get_long_description(): """ Return the README. """ with open("README.md", encoding="utf8") as f: return f.read() def get_packages(package): """ Return root package and all sub-packages. """ return [ dirpath for dirpath, dirnames, filenames in os.walk(package) if os.path.exists(os.path.join(dirpath, "__init__.py")) ] setup( name="databases", version=get_version("databases"), python_requires=">=3.8", url="https://github.com/encode/databases", license="BSD", description="Async database support for Python.", long_description=get_long_description(), long_description_content_type="text/markdown", author="Tom Christie", author_email="tom@tomchristie.com", packages=get_packages("databases"), package_data={"databases": ["py.typed"]}, install_requires=["sqlalchemy>=2.0.7"], extras_require={ "postgresql": ["asyncpg"], "asyncpg": ["asyncpg"], "aiopg": ["aiopg"], "mysql": ["aiomysql"], "aiomysql": ["aiomysql"], "asyncmy": ["asyncmy"], "sqlite": ["aiosqlite"], "aiosqlite": ["aiosqlite"], }, classifiers=[ "Development Status :: 3 - Alpha", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Topic :: Internet :: WWW/HTTP", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3 :: Only", ], zip_safe=False, ) ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 011452 x ustar 00 0000000 0000000 28 mtime=1709314764.9520538 databases-0.9.0/tests/ 0000755 0001751 0000177 00000000000 00000000000 015417 5 ustar 00runner docker 0000000 0000000 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/tests/test_connection_options.py 0000644 0001751 0000177 00000015523 00000000000 022750 0 ustar 00runner docker 0000000 0000000 """ Unit tests for the backend connection arguments. """ import sys import pytest from databases.backends.aiopg import AiopgBackend from databases.backends.postgres import PostgresBackend from databases.core import DatabaseURL from tests.test_databases import DATABASE_URLS, async_adapter if sys.version_info >= (3, 7): # pragma: no cover from databases.backends.asyncmy import AsyncMyBackend if sys.version_info < (3, 10): # pragma: no cover from databases.backends.mysql import MySQLBackend def test_postgres_pool_size(): backend = PostgresBackend("postgres://localhost/database?min_size=1&max_size=20") kwargs = backend._get_connection_kwargs() assert kwargs == {"min_size": 1, "max_size": 20} @async_adapter async def test_postgres_pool_size_connect(): for url in DATABASE_URLS: if DatabaseURL(url).dialect != "postgresql": continue backend = PostgresBackend(url + "?min_size=1&max_size=20") await backend.connect() await backend.disconnect() def test_postgres_explicit_pool_size(): backend = PostgresBackend("postgres://localhost/database", min_size=1, max_size=20) kwargs = backend._get_connection_kwargs() assert kwargs == {"min_size": 1, "max_size": 20} def test_postgres_ssl(): backend = PostgresBackend("postgres://localhost/database?ssl=true") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} def test_postgres_ssl_verify_full(): backend = PostgresBackend("postgres://localhost/database?ssl=verify-full") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": "verify-full"} def test_postgres_explicit_ssl(): backend = PostgresBackend("postgres://localhost/database", ssl=True) kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} def test_postgres_explicit_ssl_verify_full(): backend = PostgresBackend("postgres://localhost/database", ssl="verify-full") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": "verify-full"} def test_postgres_no_extra_options(): backend = PostgresBackend("postgres://localhost/database") kwargs = backend._get_connection_kwargs() assert kwargs == {} def test_postgres_password_as_callable(): def gen_password(): return "Foo" backend = PostgresBackend( "postgres://:password@localhost/database", password=gen_password ) kwargs = backend._get_connection_kwargs() assert kwargs == {"password": gen_password} assert kwargs["password"]() == "Foo" @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_pool_size(): backend = MySQLBackend("mysql://localhost/database?min_size=1&max_size=20") kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_unix_socket(): backend = MySQLBackend( "mysql+aiomysql://username:password@/testsuite?unix_socket=/tmp/mysqld/mysqld.sock" ) kwargs = backend._get_connection_kwargs() assert kwargs == {"unix_socket": "/tmp/mysqld/mysqld.sock"} @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_explicit_pool_size(): backend = MySQLBackend("mysql://localhost/database", min_size=1, max_size=20) kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_ssl(): backend = MySQLBackend("mysql://localhost/database?ssl=true") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_explicit_ssl(): backend = MySQLBackend("mysql://localhost/database", ssl=True) kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} @pytest.mark.skipif(sys.version_info >= (3, 10), reason="requires python3.9 or lower") def test_mysql_pool_recycle(): backend = MySQLBackend("mysql://localhost/database?pool_recycle=20") kwargs = backend._get_connection_kwargs() assert kwargs == {"pool_recycle": 20} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_pool_size(): backend = AsyncMyBackend( "mysql+asyncmy://localhost/database?min_size=1&max_size=20" ) kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_unix_socket(): backend = AsyncMyBackend( "mysql+asyncmy://username:password@/testsuite?unix_socket=/tmp/mysqld/mysqld.sock" ) kwargs = backend._get_connection_kwargs() assert kwargs == {"unix_socket": "/tmp/mysqld/mysqld.sock"} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_explicit_pool_size(): backend = AsyncMyBackend("mysql://localhost/database", min_size=1, max_size=20) kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_ssl(): backend = AsyncMyBackend("mysql+asyncmy://localhost/database?ssl=true") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_explicit_ssl(): backend = AsyncMyBackend("mysql+asyncmy://localhost/database", ssl=True) kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} @pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher") def test_asyncmy_pool_recycle(): backend = AsyncMyBackend("mysql+asyncmy://localhost/database?pool_recycle=20") kwargs = backend._get_connection_kwargs() assert kwargs == {"pool_recycle": 20} def test_aiopg_pool_size(): backend = AiopgBackend( "postgresql+aiopg://localhost/database?min_size=1&max_size=20" ) kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} def test_aiopg_explicit_pool_size(): backend = AiopgBackend( "postgresql+aiopg://localhost/database", min_size=1, max_size=20 ) kwargs = backend._get_connection_kwargs() assert kwargs == {"minsize": 1, "maxsize": 20} def test_aiopg_ssl(): backend = AiopgBackend("postgresql+aiopg://localhost/database?ssl=true") kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} def test_aiopg_explicit_ssl(): backend = AiopgBackend("postgresql+aiopg://localhost/database", ssl=True) kwargs = backend._get_connection_kwargs() assert kwargs == {"ssl": True} ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/tests/test_database_url.py 0000644 0001751 0000177 00000007264 00000000000 021467 0 ustar 00runner docker 0000000 0000000 from urllib.parse import quote import pytest from databases import DatabaseURL def test_database_url_repr(): u = DatabaseURL("postgresql://localhost/name") assert repr(u) == "DatabaseURL('postgresql://localhost/name')" u = DatabaseURL("postgresql://username@localhost/name") assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')" u = DatabaseURL("postgresql://username:password@localhost/name") assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')" u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name") assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')" def test_database_url_properties(): u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase") assert u.dialect == "postgresql" assert u.driver == "asyncpg" assert u.username == "username" assert u.password == "password" assert u.hostname == "localhost" assert u.port == 123 assert u.database == "mydatabase" u = DatabaseURL( "postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432" ) assert u.dialect == "postgresql" assert u.username == "username" assert u.password == "password" assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432" assert u.database == "mydatabase" u = DatabaseURL( "postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432" ) assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432" def test_database_url_escape(): u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase") assert u.username == "username" assert u.password == "[password" assert u.userinfo == f"username:{quote('[password')}".encode("utf-8") u2 = DatabaseURL(u) assert u2.password == "[password" u3 = DatabaseURL(str(u)) assert u3.password == "[password" def test_database_url_constructor(): with pytest.raises(TypeError): DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase")) u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase") assert DatabaseURL(u) == u def test_database_url_options(): u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true") assert u.options == {"pool_size": "20", "ssl": "true"} u = DatabaseURL( "mysql+asyncmy://username:password@/testsuite?unix_socket=/tmp/mysqld/mysqld.sock" ) assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"} def test_replace_database_url_components(): u = DatabaseURL("postgresql://localhost/mydatabase") assert u.database == "mydatabase" new = u.replace(database="test_" + u.database) assert new.database == "test_mydatabase" assert str(new) == "postgresql://localhost/test_mydatabase" assert u.driver == "" new = u.replace(driver="asyncpg") assert new.driver == "asyncpg" assert str(new) == "postgresql+asyncpg://localhost/mydatabase" assert u.port is None new = u.replace(port=123) assert new.port == 123 assert str(new) == "postgresql://localhost:123/mydatabase" assert u.username is None assert u.userinfo is None u = DatabaseURL("sqlite:///mydatabase") assert u.database == "mydatabase" new = u.replace(database="test_" + u.database) assert new.database == "test_mydatabase" assert str(new) == "sqlite:///test_mydatabase" u = DatabaseURL("sqlite:////absolute/path") assert u.database == "/absolute/path" new = u.replace(database=u.database + "_test") assert new.database == "/absolute/path_test" assert str(new) == "sqlite:////absolute/path_test" ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/tests/test_databases.py 0000644 0001751 0000177 00000165317 00000000000 020774 0 ustar 00runner docker 0000000 0000000 import asyncio import datetime import decimal import enum import functools import gc import itertools import os import sqlite3 from typing import MutableMapping from unittest.mock import MagicMock, patch import pytest import sqlalchemy from databases import Database, DatabaseURL assert "TEST_DATABASE_URLS" in os.environ, "TEST_DATABASE_URLS is not set." DATABASE_URLS = [url.strip() for url in os.environ["TEST_DATABASE_URLS"].split(",")] class AsyncMock(MagicMock): async def __call__(self, *args, **kwargs): return super(AsyncMock, self).__call__(*args, **kwargs) class MyEpochType(sqlalchemy.types.TypeDecorator): impl = sqlalchemy.Integer epoch = datetime.date(1970, 1, 1) def process_bind_param(self, value, dialect): return (value - self.epoch).days def process_result_value(self, value, dialect): return self.epoch + datetime.timedelta(days=value) metadata = sqlalchemy.MetaData() notes = sqlalchemy.Table( "notes", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("text", sqlalchemy.String(length=100)), sqlalchemy.Column("completed", sqlalchemy.Boolean), ) # Used to test DateTime articles = sqlalchemy.Table( "articles", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("title", sqlalchemy.String(length=100)), sqlalchemy.Column("published", sqlalchemy.DateTime), ) # Used to test Date events = sqlalchemy.Table( "events", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("date", sqlalchemy.Date), ) # Used to test Time daily_schedule = sqlalchemy.Table( "daily_schedule", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("time", sqlalchemy.Time), ) class TshirtSize(enum.Enum): SMALL = "SMALL" MEDIUM = "MEDIUM" LARGE = "LARGE" XL = "XL" class TshirtColor(enum.Enum): BLUE = 0 GREEN = 1 YELLOW = 2 RED = 3 # Used to test Enum tshirt_size = sqlalchemy.Table( "tshirt_size", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("size", sqlalchemy.Enum(TshirtSize)), sqlalchemy.Column("color", sqlalchemy.Enum(TshirtColor)), ) # Used to test JSON session = sqlalchemy.Table( "session", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("data", sqlalchemy.JSON), ) # Used to test custom column types custom_date = sqlalchemy.Table( "custom_date", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("title", sqlalchemy.String(length=100)), sqlalchemy.Column("published", MyEpochType), ) # Used to test Numeric prices = sqlalchemy.Table( "prices", metadata, sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True), sqlalchemy.Column("price", sqlalchemy.Numeric(precision=30, scale=20)), ) @pytest.fixture(autouse=True, scope="function") def create_test_database(): # Create test databases with tables creation for url in DATABASE_URLS: database_url = DatabaseURL(url) if database_url.scheme in ["mysql", "mysql+aiomysql", "mysql+asyncmy"]: url = str(database_url.replace(driver="pymysql")) elif database_url.scheme in [ "postgresql+aiopg", "sqlite+aiosqlite", "postgresql+asyncpg", ]: url = str(database_url.replace(driver=None)) engine = sqlalchemy.create_engine(url) metadata.create_all(engine) # Run the test suite yield # Drop test databases for url in DATABASE_URLS: database_url = DatabaseURL(url) if database_url.scheme in ["mysql", "mysql+aiomysql", "mysql+asyncmy"]: url = str(database_url.replace(driver="pymysql")) elif database_url.scheme in [ "postgresql+aiopg", "sqlite+aiosqlite", "postgresql+asyncpg", ]: url = str(database_url.replace(driver=None)) engine = sqlalchemy.create_engine(url) metadata.drop_all(engine) # Run garbage collection to ensure any in-memory databases are dropped gc.collect() def async_adapter(wrapped_func): """ Decorator used to run async test cases. """ @functools.wraps(wrapped_func) def run_sync(*args, **kwargs): loop = asyncio.new_event_loop() task = wrapped_func(*args, **kwargs) return loop.run_until_complete(task) return run_sync @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_queries(database_url): """ Test that the basic `execute()`, `execute_many()`, `fetch_all()``, and `fetch_one()` interfaces are all supported (using SQLAlchemy core). """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) # execute_many() query = notes.insert() values = [ {"text": "example2", "completed": False}, {"text": "example3", "completed": True}, ] await database.execute_many(query, values) # fetch_all() query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 3 assert results[0]["text"] == "example1" assert results[0]["completed"] == True assert results[1]["text"] == "example2" assert results[1]["completed"] == False assert results[2]["text"] == "example3" assert results[2]["completed"] == True # fetch_one() query = notes.select() result = await database.fetch_one(query=query) assert result["text"] == "example1" assert result["completed"] == True # fetch_val() query = sqlalchemy.sql.select(*[notes.c.text]) result = await database.fetch_val(query=query) assert result == "example1" # fetch_val() with no rows query = sqlalchemy.sql.select(*[notes.c.text]).where( notes.c.text == "impossible" ) result = await database.fetch_val(query=query) assert result is None # fetch_val() with a different column query = sqlalchemy.sql.select(*[notes.c.id, notes.c.text]) result = await database.fetch_val(query=query, column=1) assert result == "example1" # row access (needed to maintain test coverage for Record.__getitem__ in postgres backend) query = sqlalchemy.sql.select(*[notes.c.text]) result = await database.fetch_one(query=query) assert result["text"] == "example1" assert result[0] == "example1" # iterate() query = notes.select() iterate_results = [] async for result in database.iterate(query=query): iterate_results.append(result) assert len(iterate_results) == 3 assert iterate_results[0]["text"] == "example1" assert iterate_results[0]["completed"] == True assert iterate_results[1]["text"] == "example2" assert iterate_results[1]["completed"] == False assert iterate_results[2]["text"] == "example3" assert iterate_results[2]["completed"] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_queries_raw(database_url): """ Test that the basic `execute()`, `execute_many()`, `fetch_all()``, and `fetch_one()` interfaces are all supported (raw queries). """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() query = "INSERT INTO notes(text, completed) VALUES (:text, :completed)" values = {"text": "example1", "completed": True} await database.execute(query, values) # execute_many() query = "INSERT INTO notes(text, completed) VALUES (:text, :completed)" values = [ {"text": "example2", "completed": False}, {"text": "example3", "completed": True}, ] await database.execute_many(query, values) # fetch_all() query = "SELECT * FROM notes WHERE completed = :completed" results = await database.fetch_all(query=query, values={"completed": True}) assert len(results) == 2 assert results[0]["text"] == "example1" assert results[0]["completed"] == True assert results[1]["text"] == "example3" assert results[1]["completed"] == True # fetch_one() query = "SELECT * FROM notes WHERE completed = :completed" result = await database.fetch_one(query=query, values={"completed": False}) assert result["text"] == "example2" assert result["completed"] == False # fetch_val() query = "SELECT completed FROM notes WHERE text = :text" result = await database.fetch_val(query=query, values={"text": "example1"}) assert result == True query = "SELECT * FROM notes WHERE text = :text" result = await database.fetch_val( query=query, values={"text": "example1"}, column="completed" ) assert result == True # iterate() query = "SELECT * FROM notes" iterate_results = [] async for result in database.iterate(query=query): iterate_results.append(result) assert len(iterate_results) == 3 assert iterate_results[0]["text"] == "example1" assert iterate_results[0]["completed"] == True assert iterate_results[1]["text"] == "example2" assert iterate_results[1]["completed"] == False assert iterate_results[2]["text"] == "example3" assert iterate_results[2]["completed"] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_ddl_queries(database_url): """ Test that the built-in DDL elements such as `DropTable()`, `CreateTable()` are supported (using SQLAlchemy core). """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # DropTable() query = sqlalchemy.schema.DropTable(notes) await database.execute(query) # CreateTable() query = sqlalchemy.schema.CreateTable(notes) await database.execute(query) @pytest.mark.parametrize("exception", [Exception, asyncio.CancelledError]) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_queries_after_error(database_url, exception): """ Test that the basic `execute()` works after a previous error. """ async with Database(database_url) as database: with patch.object( database.connection()._connection, "acquire", new=AsyncMock(side_effect=exception), ): with pytest.raises(exception): query = notes.select() await database.fetch_all(query) query = notes.select() await database.fetch_all(query) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_results_support_mapping_interface(database_url): """ Casting results to a dict should work, since the interface defines them as supporting the mapping interface. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) # fetch_all() query = notes.select() results = await database.fetch_all(query=query) results_as_dicts = [dict(item) for item in results] assert len(results[0]) == 3 assert len(results_as_dicts[0]) == 3 assert isinstance(results_as_dicts[0]["id"], int) assert results_as_dicts[0]["text"] == "example1" assert results_as_dicts[0]["completed"] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_results_support_column_reference(database_url): """ Casting results to a dict should work, since the interface defines them as supporting the mapping interface. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): now = datetime.datetime.now().replace(microsecond=0) today = datetime.date.today() # execute() query = articles.insert() values = {"title": "Hello, world Article", "published": now} await database.execute(query, values) query = custom_date.insert() values = {"title": "Hello, world Custom", "published": today} await database.execute(query, values) # fetch_all() query = sqlalchemy.select(*[articles, custom_date]) results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0][articles.c.title] == "Hello, world Article" assert results[0][articles.c.published] == now assert results[0][custom_date.c.title] == "Hello, world Custom" assert results[0][custom_date.c.published] == today @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_result_values_allow_duplicate_names(database_url): """ The values of a result should respect when two columns are selected with the same name. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): query = "SELECT 1 AS id, 2 AS id" row = await database.fetch_one(query=query) assert list(row._mapping.keys()) == ["id", "id"] assert list(row._mapping.values()) == [1, 2] @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_fetch_one_returning_no_results(database_url): """ fetch_one should return `None` when no results match. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # fetch_all() query = notes.select() result = await database.fetch_one(query=query) assert result is None @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_execute_return_val(database_url): """ Test using return value from `execute()` to get an inserted primary key. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): query = notes.insert() values = {"text": "example1", "completed": True} pk = await database.execute(query, values) assert isinstance(pk, int) # Apparently for `aiopg` it's OID that will always 0 in this case # As it's only one action within this cursor life cycle # It's recommended to use the `RETURNING` clause # For obtaining the record id if database.url.scheme == "postgresql+aiopg": assert pk == 0 else: query = notes.select().where(notes.c.id == pk) result = await database.fetch_one(query) assert result["text"] == "example1" assert result["completed"] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_rollback_isolation(database_url): """ Ensure that `database.transaction(force_rollback=True)` provides strict isolation. """ async with Database(database_url) as database: # Perform some INSERT operations on the database. async with database.transaction(force_rollback=True): query = notes.insert().values(text="example1", completed=True) await database.execute(query) # Ensure INSERT operations have been rolled back. query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_rollback_isolation_with_contextmanager(database_url): """ Ensure that `database.force_rollback()` provides strict isolation. """ database = Database(database_url) with database.force_rollback(): async with database: # Perform some INSERT operations on the database. query = notes.insert().values(text="example1", completed=True) await database.execute(query) async with database: # Ensure INSERT operations have been rolled back. query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_commit(database_url): """ Ensure that transaction commit is supported. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): async with database.transaction(): query = notes.insert().values(text="example1", completed=True) await database.execute(query) query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 1 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_child_task_inheritance(database_url): """ Ensure that transactions are inherited by child tasks. """ async with Database(database_url) as database: async def check_transaction(transaction, active_transaction): # Should have inherited the same transaction backend from the parent task assert transaction._transaction is active_transaction async with database.transaction() as transaction: await asyncio.create_task( check_transaction(transaction, transaction._transaction) ) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_child_task_inheritance_example(database_url): """ Ensure that child tasks may influence inherited transactions. """ # This is an practical example of the above test. async with Database(database_url) as database: async with database.transaction(): # Create a note await database.execute( notes.insert().values(id=1, text="setup", completed=True) ) # Change the note from the same task await database.execute( notes.update().where(notes.c.id == 1).values(text="prior") ) # Confirm the change result = await database.fetch_one(notes.select().where(notes.c.id == 1)) assert result.text == "prior" async def run_update_from_child_task(connection): # Change the note from a child task await connection.execute( notes.update().where(notes.c.id == 1).values(text="test") ) await asyncio.create_task(run_update_from_child_task(database.connection())) # Confirm the child's change result = await database.fetch_one(notes.select().where(notes.c.id == 1)) assert result.text == "test" @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_sibling_task_isolation(database_url): """ Ensure that transactions are isolated between sibling tasks. """ start = asyncio.Event() end = asyncio.Event() async with Database(database_url) as database: async def check_transaction(transaction): await start.wait() # Parent task is now in a transaction, we should not # see its transaction backend since this task was # _started_ in a context where no transaction was active. assert transaction._transaction is None end.set() transaction = database.transaction() assert transaction._transaction is None task = asyncio.create_task(check_transaction(transaction)) async with transaction: start.set() assert transaction._transaction is not None await end.wait() # Cleanup for "Task not awaited" warning await task @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_sibling_task_isolation_example(database_url): """ Ensure that transactions are running in sibling tasks are isolated from eachother. """ # This is an practical example of the above test. setup = asyncio.Event() done = asyncio.Event() async def tx1(connection): async with connection.transaction(): await db.execute( notes.insert(), values={"id": 1, "text": "tx1", "completed": False} ) setup.set() await done.wait() async def tx2(connection): async with connection.transaction(): await setup.wait() result = await db.fetch_all(notes.select()) assert result == [], result done.set() async with Database(database_url) as db: await asyncio.gather(tx1(db), tx2(db)) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_cleanup_contextmanager(database_url): """ Ensure that task connections are not persisted unecessarily. """ ready = asyncio.Event() done = asyncio.Event() async def check_child_connection(database: Database): async with database.connection(): ready.set() await done.wait() async with Database(database_url) as database: # Should have a connection in this task # .connect is lazy, it doesn't create a Connection, but .connection does connection = database.connection() assert isinstance(database._connection_map, MutableMapping) assert database._connection_map.get(asyncio.current_task()) is connection # Create a child task and see if it registers a connection task = asyncio.create_task(check_child_connection(database)) await ready.wait() assert database._connection_map.get(task) is not None assert database._connection_map.get(task) is not connection # Let the child task finish, and see if it cleaned up done.set() await task # This is normal exit logic cleanup, the WeakKeyDictionary # shouldn't have cleaned up yet since the task is still referenced assert task not in database._connection_map # Context manager closes, all open connections are removed assert isinstance(database._connection_map, MutableMapping) assert len(database._connection_map) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_cleanup_garbagecollector(database_url): """ Ensure that connections for tasks are not persisted unecessarily, even if exit handlers are not called. """ database = Database(database_url) await database.connect() created = asyncio.Event() async def check_child_connection(database: Database): # neither .disconnect nor .__aexit__ are called before deleting this task database.connection() created.set() task = asyncio.create_task(check_child_connection(database)) await created.wait() assert task in database._connection_map await task del task gc.collect() # Should not have a connection for the task anymore assert len(database._connection_map) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_cleanup_contextmanager(database_url): """ Ensure that contextvar transactions are not persisted unecessarily. """ from databases.core import _ACTIVE_TRANSACTIONS assert _ACTIVE_TRANSACTIONS.get() is None async with Database(database_url) as database: async with database.transaction() as transaction: open_transactions = _ACTIVE_TRANSACTIONS.get() assert isinstance(open_transactions, MutableMapping) assert open_transactions.get(transaction) is transaction._transaction # Context manager closes, open_transactions is cleaned up open_transactions = _ACTIVE_TRANSACTIONS.get() assert isinstance(open_transactions, MutableMapping) assert open_transactions.get(transaction, None) is None @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_context_cleanup_garbagecollector(database_url): """ Ensure that contextvar transactions are not persisted unecessarily, even if exit handlers are not called. This test should be an XFAIL, but cannot be due to the way that is hangs during teardown. """ from databases.core import _ACTIVE_TRANSACTIONS assert _ACTIVE_TRANSACTIONS.get() is None async with Database(database_url) as database: transaction = database.transaction() await transaction.start() # Should be tracking the transaction open_transactions = _ACTIVE_TRANSACTIONS.get() assert isinstance(open_transactions, MutableMapping) assert open_transactions.get(transaction) is transaction._transaction # neither .commit, .rollback, nor .__aexit__ are called del transaction gc.collect() # TODO(zevisert,review): Could skip instead of using the logic below # A strong reference to the transaction is kept alive by the connection's # ._transaction_stack, so it is still be tracked at this point. assert len(open_transactions) == 1 # If that were magically cleared, the transaction would be cleaned up, # but as it stands this always causes a hang during teardown at # `Database(...).disconnect()` if the transaction is not closed. transaction = database.connection()._transaction_stack[-1] await transaction.rollback() del transaction # Now with the transaction rolled-back, it should be cleaned up. assert len(open_transactions) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_commit_serializable(database_url): """ Ensure that serializable transaction commit via extra parameters is supported. """ database_url = DatabaseURL(database_url) if database_url.scheme not in ["postgresql", "postgresql+asyncpg"]: pytest.skip("Test (currently) only supports asyncpg") if database_url.scheme == "postgresql+asyncpg": database_url = database_url.replace(driver=None) def insert_independently(): engine = sqlalchemy.create_engine(str(database_url)) conn = engine.connect() query = notes.insert().values(text="example1", completed=True) conn.execute(query) conn.close() def delete_independently(): engine = sqlalchemy.create_engine(str(database_url)) conn = engine.connect() query = notes.delete() conn.execute(query) conn.close() async with Database(database_url) as database: async with database.transaction(force_rollback=True, isolation="serializable"): query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 insert_independently() query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 delete_independently() @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_rollback(database_url): """ Ensure that transaction rollback is supported. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): try: async with database.transaction(): query = notes.insert().values(text="example1", completed=True) await database.execute(query) raise RuntimeError() except RuntimeError: pass query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_commit_low_level(database_url): """ Ensure that an explicit `await transaction.commit()` is supported. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): transaction = await database.transaction() try: query = notes.insert().values(text="example1", completed=True) await database.execute(query) except: # pragma: no cover await transaction.rollback() else: await transaction.commit() query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 1 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_rollback_low_level(database_url): """ Ensure that an explicit `await transaction.rollback()` is supported. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): transaction = await database.transaction() try: query = notes.insert().values(text="example1", completed=True) await database.execute(query) raise RuntimeError() except: await transaction.rollback() else: # pragma: no cover await transaction.commit() query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_decorator(database_url): """ Ensure that @database.transaction() is supported. """ database = Database(database_url, force_rollback=True) @database.transaction() async def insert_data(raise_exception): query = notes.insert().values(text="example", completed=True) await database.execute(query) if raise_exception: raise RuntimeError() async with database: with pytest.raises(RuntimeError): await insert_data(raise_exception=True) results = await database.fetch_all(query=notes.select()) assert len(results) == 0 await insert_data(raise_exception=False) results = await database.fetch_all(query=notes.select()) assert len(results) == 1 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_transaction_decorator_concurrent(database_url): """ Ensure that @database.transaction() can be called concurrently. """ database = Database(database_url) @database.transaction() async def insert_data(): await database.execute( query=notes.insert().values(text="example", completed=True) ) async with database: await asyncio.gather( insert_data(), insert_data(), insert_data(), insert_data(), insert_data(), insert_data(), ) results = await database.fetch_all(query=notes.select()) assert len(results) == 6 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_datetime_field(database_url): """ Test DataTime columns, to ensure records are coerced to/from proper Python types. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): now = datetime.datetime.now().replace(microsecond=0) # execute() query = articles.insert() values = {"title": "Hello, world", "published": now} await database.execute(query, values) # fetch_all() query = articles.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["title"] == "Hello, world" assert results[0]["published"] == now @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_date_field(database_url): """ Test Date columns, to ensure records are coerced to/from proper Python types. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): now = datetime.date.today() # execute() query = events.insert() values = {"date": now} await database.execute(query, values) # fetch_all() query = events.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["date"] == now @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_time_field(database_url): """ Test Time columns, to ensure records are coerced to/from proper Python types. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): now = datetime.datetime.now().time().replace(microsecond=0) # execute() query = daily_schedule.insert() values = {"time": now} await database.execute(query, values) # fetch_all() query = daily_schedule.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["time"] == now @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_decimal_field(database_url): """ Test Decimal (NUMERIC) columns, to ensure records are coerced to/from proper Python types. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): price = decimal.Decimal("0.700000000000001") # execute() query = prices.insert() values = {"price": price} await database.execute(query, values) # fetch_all() query = prices.select() results = await database.fetch_all(query=query) assert len(results) == 1 if database_url.startswith("sqlite"): # aiosqlite does not support native decimals --> a roud-off error is expected assert results[0]["price"] == pytest.approx(price) else: assert results[0]["price"] == price @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_enum_field(database_url): """ Test enum columns, to ensure correct cross-database support. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() size = TshirtSize.SMALL color = TshirtColor.GREEN values = {"size": size, "color": color} query = tshirt_size.insert() await database.execute(query, values) # fetch_all() query = tshirt_size.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["size"] == size assert results[0]["color"] == color @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_json_dict_field(database_url): """ Test JSON columns, to ensure correct cross-database support. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() data = {"text": "hello", "boolean": True, "int": 1} values = {"data": data} query = session.insert() await database.execute(query, values) # fetch_all() query = session.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["data"] == {"text": "hello", "boolean": True, "int": 1} @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_json_list_field(database_url): """ Test JSON columns, to ensure correct cross-database support. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # execute() data = ["lemon", "raspberry", "lime", "pumice"] values = {"data": data} query = session.insert() await database.execute(query, values) # fetch_all() query = session.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["data"] == ["lemon", "raspberry", "lime", "pumice"] @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_custom_field(database_url): """ Test custom column types. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): today = datetime.date.today() # execute() query = custom_date.insert() values = {"title": "Hello, world", "published": today} await database.execute(query, values) # fetch_all() query = custom_date.select() results = await database.fetch_all(query=query) assert len(results) == 1 assert results[0]["title"] == "Hello, world" assert results[0]["published"] == today @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connections_isolation(database_url): """ Ensure that changes are visible between different connections. To check this we have to not create a transaction, so that each query ends up on a different connection from the pool. """ async with Database(database_url) as database: try: query = notes.insert().values(text="example1", completed=True) await database.execute(query) query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 1 finally: query = notes.delete() await database.execute(query) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_commit_on_root_transaction(database_url): """ Because our tests are generally wrapped in rollback-islation, they don't have coverage for commiting the root transaction. Deal with this here, and delete the records rather than rolling back. """ async with Database(database_url) as database: try: async with database.transaction(): query = notes.insert().values(text="example1", completed=True) await database.execute(query) query = notes.select() results = await database.fetch_all(query=query) assert len(results) == 1 finally: query = notes.delete() await database.execute(query) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connect_and_disconnect(database_url): """ Test explicit connect() and disconnect(). """ database = Database(database_url) assert not database.is_connected await database.connect() assert database.is_connected await database.disconnect() assert not database.is_connected # connect and disconnect idempotence await database.connect() await database.connect() assert database.is_connected await database.disconnect() await database.disconnect() assert not database.is_connected @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_context_same_task(database_url): async with Database(database_url) as database: async with database.connection() as connection_1: async with database.connection() as connection_2: assert connection_1 is connection_2 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_context_multiple_sibling_tasks(database_url): async with Database(database_url) as database: connection_1 = None connection_2 = None test_complete = asyncio.Event() async def get_connection_1(): nonlocal connection_1 async with database.connection() as connection: connection_1 = connection await test_complete.wait() async def get_connection_2(): nonlocal connection_2 async with database.connection() as connection: connection_2 = connection await test_complete.wait() task_1 = asyncio.create_task(get_connection_1()) task_2 = asyncio.create_task(get_connection_2()) while connection_1 is None or connection_2 is None: await asyncio.sleep(0.000001) assert connection_1 is not connection_2 test_complete.set() await task_1 await task_2 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_context_multiple_tasks(database_url): async with Database(database_url) as database: parent_connection = database.connection() connection_1 = None connection_2 = None task_1_ready = asyncio.Event() task_2_ready = asyncio.Event() test_complete = asyncio.Event() async def get_connection_1(): nonlocal connection_1 async with database.connection() as connection: connection_1 = connection task_1_ready.set() await test_complete.wait() async def get_connection_2(): nonlocal connection_2 async with database.connection() as connection: connection_2 = connection task_2_ready.set() await test_complete.wait() task_1 = asyncio.create_task(get_connection_1()) task_2 = asyncio.create_task(get_connection_2()) await task_1_ready.wait() await task_2_ready.wait() assert connection_1 is not parent_connection assert connection_2 is not parent_connection assert connection_1 is not connection_2 test_complete.set() await task_1 await task_2 @pytest.mark.parametrize( "database_url1,database_url2", ( pytest.param(db1, db2, id=f"{db1} | {db2}") for (db1, db2) in itertools.combinations(DATABASE_URLS, 2) ), ) @async_adapter async def test_connection_context_multiple_databases(database_url1, database_url2): async with Database(database_url1) as database1: async with Database(database_url2) as database2: assert database1.connection() is not database2.connection() @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_connection_context_with_raw_connection(database_url): """ Test connection contexts with respect to the raw connection. """ async with Database(database_url) as database: async with database.connection() as connection_1: async with database.connection() as connection_2: assert connection_1 is connection_2 assert connection_1.raw_connection is connection_2.raw_connection @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_queries_with_expose_backend_connection(database_url): """ Replication of `execute()`, `execute_many()`, `fetch_all()``, and `fetch_one()` using the raw driver interface. """ async with Database(database_url) as database: async with database.connection() as connection: async with connection.transaction(force_rollback=True): # Get the raw connection raw_connection = connection.raw_connection # Insert query if database.url.scheme in [ "mysql", "mysql+asyncmy", "mysql+aiomysql", "postgresql+aiopg", ]: insert_query = "INSERT INTO notes (text, completed) VALUES (%s, %s)" else: insert_query = "INSERT INTO notes (text, completed) VALUES ($1, $2)" # execute() values = ("example1", True) if database.url.scheme in [ "mysql", "mysql+aiomysql", "postgresql+aiopg", ]: cursor = await raw_connection.cursor() await cursor.execute(insert_query, values) elif database.url.scheme == "mysql+asyncmy": async with raw_connection.cursor() as cursor: await cursor.execute(insert_query, values) elif database.url.scheme in ["postgresql", "postgresql+asyncpg"]: await raw_connection.execute(insert_query, *values) elif database.url.scheme in ["sqlite", "sqlite+aiosqlite"]: await raw_connection.execute(insert_query, values) # execute_many() values = [("example2", False), ("example3", True)] if database.url.scheme in ["mysql", "mysql+aiomysql"]: cursor = await raw_connection.cursor() await cursor.executemany(insert_query, values) elif database.url.scheme == "mysql+asyncmy": async with raw_connection.cursor() as cursor: await cursor.executemany(insert_query, values) elif database.url.scheme == "postgresql+aiopg": cursor = await raw_connection.cursor() # No async support for `executemany` for value in values: await cursor.execute(insert_query, value) else: await raw_connection.executemany(insert_query, values) # Select query select_query = "SELECT notes.id, notes.text, notes.completed FROM notes" # fetch_all() if database.url.scheme in [ "mysql", "mysql+aiomysql", "postgresql+aiopg", ]: cursor = await raw_connection.cursor() await cursor.execute(select_query) results = await cursor.fetchall() elif database.url.scheme == "mysql+asyncmy": async with raw_connection.cursor() as cursor: await cursor.execute(select_query) results = await cursor.fetchall() elif database.url.scheme in ["postgresql", "postgresql+asyncpg"]: results = await raw_connection.fetch(select_query) elif database.url.scheme in ["sqlite", "sqlite+aiosqlite"]: results = await raw_connection.execute_fetchall(select_query) assert len(results) == 3 # Raw output for the raw request assert results[0][1] == "example1" assert results[0][2] == True assert results[1][1] == "example2" assert results[1][2] == False assert results[2][1] == "example3" assert results[2][2] == True # fetch_one() if database.url.scheme in ["postgresql", "postgresql+asyncpg"]: result = await raw_connection.fetchrow(select_query) elif database.url.scheme == "mysql+asyncmy": async with raw_connection.cursor() as cursor: await cursor.execute(select_query) result = await cursor.fetchone() else: cursor = await raw_connection.cursor() await cursor.execute(select_query) result = await cursor.fetchone() # Raw output for the raw request assert result[1] == "example1" assert result[2] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_database_url_interface(database_url): """ Test that Database instances expose a `.url` attribute. """ async with Database(database_url) as database: assert isinstance(database.url, DatabaseURL) assert database.url == database_url @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_concurrent_access_on_single_connection(database_url): async with Database(database_url, force_rollback=True) as database: async def db_lookup(): await database.fetch_one("SELECT 1 AS value") await asyncio.gather( db_lookup(), db_lookup(), ) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_concurrent_transactions_on_single_connection(database_url: str): async with Database(database_url) as database: @database.transaction() async def db_lookup(): await database.fetch_one(query="SELECT 1 AS value") await asyncio.gather( db_lookup(), db_lookup(), ) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_concurrent_tasks_on_single_connection(database_url: str): async with Database(database_url) as database: async def db_lookup(): await database.fetch_one(query="SELECT 1 AS value") await asyncio.gather( asyncio.create_task(db_lookup()), asyncio.create_task(db_lookup()), ) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_concurrent_task_transactions_on_single_connection(database_url: str): async with Database(database_url) as database: @database.transaction() async def db_lookup(): await database.fetch_one(query="SELECT 1 AS value") await asyncio.gather( asyncio.create_task(db_lookup()), asyncio.create_task(db_lookup()), ) @pytest.mark.parametrize("database_url", DATABASE_URLS) def test_global_connection_is_initialized_lazily(database_url): """ Ensure that global connection is initialized at latest possible time so it's _query_lock will belong to same event loop that async_adapter has initialized. See https://github.com/encode/databases/issues/157 for more context. """ database_url = DatabaseURL(database_url) if database_url.dialect != "postgresql": pytest.skip("Test requires `pg_sleep()`") database = Database(database_url, force_rollback=True) @async_adapter async def run_database_queries(): async with database: async def db_lookup(): await database.fetch_one("SELECT pg_sleep(1)") await asyncio.gather(db_lookup(), db_lookup()) run_database_queries() @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_iterate_outside_transaction_with_values(database_url): """ Ensure `iterate()` works even without a transaction on all drivers. The asyncpg driver relies on server-side cursors without hold for iteration, which requires a transaction to be created. This is mentionned in both their documentation and their test suite. """ database_url = DatabaseURL(database_url) if database_url.dialect == "mysql": pytest.skip("MySQL does not support `FROM (VALUES ...)` (F641)") async with Database(database_url) as database: query = "SELECT * FROM (VALUES (1), (2), (3), (4), (5)) as t" iterate_results = [] async for result in database.iterate(query=query): iterate_results.append(result) assert len(iterate_results) == 5 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_iterate_outside_transaction_with_temp_table(database_url): """ Same as test_iterate_outside_transaction_with_values but uses a temporary table instead of a list of values. """ database_url = DatabaseURL(database_url) if database_url.dialect == "sqlite": pytest.skip("SQLite interface does not work with temporary tables.") async with Database(database_url) as database: query = "CREATE TEMPORARY TABLE no_transac(num INTEGER)" await database.execute(query) query = "INSERT INTO no_transac(num) VALUES (1), (2), (3), (4), (5)" await database.execute(query) query = "SELECT * FROM no_transac" iterate_results = [] async for result in database.iterate(query=query): iterate_results.append(result) assert len(iterate_results) == 5 @pytest.mark.parametrize("database_url", DATABASE_URLS) @pytest.mark.parametrize("select_query", [notes.select(), "SELECT * FROM notes"]) @async_adapter async def test_column_names(database_url, select_query): """ Test that column names are exposed correctly through `._mapping.keys()` on each row. """ async with Database(database_url) as database: async with database.transaction(force_rollback=True): # insert values query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) # fetch results results = await database.fetch_all(query=select_query) assert len(results) == 1 assert sorted(results[0]._mapping.keys()) == ["completed", "id", "text"] assert results[0]["text"] == "example1" assert results[0]["completed"] == True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_postcompile_queries(database_url): """ Since SQLAlchemy 1.4, IN operators needs to do render_postcompile """ async with Database(database_url) as database: query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) query = notes.select().where(notes.c.id.in_([2, 3])) results = await database.fetch_all(query=query) assert len(results) == 0 @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_result_named_access(database_url): async with Database(database_url) as database: query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) query = notes.select().where(notes.c.text == "example1") result = await database.fetch_one(query=query) assert result.text == "example1" assert result.completed is True @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_mapping_property_interface(database_url): """ Test that all connections implement interface with `_mapping` property """ async with Database(database_url) as database: query = notes.select() single_result = await database.fetch_one(query=query) assert single_result._mapping["text"] == "example1" assert single_result._mapping["completed"] is True list_result = await database.fetch_all(query=query) assert list_result[0]._mapping["text"] == "example1" assert list_result[0]._mapping["completed"] is True @async_adapter async def test_should_not_maintain_ref_when_no_cache_param(): async with Database( "sqlite:///file::memory:", uri=True, ) as database: query = sqlalchemy.schema.CreateTable(notes) await database.execute(query) query = notes.insert() values = {"text": "example1", "completed": True} with pytest.raises(sqlite3.OperationalError): await database.execute(query, values) @async_adapter async def test_should_maintain_ref_when_cache_param(): async with Database( "sqlite:///file::memory:?cache=shared", uri=True, ) as database: query = sqlalchemy.schema.CreateTable(notes) await database.execute(query) query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) query = notes.select().where(notes.c.text == "example1") result = await database.fetch_one(query=query) assert result.text == "example1" assert result.completed is True @async_adapter async def test_should_remove_ref_on_disconnect(): async with Database( "sqlite:///file::memory:?cache=shared", uri=True, ) as database: query = sqlalchemy.schema.CreateTable(notes) await database.execute(query) query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) # Run garbage collection to reset the database if we dropped the reference gc.collect() async with Database( "sqlite:///file::memory:?cache=shared", uri=True, ) as database: query = notes.select() with pytest.raises(sqlite3.OperationalError): await database.fetch_all(query=query) @pytest.mark.parametrize("database_url", DATABASE_URLS) @async_adapter async def test_mapping_property_interface(database_url): """ Test that all connections implement interface with `_mapping` property """ async with Database(database_url) as database: query = notes.insert() values = {"text": "example1", "completed": True} await database.execute(query, values) query = notes.select() single_result = await database.fetch_one(query=query) assert single_result._mapping["text"] == "example1" assert single_result._mapping["completed"] is True list_result = await database.fetch_all(query=query) assert list_result[0]._mapping["text"] == "example1" assert list_result[0]._mapping["completed"] is True ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 011453 x ustar 00 0000000 0000000 22 mtime=1709314737.0 databases-0.9.0/tests/test_importer.py 0000644 0001751 0000177 00000002202 00000000000 020665 0 ustar 00runner docker 0000000 0000000 import pytest from databases.importer import ImportFromStringError, import_from_string def test_invalid_format(): with pytest.raises(ImportFromStringError) as exc_info: import_from_string("example:") expected = 'Import string "example:" must be in format "