Many to Many relation with Model inheritance in Django - django

Question

I have an abstract object called parameter. parameter can be of several different types. For example - Numeric Parameter, Constant parameter, MultiValue parameter etc.
Each parameter can be related to many parameter of different types and vise versa.
After reviewing Django's doc on Model inheritance I decided what I need is a simple abstract base class. An example of a many to many relation from the base class can be found later on in the docs.
class ParameterBase(models.Model):
id = models.AutoField(primary_key=True)
description = models.CharField(max_length=200)
sort_order = models.DecimalField(null=False, max_digits=6, decimal_places=4)
m2m = models.ManyToManyField('self',related_name='dependent_on')
class Meta:
abstract = True
class ParameterConstant(ParameterBase):
value = models.DecimalField(null=False, blank=False, max_digits=20 , decimal_places=4)
class ParameterNumeric(ParameterBase):
minimum = models.DecimalField(null=True, blank=True, max_digits=20 , decimal_places=4)
maximum = models.DecimalField(null=True, blank=True, max_digits=20 , decimal_places=4)
So after syncing i could see that django created 4 tables -
CREATE TABLE "calc_parameterconstant_m2m" (
"id" serial NOT NULL PRIMARY KEY,
"from_parameterconstant_id" integer NOT NULL,
"to_parameterconstant_id" integer NOT NULL,
UNIQUE ("from_parameterconstant_id", "to_parameterconstant_id")
)
;
CREATE TABLE "calc_parameterconstant" (
"id" serial NOT NULL PRIMARY KEY,
"description" varchar(200) NOT NULL,
"sort_order" numeric(6, 4) NOT NULL,
"value" numeric(20, 4) NOT NULL
)
;
ALTER TABLE "calc_parameterconstant_m2m" ADD CONSTRAINT "from_parameterconstant_id_refs_id_f893bb67" FOREIGN KEY ("from_parameterconstant_id") REFERENCES "calc_parameterconstant" ("id") DEFERRABLE INITIALLY DEFERRED;
ALTER TABLE "calc_parameterconstant_m2m" ADD CONSTRAINT "to_parameterconstant_id_refs_id_f893bb67" FOREIGN KEY ("to_parameterconstant_id") REFERENCES "calc_parameterconstant" ("id") DEFERRABLE INITIALLY DEFERRED;
CREATE TABLE "calc_parameternumeric_m2m" (
"id" serial NOT NULL PRIMARY KEY,
"from_parameternumeric_id" integer NOT NULL,
"to_parameternumeric_id" integer NOT NULL,
UNIQUE ("from_parameternumeric_id", "to_parameternumeric_id")
)
;
CREATE TABLE "calc_parameternumeric" (
"id" serial NOT NULL PRIMARY KEY,
"description" varchar(200) NOT NULL,
"sort_order" numeric(6, 4) NOT NULL,
"minimum" numeric(20, 4),
"maximum" numeric(20, 4)
)
Now, This is obviously was not my intention - I want to be able to connect a parameter of each type to parameters of other types as well. Is there any way to achieve this goal using Django ORM and model inheritance ?
If the base parameter model was a table on it's own with Many to Many relation to it self and the sub tables were connected with an unbinding one to one relation this might be a good solution here database wise.

Answer 1

I think multi-table inheritance will solve your problem. To use it, just remove abstract = True from the ParameterBase.Meta subclass (or remove that subclass completely).
When using multi-table inheritance, to access attributes of a particular subclass, Django has to know that you're dealing with that subclass.
For example, this will fail:
p = ParameterBase.objects.get(...) # get a ParameterBase that is a ParameterConstant
print p.value
Instead, you would have to do this:
p = ParameterConstant.objects.get(...)
print p.value
Or this:
p = ParameterBase.objects.get(...) # get a ParameterBase that is a ParameterConstant
print p.paramaterconstant.value

Answer 2

One way to solve this would be to replace
m2m = models.ManyToManyField('self',related_name='dependent_on')
with
m2m = models.ManyToManyField('ParameterBase', related_name='dependent_on')
but Django won't let you create an m2m field that points to a model that hasn't been installed yet or one that is abstract. At this point ParameterBase is both of those.
I'd do it like this
class Parameter(models.Model):
id = models.AutoField(primary_key=True)
description = models.CharField(max_length=200)
sort_order = models.DecimalField(null=False, max_digits=6, decimal_places=4)
class ParameterType(models.Model):
parameter = models.ForeignKey(Parameter)
related_parameters = models.ManyToManyField(Parameter,related_name='dependent_on')
class Meta:
abstract = True
class ParameterConstant(ParameterType):
value = models.DecimalField(null=False, blank=False, max_digits=20 , decimal_places=4)
class ParameterNumeric(ParameterType):
minimum = models.DecimalField(null=True, blank=True, max_digits=20 , decimal_places=4)
maximum = models.DecimalField(null=True, blank=True, max_digits=20 , decimal_places=4)

Answer 3

If you use a ManyToMany field in an abstract parent class, you should provide a unique related_name as stated in the docs... in your case, this should go fine:
m2m = models.ManyToManyField('self',related_name='%(app_label)s_%(class)s_m2m')