TypeDB Philosophy

// Class inheritance in Java

class User {
    String email;
    String name;

    User(String email, String name) {
        this.name = name;
        this.email = email;
    }
}

class Employee extends User {
    int employeeId;
  
    Employee(String email, String name, int employeeId) {
        super(email, name);
        this.employeeId = employeeId;
    }
}

class PartTimeEmployee extends Employee {
    int weeklyHour;
    
    PartTimeEmployee(String email, String name, int employeeId, int weeklyHour) {
        super(email, name, employeeId);
        this.wheeklyHour = weeklyHour;
    }
}

// Class instantiation in Java

PartTimeEmployee john = new PartTimeEmployee("john.doe@vaticle.com", "John Doe", 346523, 35);

-- Table inheritance in SQL

CREATE TABLE Users (
    id SERIAL PRIMARY KEY,
    email TEXT NOT NULL,
    name TEXT NOT NULL,
    UNIQUE (email)
);

CREATE TABLE Employees (
    id INTEGER NOT NULL,
    employeeId INTEGER NOT NULL,
    PRIMARY KEY (id),
    FOREIGN KEY (id) REFERENCES Users(id),
    UNIQUE (employeeId)
);

CREATE TABLE PartTimeEmployee (
    id INTEGER NOT NULL,
    weeklyHour INTEGER NOT NULL,
    PRIMARY KEY (id),
    FOREIGN KEY (id) REFERENCES Employees(id)
);

-- Data inserting for extended tables in SQL

DO $$
DECLARE
    inserted_user_id INTEGER;
BEGIN
    INSERT INTO Users (id, email, name)
    VALUES (DEFAULT, 'john.doe@vaticle.com', 'John Doe')
    RETURNING id INTO inserted_user_id;

    INSERT INTO Employees (inserted_user_id, 346523)

    INSERT INTO PartTimeEmployees (inserted_user_id, 35)
COMMIT;
END $$;

-- Data retrieval for all Users and extended tables in SQL

SELECT Users.id AS id, Users.email AS email, Users.name AS name, null AS employeeId, null AS weeklyHours, 'user' AS userType 
FROM Users 
WHERE NOT EXISTS (SELECT id FROM Employees WHERE Users.id = Employees.id)
UNION ALL 
SELECT Users.id AS id, Users.email AS email, Users.name AS name, employeeId, null AS weeklyHours, 'employee' AS userType
FROM Users 
INNER JOIN Employees ON Users.id = Employees.id
WHERE NOT EXISTS (SELECT Employees.id FROM PartTimeEmployee WHERE Employees.id = PartTimeEmployee.id)
UNION ALL
SELECT Users.id AS id, Users.email AS email, Users.name AS name, employeeId, weeklyHours, 'partTimeEmployee' AS userType
FROM Users
INNER JOIN Employees ON Users.id = Employees.id
INNER JOIN PartTimeEmployee ON Employees.id = PartTimeEmployee.id

// Retrieval of polymorphic resources in MongoDB

db.resource_ownerships.aggregate([
    {
        $lookup:
        {
            from: "resources",
            localField: "resource",
            foreignField: "_id",
            as: "resource"
        }
    },
    {
        $unwind:
        {
            path: "$resource"
        }
    },
    {
        $lookup:
        {
            from: "users",
            localField: "owner",
            foreignField: "_id",
            as: "owner"
        }
    },
    {
        $unwind:
        {
            path: "$owner"
        }
    },
    {
        $unwind:
        {
            path: "$owner.emails"
        }
    },
    {
        $addFields:
        {
            resource_id: {
                $switch: {
                    branches: [
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "file"]
                            }, 
                            then: "$resource.path" 
                        },
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "directory"]
                            }, 
                            then: "$resource.path" 
                        },
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "commit"]
                            }, 
                            then: "$resource.hash" 
                        },
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "repository"]
                            }, 
                            then: "$resource.name" 
                        },
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "table"]
                            }, 
                            then: "$resource.name" 
                        },
                        {
                            case: { 
                                $eq: ["$resource.resource_type", "database"]
                            }, 
                            then: "$resource.name" 
                        }
                    ]
                }
            }
        }
    },
    {
        $project: {
            _id: false,
            email: "$owner.emails",
            resource_type: "$resource.resource_type",
            id: "$resource_id"
        }
    }
 ])

// Retrieval of polymorphic resources in Neo4j's Cypher

MATCH
    (user:User)-[:OWNS]->(rsrc:Resource)
WITH
    rsrc,
    [user.primary_email] + user.alias_emails AS emails,
    labels(rsrc) AS resource_types,
    keys(rsrc) AS properties
UNWIND emails AS email
UNWIND resource_types AS rsc_type
WITH
    rsrc, email, rsc_type, properties,
    {
        File: "path",
        Directory: "path",
        Commit: "hash",
        Repository: "name",
        Table: "name",
        Database: "name"
    } AS id_type_map
WHERE rsc_type IN keys(id_type_map)
AND id_type_map[rsc_type] IN properties
RETURN email, rsc_type, rsrc[id_type_map[rsc_type]] AS id

// Class inheritance in Java

class User {
    String email;
    String name;

    User(String email, String name) {
        this.name = name;
        this.email = email;
    }
}

class Employee extends User {
    int employeeId;
  
    Employee(String email, String name, int employeeId) {
        super(email, name);
        this.employeeId = employeeId;
    }
}

class PartTimeEmployee extends Employee {
    int weeklyHour;
    
    PartTimeEmployee(String email, String name, int employeeId, int weeklyHour) {
        super(email, name, employeeId);
        this.wheeklyHour = weeklyHour;
    }
}

// Class instantiation in Java

PartTimeEmployee john = new PartTimeEmployee("john.doe@vaticle.com", "John Doe", 346523, 35);

# Type inheritance in TypeQL

define

email sub attribute, value string;
name sub attribute, value string;
emloyee-id sub attribute, value long;
weekly-hour sub attribute, value long;

user sub entity,
    owns name,
    owns email;

employee sub user,
    owns employee-id;

part-time-employee sub employee,
    owns weekly-hour;

# insert of a PartTimeEmployees
insert $john isa part-time-employee,
    has email "john.doe@vaticle.com", 
    has name "John Doe",
    has employee-id 346523, 
    has weekly-hour 35;