Define an abstract type:

Copy
abstract type HasImage {
    # just a URL to the image
    required property image -> str;
    index on (.image);
}

Define a type extending from the abstract:

Copy
type User extending HasImage {
    required property name -> str {
        # Ensure unique name for each User.
        constraint exclusive;
    }
}

Define a type with constraints and defaults for properties:

Copy
type Review {
    required property body -> str;
    required property rating -> int64 {
        constraint min_value(0);
        constraint max_value(5);
    }
    required property flag -> bool {
        default := False;
    }

    required link author -> User;
    required link movie -> Movie;

    required property creation_time -> datetime {
        default := datetime_current();
    }
}

Define a type with a property that is computed from the combination of the other properties:

Copy
type Person extending HasImage {
    required property first_name -> str {
        default := '';
    }
    required property middle_name -> str {
        default := '';
    }
    required property last_name -> str;
    property full_name :=
        (
            (
                (.first_name ++ ' ')
                IF .first_name != '' ELSE
                ''
            ) ++
            (
                (.middle_name ++ ' ')
                IF .middle_name != '' ELSE
                ''
            ) ++
            .last_name
        );
    property bio -> str;
}

Define an abstract links:

Copy
abstract link crew {
    # Provide a way to specify some "natural"
    # ordering, as relevant to the movie. This
    # may be order of importance, appearance, etc.
    property list_order -> int64;
}

abstract link directors extending crew;

abstract link actors extending crew;

Define a type using abstract links and a computed property that aggregates values from another linked type:

Copy
type Movie extending HasImage {
    required property title -> str;
    required property year -> int64;

    # Add an index for accessing movies by title and year,
    # separately and in combination.
    index on (.title);
    index on (.year);
    index on ((.title, .year));

    property description -> str;

    multi link directors extending crew -> Person;
    multi link actors extending crew -> Person;

    property avg_rating := math::mean(.<movie[IS Review].rating);
}

Define an auto-incrementing scalar type and an object type using it as a property:

Copy
scalar type TicketNo extending sequence;

type Ticket {
    property number -> TicketNo {
        constraint exclusive;
    }
}
Light
Dark
System