Fix one_or_zero to dereference always for 1 col

Author: chadwhitacre

postgres/__init__.py

@@ -341,20 +341,14 @@ def all(self, sql, parameters=None):
         :type parameters: dict or tuple
         :returns: :py:class:`list` of records or single values
 
-        >>> for value in db.all("SELECT bar FROM foo"):
-        ...     print(value)
-        ...
-        buz
-        bit
+        >>> db.all("SELECT * FROM foo ORDER BY bar")
+        [Record(bar=u'bit', baz=537), Record(bar=u'buz', baz=42)]
 
         If the query results in a single column, we return a list of values
         rather than a list of records of values.
 
-        >>> for value in db.all("SELECT bar FROM foo"):
-        ...     print(value)
-        ...
-        buz
-        bit
+        >>> db.all("SELECT bar FROM foo ORDER BY bar")
+        ['bit', 'buz']
 
         """
         with self.get_transaction() as txn:
@@ -378,21 +372,25 @@ def one_or_zero(self, sql, parameters=None, zero=None):
         Use this for the common case where there should only be one record, but
         it may not exist yet.
 
+        >>> db.one_or_zero("SELECT * FROM foo WHERE bar='buz'")
+        Record(bar=u'buz', baz=42)
         >>> row = db.one_or_zero("SELECT * FROM foo WHERE bar='blam'")
         >>> if row is None:
         ...     print("No blam yet.")
         ...
         No blam yet.
 
-        If the query returns one result and that result has one field and the
-        value of that field is a :py:class:`~postgres.orm.Model` subclass, then
-        we'll unravel and return just that instance for you.
+        If the query result has only one column, then we dereference that for
+        you.
+
+        >>> db.one_or_zero("SELECT baz FROM foo WHERE bar='buz'")
+        42
 
         """
         out = self._some(sql, parameters, 0, 1)
         if out is None:
             out = zero
-        elif len(out) == 1 and isinstance(out[0], Model):
+        elif len(out) == 1:
             out = out[0]
         return out
 

postgres/orm.py

@@ -94,9 +94,9 @@
 That will plug your model into the :py:mod:`psycopg2` composite casting
 machinery, and you'll now get instances of your model back from
 :py:meth:`~postgres.Postgres.all` and :py:meth:`~postgres.Postgres.one_or_zero`
-when you cast your query results to the relevant type. If your query returns
-more than one column, you'll need to dereference the column containing the
-model just as with any other query:
+when you cast to the relevant type in your query. If your query returns more
+than one column, you'll need to dereference the column containing the model
+just as with any other query:
 
     >>> rec = db.one_or_zero("SELECT foo.*::foo, bar.* "
     ...                      "FROM foo JOIN bar ON foo.bar = bar.bar "