ORM中通常将对象引用映射到外键，但是对于继承，关系数据库中没有自然有效的方法来对应。从数据存储的角度来看，在映射继承关系时，可以采用几种方式（参考JPA中的InheritanceType.定义）：

使用单个表，在JPA中称作SINGLE_TABLE。整个继承树共用一张表。使用唯一的表，包含所有基类和子类的字段。 每个具体类一张表，在JPA中称作TABLE_PER_CLASS。这种方式下，每张表都包含具体类和继承树上所有父类的字段。因为多个表中有重复字段，从整个继承树上来说，字段是冗余的。 每个类一张表，继承关系通过表的JOIN操作来表示。在JPA中称作JOINED。这种方式下，每个表只包含类中定义的字段，不存在字段冗余，但是要同时操作子类和所有父类所对应的表。

Django的ORM也支持上述三种继承策略，同时，得益于python的动态特性，还支持代理模型和多重继承关系的映射。

JOINED映射

如果在Django中实现了Model的继承关系，如下：

from django.db import models

class Person(models.Model):
    name = models.CharField(maxlength=10)

class Man(Person):
    job = models.CharField(maxlength=20)

class Woman(Person):
    makeup = models.CharField(maxlength=20)

则使用manage.py执行sqlall命令时，会看到这样的结果：

CREATE TABLE "uom_person" (
"id" integer NOT NULL PRIMARY KEY,
"name" varchar(10) NOT NULL
)
;

CREATE TABLE "uom_man" (
"person_ptr_id" integer NOT NULL PRIMARY KEY REFERENCES "uom_person" ("id"),
"job" varchar(20) NOT NULL
)
;

CREATE TABLE "uom_woman" (
"person_ptr_id" integer NOT NULL PRIMARY KEY REFERENCES "uom_person" ("id"),
"makeup" varchar(20) NOT NULL
)
;

可见，Django ORM中默认使用JOINED方式来实现继承关系的映射。

TABLE_PER_CLASS映射

如果要实现每个具体类一张表，只需要将父类指定为抽象类(abstract)，这样就不会创建父类对应的表，而将父类的字段复制到子类中去映射。如下：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=10)

    class Meta:
        abstract = True

class Man(Person):
    job = models.CharField(max_length=20)

class Woman(Person):
    makeup = models.CharField(max_length=20)

sqlall 的结果：

CREATE TABLE "uom_man" (
"id" integer NOT NULL PRIMARY KEY,
"name" varchar(10) NOT NULL,
"job" varchar(20) NOT NULL
)
;

CREATE TABLE "uom_woman" (
"id" integer NOT NULL PRIMARY KEY,
"name" varchar(10) NOT NULL,
"makeup" varchar(20) NOT NULL
)
;

将父类声明为abstract时，该类将没有objects属性，也就是说没有Manager方法，所有无法进行数据操作，只有子类才能进行。

SINGLE_TABLE映射

在TABLE_PER_CLASS的基础上，如果进一步指定子类的映射表名与父类的相同，则子类和父类将映射到同一张表，对所有的子类都这样指定，就可以实现SINGLE—_TABLE映射：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=10)
    class Meta:
        abstract = True

class Man(Person):
    job = models.CharField(max_length=20)
    class Meta:
        db_table = 'oum_person'

class Woman(User):
    makeup = models.CharField(max_length=20)

sqlall 的结果：

CREATE TABLE "oum_person" (
"id" integer NOT NULL PRIMARY KEY,
"name" varchar(10) NOT NULL,
"job" varchar(20) NOT NULL
)
;

CREATE TABLE "uom_woman" (
"user_ptr_id" integer NOT NULL PRIMARY KEY,
"makeup" varchar(20) NOT NULL
)
;

上面的例子中只指定了一个子类，可以看出因为是在子类上指定，所以Django ORM更加灵活，可以控制单个子类的映射方式，从而实现任意的映射结构。

代理模型

有这样一种常见的场景：使用某些库(lib)中的类，只是想扩展一些方法，而不想改变其数据存储结构。在Python中，可以通过在Meta类中增加约束proxy=True来实现。此时“子类”称为“父类”的代理类，子类中只能增加方法，而不能增加属性。比如上面的例子中，如果希望Person继承Django自带的User类，又不希望破坏User类的数据存储，则可以指定Person的proxy=True：

from django.db import models
from django.contrib.auth.models import User

class Person(User):
#    name = models.CharField(max_length=10)
    class class Meta:
        proxy = True

    def do_something(self):
        ...

class Man(Person):
    job = models.CharField(max_length=20)

class Woman(Person):
    makeup = models.CharField(max_length=20)

sqlall的结果为：

CREATE TABLE "uom_man" (
"user_ptr_id" integer NOT NULL PRIMARY KEY,
"job" varchar(20) NOT NULL
)
;

CREATE TABLE "uom_woman" (
"user_ptr_id" integer NOT NULL PRIMARY KEY,
"makeup" varchar(20) NOT NULL
)
;

多重继承

python支持多重继承，尽管在Model层不推荐使用多重继承，但Django的ORM还是支持这样的使用方式：

class Mixin1(models.Model):
    attr1 = models.CharField(max_length=10)
class Mixin2(models.Model):
    attr1 = models.CharField(max_length=10)
class Multiple(Mixin1,Mixin2):
    attr3 = models.CharField(max_length=10)

sqlall的结果是：

CREATE TABLE "uom_mixin1" (
"id" integer NOT NULL PRIMARY KEY,
"attr1" varchar(10) NOT NULL
)
;

CREATE TABLE "uom_mixin2" (
"id" integer NOT NULL PRIMARY KEY,
"attr1" varchar(10) NOT NULL
)
;

CREATE TABLE "uom_multiple" (
"mixin2_ptr_id" integer NOT NULL UNIQUE REFERENCES "uom_mixin2" ("id"),
"mixin1_ptr_id" integer NOT NULL PRIMARY KEY REFERENCES "uom_mixin1" ("id"),
"attr3" varchar(10) NOT NULL
)
;

多重继承的时候，子类的ORM映射会选择第一个父类作为主键管理，其他的父类作为一般的外键管理。

小结

Django ORM在映射继承关系时非常灵活，不仅能够实现JPA约定的SINGLE_TABLE、TABLE_PER_CLASS、JOINED三种方式，还可以灵活的自定义；甚至通过python的动态语言特性，支持代理模型和多重继承的功能。但是正因为灵活，所以在使用的时候一定要非常注意，通过manage.py的sqllall功能，观察产生的sql语句，可以验证继承的实现机制，避免带来意想不到的问题。