Return list from fetchall instead of generator

Fixes #8

Author: chadwhitacre

postgres.py

@@ -185,25 +185,37 @@ def execute(self, sql, parameters=None):
         :param unicode sql: the SQL statement to execute
         :param parameters: the bind parameters for the SQL statement
         :type parameters: tuple or dict
+        :returns: :py:const:`None`
 
         """
         with self.get_cursor() as cursor:
             cursor.execute(sql, parameters)
 
     def fetchone(self, sql, parameters=None):
-        """Execute the query and return a single result (``dict`` or ``None``).
+        """Execute the query and return a single result.
+
+        :param unicode sql: the SQL statement to execute
+        :param parameters: the bind parameters for the SQL statement
+        :type parameters: tuple or dict
+        :returns: :py:class:`dict` or :py:const:`None`
+
         """
         with self.get_cursor() as cursor:
             cursor.execute(sql, parameters)
             return cursor.fetchone()
 
     def fetchall(self, sql, parameters=None):
-        """Execute the query and yield the results (``dict``).
+        """Execute the query and return all results.
+
+        :param unicode sql: the SQL statement to execute
+        :param parameters: the bind parameters for the SQL statement
+        :type parameters: tuple or dict
+        :returns: :py:class:`list` of :py:class:`dict`
+
         """
         with self.get_cursor() as cursor:
             cursor.execute(sql, parameters)
-            for row in cursor:
-                yield row
+            return list(cursor)
 
     def get_cursor(self, *a, **kw):
         """Return a :py:class:`~postgres.CursorContextManager` that uses our

tests.py

@@ -33,14 +33,14 @@ class TestExecute(WithSchema):
 
     def test_execute_executes(self):
         self.db.execute("CREATE TABLE foo (bar text)")
-        actual = list(self.db.fetchall("SELECT tablename FROM pg_tables "
-                                       "WHERE schemaname='public'"))
+        actual = self.db.fetchall("SELECT tablename FROM pg_tables "
+                                  "WHERE schemaname='public'")
         assert actual == [{"tablename": "foo"}]
 
     def test_execute_inserts(self):
         self.db.execute("CREATE TABLE foo (bar text)")
         self.db.execute("INSERT INTO foo VALUES ('baz')")
-        actual = len(list(self.db.fetchone("SELECT * FROM foo ORDER BY bar")))
+        actual = len(self.db.fetchone("SELECT * FROM foo ORDER BY bar"))
         assert actual == 1
 
 
@@ -55,7 +55,7 @@ def test_fetchone_returns_None_if_theres_none(self):
         assert actual is None
 
     def test_fetchall_fetches_all(self):
-        actual = list(self.db.fetchall("SELECT * FROM foo ORDER BY bar"))
+        actual = self.db.fetchall("SELECT * FROM foo ORDER BY bar")
         assert actual == [{"bar": "baz"}, {"bar": "buz"}]
 
 
@@ -81,14 +81,14 @@ def test_transaction_is_isolated(self):
         with self.db.get_transaction() as txn:
             txn.execute("INSERT INTO foo VALUES ('blam')")
             txn.execute("SELECT * FROM foo ORDER BY bar")
-            actual = list(self.db.fetchall("SELECT * FROM foo ORDER BY bar"))
+            actual = self.db.fetchall("SELECT * FROM foo ORDER BY bar")
         assert actual == [{"bar": "baz"}, {"bar": "buz"}]
 
     def test_transaction_commits_on_success(self):
         with self.db.get_transaction() as txn:
             txn.execute("INSERT INTO foo VALUES ('blam')")
             txn.execute("SELECT * FROM foo ORDER BY bar")
-        actual = list(self.db.fetchall("SELECT * FROM foo ORDER BY bar"))
+        actual = self.db.fetchall("SELECT * FROM foo ORDER BY bar")
         assert actual == [{"bar": "baz"}, {"bar": "blam"}, {"bar": "buz"}]
 
     def test_transaction_rolls_back_on_failure(self):
@@ -100,7 +100,7 @@ class Heck(Exception): pass
                 raise Heck
         except Heck:
             pass
-        actual = list(self.db.fetchall("SELECT * FROM foo ORDER BY bar"))
+        actual = self.db.fetchall("SELECT * FROM foo ORDER BY bar")
         assert actual == [{"bar": "baz"}, {"bar": "buz"}]