Looking up foreign keys now avoids db access if possible

tests/test_relations.py

@@ -138,3 +138,12 @@ def test_relation_6(connection):
     Child7(parent=p).insert()
     Child7(parent=p).insert()
     assert len(p.children) == 0
+
+
+def test_relation_7(connection):
+    p = Parent()
+    p.insert()
+    Child(parent=p).insert()
+    Parent.del_object(p)
+    c, = Child
+    assert len(c.parent.children) == 1

wurm/tables.py

@@ -5,8 +5,8 @@
 from weakref import WeakValueDictionary
 
 from .typemaps import (to_stored, Primary, is_primary, unwrap_type,
-    is_unique)
-from .queries import Query
+    is_unique, columns_for)
+from .queries import Query, decode_row
 from .connection import execute
 from . import sql
 
@@ -28,10 +28,10 @@ def indexes(fields):
         if is_unique(value))
 
 def primary_key_columns(item):
-    for fieldname, ty in item.__fields_info__.items():
-        if fieldname in item.__primary_key__:
-            yield from to_stored(fieldname, ty,
-                getattr(item, fieldname)).values()
+    info = item.__fields_info__
+    for fieldname in item.__primary_key__:
+        yield from to_stored(fieldname, info[fieldname],
+            getattr(item, fieldname)).values()
 
 class relation:
     """Describe a relationship between two tables.
@@ -156,6 +156,16 @@ def query(self, **kwargs):
         return Query(self, kwargs)
     def get_object(self, pk, values):
         if pk not in self.__id_map__:
+            if values is None:
+                info = self.__fields_info__
+                params = {name: value for field in self.__primary_key__
+                    for name, value
+                    in zip(columns_for(field, info[field]), pk)}
+                comparisons = ' and '.join(f'{column}=:{column}'
+                    for column in params)
+                params['_limit_'] = 1
+                row = execute(sql.select(self, comparisons, True), params).fetchone()
+                return decode_row(self, row)
             if 'rowid' in values:
                 rowid = values.pop('rowid')
             else:

wurm/typemaps.py

@@ -153,11 +153,10 @@ def from_stored(stored_tuple, python_type):
     if all(v is None for v in stored_tuple):
         return None
     from .tables import BaseTable
-    from .queries import Query
     if issubclass(python_type, BaseTable):
         # FIXME: this is problematic for recursive foreign keys
         # not to mention the n + 1 problem
-        return Query(python_type, dict(zip(python_type.__primary_key__, stored_tuple))).one()
+        return python_type.get_object(stored_tuple, None)
     return TYPE_MAPPING[python_type].decode(*stored_tuple)
 
 def sql_type_for(fieldname, python_type):