Changeset 405

Timestamp:

02/01/07 00:03:53

Author:

fumanchu

Message:

New arena.view, sum, distinct, count, range methods (just like the sandbox methods, but without using a cache).

Files:

• trunk/arenas.py (modified) (1 diff)
• trunk/test/zoo_fixture.py (modified) (2 diffs)

trunk/arenas.py

@@ -258 +258 @@
-                if not copy_only:
-                    self._registered_classes[cls] = new_store
+    
+    def view(self, cls, attrs, expr=None, **kwargs):
+        """Yield tuples of attrs for the given cls which match the expr.
+        
+        cls: The Unit subclass for which to yield property tuples.
+        attrs: a sequence of strings; each should be the name of
+            a UnitProperty on the given cls.
+        expr: a lambda or logic.Expression. If provided, data will only
+            be yielded for units of the given cls which match the expr.
+        **kwargs: additional expr filters in name=value format.
+        
+        Each yielded value will be a list of values, in the same order as
+        the attrs arg. This facilitates unpacking in iterative consumer
+        code like:
+        
+        for id, name in sandbox.view(Invoice, ['ID', 'Name'], f):
+            print id, ": ", name
+        
+        This is generally much faster than recall, and should be preferred
+        for performance-sensitive code.
+        """
+        if expr and not isinstance(expr, logic.Expression):
+            expr = logic.Expression(expr)
+        if kwargs:
+            f = logic.filter(**kwargs)
+            if expr:
+                expr += f
+            else:
+                expr = f
+        
+        if self.logflags & logflags.VIEW:
+            self.log("VIEW %s [%s]: %s" % (cls.__name__, attrs, expr))
+        
+        for row in self.storage(cls).view(cls, attrs, expr):
+            yield row
+    
+    def sum(self, cls, attr, expr=None, **kwargs):
+        """Sum of all non-None values for the given cls.attr."""
+        expr = logic.Expression(lambda x: getattr(x, attr) != None) + expr
+        return sum([row[0] for row in self.view(cls, (attr,), expr, **kwargs)])
+    
+    def distinct(self, cls, attrs, expr=None, **kwargs):
+        """List of distinct UnitProperty tuples for the given cls.
+        
+        If only one attribute is specified, a list of values will be returned.
+        If more than one attribute is specified, a zipped list will be returned.
+        
+        Notice that you can also use this function as a count() function
+        (in fact it's the only way to do it) by using attrs = ['ID'].
+        """
+        if expr and not isinstance(expr, logic.Expression):
+            expr = logic.Expression(expr)
+        if kwargs:
+            f = logic.filter(**kwargs)
+            if expr:
+                expr += f
+            else:
+                expr = f
+        
+        if self.logflags & logflags.VIEW:
+            self.log("DISTINCT %s [%s]: %s" % (cls.__name__, attrs, expr))
+        
+        seen = {}
+        for row in self.storage(cls).distinct(cls, attrs, expr):
+            if row not in seen:
+                seen[row] = None
+        
+        seen = seen.keys()
+        seen.sort()
+        if len(attrs) == 1:
+            seen = [x[0] for x in seen]
+        return seen
+    
+    def count(self, cls, expr):
+        """Number of Units of the given cls which match the given expr."""
+        return len(self.distinct(cls, cls.identifiers, expr))
+    
+    def range(self, cls, attr, expr=None, **kwargs):
+        """Distinct, non-None attr values (ordered and continuous, if possible).
+        
+        If the given attribute is a known discrete, ordered type
+        (like int, long, datetime.date), this returns the closed interval:
+            
+            [min(attr), ..., max(attr)]
+        
+        That is, all possible values will be output between min and max,
+        even if they do not appear in the dataset.
+        
+        If the given attribute is not reasonably discrete (e.g., str,
+        unicode, or float) then all distinct, non-None values are returned
+        (sorted, if possible).
+        """
+        existing = [x for x in self.distinct(cls, [attr], expr, **kwargs)
+                    if x is not None]
+        if not existing:
+            return []
+        
+        attr_type = getattr(cls, attr).type
+        if issubclass(attr_type, (int, long)):
+            return range(min(existing), max(existing) + 1)
+        else:
+            try:
+                import datetime
+            except ImportError:
+                pass
+            else:
+                if issubclass(attr_type, datetime.date):
+                    def date_gen():
+                        start, end = min(existing), max(existing)
+                        for d in range((end + 1) - start):
+                            yield start + datetime.timedelta(d)
+                    return date_gen()
+        
+        try:
+            existing.sort()
+        except TypeError:
+            pass
+        
+        return existing
-
-

trunk/test/zoo_fixture.py

@@ -719 +719 @@
-        finally:
-            box.flush_all()
-        
+
-    def test_8_CustomAssociations(self):
-        box = arena.new_sandbox()
@@ -744 +744 @@
-        finally:
-            box.flush_all()
+    
+    def test_9_arena_views(self):
+        # views
+        legs = [x[0] for x in arena.view(Animal, ['Legs'])]
+        legs.sort()
+        self.assertEqual(legs, [1, 2, 2, 2, 2, 2, 4, 4, 4, 4, 100, 1000000])
+        
+        expected = {'Leopard': 73.5,
+                    'Slug': .75,
+                    'Tiger': None,
+                    'Lion': None,
+                    'Bear': None,
+                    'Ostrich': 103.2,
+                    'Centipede': None,
+                    'Emperor Penguin': None,
+                    'Adelie Penguin': None,
+                    'Millipede': None,
+                    'Ape': None,
+                    }
+        for species, lifespan in arena.view(Animal, ['Species', 'Lifespan']):
+            if expected[species] is None:
+                self.assertEqual(lifespan, None)
+            else:
+                self.assertAlmostEqual(expected[species], lifespan, places=5)
+        
+        expected = [u'Montr\xe9al Biod\xf4me', 'Wild Animal Park']
+        e = (lambda x: x.Founded != None
+             and x.Founded <= dejavu.today()
+             and x.Founded >= datetime.date(1990, 1, 1))
+        values =  [val[0] for val in arena.view(Zoo, ['Name'], e)]
+        for name in expected:
+            self.assert_(name in values)
+        
+        # distinct
+        legs = arena.distinct(Animal, ['Legs'])
+        legs.sort()
+        self.assertEqual(legs, [1, 2, 4, 100, 1000000])
+        
+        # This may raise a warning on some DB's.
+        f = (lambda x: x.Species == 'Lion')
+        escapees = arena.distinct(Animal, ['Legs'], f)
+        self.assertEqual(escapees, [4])
+        
+        # range should return a sorted list
+        legs = arena.range(Animal, 'Legs', lambda x: x.Legs <= 100)
+        self.assertEqual(legs, range(1, 101))
+        topics = arena.range(Exhibit, 'Name')
+        self.assertEqual(topics, ['The Penguin Encounter', 'Tiger River'])
+        vets = arena.range(Vet, 'Name')
+        self.assertEqual(vets, ['Charles Schroeder', 'Jim McBain'])
-    
-    def test_Iteration(self):