Changeset 356

Timestamp:

07/08/08 11:07:14 (4 years ago)

Author:

ged

Message:

• better support for viewonly relationships
  
• restore flush method on Entity (accidentaly renamed in r349... ooops)
  (closes ticket #54)
  
• Added support for filtered OneToMany relationships. Produce viewonly
  relations. See source:elixir/trunk/tests/test_o2m.py for an example.
  
• optimized "inverse" property on relation a bit (if None is found once, it's
  stored and not recomputed over and over)
  
• embryonic debugging output
  

Location:

elixir/trunk

Files:

• CHANGES (modified) (1 diff)
• TODO (modified) (1 diff)
• elixir/__init__.py (modified) (2 diffs)
• elixir/entity.py (modified) (8 diffs)
• elixir/relationships.py (modified) (8 diffs)
• tests/test_o2m.py (modified) (2 diffs)

elixir/trunk/CHANGES

@@ -23 +23 @@
 - Added on_reconstitute event/method decorator. Only works with SA 0.5.
 - Added support for viewonly relationships (OneToMany and OneToOne).
+- Added support for filtered OneToMany relationships. Produce viewonly
+  relations. See source:elixir/trunk/tests/test_o2m.py for an example.
 
 Changes:

elixir/trunk/TODO

@@ -84 +84 @@
   instead of the acts_as_taggable Jonathan demonstrated
 
-- implement something like:
-
-    class A(Entity):
-        has_many('b', of_kind='B')
-        has_many('b_filtered', of_kind='B', filter=lambda c: c.extra < 10)
-    class B(Entity):
-        has_field('extra', Integer)
-        belongs_to('a', of_kind='A')
-
-  this is the more or less the same as what is described at:
+- support custom selectable on relationships, as is done at:
 
   http://spyced.blogspot.com/2007/01/why-sqlalchemy-impresses-me.html

elixir/trunk/elixir/__init__.py

@@ -165 +165 @@
     Optionally drops the tables.
     '''
+    session.rollback()
+    session.clear()
+    session.close()
+
+    cleanup_entities(entities)
+
+    sqlalchemy.orm.clear_mappers()
+    entities._entities = {}
+    del entities[:]
+
     if drop_tables:
         drop_all(*args, **kwargs)
-
-    cleanup_entities(entities)
 
     for md in metadatas:
@@ -174 +182 @@
     metadatas.clear()
 
-    session.close()
 
-    sqlalchemy.orm.clear_mappers()
-    del entities[:]
-

elixir/trunk/elixir/entity.py

@@ -22 +22 @@
 from elixir.properties import Property
 
+DEBUG = False
 
 __doc_all__ = ['Entity', 'EntityMeta']
-
 
 
@@ -454 +454 @@
                                 (col.key, table.name))
             table.append_column(col)
+            if DEBUG:
+                print "table.append_column(%s)" % col
 
     def add_constraint(self, constraint):
@@ -478 +480 @@
         if mapper:
             mapper.add_property(name, property)
+            if DEBUG:
+                print "mapper.add_property('%s', %s)" % (name, repr(property))
 
     def add_mapper_extension(self, extension):
@@ -497 +501 @@
         return None
 
-    def get_inverse_relation(self, rel, reverse=False):
+    def get_inverse_relation(self, rel, check_reverse=True):
         '''
         Return the inverse relation of rel, if any, None otherwise.
@@ -504 +508 @@
         matching_rel = None
         for other_rel in self.relationships:
-            if other_rel.is_inverse(rel):
+            if rel.is_inverse(other_rel):
                 if matching_rel is None:
                     matching_rel = other_rel
@@ -518 +522 @@
         # of the method though. But we do need to be careful not to start an
         # infinite recursive loop.
-        if matching_rel and not reverse:
-            rel.entity._descriptor.get_inverse_relation(matching_rel, True)
+        if matching_rel and check_reverse:
+            rel.entity._descriptor.get_inverse_relation(matching_rel, False)
 
         return matching_rel
@@ -921 +925 @@
 
     # session methods
-    def commit(self, *args, **kwargs):
-        return object_session(self).commit([self], *args, **kwargs)
+    def flush(self, *args, **kwargs):
+        return object_session(self).flush([self], *args, **kwargs)
 
     def delete(self, *args, **kwargs):
@@ -951 +955 @@
         return self._global_session.update(self, *args, **kwargs)
 
+    # only exist in SA < 0.5
+    # IMO, the replacement (session.add) doesn't sound good enough to be added
+    # here. For example: "o = Order(); o.add()" is not very telling. It's
+    # better to leave it as "session.add(o)"
     def save_or_update(self, *args, **kwargs):
         return self._global_session.save_or_update(self, *args, **kwargs)

elixir/trunk/elixir/relationships.py

@@ -356 +356 @@
 
         self._target = None
-        self._inverse = None
 
         self.property = None # sqlalchemy property
@@ -395 +394 @@
             return
 
-        kwargs = {}
-        if self.inverse:
+        kwargs = self.get_prop_kwargs()
+
+        # viewonly relationships need to create "standalone" relations (ie
+        # shouldn't be a backref of another relation).
+        if self.inverse and not kwargs.get('viewonly', False):
             # check if the inverse was already processed (and thus has already
             # defined a backref we can use)
             if self.inverse.backref:
-                kwargs['backref'] = self.inverse.backref
+                # let the user override the backref argument
+                if 'backref' not in kwargs:
+                    kwargs['backref'] = self.inverse.backref
             else:
-                kwargs = self.get_prop_kwargs()
-
                 # SQLAlchemy doesn't like when 'secondary' is both defined on
                 # the relation and the backref
@@ -411 +413 @@
                 self.backref = backref(self.name, **kwargs)
                 return
-
-        kwargs.update(self.get_prop_kwargs())
 
         self.property = relation(self.target, **kwargs)
@@ -428 +428 @@
 
     def inverse(self):
-        if not self._inverse:
+        if not hasattr(self, '_inverse'):
             if self.inverse_name:
                 desc = self.target._descriptor
@@ -439 +439 @@
                 assert self.match_type_of(inverse)
             else:
-                inverse = self.target._descriptor.get_inverse_relation(self)
-
-            if inverse:
-                self._inverse = inverse
+                check_reverse = not self.kwargs.get('viewonly', False)
+                inverse = self.target._descriptor.get_inverse_relation(self,
+                            check_reverse=check_reverse)
+
+            self._inverse = inverse
+            if inverse and not self.kwargs.get('viewonly', False):
                 inverse._inverse = self
 
@@ -452 +454 @@
 
     def is_inverse(self, other):
-        # viewonly relationships shouldn't match as inverse of anything (so
-        # that no backref is created -- which doesn't make sense in that case)
-        viewonly = self.kwargs.get('viewonly', False) or \
-                   other.kwargs.get('viewonly', False)
-        return not viewonly and \
+        # viewonly relationships are not symmetrical: a viewonly relationship
+        # should have exactly one inverse (a ManyToOne relationship), but that
+        # inverse shouldn't have the viewonly relationship as its inverse.
+        return not other.kwargs.get('viewonly', False) and \
                other is not self and \
                self.match_type_of(other) and \
@@ -614 +615 @@
     uselist = False
 
+    def __init__(self, *args, **kwargs):
+        self.filter = kwargs.pop('filter', None)
+        if self.filter is not None:
+            kwargs['viewonly'] = True
+        super(OneToOne, self).__init__(*args, **kwargs)
+
     def match_type_of(self, other):
         return isinstance(other, ManyToOne)
 
     def create_keys(self, pk):
-        # When using a viewonly relationship, you are on your own: Elixir
-        # doesn't check that a corresponding ManyToOne relationship exists.
-        if self.kwargs.get('viewonly', False):
-            return
-
         # make sure an inverse relationship exists
         if self.inverse is None:
@@ -648 +650 @@
             kwargs['remote_side'] = self.inverse.foreign_key
 
-        # viewonly relationships do not have any inverse (and they provide 
-        # their primaryjoin argument manually anyway).
-        if not self.kwargs.get('viewonly', False):
-            if self.inverse.primaryjoin_clauses:
-                kwargs['primaryjoin'] = and_(*self.inverse.primaryjoin_clauses)
+        joinclauses = self.inverse.primaryjoin_clauses
+        if self.filter:
+            joinclauses.append(self.filter(self.target.table.c))
+        if joinclauses:
+            kwargs['primaryjoin'] = and_(*joinclauses)
 
         kwargs.update(self.kwargs)

elixir/trunk/tests/test_o2m.py

@@ -108 +108 @@
 
     def test_viewonly(self):
+        # the callable primaryjoin seem to be unstable... sometime it works,
+        # sometime it doesn't... for no apparent reason. I think it's a bug in
+        # the current revision of SQLAlchemy I'm using (4900).
         class User(Entity):
             two_blurbs = OneToMany('Blurb', primaryjoin=lambda:
@@ -113 +116 @@
                 viewonly=True
             )
+            blurbs = OneToMany('Blurb',
+                               collection_class=ordering_list('position'),
+                               order_by='position')
+
+        class Blurb(Entity):
+            user = ManyToOne('User')
+            position = Field(Integer)
+            blurb = Field(Unicode(255))
+
+            def __init__(self, blurb, **kwargs):
+                super(Blurb, self).__init__(blurb=blurb, **kwargs)
+
+            def __repr__(self):
+                return 'Blurb(%r, %r)' % (self.position, self.blurb)
+
+        setup_all(True)
+
+        user = User(blurbs=[Blurb(u'zero'), Blurb(u'one'), Blurb(u'two')])
+
+        session.commit()
+        session.clear()
+
+        user = User.get(1)
+        assert len(user.two_blurbs) == 2
+        assert user.two_blurbs[0].blurb == 'zero'
+        assert user.two_blurbs[1].blurb == 'one'
+
+    def test_filtered(self):
+        class User(Entity):
+            two_blurbs = OneToMany('Blurb', filter=lambda c: c.position < 2)
             blurbs = OneToMany('Blurb',
                                collection_class=ordering_list('position'),