Inheritance

Inheritance is a crucial aspect of schema modeling in EdgeDB. Schema items can extend one or more parent types. When extending, the child (subclass) inherits the definition of its parents (superclass).

You can declare abstract object types, properties, links, constraints, and annotations.

Object types

Object types can extend other object types. The extending type (AKA the subtype) inherits all links, properties, indexes, constraints, etc. from its supertypes.

  1. abstract type Animal {
  2.   property species -> str;
  3. }
  5. type Dog extending Animal {
  6.   property breed -> str;
  7. }

For details on querying polymorphic data, see EdgeQL > Select > Polymorphic queries.

Multiple Inheritance

Object types can extend more than one type — that’s called multiple inheritance. This mechanism allows building complex object types out of combinations of more basic types.

  1. abstract type HasName {
  2.   property first_name -> str;
  3.   property last_name -> str;
  4. }
  6. abstract type HasEmail {
  7.   property email -> str;
  8. }
  10. type Person extending HasName, HasEmail {
  11.   property profession -> str;
  12. }

Overloading

An object type can overload an inherited property or link. All overloaded declarations must be prefixed with the overloaded prefix to avoid unintentional overloads.

  1. abstract type Person {
  2.   property name -> str;
  3.   multi link friends -> Person;
  4. }
  6. type Student extending Person {
  7.   overloaded property name -> str {
  8.     constraint exclusive;
  9.   }
  10.   overloaded multi link friends -> Student;
  11. }

Overloaded fields cannot generalize the associated type; it can only make it more specific by setting the type to a subtype of the original or adding additional constraints.

Properties

Properties can be concrete (the default) or abstract. Abstract properties are declared independent of a source or target, can contain annotations, and can be marked as readonly.

  1. abstract property title_prop {
  2.   annotation title := 'A title.';
  3.   readonly := false;
  4. }

It’s possible to define abstract links that aren’t tied to a particular source or target. Abstract links can be marked as readonly and contain annotations, property declarations, constraints, and indexes.

  1. abstract link link_with_strength {
  2.   property strength -> float64;
  3.   index on (__subject__@strength);
  4. }
  6. type Person {
  7.   multi link friends extending link_with_strength -> Person;
  8. }

Constraints

Use abstract to declare reusable, user-defined constraint types.

  1. abstract constraint in_range(min: anyreal, max: anyreal) {
  2.   errmessage :=
  3.     'Value must be in range [{min}, {max}].';
  4.   using (max > __subject__ and __subject__ >= min);
  5. }
  7. type Player {
  8.   property points -> int64 {
  9.     constraint in_range(0, 100);
  10.   }
  11. }

Annotations

EdgeQL supports three annotations types by default: title, description, and deprecated. Use abstract annotation to declare custom user-defined annotation types.

  1. abstract annotation admin_note;
  3. type Status {
  4.   annotation admin_note := 'system-critical';
  5.   # more properties
  6. }

By default, annotations defined on abstract types, properties, and links will not be inherited by their subtypes. To override this behavior, use the inheritable modifier.

  1. abstract inheritable annotation admin_note;