Removed AsyncDatabase.fetch_results() + compat logic updated

Author: rudyryk

peewee_async.py

@@ -298,15 +298,6 @@ def execute_sql(self, *args, **kwargs):
                         (str(args), str(kwargs)))
         return super().execute_sql(*args, **kwargs)
 
-    async def fetch_results(self, query, cursor):
-        # TODO: Probably we don't need this method at all?
-        # We might get here if we use older `Manager` interface. 
-        if isinstance(query, peewee.BaseModelSelect):
-            return await AsyncQueryWrapper.make_for_all_rows(cursor, query)
-        if isinstance(query, peewee.RawQuery):
-            return await AsyncQueryWrapper.make_for_all_rows(cursor, query)
-        assert False, "Unsupported type of query '%s', use AioModel instead" % type(query)
-
     def connection(self) -> ConnectionContext:
         return ConnectionContext(self.aio_pool, self._task_data)
 
@@ -324,16 +315,12 @@ async def aio_execute(self, query, fetch_results=None):
 
         :param query: peewee query instance created with ``Model.select()``,
                       ``Model.update()`` etc.
-        :param fetch_results: function with cursor param. It let you get data manually and don't need to close cursor
-                It will be closed automatically
-        :return: result depends on query type, it's the same as for sync
-            ``query.execute()``
+        :param fetch_results: function with cursor param. It let you get data manually and
+                              don't need to close cursor It will be closed automatically.
+        :return: result depends on query type, it's the same as for sync `query.execute()`
         """
         sql, params = query.sql()
-        if fetch_results is None:
-            query_fetch_results = getattr(query, 'fetch_results', None)
-            database_fetch_results = functools.partial(self.fetch_results, query)
-            fetch_results = query_fetch_results or database_fetch_results
+        fetch_results = fetch_results or getattr(query, 'fetch_results', None)
         return await self.aio_execute_sql(sql, params, fetch_results=fetch_results)
 
 

peewee_async_compat.py

@@ -49,7 +49,23 @@ def _patch_query_with_compat_methods(query, async_query_cls):
     - aio_get (for SELECT)
     - aio_scalar (for SELECT)
     """
-    from peewee_async import AioModelSelect
+    from peewee_async import AioModelSelect, AioModelUpdate, AioModelDelete, AioModelInsert
+
+    if getattr(query, 'aio_execute', None):
+        # No need to patch
+        return
+
+    if async_query_cls is None:
+        if isinstance(query, peewee.RawQuery):
+            async_query_cls = AioModelSelect
+        if isinstance(query, peewee.SelectBase):
+            async_query_cls = AioModelSelect
+        elif isinstance(query, peewee.Update):
+            async_query_cls = AioModelUpdate
+        elif isinstance(query, peewee.Delete):
+            async_query_cls = AioModelDelete
+        elif isinstance(query, peewee.Insert):
+            async_query_cls = AioModelInsert
 
     query.aio_execute = partial(async_query_cls.aio_execute, query)
     query.fetch_results = partial(async_query_cls.fetch_results, query)
@@ -345,6 +361,7 @@ async def create_or_get(self, model_, **kwargs):
 
     async def execute(self, query):
         """Execute query asyncronously."""
+        _patch_query_with_compat_methods(query, None)
         return await self.database.aio_execute(query)
 
     async def prefetch(self, query, *subqueries, prefetch_type=peewee.PREFETCH_TYPE.JOIN):