Page History

An expression constraint is either a refined expression constraint, a compound expression constraint, a dotted expression constraint, or a sub expression constraint.

A refined expression constraint includes a simple expression subexpression constraint followed by a refinement.

A compound expression constraint contains two or more expression constraints joined by either a conjunction, disjunction or exclusion. When potential ambiguity in binary operator precedence may occur, round brackets must be used to clearly disambiguate the order in which these operator are applied. Brackets are not required in expression constraints in which all binary operators are conjunctions, or all binary operators are disjunctions. Please note that unary operators (i.e. constraint operators and member of functions) are always applied before binary operators (i.e. conjunction, disjunction and exclusion).

A dotted expression constraint contains a sub expression constraint, followed by one or more

dotted attributes. When a single dotted attribute is used, the result is the set of attribute values (for the given attribute name) of each concept that results from evaluating the subExpressionConstraint. When more than one dotted attribute is used, each dottedExpressionAttribute is sequentially evaluated (from left to right) against the given result set.

A simple sub expression constraint consists of a focus concept, optionally preceded by optionally begins with a constraint operator and/or a memberOf function. It then includes either a single focus concept or an expression constraint (enclosed in brackets). A memberOf function should be used only when the eclFocusConcept or expressionConstraint refers to a reference set concept, a set of reference set concepts, or a wild card. If When both a memberOf function and constraintOperator are usedconstraintOperator and a memberOf function are used, they are applied from the inside to out (i.e. from right to left) - see 5.4 Operator Precedence. Therefore, if a constraintOperator is followed by a memberOf function, then the memberOf function is processed prior to the constraintOperator.

A focus concept is a concept reference or a wild card.

The 'memberOf' function returns the set of referenced components in the reference set whose concept identifier follows. In the brief syntax, the memberOf function is represented using the "^" symbol. In the long syntax, the text "memberOf " (case insensitive and followed by at least one white space) is also allowed.

A conceptReference is represented by a ConceptId, optionally followed by a 

The ConceptId must be a valid  for a valid 

The 

A wild card represents any concept in the given substrate. In the brief syntax, a wildcard is represented using the "*" symbol. In the long syntax, the text "ANY" (case insensitive) is also allowed.

A constraint operator is either 'childOf', 'descendantOrSelfOf', 'descendantOf', 'parentOf', 'ancestorOrSelfOf', or 'ancestorOf'.

The descendantOf operator returns the set of all subtypes of the given concept (or set of concepts). In the brief syntax, the descendantOf operator is represented using the symbol "<". In the long syntax, the text "descendantOf" (case insensitive and followed by at least one white space) is also allowed.

The descendantOrSelfOf operator returns the set of all subtypes of the given concept (or set of concepts), plus the concept (or set of concepts) itself. In the brief syntax, the descendantOrSelfOf operator is represented using the symbols "<<". In the long syntax, the text "descendantOrSelfOf" (case insensitive and followed by at least one white space) is also allowed.

The childOf operator returns the set of all immediate children of the given concept (or set of concepts). In the brief syntax, the childOf operator is represented using the symbols "<!". In the long syntax, the text "childOf" (case insensitive and followed by at least one white space) is also allowed.

The ancestorOf operator returns the set of all supertypes of the given concept (or set of concepts). In the brief syntax, the ancestorOf operator is represented using the symbol ">". In the long syntax, the text "ancestorOf " (case insensitive and followed by at least one white space) is also allowed.

The ancestorOrSelfOf operator returns the set of all supertypes of the given concept (or set of concepts), plus the concept (or set of concepts) itself. In the brief syntax, the ancestorOrSelfOf operator is represented using the symbols ">>". In the long syntax, the text "ancestorOrSelfOf" (case insensitive and followed by at least one white space) is also allowed.

The parentOf operator returns the set of all immediate parents of the given concept (or set of concepts). In the brief syntax, the parentOf operator is represented using the symbols ">!". In the long syntax, the text "parentOf" (case insensitive and followed by at least one white space) is also allowed.

A conjunction is represented either by the word "and" (case insensitive and followed by at least one white space), or by a comma.

A disjunction is represented by the word "or" (case insensitive and followed by at least one white space).

The exclusion operator is represented by the word "minus" (case insensitive and followed by at least one white space).

A refinement contains all the grouped and ungrouped attributes that refine the set of clinical meanings satisfied by the expression constraint. Refinements may represent the conjunction or disjunction of two smaller refinements, and may optionally be placed in brackets. Where both conjunction and disjunction are used, brackets are mandatory to disambiguate the intended meaning.

A conjunction refinement set consists of one or more conjunction operators, each followed by a subRefinement.

A disjunction refinement set consists of one or more disjunction operators, each followed by a subRefinement.

A subRefinement is either an attribute set, an attribute group or a bracketed refinement.

An attribute set contains one or more 

A conjunction attribute set consists of one or more conjunction operators, each followed by a subAttributeSet.

A disjunction attribute set consists of one or more disjunction operators, each followed by a subAttributeSet.

A subAttributeSet is either an attribute or a bracketed attribute set.

An 

An  contains a collection of attributes that operate together as part of the  of the containing constraintthe 

The cardinality represents a constraint on the minimum and maximum number of times that the given attribute or attribute group may appear in a matching expression. The cardinality is enclosed in square brackets with the minimum cardinality appearing first, followed by a separator (two dots in the brief syntax), and then the maximum cardinality.

A value that represents the minimum number of times that an attribute or attribute group may appear. The minimum cardinality must always be less than or equal to the maximum cardinality.

In the brief syntax, the minimum and maximum cardinality are separated by two dots (i.e. ".."). In the long syntax, the text "to" (case insensitive with at least one white space before and after) is also allowed between the two cardinalities.

A value that represents the maximum number of times that an attribute or attribute group may appear. A maximum cardinality of 'many' indicates that there is no limit on the number of times the attribute may appear.

In the brief syntax, a cardinality of 'many' is represented using the symbol "*". In the long syntax, the text "many" (case insensitive, with no trailing space) is also allowed.

When a reverse flag is used on an attribute, the matching relationships are traversed in the reverse of the normal direction. This means that the target concept of each relationship must match the focus concept to which the attribute is applied, while the source concept of the relationship must match the attribute value. In the brief syntax, the reverse flag is represented using the character "R" (in uppercase). In the long syntax, the text "reverseOf " (case insensitive) is also allowed.

An attribute operator indicates that instead of just matching the named attribute with the given attribute value, any descendants of or any descendants or self of the named attribute may match the given attribute value). In the long syntax, the text "reverseOf " (case insensitive) is also allowed.

Attributes whose value is a concept may be compared to an expression constraint using either equals ("=") or not equals ("!="). In the long syntax "<>" and "not =" (case insensitive) are also valid ways to represent not equals.

Attributes whose value is numeric (i.e. integer or decimal) may be compared to a specific concrete value using a variety of comparison operators, including equals ("="), less than ("<"), less than or equals ("<="), greater than (">"), greater than or equals (">=") and not equals ("!="). In the long syntax "<>" and "not =" (case insensitive) are also valid ways to represent not equals.

Attributes whose value is numeric may be compared to an expression constraint using either equals ("=") or not equals ("!="). In the long syntax "<>" and "not =" (case insensitive) are also valid ways to represent not equals.

A numeric value is either an integer or a decimal. Positive numbers optionally start with a plus sign ("+"), while negative integers begin with a minus sign ("-").

A string value includes one or more of any printable ASCII characters enclosed in quotation marks. Quotes and backslash characters within the string must be preceded by the escape character ("\").

An integer value is either starts with a non-zero digit followed by zero to many additional digits, or is the integer zero itself. 

A decimal value starts with an integer. This is followed by a decimal point and one to many digits.

A non-negative integer value (i.e. positive integers or zero), without a preceding plus sign ("+").

A SNOMED CT id is used to represent an attribute id or a  ida 

Optional whitespace characters (space, tab, carriage return, linefeed or a comment) are ignored everywhere in the  exceptthe 

1. Whitespace within a conceptId is an error.
   Note: Whitespace before or after the last digit of a valid  is valid 

   Gloss
   t Identifier

    is ignored.

2. Non-consecutive spaces within a term are treated as a significant character of the term.
   Note: Whitespace before the first or after the last non-whitespace character of a 

   Specref
   RefType field t term

    is ignored
3. Whitespace within the quotation marks of a concrete value is treated as a significant character.

Mandatory whitespace (i.e. space, tab, carriage return, linefeed or a comment) is required after certain keywords, including "And" and "Or".

A comment, which provides additional human-readable details about the expression constraint. Comments begin with a forward slash directly followed by a star (i.e. "/") and end with a star directly followed by a forward slash (i.e. "/").

A character that is not a star (i.e. not %x2A).

A star (i.e. "*") followed by a character that is not a forward slash (i.e. not "/").

A character that is not a forward slash (i.e. not "/").

Space character.

Tab character.

Carriage return character.

Line feed character.

Quotation mark character.

Any digit 0 through 9.

The digit 0.

Digits 1 through 9, but excluding 0.

The first character of a  is a 

Non whitespace (and non pipe) includes printable ASCII characters (these are also valid UTF8 characters encoded as one octet) and also includes all UTF8 characters encoded as 2- 3- or 4-octet sequences. It excludes space (which is %x20) and the pipe character "

anyNonEscapedChar includes any printable ASCII characters which do not need to be preceded by an escape character (i.e. "\"). This includes valid UTF8 characters encoded as one octet and all UTF8 characters encoded as 2, 3 or 4 octet sequences. It does, however, exclude the quotation mark (") and the backslash (). See RFC 3629 (  UTF-8, a  format of  10646 a 

The double quotation mark and the back slash character must both be escaped within a string-based concrete value by preceding them with a back slash.

UTF8 characters encoded as 2-octet sequences.

UTF8 characters encoded as 3-octet sequences.

UTF8 characters encoded as 4-octet sequences.

UTF8 characters encoded as 8-octet sequences.