Merge branch 'master' into aiopg

Author: gvbgduh

README.md

@@ -18,7 +18,7 @@ It allows you to make queries using the powerful [SQLAlchemy Core][sqlalchemy-co
 expression language, and provides support for PostgreSQL, MySQL, and SQLite.
 
 Databases is suitable for integrating against any async Web framework, such as [Starlette][starlette],
-[Sanic][sanic], [Responder][responder], [Quart][quart], [aiohttp][aiohttp], [Tornado][tornado], [FastAPI][fastapi], or [Bocadillo][bocadillo].
+[Sanic][sanic], [Responder][responder], [Quart][quart], [aiohttp][aiohttp], [Tornado][tornado], or [FastAPI][fastapi].
 
 **Documentation**: [https://www.encode.io/databases/](https://www.encode.io/databases/)
 
@@ -107,4 +107,3 @@ for examples of how to start using databases together with SQLAlchemy core expre
 [aiohttp]: https://github.com/aio-libs/aiohttp
 [tornado]: https://github.com/tornadoweb/tornado
 [fastapi]: https://github.com/tiangolo/fastapi
-[bocadillo]: https://github.com/bocadilloproject/bocadillo

databases/__init__.py

@@ -1,4 +1,4 @@
 from databases.core import Database, DatabaseURL
 
-__version__ = "0.2.3"
+__version__ = "0.2.6"
 __all__ = ["Database", "DatabaseURL"]

databases/backends/mysql.py

@@ -10,7 +10,7 @@
 from sqlalchemy.sql import ClauseElement
 from sqlalchemy.types import TypeEngine
 
-from databases.core import DatabaseURL
+from databases.core import LOG_EXTRA, DatabaseURL
 from databases.interfaces import ConnectionBackend, DatabaseBackend, TransactionBackend
 
 logger = logging.getLogger("databases")
@@ -179,7 +179,8 @@ def _compile(
             compiled._textual_ordered_columns,
         )
 
-        logger.debug("Query: %s\nArgs: %s", compiled.string, args)
+        query_message = compiled.string.replace(" \n", " ").replace("\n", " ")
+        logger.debug("Query: %s Args: %s", query_message, repr(args), extra=LOG_EXTRA)
         return compiled.string, args, CompilationContext(execution_context)
 
     @property

databases/backends/postgres.py

@@ -9,7 +9,7 @@
 from sqlalchemy.sql.schema import Column
 from sqlalchemy.types import TypeEngine
 
-from databases.core import DatabaseURL
+from databases.core import LOG_EXTRA, DatabaseURL
 from databases.interfaces import ConnectionBackend, DatabaseBackend, TransactionBackend
 
 logger = logging.getLogger("databases")
@@ -115,10 +115,10 @@ def __getitem__(self, key: typing.Any) -> typing.Any:
         return raw
 
     def __iter__(self) -> typing.Iterator:
-        return iter(self._column_map)
+        return iter(self._row.keys())
 
     def __len__(self) -> int:
-        return len(self._column_map)
+        return len(self._row)
 
 
 class PostgresConnection(ConnectionBackend):
@@ -192,7 +192,10 @@ def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
             for key, val in compiled_params
         ]
 
-        logger.debug("Query: %s\nArgs: %s", compiled_query, args)
+        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, compiled._result_columns
 
     @property

databases/backends/sqlite.py

@@ -9,7 +9,7 @@
 from sqlalchemy.sql import ClauseElement
 from sqlalchemy.types import TypeEngine
 
-from databases.core import DatabaseURL
+from databases.core import LOG_EXTRA, DatabaseURL
 from databases.interfaces import ConnectionBackend, DatabaseBackend, TransactionBackend
 
 logger = logging.getLogger("databases")
@@ -154,7 +154,10 @@ def _compile(
             compiled._textual_ordered_columns,
         )
 
-        logger.debug("Query: %s\nArgs: %s", compiled.string, args)
+        query_message = compiled.string.replace(" \n", " ").replace("\n", " ")
+        logger.debug(
+            "Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA
+        )
         return compiled.string, args, CompilationContext(execution_context)
 
     @property

databases/core.py

@@ -1,5 +1,6 @@
 import asyncio
 import functools
+import logging
 import sys
 import typing
 from types import TracebackType
@@ -16,11 +17,33 @@
 else:  # pragma: no cover
     from aiocontextvars import ContextVar
 
+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")
+
 
 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",
         "sqlite": "databases.backends.sqlite:SQLiteBackend",
     }
@@ -51,23 +74,27 @@ def __init__(
         self._global_connection = None  # type: typing.Optional[Connection]
         self._global_transaction = None  # type: typing.Optional[Transaction]
 
-        if self._force_rollback:
-            self._global_connection = Connection(self._backend)
-            self._global_transaction = self._global_connection.transaction(
-                force_rollback=True
-            )
-
     async def connect(self) -> None:
         """
         Establish the connection pool.
         """
         assert not self.is_connected, "Already connected."
 
         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_transaction is not None
+            assert self._global_connection is None
+            assert self._global_transaction is None
+
+            self._global_connection = Connection(self._backend)
+            self._global_transaction = self._global_connection.transaction(
+                force_rollback=True
+            )
+
             await self._global_transaction.__aenter__()
 
     async def disconnect(self) -> None:
@@ -77,10 +104,20 @@ async def disconnect(self) -> None:
         assert self.is_connected, "Already disconnected."
 
         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
+
         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":
@@ -367,7 +404,10 @@ def netloc(self) -> typing.Optional[str]:
 
     @property
     def database(self) -> str:
-        return self.components.path.lstrip("/")
+        path = self.components.path
+        if path.startswith("/"):
+            path = path[1:]
+        return path
 
     @property
     def options(self) -> dict:
@@ -414,14 +454,17 @@ def replace(self, **kwargs: typing.Any) -> "DatabaseURL":
         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:
-        url = str(self)
-        if self.password:
-            url = str(self.replace(password="********"))
-        return f"{self.__class__.__name__}({repr(url)})"
+        return f"{self.__class__.__name__}({repr(self.obscure_password)})"
 
     def __eq__(self, other: typing.Any) -> bool:
         return str(self) == str(other)

docs/index.md

@@ -18,7 +18,7 @@ It allows you to make queries using the powerful [SQLAlchemy Core][sqlalchemy-co
 expression language, and provides support for PostgreSQL, MySQL, and SQLite.
 
 Databases is suitable for integrating against any async Web framework, such as [Starlette][starlette],
-[Sanic][sanic], [Responder][responder], [Quart][quart], [aiohttp][aiohttp], [Tornado][tornado], [FastAPI][fastapi], or [Bocadillo][bocadillo].
+[Sanic][sanic], [Responder][responder], [Quart][quart], [aiohttp][aiohttp], [Tornado][tornado], or [FastAPI][fastapi].
 
 **Community**: [https://discuss.encode.io/c/databases](https://discuss.encode.io/c/databases)
 
@@ -105,4 +105,3 @@ for examples of how to start using databases together with SQLAlchemy core expre
 [aiohttp]: https://github.com/aio-libs/aiohttp
 [tornado]: https://github.com/tornadoweb/tornado
 [fastapi]: https://github.com/tiangolo/fastapi
-[bocadillo]: https://github.com/bocadilloproject/bocadillo

tests/test_database_url.py

@@ -51,3 +51,9 @@ def test_replace_database_url_components():
     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"

tests/test_databases.py

@@ -104,7 +104,7 @@ def async_adapter(wrapped_func):
 
     @functools.wraps(wrapped_func)
     def run_sync(*args, **kwargs):
-        loop = asyncio.get_event_loop()
+        loop = asyncio.new_event_loop()
         task = wrapped_func(*args, **kwargs)
         return loop.run_until_complete(task)
 
@@ -770,6 +770,34 @@ async def db_lookup():
         await asyncio.gather(db_lookup(), 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):
@@ -820,3 +848,25 @@ async def test_iterate_outside_transaction_with_temp_table(database_url):
             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 `.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].keys()) == ["completed", "id", "text"]
+            assert results[0]["text"] == "example1"
+            assert results[0]["completed"] == True

tests/test_importer.py

@@ -4,28 +4,28 @@
 
 
 def test_invalid_format():
-    with pytest.raises(ImportFromStringError) as exc:
+    with pytest.raises(ImportFromStringError) as exc_info:
         import_from_string("example:")
     expected = 'Import string "example:" must be in format "<module>:<attribute>".'
-    assert expected in str(exc)
+    assert exc_info.match(expected)
 
 
 def test_invalid_module():
-    with pytest.raises(ImportFromStringError) as exc:
+    with pytest.raises(ImportFromStringError) as exc_info:
         import_from_string("module_does_not_exist:myattr")
     expected = 'Could not import module "module_does_not_exist".'
-    assert expected in str(exc)
+    assert exc_info.match(expected)
 
 
 def test_invalid_attr():
-    with pytest.raises(ImportFromStringError) as exc:
+    with pytest.raises(ImportFromStringError) as exc_info:
         import_from_string("tempfile:attr_does_not_exist")
     expected = 'Attribute "attr_does_not_exist" not found in module "tempfile".'
-    assert expected in str(exc)
+    assert exc_info.match(expected)
 
 
 def test_internal_import_error():
-    with pytest.raises(ImportError) as exc:
+    with pytest.raises(ImportError):
         import_from_string("tests.importer.raise_import_error:myattr")