This section describes the SDL declarations pertaining to properties.
Declare an abstract property “address_base” with a helpful title:
abstract property address_base {
# declare a specific title for the link
annotation title := 'Mailing address';
}
Declare concrete properties “name” and “address” within a “User” type:
type User {
# define concrete properties
required property name -> str;
property address extending address_base -> str;
multi link friends -> User;
index on (__subject__.name);
}
Any time that the SDL declaration refers to an inherited property that
is being overloaded (by adding more constraints, for example), the
overloaded
keyword must be used. This is to prevent unintentional
overloading due to name clashes:
abstract type Named {
property name -> str;
}
type User extending Named {
# define concrete properties
overloaded required property name -> str;
# ... other links and properties
}
Define a new property corresponding to the more explicit DDL commands.
Concrete property form used inside type declaration:
[ overloaded ] [{required | optional}] [{single | multi}]
property name
[ extending base [, ...] ] -> type
[ "{"
[ default := expression ; ]
[ readonly := {true | false} ; ]
[ annotation-declarations ]
[ constraint-declarations ]
...
"}" ]
Computable property form used inside type declaration:
[{required | optional}] [{single | multi}]
property name := expression;
Computable property form used inside type declaration (extended):
[ overloaded ] [{required | optional}] [{single | multi}]
property name
[ extending base [, ...] ] [-> type]
[ "{"
USING (expression) ;
[ annotation-declarations ]
[ constraint-declarations ]
...
"}" ]
Abstract property form:
abstract property [module::]name [extending base [, ...]]
[ "{"
[ readonly := {true | false} ; ]
[ annotation-declarations ]
...
"}" ]
There are several forms of property
declaration, as shown in the
syntax synopsis above. The first form is the canonical definition
form, the second and third forms are used for defining a
computable property, and the last
one is a form to define an abstract property
. The abstract
form allows declaring the property directly inside a module. Concrete property forms are always used
as sub-declarations for an object type or a link.
The following options are available:
If specified, indicates that the property is inherited and that some feature of it may be altered in the current object type. It is an error to declare a property as overloaded if it is not inherited.
If specified, the property is considered required for the parent object type. It is an error for an object to have a required property resolve to an empty value. Child properties always inherit the required attribute, i.e it is not possible to make a required property non-required by extending it.
This is the default qualifier assumed when no qualifier is specified, but it can also be specified explicitly. The property is considered optional for the parent object type, i.e. it is possible for the property to resolve to an empty value.
Specifies that there may be more than one instance of this
property in an object, in other words, Object.property
may
resolve to a set of a size greater than one.
Specifies that there may be at most one instance of this
property in an object, in other words, Object.property
may
resolve to a set of a size not greater than one. single
is
assumed if nether multi
nor single
qualifier is specified.
Optional clause specifying the parents of the new property item.
Use of extending
creates a persistent schema relationship
between the new property and its parents. Schema modifications
to the parent(s) propagate to the child.
The type must be a valid type expression denoting a non-abstract scalar or a container type.
The valid SDL sub-declarations are listed below:
Specifies the default value for the property as an EdgeQL expression.
The default value is used in an INSERT
statement if an explicit
value for this property is not specified.
If true
, the property is considered read-only.
Modifications of this property are prohibited once an object is
created. All of the derived properties must preserve the
original read-only value.
Set property annotation to a given value.
Define a concrete constraint on the property.