anchor.diff:  
   There are two kinds of statements: *unary statements* and *binary statements*.
   
  -Binary statements are composed by an attribute path (e.g. "temperature"), an operator and a value
  +Binary statements are composed by an attribute path (e.g. `temperature`), an operator and a value
   (whose format depends on the operator), e.g.:
   
   ```
  
positive.code: temperature<=20
  ```
  
  The attribute path is used to select the *element under evaluation* for the statement. Its general
  syntax consists of an attribute name optionally followed by a *navigation path* using the `.`
  character as delimiter, e.g. "temperature.accuracy.average" refers to the navigation path "accuracy.average"
  within the "temperature" attribute.
  
  How the navigation path is interpreted depends on where the Simple Query Language statement is used:
  
  * If used in a `q` query, then the navigation path refers to a sub-key of the attribute value
    (assuming that the attribute value is a JSON object). If no navigation path is provided (i.e.
    the attribute path doesn't have any `.`) then the attribute itself is taken into account.
  * If used in a `mq` query, then the first element of the navigation path is mandatory and it means the
    name of a metadata of the attribute. Additional elements in the navigation path refer to a sub-key of
    the metadata value (assuming that the metadata value is a JSON object). If no navigation path is provided
    (beyond the first element which identifies the metadata name) then the metadata itself
    is taken into account.
  
  The list of operators (and the format of the values they use) is as follows:
  
  + **Equal**: `==`. This operator accepts the following types of right-hand side:
      + Single element, e.g. `temperature==40`. For an entity to match, it must contain an element
        under evaluation with that exact name (temperature) and value (40) (or which includes the
        value, in the case of elements under evaluation which value is an array).
      + A list of comma-separated values, e.g. `color==black,red`. For an entity to match, it must
        contain an element under evaluation with that name and its value must be **any** of the
        values in the list (OR clause) (or which includes **any** of the values in the case of
        elements under evaluation which value is an array).
        E.g. entities with an attribute named `color`, whose value is `black` are a match, while
        entities with an attribute named `color` but whose value is `white` do not match.
      + A range, specified as a minimum and a maximum, separated by `..`, e.g. `temperature==10..20`.
        For an entity to match, it must contain an element under evaluation with that name (temperature),
        and its value must be in the interval between the minimum and maximum of the range (both included).
        Ranges can only be used with elements under evaluation that represent dates (in ISO8601 format),
        numbers or strings.
  + **Unequal**: `!=`. This operator accepts the following types of right-hand side:
      + Single element, e.g. `temperature!=41`. For an entity to match, it must contain an element
        under evaluation with that exact name (temperature) and whose value is **not** that exact value (41).
      + A list of comma-separated values, e.g. `color!=black,red`. For an entity to match, it must
        contain an element under evaluation with that name, and whose value is **not** any of the values
        in the list (AND clause).
        Eg. entities whose attribute `color` is set to `black` will not match, while entities whose
        attribute `color` is set to `white` will match.
      + A range, specified as a minimum and maximum separated by `..`, e.g. `temperature!=10..20`.
        For an entity to match, it must contain an element under evaluation with that exact name
        (temperature) and whose value is **not** in the interval between the minimum and the maximum
        (both included). Ranges can only be used with elements under evaluation that represent dates
        (in ISO8601 format), numbers or strings.
  + **Greater than**: `>`. The right-hand side must be a single element, e.g. `temperature>42`.
      For an entity to match, it must contain an element under evaluation with that exact name (temperature) and
      whose value is strictly greater than that value (42).
      This operation is only valid for elements under evaluation of type date, numbers or strings (used with
      elements under evaluation of other types may lead to unpredictable results).
  + **Less than**: `<`. The right-hand side must be a single element, e.g. `temperature<43`.
      For an entity to match, it must contain an element under evaluation with that exact name (temperature) and
      whose value is strictly less than that value (43).
      This operation is only valid for elements under evaluation of type date, numbers or strings (used with
      elements under evaluation of other types may lead to unpredictable results).
  + **Greater or equal than**: `>=`. The right-hand side must be a single element, e.g. `temperature>=44`.
      For an entity to match, it must contain an element under evaluation with that exact name (temperature) and
      whose value is greater than or equal to that value (44).
      This operation is only valid for elements under evaluation of type date, numbers or strings (used with
      elements under evaluation of other types may lead to unpredictable results).
  + **Less or equal than**: `<=`. The right-hand side must be a single element, e.g. `temperature<=45`.
      For an entity to match, it must contain an element under evaluation with that exact name (temperature) and
      whose value is less than or equal to that value (45).
      This operation is only valid for elements under evaluation of type date, numbers or strings (used with
      elements under evaluation of other types may lead to unpredictable results).
  + **Match pattern**: `~=`. The value matches a given pattern, expressed as a regular expression, e.g.
      `color~=ow`.
      For an entity to match, it must contain an element under evaluation with that exact name (color), and
      whose value matches the string in the right-hand side, 'ow' in this example (`brown` and `yellow`
      would match, `black` and `white` would not).
      This operation is only valid for elements under evaluation of type string.
  
  The symbol `:` can be used instead of `==`.
  
  
negative.code: 
  Unary negatory statements use the unary operator `!`, while affirmative unary statements use no
  operator at all.
  The unary statements are used to check for the existence of the target property.
  E.g. `temperature` matches entities that have an attribute called 'temperature' (no matter its
  value), while `!temperature` matches entities that do not have a temperature called 'attribute'.
   
  