connect loaders and fix tests:

  tests/test_bind.py
  tests/test_core.py
  tests/test_engine.py

Author: fantix

src/gino/api.py

@@ -2,12 +2,13 @@
 
 import sqlalchemy as sa
 from sqlalchemy.engine.url import make_url, URL
-from sqlalchemy.sql.base import Executable
+from sqlalchemy.sql.base import Executable, _bind_or_error
+from sqlalchemy.sql.schema import SchemaItem
 
 from . import json_support
-from .engine import create_engine
 from .crud import CRUDModel
 from .declarative import declarative_base, declared_attr
+from .engine import create_engine
 from .exceptions import UninitializedError
 
 
@@ -209,6 +210,23 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self._args[0].pop_bind().close()
 
 
+class GinoSchemaVisitor:
+    __slots__ = ("_item",)
+
+    def __init__(self, item):
+        self._item = item
+
+    def __getattr__(self, item):
+        sync_func = getattr(self._item, item)
+
+        async def _wrapper(bind=None, *args, **kwargs):
+            if bind is None:
+                bind = _bind_or_error(self._item)
+            return await bind.run_sync(sync_func, *args, **kwargs)
+
+        return _wrapper
+
+
 class Gino(sa.MetaData):
     """
     All-in-one API class of GINO, providing several shortcuts.
@@ -301,7 +319,7 @@ class Gino(sa.MetaData):
 
     """
 
-    # schema_visitor = GinoSchemaVisitor
+    schema_visitor = GinoSchemaVisitor
     """
     The overridable ``gino`` extension class on
     :class:`~sqlalchemy.schema.SchemaItem`.
@@ -375,9 +393,8 @@ def __init__(
         if ext:
             if query_ext:
                 Executable.gino = property(self.query_executor)
-            # if schema_ext:
-            # SchemaItem.gino = property(self.schema_visitor)
-            # patch_schema(self)
+            if schema_ext:
+                SchemaItem.gino = property(self.schema_visitor)
 
     # noinspection PyPep8Naming
     @property

src/gino/crud.py

@@ -170,8 +170,10 @@ async def apply(self, bind=None, timeout=DEFAULT):
         row = await bind.first(clause)
         if not row:
             raise NoSuchRowError()
-        for k, v in row.items():
-            self._instance.__values__[self._instance._column_name_map.invert_get(k)] = v
+        for k in row.keys():
+            self._instance.__values__[
+                self._instance._column_name_map.invert_get(k)
+            ] = row[k]
         for prop in self._props:
             prop.reload(self._instance)
         return self
@@ -475,8 +477,8 @@ async def _create(self, bind=None, timeout=DEFAULT):
         if bind is None:
             bind = cls.__metadata__.bind
         row = await bind.first(q)
-        for k, v in row.items():
-            self.__values__[self._column_name_map.invert_get(k)] = v
+        for k in row.keys():
+            self.__values__[self._column_name_map.invert_get(k)] = row[k]
         self.__profile__ = None
         return self
 

src/gino/engine.py

@@ -3,8 +3,9 @@
 import asyncio
 import inspect
 import warnings
+import weakref
 from contextvars import ContextVar
-from typing import Optional
+from typing import Optional, Callable, Any
 
 from sqlalchemy import text
 from sqlalchemy.engine import Engine
@@ -23,6 +24,8 @@
 from sqlalchemy.sql import ClauseElement, WARN_LINTING
 from sqlalchemy.util.concurrency import greenlet_spawn
 
+from .loader import Loader, LoaderResult
+
 
 async def create_engine(
     url, *arg, isolation_level=None, min_size=1, max_size=None, **kw
@@ -212,6 +215,18 @@ async def _execute_sa10(self, object_, multiparams, params):
                 return await asyncio.wait_for(coro, timeout)
         return await coro
 
+    def _load_result(self, result):
+        options = result.context.execution_options
+        loader = options.get("loader")
+        model = options.get("model")
+        if loader is None and model is not None:
+            if isinstance(model, weakref.ref):
+                model = model()
+            loader = Loader.get(model)
+        if loader is not None and options.get("return_model", True):
+            result = LoaderResult(result, loader)
+        return result
+
     async def _execute(self, object_, params_20style):
         if isinstance(object_, str):
             return await self.exec_driver_sql(object_, params_20style)
@@ -281,6 +296,7 @@ async def all(self, clause, *multiparams, **params):
 
         """
         result = await self._execute_sa10(clause, multiparams, params)
+        result = self._load_result(result)
         return result.all()
 
     async def first(self, clause, *multiparams, **params):
@@ -293,6 +309,7 @@ async def first(self, clause, *multiparams, **params):
 
         """
         result = await self._execute_sa10(clause, multiparams, params)
+        result = self._load_result(result)
         try:
             return result.first()
         except ResourceClosedError as e:
@@ -313,6 +330,7 @@ async def one_or_none(self, clause, *multiparams, **params):
 
         """
         result = await self._execute_sa10(clause, multiparams, params)
+        result = self._load_result(result)
         return result.one_or_none()
 
     async def one(self, clause, *multiparams, **params):
@@ -328,6 +346,7 @@ async def one(self, clause, *multiparams, **params):
 
         """
         result = await self._execute_sa10(clause, multiparams, params)
+        result = self._load_result(result)
         return result.one()
 
     async def scalar(self, clause, *multiparams, **params):
@@ -352,7 +371,7 @@ async def status(self, clause, *multiparams, **params):
 
         """
         result = await self._execute_sa10(clause, multiparams, params)
-        return f"SELECT {result.rowcount}", result.all()
+        return result.context
 
     class _IterateResult(StartableContext):
         def __init__(self, conn, *args):
@@ -633,6 +652,10 @@ async def status(self, clause, *multiparams, **params):
         async with self.acquire(reuse=True) as conn:
             return await conn.status(clause, *multiparams, **params)
 
+    async def run_sync(self, fn: Callable, *arg, **kw) -> Any:
+        async with self.acquire(reuse=True) as conn:
+            return await conn.run_sync(fn, *arg, **kw)
+
     class _CompileConnection:
         def __init__(self, dialect):
             self.dialect = dialect
@@ -737,7 +760,7 @@ def repr(self, color=False):
         return repr(self)
 
     def __repr__(self):
-        return f'{self.__class__.__name__}<{self.sync_engine.pool.status()}>'
+        return f"{self.__class__.__name__}<{self.sync_engine.pool.status()}>"
 
 
 class AsyncOptionEngine(OptionEngineMixin, GinoEngine):

src/gino/loader.py

@@ -2,6 +2,7 @@
 import warnings
 
 from sqlalchemy import select
+from sqlalchemy.engine.result import FilterResult
 from sqlalchemy.schema import Column
 from sqlalchemy.sql.elements import Label
 
@@ -213,12 +214,13 @@ def __init__(self, model, *columns, **extras):
         self.on_clause = None
 
     def _do_load(self, row):
-        values = dict((c.name, row[c]) for c in self.columns if c in row)
+        columns = row.keys()
+        values = dict((c.name, row[c]) for c in self.columns if c in columns)
         if all((v is None) for v in values.values()):
             return None
         rv = self.model()
         for c in self.columns:
-            if c in row:
+            if c in columns:
                 # noinspection PyProtectedMember
                 instance_key = self.model._column_name_map.invert_get(c.name)
                 rv.__values__[instance_key] = row[c]
@@ -424,3 +426,97 @@ def do_load(self, row, context):
         """
 
         return self.value, True
+
+
+class LoaderResult(FilterResult):
+    def __init__(self, result, loader):
+        self._real_result = result
+        self._loader = loader
+        self._ctx = {}
+        self._metadata = result._metadata
+        if result._source_supports_scalars:
+            self._metadata = self._metadata._reduce([0])
+
+    def _post_creational_filter(self, row):
+        obj, distinct = self._loader.do_load(row, self._ctx)
+        return obj
+
+    def fetchall(self):
+        # type: () -> List[Mapping]
+        """A synonym for the :meth:`_engine.MappingResult.all` method."""
+
+        return self._allrows()
+
+    def fetchone(self):
+        # type: () -> Mapping
+        """Fetch one object.
+
+        Equivalent to :meth:`_result.Result.fetchone` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+        """
+
+        row = self._onerow_getter(self)
+        if row is _NO_ROW:
+            return None
+        else:
+            return row
+
+    def fetchmany(self, size=None):
+        # type: (Optional[Int]) -> List[Mapping]
+        """Fetch many objects.
+
+        Equivalent to :meth:`_result.Result.fetchmany` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+        """
+
+        return self._manyrow_getter(self, size)
+
+    def all(self):
+        # type: () -> List[Mapping]
+        """Return all scalar values in a list.
+
+        Equivalent to :meth:`_result.Result.all` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+        """
+
+        return self._allrows()
+
+    def first(self):
+        # type: () -> Optional[Mapping]
+        """Fetch the first object or None if no object is present.
+
+        Equivalent to :meth:`_result.Result.first` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+
+        """
+        return self._only_one_row(False, False, False)
+
+    def one_or_none(self):
+        # type: () -> Optional[Mapping]
+        """Return at most one object or raise an exception.
+
+        Equivalent to :meth:`_result.Result.one_or_none` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+        """
+        return self._only_one_row(True, False, False)
+
+    def one(self):
+        # type: () -> Mapping
+        """Return exactly one object or raise an exception.
+
+        Equivalent to :meth:`_result.Result.one` except that
+        mapping values, rather than :class:`_result.Row` objects,
+        are returned.
+
+        """
+        return self._only_one_row(True, True, False)

tests/test_bind.py

@@ -48,9 +48,8 @@ async def test_db_api(bind, random_name):
         await db.first(User.query.where(User.nickname == random_name))
     ).nickname == random_name
     assert len(await db.all(User.query.where(User.nickname == random_name))) == 1
-    assert (await db.status(User.delete.where(User.nickname == random_name)))[
-        0
-    ] == "DELETE 1"
+    ctx = await db.status(User.delete.where(User.nickname == random_name))
+    assert ctx.rowcount == 1
     stmt, params = db.compile(User.query.where(User.id == 3))
     assert params[0] == 3
 

tests/test_core.py

@@ -8,8 +8,7 @@
 
 async def test_engine_only():
     import gino
-    from gino.schema import GinoSchemaVisitor
-    from sqlalchemy.engine.result import RowProxy
+    from sqlalchemy.engine import Row
 
     metadata = MetaData()
 
@@ -30,18 +29,19 @@ async def test_engine_only():
     )
 
     engine = await gino.create_engine(PG_URL)
-    await GinoSchemaVisitor(metadata).create_all(engine)
+    await engine.run_sync(metadata.create_all)
     try:
         ins = users.insert().values(name="jack", fullname="Jack Jones")
         await engine.status(ins)
         res = await engine.all(users.select())
-        assert isinstance(res[0], RowProxy)
+        assert isinstance(res[0], Row)
     finally:
-        await GinoSchemaVisitor(metadata).drop_all(engine)
+        await engine.run_sync(metadata.drop_all)
 
 
 async def test_core():
     from gino import Gino
+    from sqlalchemy.engine import Row
 
     db = Gino()
 
@@ -68,7 +68,7 @@ async def test_core():
                 name="jack", fullname="Jack Jones",
             ).gino.status()
             res = await users.select().gino.all()
-            assert isinstance(res[0], RowProxy)
+            assert isinstance(res[0], Row)
         finally:
             await db.gino.drop_all()
 

tests/test_engine.py

@@ -48,9 +48,8 @@ async def test_basic(engine):
     assert isinstance((await engine.all("select now()"))[0][0], datetime)
     assert isinstance((await engine.one("select now()"))[0], datetime)
     assert isinstance((await engine.one_or_none("select now()"))[0], datetime)
-    status, result = await engine.status("select now()")
-    assert status == "SELECT 1"
-    assert isinstance(result[0][0], datetime)
+    ctx = await engine.status("select now()")
+    assert ctx.rowcount == 1
     with pytest.raises(ObjectNotExecutableError):
         await engine.all(object())