Couple of things.
bruno, your save example should maybe look call the superclass save
first. Otherwise parent may not have been set yet.
def save(self, *args, **kw):
super(Node, self).save(*args, **kw)
if self.parent and type(self.parent) != Group:
raise ValueError("only Group nodes can be parents")
Also, the issue I see with this is how do you know find out which type
of Node you have so you can query the right model? For instance when
you query Node.objects.filter(parent_id=parent_id) you'll get a list
of Node objects. But they will not have any of the properties there
were put on the Group and Item subclasses. Because the Node class
doesn't know about them. This is a problem I've had with django for a
while now and i would love to see a solution that addresses it.
:Marco
On Feb 24, 5:01 pm, bruno desthuilliers
<bruno.desthuilli...@gmail.com> wrote:
> On 24 fév, 18:08, Peter Reimer <pet.rei...@googlemail.com> wrote:
>
> > Hi folks,
>
> > I'm looking for a solution/tip for the following problem: I need to
> > store hierarchical data, but, with two different kinds of objects
> > (groups and items).
>
> That's something the relational model (at least in it's SQL
> implementation) is not very good at.
>
> > I googled around and found the often suggested
> > mptt package.
>
> The mptt pattern is mostly useful for deep hierarchies that are often
> queried for a whole branch at once and rarely updated.
>
> If you have a not-that-deep tree with frequent updates and don't need
> to retrieve whole branches at once, the adjacency list or materialized
> path patterns (or a combination of both) might yield better results.
>
>
>
> > One idea is, to build the hierarchical structure with one model and
> > mptt and in it, I define two ForeignKeys to the concrete data objects
> > I want to store (ForeignKey(Group) and Foreignkey(Item)). But this
> > sounds a bit strange to me. I think there should be a much smarter
> > way.
>
> From the OOD perspective, this looks like a canonical use case for the
> composite design pattern. Applied to Django's models and using the
> adjacency list pattern, you'd have a Node base class with Groups and
> Items subclasses (Q&D example, may contains obvious stupid errors):
>
> class Node(models.Model):
> parent = models.ForeignKey(
> "self",
> blank=True,
> null=True,
> related_name="children"
> )
>
> def save(self, *args, **kw):
> if self.parent and type(self.parent) != Group:
> raise ValueError("only Group nodes can be parents")
> super(Node, self).save(*args, **kw)
>
> class Group(Node):
> # code here
>
> class Item(Node):
> # code here
>
> Don't know if and how it would solve your problem, but this might get
> you started one way or another... Else, well, sorry but that's all I
> have :-/
--
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-us...@googlegroups.com.
To unsubscribe from this group, send email to
django-users+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en.
