SQL: Modelling template inheritance - sql

Question

I wanted to ask whether it is possible to model a templated datastructure which can be overriden if necessary.
Suppose we have a list with the following items:
Template List
Item 1 Position 0
Item 2 Position 1
Item 3 Position 2
Item 4 Position 3
Now I want to create a list which uses Template List as a base, but modifies some parts of it:
Concrete List, based on Template List
Item 1 Position 0 // Inherited from Template List
Item 5 Position 1 // New and only available in Concrete List
Item 4 Position 2 // Inherited from Template List, but with a different position
Item 3 Position 3 // Inherited from Template List, but with a different position
In this list Item 2 from Template List is missing should not be a part of the resulting list.
Is it possible to model these relations in SQL? (We are using PostgreSQL)

Answer 1

It's possible to do something like what you want, but it's not necessarily a good solution or what you need. What you're asking for looks like a metamodel, but relational databases were designed for first-order logical models, and while SQL can go beyond that somewhat, it's usually better not to go too abstract.
That said, here's an example. I assumed the identity of list items were position or slot-based.
CREATE TABLE template_list (
template_list_id SERIAL NOT NULL,
PRIMARY KEY (template_list_id)
);
CREATE TABLE template_list_items (
template_list_id INTEGER NOT NULL,
slot_number INTEGER NOT NULL,
item_number INTEGER NOT NULL,
PRIMARY KEY (template_list_id, slot_number),
FOREIGN KEY (template_list_id) REFERENCES template_list (template_list_id)
);
CREATE TABLE concrete_list (
concrete_list_id SERIAL NOT NULL,
template_list_id INTEGER NOT NULL,
FOREIGN KEY (template_list_id) REFERENCES template_list (template_list_id),
UNIQUE (concrete_list_id, template_list_id)
);
CREATE TABLE concrete_list_items (
concrete_list_id INTEGER NOT NULL,
template_list_id INTEGER NOT NULL,
slot_number INTEGER NOT NULL,
item_number INTEGER NULL,
PRIMARY KEY (concrete_list_id, slot_number),
FOREIGN KEY (concrete_list_id, template_list_id) REFERENCES concrete_list (concrete_list_id, template_list_id),
FOREIGN KEY (template_list_id, slot_number) REFERENCES template_list_items (template_list_id, slot_number)
);
Now, to get the items in a concrete list, you would use a query like:
SELECT c.concrete_list_id, x.slot_number, x.item_number
FROM concrete_list c
LEFT JOIN (
SELECT ci.concrete_list_id,
COALESCE(ci.template_list_id, ti.template_list_id) AS template_list_id,
COALESCE(ci.slot_number, ti.slot_number) AS slot_number,
COALESCE(ci.item_number, ti.item_number) AS item_number
FROM concrete_list_items AS ci
FULL JOIN template_list_items AS ti ON ci.template_list_id = ti.template_list_id
AND ci.slot_number = ti.slot_number
) x ON c.concrete_list_id = x.concrete_list_id OR c.template_list_id = x.template_list_id;
Here's a SQL fiddle for demonstration. Note that I replaced the serial types with integers and hardcoded values for simplicity of demonstration.