"Tabellenvererbung" bedeutet etwas anderes als "Klassenvererbung" und dient unterschiedlichen Zwecken.
Bei Postgres dreht sich alles um Datendefinitionen. Manchmal sehr komplexe Datendefinitionen. Bei OOP (im üblichen Java-farbigen Sinne) geht es darum, Verhaltensweisen Datendefinitionen in einer einzelnen Atomstruktur unterzuordnen. Der Zweck und die Bedeutung des Wortes "Vererbung" unterscheiden sich hier erheblich.
In OOP-Land könnte ich definieren (hier sehr locker mit Syntax und Semantik):
import life
class Animal(life.Autonomous):
metabolism = biofunc(alive=True)
def die(self):
self.metabolism = False
class Mammal(Animal):
hair_color = color(foo=bar)
def gray(self, mate):
self.hair_color = age_effect('hair', self.age)
class Human(Mammal):
alcoholic = vice_boolean(baz=balls)
Die Tabellen hierfür könnten folgendermaßen aussehen:
CREATE TABLE animal
(name varchar(20) PRIMARY KEY,
metabolism boolean NOT NULL);
CREATE TABLE mammal
(hair_color varchar(20) REFERENCES hair_color(code) NOT NULL,
PRIMARY KEY (name))
INHERITS (animal);
CREATE TABLE human
(alcoholic boolean NOT NULL,
FOREIGN KEY (hair_color) REFERENCES hair_color(code),
PRIMARY KEY (name))
INHERITS (mammal);
Aber wo sind die Verhaltensweisen? Sie passen nirgendwo hin. Dies ist nicht der Zweck von "Objekten", wie sie in der Datenbankwelt diskutiert werden, da sich Datenbanken mit Daten befassen, nicht mit Verfahrenscode. Sie könnten Funktionen in die Datenbank schreiben, um Berechnungen für Sie durchzuführen (oft eine sehr gute Idee, aber nicht wirklich etwas, das in diesen Fall passt), aber Funktionen sind nicht dasselbe wie Methoden - Methoden, wie sie in Form von OOP verstanden werden, von dem Sie sprechen etwa sind bewusst weniger flexibel.
Bei der Vererbung als schematisches Gerät ist noch eines zu beachten: Ab Postgres 9.2 gibt es keine Möglichkeit, eine Fremdschlüsseleinschränkung auf alle Mitglieder der Partitionen / Tabellenfamilie gleichzeitig zu verweisen. Sie können Schecks schreiben, um dies zu tun, oder es auf andere Weise umgehen, aber es ist keine integrierte Funktion (es kommt wirklich auf Probleme mit der komplexen Indizierung an, und niemand hat die Bits geschrieben, die erforderlich sind, um dies automatisch zu machen). Anstatt die Tabellenvererbung für diesen Zweck zu verwenden, besteht eine bessere Übereinstimmung in der Datenbank für die Objektvererbung häufig darin, schematische Erweiterungen für Tabellen vorzunehmen. Etwas wie das:
CREATE TABLE animal
(name varchar(20) PRIMARY KEY,
ilk varchar(20) REFERENCES animal_ilk NOT NULL,
metabolism boolean NOT NULL);
CREATE TABLE mammal
(animal varchar(20) REFERENCES animal PRIMARY KEY,
ilk varchar(20) REFERENCES mammal_ilk NOT NULL,
hair_color varchar(20) REFERENCES hair_color(code) NOT NULL);
CREATE TABLE human
(mammal varchar(20) REFERENCES mammal PRIMARY KEY,
alcoholic boolean NOT NULL);
Jetzt haben wir eine kanonische Referenz für die Instanz des Tieres, die wir zuverlässig als Fremdschlüsselreferenz verwenden können, und wir haben eine "ilk" -Spalte, die auf eine Tabelle mit xxx_ilk-Definitionen verweist, die auf die "nächste" Tabelle mit erweiterten Daten verweist ( oder zeigt an, dass es keine gibt, wenn der ilk der generische Typ selbst ist). Das Schreiben von Tabellenfunktionen, Ansichten usw. für diese Art von Schema ist so einfach, dass die meisten ORM-Frameworks genau dies im Hintergrund tun, wenn Sie auf die Klassenvererbung im OOP-Stil zurückgreifen, um Familien von Objekttypen zu erstellen.