CODEWITHSUNDEEP
pythondjangodjango-polymorphic
Blake Gibbs
Blake Gibbs

Reputation: 495

Django Polymoprhic

I want to implement models using inheritance and I've found this package django-polymorphic. But I was reading about inheritance in django models and almost on every page I found they recommend using abstract = True in parent model. Which will duplicate fields for subclasses, resultsing in making queries faster.

I've done some testing and found out that this library doesn't use use abstract varaible:

class Parent(PolymorphicModel):
    parent_field = models.TextField()

class Child(Parent):
    child_field = models.TextField()

This results in:

Parent table:

| app_parent| CREATE TABLE `app_parent` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `parent_field` longtext NOT NULL,
  `polymorphic_ctype_id` int(11),
  PRIMARY KEY (`id`),
  KEY `app_polymorphic_ctype_id_a7b8d4c7_fk_django_content_type_id` (`polymorphic_ctype_id`),
  CONSTRAINT `app_polymorphic_ctype_id_a7b8d4c7_fk_django_content_type_id` FOREIGN KEY (`polymorphic_ctype_id`) REFERENCES `django_content_type` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |

Child table:

| app_child | CREATE TABLE `app_child` (
  `parent_ptr_id` int(11) NOT NULL,
  `child_field` varchar(20) NOT NULL,
  PRIMARY KEY (`parent_ptr_id`),
  CONSTRAINT `no_parent_ptr_id_079ccc0e_fk_app_parent_id` FOREIGN KEY (`parent_ptr_id`) REFERENCES `app_arent` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |

Should I use my own classes which uses abstract field or should i stick with this?

Upvotes: 2

Views: 1456

Answers (1)

Ski
Ski

Reputation: 14487

Do you have a need to be able to query parent table?

Parent.objects.all()

If yes, then most probably you will need to use the multi-table inheritance with abstract=False.

Using model inheritance with abstract=False you get more complicated database schema, with more database relations. Creating a child instance will take 2 inserts instead of 1 (parent and child table). Querying child data will require table join. So this method certainly has got it's shortcomings. But when you want to query for common columns data, it's best supported way in django.

Django polymorphic builds on top of standard django model inheritance, by adding extra column polymorphic_ctype which allows to identify subclass having only a parent object.

There are various ways that you can use to achieve similar results using abstract=True. But often it results in more complicated querying code.

If using abstract=True bellow is 2 examples how you can query common-data of all childs.

  • Chaining multiple queries

    def query_all_childs(**kwargs):
    return chain(
        Child1.objects.filter(**kwargs)
        Child2.objects.filter(**kwargs)
    )

  • Using database views

    Manually create a database view that combines several tables (this could be done by attaching sql code to post-migrate signal):

    create database view myapp_commonchild
select 'child1' as type, a, b from child1
union all
select 'child2' as type, a, b from child2

    Create a concrete-parent model with managed=False. This flag tells django to ignore the table in database migrations (because we have manually created database view for that).

    class Parent(models.Model):
    a = CharField()
    b = CharField()

class CommonChild(Parent):
    type = models.CharField()
    class Meta:
        managed = False

class Child1(Parent):
    pass

class Child2(Parent):
    pass

    Now you can query CommonChild.objects.all() and access common fields of child classes.

Speaking of performance, I don't know how big your tables are or how heavy reads/writes are, but most probably using abstract=False will not impact your performance in a noticeable way.

Upvotes: 1

Related Questions