Merge lp:~jamesh/storm/resultset-find into lp:storm

[James Henstridge]

[James Henstridge (jamesh)]

Implement a ResultSet.find() method. In this early implementation, it only handles simple cases and raises FeatureError for other cases (sliced results, grouped result sets, set expressions, etc). We can look at extending the method to handle some of those later.

[lp:~jamesh/storm/resultset-find]

307. By James Henstridge on 2009-04-28

More test tweaks.

[Thomas Herve (therve)]

+ This is analogous to L{Store.find}, although it doesn't take a
+ C{cls_spec} argument, instead using the same tables as the
+ existing result set.

It looks slightly misleading, because it doesn't only take the same tables but also the current where arguments.

+1!

review: Approve

[lp:~jamesh/storm/resultset-find]

308. By James Henstridge on 2009-07-01

Fix up docstring, as per therve's review.

[James Henstridge (jamesh)]

> + This is analogous to L{Store.find}, although it doesn't take a
> + C{cls_spec} argument, instead using the same tables as the
> + existing result set.
>
> It looks slightly misleading, because it doesn't only take the same tables but
> also the current where arguments.

Thanks for the review. I've updated the docstring to state that it also restricts the results to those in the current set.

[Jamu Kakar (jkakar)]

Nice and simple, thanks. +1!

review: Approve

=== modified file 'storm/store.py'
--- storm/store.py	2009-05-19 15:17:29 +0000
+++ storm/store.py	2009-07-28 05:20:38 +0000
@@ -1363,6 +1363,37 @@
                      # in get_column().
         return objects
 
+    def find(self, *args, **kwargs):
+        """Perform a query on objects within this result set.
+
+        This is analogous to L{Store.find}, although it doesn't take a
+        C{cls_spec} argument, instead using the same tables as the
+        existing result set, and restricts the results to those in
+        this set.
+
+        @param args: Instances of L{Expr}.
+        @param kwargs: Mapping of simple column names to values or
+            expressions to query for.
+
+        @return: A L{ResultSet} of matching instances.
+        """
+        if self._select is not Undef:
+            raise FeatureError("Can't query set expressions")
+        if self._offset is not Undef or self._limit is not Undef:
+            raise FeatureError("Can't query a sliced result set")
+        if self._group_by is not Undef:
+            raise FeatureError("Can't query grouped result sets")
+
+        result_set = self.copy()
+        extra_where = get_where_for_args(
+            args, kwargs, self._find_spec.default_cls)
+        if extra_where is not Undef:
+            if result_set._where is Undef:
+                result_set._where = extra_where
+            else:
+                result_set._where = And(result_set._where, extra_where)
+        return result_set
+
     def _set_expr(self, expr_cls, other, all=False):
         if not self._find_spec.is_compatible(other._find_spec):
             raise FeatureError("Incompatible results for set operation")
@@ -1492,6 +1523,9 @@
     def cached(self):
         return []
 
+    def find(self, *args, **kwargs):
+        return self
+
     def union(self, other):
         if isinstance(other, EmptyResultSet):
             return self

=== modified file 'tests/store/base.py'
--- tests/store/base.py	2009-02-19 16:44:33 +0000
+++ tests/store/base.py	2009-07-28 05:20:38 +0000
@@ -5015,6 +5015,62 @@
         self.store.reset()
         self.assertIdentical(Store.of(foo1), None)
 
+    def test_result_find(self):
+        result1 = self.store.find(Foo, Foo.id <= 20)
+        result2 = result1.find(Foo.id > 10)
+        foo = result2.one()
+        self.assertTrue(foo)
+        self.assertEqual(foo.id, 20)
+
+    def test_result_find_kwargs(self):
+        result1 = self.store.find(Foo, Foo.id <= 20)
+        result2 = result1.find(id=20)
+        foo = result2.one()
+        self.assertTrue(foo)
+        self.assertEqual(foo.id, 20)
+
+    def test_result_find_introduce_join(self):
+        result1 = self.store.find(Foo, Foo.id <= 20)
+        result2 = result1.find(Foo.id == Bar.foo_id,
+                               Bar.title == u"Title 300")
+        foo = result2.one()
+        self.assertTrue(foo)
+        self.assertEqual(foo.id, 10)
+
+    def test_result_find_tuple(self):
+        result1 = self.store.find((Foo, Bar), Foo.id == Bar.foo_id)
+        result2 = result1.find(Bar.title == u"Title 100")
+        foo_bar = result2.one()
+        self.assertTrue(foo_bar)
+        foo, bar = foo_bar
+        self.assertEqual(foo.id, 30)
+        self.assertEqual(bar.id, 300)
+
+    def test_result_find_undef_where(self):
+        result = self.store.find(Foo, Foo.id == 20).find()
+        foo = result.one()
+        self.assertTrue(foo)
+        self.assertEqual(foo.id, 20)
+        result = self.store.find(Foo).find(Foo.id == 20)
+        foo = result.one()
+        self.assertTrue(foo)
+        self.assertEqual(foo.id, 20)
+
+    def test_result_find_fails_on_set_expr(self):
+        result1 = self.store.find(Foo)
+        result2 = self.store.find(Foo)
+        result = result1.union(result2)
+        self.assertRaises(FeatureError, result.find, Foo.id == 20)
+
+    def test_result_find_fails_on_slice(self):
+        result = self.store.find(Foo)[1:2]
+        self.assertRaises(FeatureError, result.find, Foo.id == 20)
+
+    def test_result_find_fails_on_group_by(self):
+        result = self.store.find(Foo)
+        result.group_by(Foo)
+        self.assertRaises(FeatureError, result.find, Foo.id == 20)
+
     def test_result_union(self):
         result1 = self.store.find(Foo, id=30)
         result2 = self.store.find(Foo, id=10)
@@ -5641,6 +5697,10 @@
         self.assertEquals(self.result.cached(), [])
         self.assertEquals(self.empty.cached(), [])
 
+    def test_find(self):
+        self.assertEquals(list(self.result.find(Foo.title == u"foo")), [])
+        self.assertEquals(list(self.empty.find(Foo.title == u"foo")), [])
+
     def test_union(self):
         self.assertEquals(self.empty.union(self.empty), self.empty)
         self.assertEquals(type(self.empty.union(self.result)),