Model with other models as foreign keys but all inherited from the same model

I am building an e-commerce backend for bicycles using Django and DRM. I have bikes and bike parts. I want to make them all items and want to relate each bike to the parts it was built from.

Item model:

class Item(TimeStampedModel):
    ID_LENGHT = 6
    
    item_id = models.CharField(
        primary_key=True,
        max_length=ID_LENGHT,
        unique=True,
        editable=False,
        blank=False
        )  
    name = models.CharField(max_length=255)
    active = models.BooleanField(default=False)
    quantity = models.PositiveIntegerField()
    unit_price = models.DecimalField(max_digits=10, decimal_places=2)

One of the parts models:

class Tire(Item):    
    type = models.CharField(max_length=50, choices=TIRE_TYPES)

Bike model:

class Bike(Item):
    frame = models.ForeignKey(Frame, on_delete=models.CASCADE)
    tires = models.ForeignKey(Tire, on_delete=models.CASCADE)
    seat = models.ForeignKey(Seat, on_delete=models.CASCADE)
    wheel = models.ForeignKey(Wheel, on_delete=models.CASCADE)

Errors:

SystemCheckError: System check identified some issues:

ERRORS:
bikeshop.Bike.frame: (models.E006) The field 'frame' clashes with the field 'frame' from model 'bikeshop.item'.
bikeshop.Bike.seat: (models.E006) The field 'seat' clashes with the field 'seat' from model 'bikeshop.item'.
bikeshop.Bike.wheel: (models.E006) The field 'wheel' clashes with the field 'wheel' from model 'bikeshop.item'.

I want to add attachments and other related items. Item model was just abstract and because of that I have an issue with shopping cart. After reading this article I decided to make base model concrete but run into this new issue. I tried to add related_name= to the foreign keys but it hasn't solved the issue.

The reason this happens is because you work with concrete inheritance. Indeed, Item is a concrete (non-abstract) model, and you inherit Item in a lot of extra models.

This means that Django will construct a model Item with a database table behind it, and make models like Frame and Tire with a OneToOneField to the Item named item_ptr. So if we would do the inheritance ourselves, it would look like:

<pre><code>class Item(TimestampedModel):
# some data&hellip;
pass

class Frame(models.Model):
item_ptr = models.OneToOneFIeld(Item, <b>related_name='tire'</b>)
# extra fields</code></pre>

So that means there is a relation from Item to Frame: indeed .frame is when an Item is a Frame to obtain the data specific to the Frame.

This thus means that you can make extra subclasses of Item that will have a field to Frame, but you can not name these frame, since that name is already "taken" because of the related relation. You can for example decide to name these component_frame. This is the reason that tires is not listed: tires and tire do not conflict. So an "easy" fix is:

<pre><code>class Bike(Item):
<b>component_</b>frame = models.ForeignKey(Frame, on_delete=models.CASCADE)
<b>component_</b>tires = models.ForeignKey(Tire, on_delete=models.CASCADE)
# &hellip;</code></pre>

But even if you manage to do that, it is still cumbersome. Relational databases have no "native" support for subclasses. The concept of classes does not exist at all. While there are several ways to model subclassing, it nearly always results in complicated queries anyway.

If you don't have to reference to an Item itself, but always to "subclasses" of an Item, an alternative way is to make Item abstract, in which case it will not construct these OneToOneField. In that case there is no table named Item, but the Bike, Tire, etc. models will all use the fields you defined in Item:

<pre><code>class Item(TimeStampedModel):
ID_LENGHT = 6
item_id = models.CharField(
primary_key=True,
max_length=ID_LENGHT,
editable=False,
)
name = models.CharField(max_length=255)
active = models.BooleanField(default=False)
quantity = models.PositiveIntegerField()
unit_price = models.DecimalField(max_digits=10, decimal_places=2)

class Meta:
    <b>abstract = True</b>

class Bike(Item):
frame = models.ForeignKey(Frame, on_delete=models.CASCADE)
tires = models.ForeignKey(Tire, on_delete=models.CASCADE)
seat = models.ForeignKey(Seat, on_delete=models.CASCADE)
wheel = models.ForeignKey(Wheel, on_delete=models.CASCADE)</code></pre>