Changeset 50

Timestamp:

01/08/05 07:26:45

Author:

fumanchu

Message:

1. Modified Unit.add() to take multiple units.
2. Pulled multirecall out of sandbox.recall.
3. db.SM now has multirecall, multiselect methods.
4. zoo_fixture has new multirecall test.
5. zoo_fixture now does profiling.

Files:

• trunk/__init__.py (modified) (3 diffs)
• trunk/doc/managing.html (modified) (1 diff)
• trunk/doc/modeling.html (modified) (5 diffs)
• trunk/storage/db.py (modified) (5 diffs)
• trunk/storage/storeado.py (modified) (1 diff)
• trunk/storage/storepypgsql.py (modified) (1 diff)
• trunk/storage/storeshelve.py (modified) (3 diffs)
• trunk/storage/zoo_fixture.py (modified) (4 diffs)

trunk/__init__.py

@@ -414 +414 @@
-        return self.sandbox.unit(farClass, **kwargs)
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            else:
-
-
-
-
+
+
-
-
@@ -661 +663 @@
-        unit.sandbox = None
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        
-        store = self.arena.storage(cls)
-        
-        if args:
-            # Deal with multiple class/expr pairs.
-            
-            # Format extra class/expr pairs more rigorously
-            pairs = []
-            args = list(args)
-            while args:
-                c = args.pop(0)
-                if self.arena.storage(c) is not store:
-                    raise ValueError(u"recall() does not currently support "
-                                     u"multiple classes in disparate stores.")
-                if args:
-                    e = args.pop(0)
-                else:
-                    e = None
-                pairs.append((c, e))
-            
-            # Don't try any in-memory techniques, just flush it all,
-            # and ask the SM to give us what we want.
-            self.flush(cls)
-            for c, e in pairs:
-                self.flush(c)
-            for units in store.recall(cls, expr, pairs):
-                confirmed = True
-                for unit in units:
-                    if unit is not None:
-                        ID = unit.ID
-                        cache = self._cache(unit.__class__)
-                        if ID not in cache:
-                            cache[ID] = unit
-                        unit.sandbox = self
-                    if hasattr(unit, 'on_recall'):
-                        try:
-                            unit.on_recall()
-                        except UnrecallableError:
-                            confirmed = False
-                if confirmed:
-                    yield units
-            raise StopIteration
-        
-        # Run through our cache first.
@@ -778 +714 @@
-                        yield unit
-    
+    def multirecall(self, *pairs):
+        """multirecall((cls1, expr1), ...) -> [[unit, ...], [unit, ...], ...]
+        Recall units of each cls which match each expr.
+        
+        Units of each additional cls/expr pair will be recalled; however,
+        only those Units with associations to Units in the PRIMARY set will
+        be returned. For you database guys, it's a set of inner joins,
+        ALL of which are between the FIRST set and the subsequent set(s).
+        
+        Instead of single Units, each yielded value will be a tuple of
+        Units, in the same order as the cls args were supplied. This
+        facilitates unpacking in iterative consumer code like:
+        
+        for invoice, price in sandbox.multirecall(Invoice, f, Price, None):
+            deal_with(invoice)
+            deal_with(price)
+        """
+        
+        store = self.arena.storage(pairs[0][0])
+        for c, e in pairs:
+            if self.arena.storage(c) is not store:
+                raise ValueError(u"multirecall() does not support multiple"
+                                 u" classes in disparate stores.")
+        
+        # Don't try any in-memory mixing; just flush it all,
+        # and ask the SM to give us what we want.
+        for c, e in pairs:
+            self.flush(c)
+        for unitset in store.multirecall(*pairs):
+            confirmed = True
+            for index in xrange(len(unitset)):
+                unit = unitset[index]
+                ID = unit.ID
+                cache = self._cache(unit.__class__)
+                if ID in cache:
+                    # Force using the same unit each time.
+                    unitset[index] = cache[ID]
+                else:
+                    cache[ID] = unit
+                    unit.sandbox = self
+                    if hasattr(unit, 'on_recall'):
+                        try:
+                            unit.on_recall()
+                        except UnrecallableError:
+                            confirmed = False
+                            break
+            if confirmed:
+                yield unitset
+    
-    def unit(self, cls, **kwargs):
-        """unit(cls, **kwargs) -> A single matching Unit, else None.

trunk/doc/managing.html

@@ -304 +304 @@
-any Rules.</p>
-
-Rules
+<a name='unitenginerules'>Rules</a>
-<p>Just like Collections and Engines, <tt>UnitEngineRule</tt> is <i>also</i>
-a subclass of <tt>Unit</tt>, and can be persisted via Storage Managers. All

trunk/doc/modeling.html

@@ -300 +300 @@
-know; I might be convinced to add a <tt>recall_list</tt> method.</p>
-
-<p><strike>The <tt>recall</tt> method will take additional arguments in pairs of
-<tt>cls</tt>, <tt>expr</tt>.</strike> This feature isn't fully developed yet.
-It's designed to emulate JOINs, returning units which match each expr
-and are related.</p>
-
-<p>If your Unit class defines an <tt>on_recall()</tt> method, it will be
-called when each Unit has been loaded from storage (at the end of the
@@ -328 +323 @@
-(although the rest are probably loaded into memory).</p>
-
+<h5>multirecall()</h5>
+<p>The <tt>multirecall</tt> method will take multiple pairs of
+(<tt>cls</tt>, <tt>expr</tt>), and return a series of unitsets. Each
+unitset will be a list of units, one per cls passed in to the method.
+<pre>pubs = box.multirecall((Publisher, logic.filter(ID=4)),
+                            (Publication, None))</pre>
+This example will retrieve a list of (Publisher, Publication) pairs.</p>
+
+<p>In database terminology, the multirecall method performs a series of
+full inner joins between the first unit class and each subsequent class.
+That is, class 2 is joined to class 1, then class 3 is joined to class 1,
+etcetera. Since each join is an inner join, the result set is guaranteed
+to contain a complete set of units for each iteration; however, repeated
+units will reference the same object; in the example above, each Publisher
+unit will be the same object, since we limited that expression to a single
+Publisher. So we might iterate over "pubs" multiple times, but each time,
+the first unit in the set will be the same unit instance.</p>
+
-<h4>Forgetting and Repressing</h4>
-<p>To <i>forget</i> a Unit is to destroy it forever. You have two options
@@ -395 +408 @@
-</p>
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-and the value is a tuple of (near key, far key).</p>
-
+<h4><tt>Unit.add()</tt></h4>
+<p>Once two classes have been associated, you attach Unit <i>instances</i>
+to each other by equating their associated properties. That was a
+mouthful. Here's an example:
+<pre>>>> evbio = Biography()
+>>> evbio.ArchID = Eversley.ID
+</pre>
+The two unit <i>instances</i> (evbio and Eversley) are now associated
+(only their <i>classes</i> were before).</p>
+
+<p>Rather than forcing you to remember all of the related classes and keys,
+Dejavu Units all have an <tt>add</tt> method, which does the same thing:
+<pre>>>> evbio = Biography()
+>>> evbio.add(Eversley)
+</pre>
+The <tt>add</tt> method works in either direction, so you could just as
+well write:
+<pre>>>> evbio = Biography()
+>>> Eversley.add(evbio)
+</pre>
+The <tt>add</tt> method will take any number of unit instances as
+arguments, and add each one in turn. That is:
+<pre>
+>>> evbio1 = Biography()
+>>> evbio2 = Biography()
+>>> evbio3 = Biography()
+>>> Eversley.add(evbio1, evbio2, evbio3)
+</pre>
+</p>
+
-<h4><tt>related_units</tt> methods</h4>
-In addition
+To make querying easier
-<i>related_units</i> method which simplifies looking up related instances
-of the other class. The new method for Unit_B will have the name of Unit_A,
@@ -418 +463 @@
-&lt;listiterator object at 0x012150D0>
->>> list(bios)
-
+
+
+
-</pre>
-
-
-
-
-
+
+
+
+
-
-<p>Because the related_units method names are formed automatically, you need
-to take care not to use the names of Unit classes for your Unit properties.
-
-
-
-
-
-futur
+ If we
+
+
+
+
+approach is probably to end your property name with "ID" every tim
-
-<p>Unlike some other ORM's, Dejavu doesn't cache far Units within the near
@@ -453 +499 @@
-properties and call sandbox.unit() for you, returning either the first
-such far Unit or None if not found.</p>
-
-
-<h3>The Arena Object</h3>

trunk/storage/db.py

@@ -800 +800 @@
-        return res.row_list, res.col_defs
-    
-, pairs=None
+
-        if expr is None:
-            expr = logic.Expression(lambda x: True)
@@ -806 +806 @@
-        data, col_defs = self.fetch(sql)
-        
-
-
-
-
-
+
+
-        
-        # Get specs on properties. Get the ID property first in case other
@@ -937 +934 @@
-    
-    def destroy(self, unit):
-
+destroy(unit). 
-        self.execute(u'DELETE * FROM %s WHERE %s = %s;' %
-                     (self.tablename(unit), self.identifier("ID"),
@@ -943 +940 @@
-    
-    def distinct(self, cls, fields, expr=None):
-Return distinct values for specified
+distinct(cls, fields, expr=None) -> Distinct values for given
-        if expr is None:
-            expr = logic.Expression(lambda x: True)
@@ -965 +962 @@
-                       for i, val in enumerate(row)])
-                 for row in data]
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/storage/storeado.py

@@ -311 +311 @@
-            raise
-    
-    def _join(self, path=[]):
-        if not path:
-            return u''
-        firstcls = path.pop(0)
-        if not path:
-            return firstcls.__name__
-        
-        spath = self.arena.associations.shortest_path(firstcls, path[0])
-        spath.pop(0)
-        cls = spath[0]
-        
-        p = self.prefix
-        i = self.identifier
-        left = i(p, firstcls.__name__)
-        right = i(p, cls.__name__)
-        if len(spath) == 1:
-            child = right
-        else:
-            child = u"(%s)" % self._join(spath)
-        leftkey, rightkey = firstcls._associations[cls]
-        
-        return (u"%s LEFT JOIN %s ON %s.%s = %s.%s" %
-                (left, child, left, leftkey, right, rightkey))
-    
-    def multiselect(self, firstcls, firstexpr, pairs):
-        firstwhere, imp = self.where(firstcls, firstexpr)
-        cols = [(firstcls, k) for k in firstcls.properties()]
-        
-        if len(pairs) != 1:
-            raise ValueError("Multiselect does not yet work on multiple pairs.")
-        
-        for cls, expr in pairs:
-            if expr is None:
-                expr = logic.Expression(lambda x: True)
-            
-            j = self._join([firstcls, cls])
-            
-            w, new_imp = self.where(cls, expr)
-            imp |= new_imp
-            if w and w != "TRUE":
-                w = " WHERE %s AND %s" % (w, firstwhere)
-            else:
-                w = " WHERE %s" % firstwhere
-            
-            cols += [(cls, k) for k in cls.properties()]
-            colnames = ["%s.%s" % (self.identifier(self.prefix, colcls.__name__),
-                                   self.identifier(k))
-                        for colcls, k in cols]
-            
-            statement = "SELECT %s FROM %s%s" % (u', '.join(colnames), j, w)
-            
-            return statement, imp, cols
-    
-    def execute(self, query, conn=None):
-        if conn is None:

trunk/storage/storepypgsql.py

@@ -100 +100 @@
-                columns.append((res.fname(index), res.ftype(index)))
-        
-
-
-
-
-
+
+
+
-        
-iterator()
+data
-

trunk/storage/storeshelve.py

@@ -36 +36 @@
-        return s, lock
-    
-, pairs=None
+
-        units = []
-        data, lock = self.shelf(cls)
@@ -97 +97 @@
-    
-    def distinct(self, cls, fields, expr=None):
-Return distinct values for specified
+distinct(cls, fields, expr=None) -> Distinct values for given
-        if expr is None:
-            expr = logic.Expression(lambda x: True)
@@ -114 +114 @@
-        finally:
-            lock.release()
+    
+    def multirecall(self, *pairs):
+        """multirecall(*pairs) -> Full inner join units for each (cls, expr) pair."""
+        raise NotImplementedError("This method doesn't yet work for shelve.")
+        unitsets = []
+        
+        firstcls = pairs[0][0]
+        for cls, expr in pairs:
+            if cls is not firstcls:
+                spath = self.arena.associations.shortest_path(firstcls, cls)
+                # This should be firstcls in every case.
+                cls1 = spath.pop(0)
+                for cls2 in spath:
+                    leftkey, rightkey = cls1._associations[cls2]
+                    wheres.append("(%s.%s = %s.%s)" %
+                                  (t(cls1), i(leftkey),
+                                   t(cls2), i(rightkey)))
+                    cls1 = cls2
+                join = logic.Expression()
+                expr = expr + join
+            
+            unitset = [unit for unit in self.recall(cls, expr)]
+            unitsets.append(unitset)
+        
+        for unitset in unitsets:
+            yield unitset
-

trunk/storage/zoo_fixture.py

@@ -60 +60 @@
-        box.memorize(zoo.Animal(Name='Ostrich', Legs=2, PreviousZoos=[]))
-        box.memorize(zoo.Animal(Name='Centipede', Legs=100))
+        
-        emp = zoo.Animal(Name='Emperor Penguin', Legs=2)
-        box.memorize(emp)
@@ -66 +67 @@
-        
-        millipede = zoo.Animal(Name='Millipede', Legs=1000000)
-        millipede.add(SDZ)
-        millipede.PreviousZoos = [WAP.ID]
-        box.memorize(millipede)
+        
+        SDZ.add(emp, adelie, millipede)
-        
-        # Exhibits
@@ -204 +206 @@
-        self.assertEqual(legs, [1, 2, 4, 100, 1000000])
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -242 +257 @@
-            pass
-
-
+, profile=True
-    import traceback
-    try:
-        try:
-            setup_SM(SM_class, opts)
-
+
+
+
+
+
+
-        except SystemExit:
-            # unittest.main normally raises SystemExit when complete.