Changes between Version 12 and Version 13 of DjangoSpecifications/Core/SingleInstance

Timestamp:

Mar 24, 2008, 4:47:37 PM (17 years ago)

Author:

Philippe Raoult

Comment:

--

DjangoSpecifications/Core/SingleInstance

@@ -108 +108 @@
  * the API for enabling/disabling the feature is very crude and consists only of two class methods. It should at the very least be possible to set the value as a member of the Meta class. 
  * the Model dict should be set threadlocally.
- * it should be possible to force instantiation, because the serializers want that (solved by next item).
- * the internals of the patch should be changed to be less magic: overriding __call__ is a neat trick but I'd rather have something like Model.get_singleton(pk, kwargs = None) and use this where needed (the places are few!). If the user wants to do Model(id = something, kwargs) he should get a fresh instance. If he wanted to have the DB one he'd have used get or something like that. 
- * ^--- This is an opinion, and goes against the idea of this patch.
- * For the sake of completeness, it should be possible to do Model.objects.get_fresh_instance(id=something) to bypass the singleton
+ * it should be possible to force instantiation, because the serializers want that.
+ * For the sake of completeness, it should be possible to do Model.objects.get_from_db(id=something) to bypass the singleton.
+
+=== Discussion ===
+The current patch design overrides the __call__ method for the model base which means it magically returns singleton instances when available. This is convenient because XXX (David or Brian: feel free to fill this out).
+
+Another approach would be to skip the magic and have a simple API along the lines of:
+{{{
+class ModelBase:
+    def get_singleton(pk, kwargs = None):
+        """ returns the current singleton for the instance corresponding to pk. If there isn't one in memory and kwargs is specified, it will be built from kwargs  """
+    
+}}}
+That means writing Model(kwargs) would always return a fresh instance and bypass the instance. Since Django's ORM would use the API internally, doing Model.objects.get would (by default, overridable in the manager) return the singleton. The default related manager would also have a new get_from_db method to force retrieving and instantiating from the DB only.