Technically, a query consists of a single compound predicate. A compound predicate starts with an optional declaration of query variables. Its main part is a predicate list, which defines the properties of the compound predicate.
Queries and Compound Predicates  


The inparameter of a predicate list is the inparameter of its first connected predicate which has an inparameter, or the predicate list has no inparameter if no such connected predicate exists. The outparameter of the predicate list is the outparameter of its last connected predicate which has an outparameter, or the predicate list has no outparameter if no such connected predicate exists.
A predicate list is fulfilled if and only if all of its contained connected predicates are fulfilled.
Context predicates and branch predicates inherit their in and outparameters from the contained predicate list. They are fulfilled if and only if the contained predicate list is fulfilled.
A place denotes a set of predicate parameters which are associated with each other. A place also has a set of associated query variables. One of these query variables may be the label of the place. One of these query variables is the main variable of the place. Places may be node places, main variables of node places are bound to nodes of the current extent (Chapter 3, Data Model Interface).
Initially, a place is created for each predicate parameter, and the parameter is associated with this place. Later on, places my be merged, resulting in a single place which contains all associations of the merged places. Places are merged in two cases:
If two places have the same label variable, they are merged.
A predicate list may merge places of neighbouring primary predicates (Section 17.3.3, “Connecting Primary Predicates”).
Like a predicate, a place imposes conditions on its query variables which have to be fulfilled for the place to match for a binding of the variables.
The main variable is determined as follows:
If the place is a node place and has a label variable
q
whose values have to be wrapped in order to be represented as
nodes (Section 3.1, “CompileTime Model”), then an additional query variable
is declared and associated with the place.
It wraps the values of q
.
Its identifier is the identifier of q
with the single character $
prepended.
Its preliminary type
is determined by the invocation of the method
getWrapperClassFor
of the current
compiletime model (Section 3.1, “CompileTime Model”) with the type
of q
as argument. The wrapper variable
is the main variable of the place. For a binding
of the query variables, the bound value of
q
must be equal to
the result of the invocation of the method
unwrap
A
on the
current runtime model (Section 3.2, “RunTime Model”) with
the bound value of the wrapper variable as argument.
A
is the type affix
(Section 6.1, “Type Affixes and Type Letters”) of the type of q
.
Otherwise, if the place is a node place without label variable,
and if there are
associated predicate parameters whose values are not representable
as nodes, an unnamed variable is declared implicitly, its type
being the type of the first parameter (in order of association) which needs
a wrapper. Now one proceeds as before, with q
being replaced by the implicitly declared variable.
Otherwise, if the place is a node place,
the main variable is declared implicitly, its preliminary
type being Object
.
Otherwise, the place is not a node place. If the place has a label, the main variable is the label variable. If the place has no label, the main variable is declared implicitly, its preliminary type being the type of the first parameter (in order of association).
For each associated predicate parameter, there is a query variable of suitable type. Depending on the type of the predicate parameters, a single query variable is sufficient for all parameters, or the compiler has to provide several distinct, implicitly declared query variables. The query variable for the parameters are determined as follows:
If there exist parameters of numeric type,
let N
be the first (in order of
association) of these types.
If the place is a node place, it follows from the previous statements
that there is a wrapper variable which wraps a query variable
s
. Otherwise, if the place is not a node place,
let s
be the main variable.
If s
does not have a numeric type,
a compiletime error occurs. Now for each parameter having a numeric
type T
, its query variable is determined:
If T
and the type of
some query variable v
of the place
are assignable to int
,
or if there exists a query variable v
having type T
,
the query variable for the parameter is v
.
Otherwise, an implicit query variable t
is declared in the place,
its type being T
. This variable is the
query variable for the parameter. For a binding
of the query variables, the bound value of
t
, converted to the type
of s
by a casting conversion,
has to be equal to the bound value of s
in order for the place to match.
For each of the remaining parameters of nonnumeric type
T
:
If the place has a wrapper variable and values of type
T
have to be wrapped,
the preliminary type of the wrapper variable is replaced
by the intersection (Section 6.2, “Intersection Types”)
of the preliminary type and
the type returned by the invocation of the method
getWrapperClassFor
of the current
compiletime model (Section 3.1, “CompileTime Model”) with
T
as argument.
The preliminary type of the wrapped variable is replaced
by the intersection of the preliminary type and
T
. The wrapped variable is the query
variable for the parameter.
Otherwise, if the place has a wrapper variable, but values of type
T
need not be wrapped, or if the place
is not a node place,
the preliminary type of the main variable is replaced
by the intersection of the preliminary type and
T
. The main variable is the query
variable for the parameter.
Afterwards, the actual types of query variables are set to their preliminary types.
When we speak of the bound value of a predicate parameter in the context of a binding of query variables, the bound value of the query variable associated with this predicate parameter is to be understood.
A connected predicate is either a single
condition predicate, or a list of
primary predicates. If it is a condition predicate,
it has no in and outparameters, and it is fulfilled
if and only if the contained
expression evaluates to true
. It is a compiletime
error if the type of this expression is not boolean
.
If the connected predicate consists of a list of primary predicates, its inparameter is the inparameter of the first primary predicate which has an inparameter and which is not a context predicate or a branch predicate, or it has no inparameter if no such predicate exists. The same holds for the outparameter, with the role of the first primary predicate replaced by the last primary predicate. A list of primary predicates is fulfilled if and only if all of its primary predicates are fulfilled.
A list of primary predicates also defines the node places: A place is a node place if and only if an in or outparameter of a primary predicate of a list is associated with the place.
A list of primary predicates is connected by a pairwise connection
of neighbouring primary predicates. The primary predicates of
an ordered pair (L
, R
)
are neighbouring if L
is not a branch predicate and
L
textually precedes R
with at most branch predicates inbetween. For every
ordered pair (L
, R
)
of neighbouring primary predicates,
the connection is established as follows:
If L
has a closed outparameter and
R
has a closed inparameter,
an implicit standard edge predicate
(Section 17.5.5, “Standard Edge Predicates”) is inserted.
If R
is a branch predicate, the standard edge is a forward branch edge, otherwise
it is a forward successor edge.
The inparameter of the edge predicate is associated
with the place of L
's outparameter,
the outparameter of the edge predicate is associated with the
place of R
's inparameter.
Otherwise, if L
has an outparameter and
R
has an inparameter, their places
are merged to a single place.
Otherwise, if L
has an open outparameter and
R
has no inparameter,
or if L
has no outparameter and
R
has an open inparameter,
a compiletime error occurs.
Otherwise, L
and R
are not connected.