From 9c8392f5a4830eac9e7c812f55ddcab6175729e7 Mon Sep 17 00:00:00 2001 From: Willem Bult Date: Thu, 24 Oct 2013 20:12:19 -0700 Subject: [PATCH 1/2] Manager attaches itself to queries so they can run directly --- datastore/objects/managed_query.py | 16 ++++++++++++++++ datastore/objects/manager.py | 5 +++-- datastore/objects/test/test_objects_manager.py | 10 ++++++++-- 3 files changed, 27 insertions(+), 4 deletions(-) create mode 100644 datastore/objects/managed_query.py diff --git a/datastore/objects/managed_query.py b/datastore/objects/managed_query.py new file mode 100644 index 0000000..b5f43f9 --- /dev/null +++ b/datastore/objects/managed_query.py @@ -0,0 +1,16 @@ +from datastore.core import Query + +class ManagedQuery(Query): + '''Query that knows its manager so that it can run directly''' + + def __init__(self, key, manager=None): + super(ManagedQuery, self).__init__(key) + # The manager to perform this query + self._manager = manager + + def perform(self): + ''' Perform the query on the manager ''' + return self._manager.query(self) + + def __repr__(self): + return '<%s %s>' % (self.__class__.__name__, super(ManagedQuery, self).__repr__()) \ No newline at end of file diff --git a/datastore/objects/manager.py b/datastore/objects/manager.py index b534202..9c3ac81 100644 --- a/datastore/objects/manager.py +++ b/datastore/objects/manager.py @@ -2,6 +2,7 @@ from .model import Model from datastore import Query from .object_datastore import ObjectDatastore +from .managed_query import ManagedQuery class Manager(object): @@ -54,10 +55,10 @@ def delete(self, key_or_name): def init_query(self): - '''Initiates a Query object for the model''' + '''Initiates a ManagedQuery object for the model''' if not self.model: raise Exception('Can not query when no model is set on the manager') - return Query(Key('/' + self.model.key_type)) + return ManagedQuery(Key('/' + self.model.key_type), manager=self) def query(self, query): diff --git a/datastore/objects/test/test_objects_manager.py b/datastore/objects/test/test_objects_manager.py index 52b4fac..a734d05 100644 --- a/datastore/objects/test/test_objects_manager.py +++ b/datastore/objects/test/test_objects_manager.py @@ -134,14 +134,20 @@ def __eq__(self, other): q = mgr.init_query() self.assertFalse(q is None) + + # Query on the manager results = list(mgr.query(q)) self.assertEqual(len(results), 2) - results = list(mgr.query(mgr.init_query().filter('foo','=','bar1'))) + # Perform the query directly + results = list(q.perform()) + self.assertEqual(len(results), 2) + + results = list(mgr.init_query().filter('foo','=','bar1').perform()) self.assertEqual(len(results), 1) self.assertEqual(results[0], instance1) - results = list(mgr.query(mgr.init_query().filter('foo','=','bar2'))) + results = list(mgr.init_query().filter('foo','=','bar2').perform()) self.assertEqual(len(results), 1) self.assertEqual(results[0], instance2) From 5301d7a595308261f7b3dcc31ac4c5da6fef62f6 Mon Sep 17 00:00:00 2001 From: Willem Bult Date: Sat, 26 Apr 2014 01:39:33 -0700 Subject: [PATCH 2/2] Instead of attaching to query, prepend Manager.key to queries --- datastore/objects/collection_manager.py | 4 +-- datastore/objects/managed_query.py | 16 --------- datastore/objects/manager.py | 33 +++++++++---------- .../test/test_objects_collection_manager.py | 2 +- .../objects/test/test_objects_manager.py | 17 ++++------ 5 files changed, 24 insertions(+), 48 deletions(-) delete mode 100644 datastore/objects/managed_query.py diff --git a/datastore/objects/collection_manager.py b/datastore/objects/collection_manager.py index de54fe2..fbbf683 100644 --- a/datastore/objects/collection_manager.py +++ b/datastore/objects/collection_manager.py @@ -11,8 +11,8 @@ class CollectionManager(Manager): Collection = Collection - def key(self, key_or_name): - '''Overrides Manager.key''' + def instance_key(self, key_or_name): + '''Overrides Manager.instance_key''' if not isinstance(key_or_name, Key): return self.collection_key.instance(key_or_name) diff --git a/datastore/objects/managed_query.py b/datastore/objects/managed_query.py deleted file mode 100644 index b5f43f9..0000000 --- a/datastore/objects/managed_query.py +++ /dev/null @@ -1,16 +0,0 @@ -from datastore.core import Query - -class ManagedQuery(Query): - '''Query that knows its manager so that it can run directly''' - - def __init__(self, key, manager=None): - super(ManagedQuery, self).__init__(key) - # The manager to perform this query - self._manager = manager - - def perform(self): - ''' Perform the query on the manager ''' - return self._manager.query(self) - - def __repr__(self): - return '<%s %s>' % (self.__class__.__name__, super(ManagedQuery, self).__repr__()) \ No newline at end of file diff --git a/datastore/objects/manager.py b/datastore/objects/manager.py index 9c3ac81..6c497cc 100644 --- a/datastore/objects/manager.py +++ b/datastore/objects/manager.py @@ -2,7 +2,6 @@ from .model import Model from datastore import Query from .object_datastore import ObjectDatastore -from .managed_query import ManagedQuery class Manager(object): @@ -16,15 +15,18 @@ def __init__(self, datastore, model=None): self.datastore = ObjectDatastore(datastore, model=self.model) + @property + def key(self): + return Key(self.model.key_type) - def key(self, key_or_name): + def instance_key(self, key_or_name): '''Coerces `key_or_name` to be a proper model Key''' if not isinstance(key_or_name, Key): - return self.model.key.instance(key_or_name) + return self.key.instance(key_or_name) - if key_or_name.type != self.model.key.name: + if key_or_name.type != self.key.name: err = 'key %s must have key type %s' - raise TypeError(err % (key_or_name, self.model.key.name)) + raise TypeError(err % (key_or_name, self.key.name)) return key_or_name @@ -33,12 +35,12 @@ def key(self, key_or_name): def contains(self, key): '''Returns whether manager contains instance named by `key_or_name`.''' - return self.datastore.contains(self.key(key)) + return self.datastore.contains(self.instance_key(key)) def get(self, key): '''Retrieves instance named by `key_or_name`.''' - return self.datastore.get(self.key(key)) + return self.datastore.get(self.instance_key(key)) def put(self, instance): @@ -51,22 +53,17 @@ def put(self, instance): def delete(self, key_or_name): '''Deletes instance named by `key_or_name`.''' - self.datastore.delete(self.key(key_or_name)) + self.datastore.delete(self.instance_key(key_or_name)) - def init_query(self): - '''Initiates a ManagedQuery object for the model''' - if not self.model: - raise Exception('Can not query when no model is set on the manager') - return ManagedQuery(Key('/' + self.model.key_type), manager=self) - - - def query(self, query): + def query(self, query=None): '''Execute a query on the underlying datastore''' - return self.datastore.query(query) + mgr_query = query.copy() if query else Query() + mgr_query.key = self.key.child(mgr_query.key) + return self.datastore.query(mgr_query) def remove_all_items(self): '''Removes all items from the datastore''' - for obj in self.query(self.init_query()): + for obj in self.query(): self.delete(obj.key) \ No newline at end of file diff --git a/datastore/objects/test/test_objects_collection_manager.py b/datastore/objects/test/test_objects_collection_manager.py index 344cf83..28817eb 100644 --- a/datastore/objects/test/test_objects_collection_manager.py +++ b/datastore/objects/test/test_objects_collection_manager.py @@ -39,7 +39,7 @@ class Foo(Model): pass ds = datastore.DictDatastore() mgr = CollectionManager(ds) mgr.model = Foo - self.assertEqual(mgr.key('bar'), Key('/foo:bar')) + self.assertEqual(mgr.instance_key('bar'), Key('/foo:bar')) def test_collection(self): diff --git a/datastore/objects/test/test_objects_manager.py b/datastore/objects/test/test_objects_manager.py index a734d05..25028cd 100644 --- a/datastore/objects/test/test_objects_manager.py +++ b/datastore/objects/test/test_objects_manager.py @@ -5,6 +5,7 @@ from ..manager import Manager from ..model import Key from ..model import Model +from datastore.core import Query from ..object_datastore import ObjectDatastore @@ -132,22 +133,16 @@ def __eq__(self, other): mgr.put(instance1) mgr.put(instance2) - q = mgr.init_query() - self.assertFalse(q is None) - - # Query on the manager - results = list(mgr.query(q)) - self.assertEqual(len(results), 2) - - # Perform the query directly - results = list(q.perform()) + # Query all on the manager + results = list(mgr.query()) self.assertEqual(len(results), 2) - results = list(mgr.init_query().filter('foo','=','bar1').perform()) + # Query with filter + results = list(mgr.query(Query().filter('foo','=','bar1'))) self.assertEqual(len(results), 1) self.assertEqual(results[0], instance1) - results = list(mgr.init_query().filter('foo','=','bar2').perform()) + results = list(mgr.query(Query().filter('foo','=','bar2'))) self.assertEqual(len(results), 1) self.assertEqual(results[0], instance2)