ORACLE SQL - Creating a disjoint specialisation - sql

Question

The following is what I am expecting from my tables. An item can be disjointed into a 'Computer' or 'Clothes'.
Computer has attributes 'computer_type', & 'operating_system'.
Clothes has only 'clothes_type'. As I want these as sub types they'll both take the 'item_id' as a foreign key.
My plan is to have these two sub tables derived from the parent item, and insert (the imported data that I am working on) into the appropriate tables. The 'item' table stores all the 'items' but the sub tables will reference a given item ID and be populated.
Table: Item (item_id,)
table: computer (sub type) with its own attributes
table: clothes (sub type) with its own attributes.
I saw another post here:
How to write Tables in SQL with a Disjoint Connection
So I wondered (as my approach is similar to his) whether I should create the tables as they are with a foreign key within both of my disjoined tables, and use a 'select' accordingly. Or is there a way without having seperate tables to store individual attributes.

Answer 1

"Or is there a way without having seperate tables to store individual attributes."
There is no good way to avoid having separate tables. Bad ways include using a so-called generic data model (the entity-attribute-value pattern) or some form of quasi-structured storage such as JSON or XML.
These approaches are bad for several reasons.
It is very hard to understand the data model. The model is
embedded how the data is stored rather than being expressed in
tables and keys.
We cannot enforce keys and data integrity constraints on such
models.
It is harder to write queries against such "models" because SQL is a strongly-typed language suited to static data models. The time saved by not doing proper data modelling is lost in writing the convoluted queries needed to handle the poor quality data (because of the previous point).
A robust solution would enforce the arc across the subtype tables with the full range of keys.
create table items
(item_id number not null primary key
, item_type varchar2(10) not null
, item_name varchar2(30) not null
, constraint item_uk unique (item_id, item_type)
, constraint item_type_ck check (item_type in ('CLOTHES', 'COMPUTER'))
);
Two keys? Why two keys? So we can enforce the one-to-one relationship between parent and child records:
create table clothes
(item_id number not null primary key
, item_type varchar2(10) not null
, size not null varchar2(5)
, colour not null varchar2(5)
, category not null varchar2(5)
, constraint clothes_type_ck check (item_type = 'CLOTHES')
, constraint clothes_item_fk foreign key (item_id, item_type)
references items (item_id, item_type)
);
create table computers
(item_id number not null primary key
, item_type varchar2(10) not null
, ram_gb not null number
, storage_gb not null number
, os not null varchar2(10)
, constraint computers_type_ck check (item_type = 'COMPUTER')
, constraint computers_item_fk foreign key (item_id, item_type)
references items (item_id, item_type)
);
The primary key on ITEMS ensures we only have one record for a given item_id. The unique key provides a reference point for the child tables, so we cannot have a COMPUTERS records and a CLOTHES record pointing to the same ITEMS record.

Answer 2

You can try and do this with 3 tables, a CHECK constraint (for the "supertype" table), and foreign key constraints. However, a good alternative may be the object-relational approach: create 3 TYPEs, and only one table that can hold all the data.
Example (Oracle 12c)
-- supertype
create or replace type item_t as object (
name varchar2(64)
)
not final; -- subtypes can be derived
/
-- subtypes
create or replace type computer_t under item_t (
operating_system varchar2(128)
)
/
create or replace type clothes_t under item_t (
description varchar2(128)
)
/
-- Table that handles all 3 types. No foreign key constraints or CHECKS needed.
create table items (
id number generated always as identity primary key
, item item_t
);
Testing: INSERTs
begin
-- "standard" INSERTs
insert into items ( item )
values ( computer_t( 'iMac', 'Mac OS' ) );
insert into items ( item )
values ( clothes_t( 'coat', 'black' ) );
-- object of SUPERtype can be inserted
insert into items ( item )
values ( item_t( 'supertype' ) );
end;
/
-- Unknown types cannot be inserted. Good.
insert into items ( item )
values ( unknown_t( 'type unknown!', 'not available', 999 ) );
-- ORA-00904: "UNKNOWN_T": invalid identifier
insert into items ( item )
values ( item_t( 'supertype', 'not available') );
-- ORA-02315: incorrect number of arguments for default constructor
For queries, use the appropriate functions. A simple SELECT * FROM items will probably not give you the results you need eg
SQL> select * from items;
ID ITEM
1 oracle.sql.STRUCT#2d901eb0
2 oracle.sql.STRUCT#3ba987b8
3 oracle.sql.STRUCT#3f191845
Query
select
id
, treat( item as computer_t ).name as computer_name
, treat( item as clothes_t ).name as garment_name
, treat( item as item_t ).name as item_name
, case
when treat( item as item_t ) is not null
then 'ITEM_T'
when treat( item as computer_t ) is not null -- "is an" item
then 'COMPUTER_T'
when treat( item as clothes_t ) is not null -- "is an" item
then 'CLOTHES_T'
else
'TYPE unknown :-|'
end type_
, case
when treat( item as computer_t ) is not null
then 'COMPUTER_T'
when treat( item as clothes_t ) is not null
then 'CLOTHES_T'
when treat( item as item_t ) is not null
then 'ITEM_T'
else
'TYPE unknown :-|'
end type_
from items ;
-- result
ID COMPUTER_NAME GARMENT_NAME ITEM_NAME TYPE_ TYPE_
1 iMac NULL iMac ITEM_T COMPUTER_T
2 NULL coat coat ITEM_T CLOTHES_T
3 NULL NULL supertype ITEM_T ITEM_T