Model inheritance

[Andy Dustman]

(Maybe this should go to django-developers, but I'm still a relative
noob on Django.)

I've been reading (and making some notes on) this page:

http://code.djangoproject.com/wiki/ModelInheritance

Surprisingly (a bit, at least), I created an app with the example model:

{{{
class Place(models.Model):
    name = models.CharField(maxlength=50)

class Restaurant(Place):
    description = models.TextField()

class ItalianRestaurant(Restaurant):
    has_decent_gnocchi = models.BooleanField()
}}}

That page suggests the resulting schema would look like this:

{{{
CREATE TABLE "myapp_place" (
    "id" integer NOT NULL PRIMARY KEY,
    "name" varchar(50) NOT NULL
);

CREATE TABLE "myapp_restaurant" (
    "id" integer NOT NULL PRIMARY KEY REFERENCES "myapp_places" ("id"),
    "description" text NOT NULL
);

CREATE TABLE "myapp_italianrestaurant" (
    "id" integer NOT NULL PRIMARY KEY REFERENCES "myapp_restaurant" ("id"),
    "has_decent_gnocchi" bool NOT NULL
);
}}}

However the resulting sql schema generated (using current
magic-removal and mysql for the DATABASE_ENGINE) is:

{{{
CREATE TABLE `places_italianrestaurant` (
    `id` integer auto_increment NOT NULL PRIMARY KEY,
    `name` varchar(50) NOT NULL,
    `description` longtext NOT NULL,
    `has_decent_gnocchi` bool NOT NULL
);
CREATE TABLE `places_place` (
    `id` integer auto_increment NOT NULL PRIMARY KEY,
    `name` varchar(50) NOT NULL
);
CREATE TABLE `places_restaurant` (
    `id` integer auto_increment NOT NULL PRIMARY KEY,
    `name` varchar(50) NOT NULL,
    `description` longtext NOT NULL
);
}}}

Which is not what you'd expect based on that page, so presumably the
changes haven't been implemented yet. Or is the page obsolete? I'd
assume not since there are some post-PyCon Sprint notes there.

I had some ideas about implementing some of this as views, or at least
for reading (all implementations I could find could not deal with view
updates that affected more than one table without using triggers of
some sort), so you'd still have to update the base tables separately
as needed, but that is no worse (in fact the same) as if you doing an
explicit join.

Another weird thing I've found is model inheritance and
ManyToManyFields. I have a model that looks kind of like this:

{{{
class Tag(models.Model):
    name = models.SlugField(unique = True, blank = False)

class Source(models.Model):
    tags = models.ManyToManyField(Tag)

class Feed(Source):
    url = models.URLField()
}}}

(There are other fields defined, but I'm omitting them for clarity, or
at least I hope so.)

As you'd expect, you get a tag table, a source table,  a source_tags
table (for the ManyToMany relation), and a feed table, but instead of
the feed table having all the columns from Feed and Source, it is
lacking a feed_tags table, i.e. Feed is not inheriting tags =
models.ManyToManyField(Tag) from Source. This seems wrong.

It looks like ManyToManyField is not accounted for in
Source._meta.fields, and so it's not inherited by Feed. Instead it's
kept in _meta.many_to_many. Maybe the class inheritance scheme should
account for those as well?

--
The Pythonic Principle: Python works the way it does
because if it didn't, it wouldn't be Python.

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/django-users
-~----------~----~----~----~------~----~------~--~---