Appendix B – CQL Reference

Definition:

Description:

The Any type is the maximal supertype in the CQL type system, meaning that all types derive from Any, including list, interval, and structured types. In addition, the type of a null result is Any.

Definition:

Description:

The Boolean type represents the logical boolean values true and false. The result of logical operations within CQL use the Boolean type, and constructs within the language that expect a conditional result, such as a where clause or conditional expression, expect results of the Boolean type.

For more information, see the Logical Operators section.

Definition:

Description:

The Code type represents single terminology codes within CQL.

Definition:

Description:

The Concept type represents a single terminological concept within CQL.

Definition:

Description:

The Date type represents date values with potential uncertainty within CQL.

CQL supports date values in the range @0001-01-01 to @9999-12-31 with a 1 day step size.

CQL also supports partial date values. For example, the date @2014 represents some day in the year 2014.

Definition:

Description:

The DateTime type represents date and time values with potential uncertainty within CQL.

CQL supports date and time values in the range @0001-01-01T00:00:00.0 to @9999-12-31T23:59:59.999 with a 1 millisecond step size. Note that DateTime values may also optionally indicate an offset.

CQL also supports partial date/time values. For example, the datetime @2014-01-01T03 represents some instant during the hour of 3:00 on January 1st, 2014.

Definition:

Description:

The Decimal type represents real values within CQL.

CQL supports positive and negative decimal values with a precision (meaning total number of possible digits) of 28 and a scale (meaning number of possible digits to the right of the decimal) of 8. In other words, decimal values in the range (-10²⁸ + 1)/10⁸ to (10²⁸-1)/10^-8 with a step size of 10^-8.

Definition:

Description:

The Integer type represents whole number values within CQL.

CQL supports integer values in the range -2³¹ to 2³¹-1 with a step size of 1.

Definition:

Description:

The Quantity type represents quantities with a specified unit within CQL. The unit must be a valid UCUM unit or CQL temporal keyword. UCUM units in CQL use the case-sensitive (c/s) form. When a quantity value has no unit specified, operations are performed with the default UCUM unit ('1'). The value element of a Quantity must be present.

Definition:

Description:

The String type represents string values within CQL.

CQL supports string values up to 2³¹-1 characters in length.

For string literals, CQL uses standard escape sequences:

Definition:

Description:

The Time type represents time-of-day values within CQL.

CQL supports time values in the range @T00:00:00.0 to @T23:59:59.999 with a step size of 1 millisecond. Not that Time values may also optionally indicate an offset.

CQL also supports partial time values. For example, the time @T03 represents some instant during the hour of 3:00.

Signature:

Description:

The and operator returns true if both its arguments are true. If either argument is false, the result is false. Otherwise, the result is null.

The following table defines the truth table for this operator:

Table 9‑A

Example:

The following examples illustrate the behavior of the and operator:

Note that CQL does not prescribe short-circuit evaluation of logical operators.

Signature:

Description:

The implies operator returns the logical implication of its arguments. This means that if the left operand evaluates to true, this operator returns the boolean evaluation of the right operand. If the left operand evaluates to false, this operator returns true. Otherwise, this operator returns true if the right operand evaluates to true, and null otherwise.

The following table defines the truth table for this operator:

Table 9‑A

Example:

The following examples illustrate the behavior of the implies operator:

Signature:

Description:

The not operator returns true if the argument is false and false if the argument is true. Otherwise, the result is null.

The following table defines the truth table for this operator:

Table 9‑B

The following examples illustrate the behavior of the not operator:

Signature:

Description:

The or operator returns true if either of its arguments are true. If both arguments are false, the result is false. Otherwise, the result is null.

The following table defines the truth table for this operator:

Table 9‑C

Example:

The following examples illustrate the behavior of the or operator:

Note that CQL does not prescribe short-circuit evaluation of logical operators.

Signature:

Description:

The xor (exclusive or) operator returns true if one argument is true and the other is false. If both arguments are true or both arguments are false, the result is false. Otherwise, the result is null.

The following table defines the truth table for this operator:

Table 9‑D

The following examples illustrate the behavior of the xor operator:

Signature:

Description:

The as operator allows the result of an expression to be cast as a given target type. This allows expressions to be written that are statically typed against the expected run-time type of the argument.

If the argument is not of the specified type at run-time the result is null.

The cast prefix indicates that if the argument is not of the specified type at run-time then an exception is thrown.

Example:

The following examples illustrate the use of the as operator.

Signature:

Description:

For structured types, the Children operator returns a list of all the values of the elements of the type. List-valued elements are expanded and added to the result individually, rather than as a single list.

For list types, the result is the same as invoking Children on each element in the list and flattening the resulting lists into a single result.

If the source is null, the result is null.

Signature:

Description:

The convert operator converts a value to a specific type. The result of the operator is the value of the argument converted to the target type, if possible. If there is no valid conversion from the actual value to the target type, the result is null.

The following table lists the conversions supported in CQL:

Table 9‑E

For conversions between date/time and string values, ISO-8601 standard format is used:

yyyy-MM-ddThh:mm:ss.fff(Z | +/- hh:mm)

For example, the following are valid string representations for date/time values:

For specific semantics for each conversion, refer to the explicit conversion operator documentation.

Signature:

Description:

For structured types, the Descendents operator returns a list of all the values of the elements of the type, recursively. List-valued elements are expanded and added to the result individually, rather than as a single list.

For list types, the result is the same as invoking Descendents on each element in the list and flattening the resulting lists into a single result.

If the source is null, the result is null.

Signature:

Description:

The is operator allows the type of a result to be tested. If the run-time type of the argument is of the type being tested, the result of the operator is true; otherwise, the result is false.

The following examples illustrate the behavior of the is operator:

Signature:

Description:

The ConvertsToBoolean operator returns true if its argument can be converted to a Boolean value. See the ToBoolean operator for a description of the supported conversions.

If the input cannot be interpreted as a valid Boolean value, the result is false.

If the argument is null, the result is null.

Signature:

Description:

The ConvertsToDate operator returns true if its argument can be converted to a Date value. See the ToDate operator for a description of the supported conversions.

If the input string is not formatted correctly, or does not represent a valid date value, the result is false.

As with date literals, date values may be specified to any precision.

If the argument is null, the result is null.

Signature:

Description:

The ConvertsToDateTime operator returns true if its argument can be converted to a DateTime value. See the ToDateTime operator for a description of the supported conversions.

If the input string is not formatted correctly, or does not represent a valid date/time value, the result is false.

As with date/time literals, date/time values may be specified to any precision. If no timezone offset is supplied, the timezone offset of the evaluation request timestamp is assumed.

If the argument is null, the result is null.

Signature:

Description:

The ToDecimal operator returns true if its argument can be converted to a Decimal value. See the ToDecimal operator for a description of the supported conversions.

If the input string is not formatted correctly, or cannot be interpreted as a valid Decimal value, the result is false.

If the argument is null, the result is null.

Signature:

Description:

The ConvertsToInteger operator returns true if its argument can be converted to an Integer value. See the ToInteger operator for a description of the supported conversions.

If the input string is not formatted correctly, or cannot be interpreted as a valid Integer value, the result is false.

Signature:

Description:

The ConvertsToQuantity operator returns true if its argument can be converted to a Quantity value. See the ToQuantity operator for a description of the supported conversions.

If the input string is not formatted correctly, or cannot be interpreted as a valid Quantity value, the result is false.

If the argument is null, the result is null.

Signature:

Description:

The ConvertsToString operator returns true if its argument can be converted to a String value. See the ToString operator for a description of the supported conversions.

If the argument is null, the result is null.

Signature:

Description:

The ConvertsToTime operator returns true if its argument can be converted to a Time value. See the ToTime operator for a description of the supported conversions.

If the input string is not formatted correctly, or does not represent a valid time-of-day value, the result is false.

If the argument is null, the result is null.

Signature:

Description:

The ToBoolean operator converts the value of its argument to a Boolean value. The operator accepts the following string representations:

Table 9‑F

Note that the operator will ignore case when interpreting the string as a Boolean value.

If the input cannot be interpreted as a valid Boolean value, the result is null.

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToBoolean operator:

Signature:

Description:

The ToConcept operator converts a value of type Code to a Concept value with the given Code as its primary and only Code. If the Code has a display value, the resulting Concept will have the same display value.

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToConcept operator:

Signature:

Description:

The ToDate operator converts the value of its argument to a Date value. The operator expects the string to be formatted using the ISO-8601 date representation:

YYYY-MM-DD

In addition, the string must be interpretable as a valid date value.

For example, the following are valid string representations for date values:

If the input string is not formatted correctly, or does not represent a valid date value, the result is null.

As with date literals, date values may be specified to any precision.

If the argument is null, the result is null.

Signature:

Description:

The ToDateTime operator converts the value of its argument to a DateTime value.

For the string overload, the operator expects the string to be formatted using the ISO-8601 date/time representation:

YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm or YYYY-MM-DDThh:mm:ss.fffZ

In addition, the string must be interpretable as a valid date/time value.

For example, the following are valid string representations for date/time values:

If the input string is not formatted correctly, or does not represent a valid date/time value, the result is null.

As with date/time literals, date/time values may be specified to any precision. If no timezone offset is supplied, the timezone offset of the evaluation request timestamp is assumed.

For the Date overload, the result will be a DateTime with the time components set to zero, except for the timezone offset, which will be set to the timezone offset of the evaluation request timestamp.

If the argument is null, the result is null.

Signature:

Description:

The ToDecimal operator converts the value of its argument to a Decimal value. The operator accepts strings using the following format:

Meaning an optional polarity indicator, followed by any number of digits (including none), followed by at least one digit, followed optionally by a decimal point, at least one digit, and any number of additional digits (including none).

Note that the decimal value returned by this operator must be limited in precision and scale to the maximum precision and scale representable for Decimal values within CQL.

If the input string is not formatted correctly, or cannot be interpreted as a valid Decimal value, the result is null.

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToDecimal operator:

Signature:

Description:

The ToInteger operator converts the value of its argument to an Integer value. The operator accepts strings using the following format:

Meaning an optional polarity indicator, followed by any number of digits (including none), followed by at least one digit.

Note that the integer value returned by this operator must be a valid value in the range representable for Integer values in CQL.

If the input string is not formatted correctly, or cannot be interpreted as a valid Integer value, the result is null.

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToInteger operator:

Signature:

Description:

The ToQuantity operator converts the value of its argument to a Quantity value.

For the String overload, the operator accepts strings using the following format:

Meaning an optional polarity indicator, followed by any number of digits (including none) followed by at least one digit, optionally followed by a decimal point, at least one digit, and any number of additional digits, all optionally followed by a unit designator as a string literal specifying a valid, case-sensitive UCUM unit of measure. Spaces are allowed between the quantity value and the unit designator.

Note that the decimal value of the quantity returned by this operator must be a valid value in the range representable for Decimal values in CQL.

If the input string is not formatted correctly, or cannot be interpreted as a valid Quantity value, the result is null.

For the Integer and Decimal overloads, the operator returns a quantity with the value of the argument and a unit of '1' (the default unit).

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToQuantity operator:

Signature:

Description:

The ToString operator converts the value of its argument to a String value. The operator uses the following string representations for each type:

Table 9‑G

The result of any ToString must be round-trippable back to the source value.

If the argument is null, the result is null.

The following examples illustrate the behavior of the ToString operator:

Signature:

Description:

The ToTime operator converts the value of its argument to a Time value. The operator expects the string to be formatted using ISO-8601 time representation:

Thh:mm:ss.fff(+|-)hh:mm or Thh:mm:ss.fffZ

In addition, the string must be interpretable as a valid time-of-day value.

For example, the following are valid string representations for time-of-day values:

If the input string is not formatted correctly, or does not represent a valid time-of-day value, the result is null.

As with time-of-day literals, time-of-day values may be specified to any precision. If no timezone offset is supplied, the timezone offset of the evaluation request timestamp is assumed.

If the argument is null, the result is null.

Signature:

Description:

The Coalesce operator returns the first non-null result in a list of arguments. If all arguments evaluate to null, the result is null.

The static type of the first argument determines the type of the result, and all subsequent arguments must be of that same type.

The following examples illustrate the behavior of the Coalesce operator:

Signature:

Description:

The is null operator determines whether or not its argument evaluates to null. If the argument evaluates to null, the result is true; otherwise, the result is false.

The following examples illustrate the behavior of the is null operator:

Signature:

Description:

The is false operator determines whether or not its argument evaluates to false. If the argument evaluates to false, the result is true; otherwise, the result is false.

The following examples illustrate the behavior of the is false operator:

Signature:

Description:

The is true operator determines whether or not its argument evaluates to true. If the argument evaluates to true, the result is true; otherwise, the result is false.

The following examples illustrate the behavior of the is true operator:

Signature:

Description:

The between operator determines whether the first argument is within a given range, inclusive. If the first argument is greater than or equal to the low argument, and less than or equal to the high argument, the result is true, otherwise, the result is false.

For comparisons involving quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null.

For comparisons involving date/time values with imprecision, note that the result of the comparison may be null, depending on whether the values involved are specified to the level of precision used for the comparison. For example:

String comparisons are strictly lexical based on the Unicode value of the individual characters in the string.

If any argument is null, the result is null.

The following examples illustrate the behavior of the between operator:

Signature:

Description:

The equal (=) operator returns true if the arguments are equal; false if the arguments are known unequal, and null otherwise. Equality semantics are defined to be value-based.

For simple types, this means that equality returns true if and only if the result of each argument evaluates to the same value.

For string values, equality is strictly lexical based on the Unicode values for the individual characters in the strings.

For decimal values, trailing zeroes are ignored.

For quantities, this means that the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

For tuple types, this means that equality returns true if and only if the tuples are of the same type, and the values for all elements that have values, by name, are equal.

For list types, this means that equality returns true if and only if the lists contain elements of the same type, have the same number of elements, and for each element in the lists, in order, the elements are equal using equality semantics.

For interval types, equality returns true if and only if the intervals are over the same point type, and they have the same value for the starting and ending points of the interval as determined by the Start and End operators.

For date/time values, the comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the values are different, the comparison stops and the result is false. If one input has a value for the precision and the other does not, the comparison stops and the result is null; if neither input has a value for the precision, or the last precision has been reached, the comparison stops and the result is true.

If either argument is null, the result is null.

The following examples illustrate the behavior of the equal operator:

Signature:

Description:

The equivalent (~) operator returns true if the arguments are equivalent in value, or if they are both null; and false otherwise.

For string values, equivalence is case- and locale-insensitive.

For tuple types, this means that two tuple values are equivalent if and only if the tuples are of the same type, and the values for all elements by name are equivalent.

For list types, this means that two list values are equivalent if and only if the lists contain elements of the same type, have the same number of elements, and for each element in the lists, in order, the elements are equivalent.

For interval types, this means that two intervals are equivalent if and only if the intervals are over the same point type, and the starting and ending points of the intervals as determined by the Start and End operators are equivalent.

For date/time values, the comparison is performed in the same way as it is for equality, except that if one input has a value for a given precision and the other does not, the comparison stops and the result is false, rather than null.

For Code values, equivalence is defined based on the code and system elements only. The version and display elements are ignored for the purposes of determining Code equivalence.

For Concept values, equivalence is defined as a non-empty intersection of the codes in each Concept.

Note that this operator will always return true or false, even if either or both of its arguments are null, or contain null components.

The following examples illustrate the behavior of the equivalent operator:

Signature:

Description:

The greater (>) operator returns true if the first argument is greater than the second argument.

String comparisons are strictly lexical based on the Unicode value of the individual characters in the string.

For comparisons involving quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

For date/time values, the comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is greater than the second, the result is true; if the first value is less than the second, the result is false; if one input has a value for the precision and the other does not, the comparison stops and the result is null; if neither input has a value for the precision or the last precision has been reached, the comparison stops and the result is false. For example:

If either argument is null, the result is null.

The following examples illustrate the behavior of the greater operator:

Signature:

Description:

The greater or equal (>=) operator returns true if the first argument is greater than or equal to the second argument.

String comparisons are strictly lexical based on the Unicode value of the individual characters in the string.

For comparisons involving quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

For date/time values, the comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is greater than the second, the result is true; if the first value is less than the second, the result is false; if one input has a value for the precision and the other does not, the comparison stops and the result is null; if neither input has a value for the precision or the last precision has been reached, the comparison stops and the result is true. For example:

If either argument is null, the result is null.

The following examples illustrate the behavior of the greater or equal operator:

Signature:

Description:

The less (<) operator returns true if the first argument is less than the second argument.

String comparisons are strictly lexical based on the Unicode value of the individual characters in the string.

For comparisons involving quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

For date/time values, the comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is less than the second, the result is true; if the first value is greater than the second, the result is false; if one input has a value for the precision and the other does not, the comparison stops and the result is null; if neither input has a value for the precision or the last precision has been reached, the comparison stops and the result is false. For example:

If either argument is null, the result is null.

The following examples illustrate the behavior of the less operator:

Signature:

Description:

The less or equal (<=) operator returns true if the first argument is less than or equal to the second argument.

String comparisons are strictly lexical based on the Unicode value of the individual characters in the string.

For comparisons involving quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' are comparable, but units of 'cm2' and 'cm' are not. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

For date/time values, the comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is less than the second, the result is true; if the first value is greater than the second, the result is false; if one input has a value for the precision and the other does not, the comparison stops and the result is null; if neither input has a value for the precision or the last precision has been reached, the comparison stops and the result is true. For example:

If either argument is null, the result is null.

The following examples illustrate the behavior of the less or equal operator:

Signature:

Description:

The not equal (!=) operator returns true if its arguments are not the same value.

The not equal operator is a shorthand for invocation of logical negation (not) of the equal operator.

The following examples illustrate the behavior of the not equal operator:

Signature:

Description:

The not equivalent (!~) operator returns true if its arguments are not equivalent.

The not equivalent operator is a shorthand for invocation of logical negation (not) of the equivalent operator.

The following examples illustrate the behavior of the not equivalent operator:

Signature:

Description:

The Abs operator returns the absolute value of its argument.

When taking the absolute value of a quantity, the unit is unchanged.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Abs operator:

Signature:

Description:

The add (+) operator performs numeric addition of its arguments.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

When adding quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' can be added, but units of 'cm2' and 'cm' cannot. The unit of the result will be the most granular unit of either input. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

If either argument is null, the result is null.

The following examples illustrate the behavior of the add operator:

Signature:

Description:

The Ceiling operator returns the first integer greater than or equal to the argument.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Ceiling operator:

Signature:

Description:

The divide (/) operator performs numeric division of its arguments. Note that this operator is Decimal division; for Integer division, use the truncated divide (div) operator.

When invoked with Integer arguments, the arguments will be implicitly converted to Decimal.

When invoked with a mixture of Decimal and Quantity arguments, the Decimal arguments will be implicitly converted to Quantity.

For division operations involving quantities, the resulting quantity will have the appropriate unit. For example:

In this example, the result will have a unit of 'cm'. Note that when performing division of quantities with the same units, the result will have the default UCUM unit ('1'). When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

If either argument is null, the result is null.

The following examples illustrate the behavior of the divide operator:

Signature:

Description:

The Floor operator returns the first integer less than or equal to the argument.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Floor operator:

Signature:

Description:

The Exp operator raises e to the power of its argument.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Exp operator:

Signature:

Description:

The Log operator computes the logarithm of its first argument, using the second argument as the base.

When invoked with Integer arguments, the arguments will be implicitly converted to Decimal.

If either argument is null, the result is null.

The following examples illustrate the behavior of the Log operator:

Signature:

Description:

The Ln operator computes the natural logarithm of its argument.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Ln operator:

Signature:

Description:

The maximum operator returns the maximum representable value for the given type.

The maximum operator is defined for the Integer, Decimal, Date, DateTime, and Time types.

For Integer, maximum returns the maximum signed 32-bit integer, 2³¹ - 1.

For Decimal, maximum returns the maximum representable decimal value, (10²⁸ – 1) / 10⁸ (99999999999999999999.99999999).

For Date, maximum returns the maximum representable date value, Date(9999, 12, 31).

For DateTime, maximum returns the maximum representable date/time value, DateTime(9999, 12, 31, 23, 59, 59, 999).

For Time, maximum returns the maximum representable time value, Time(23, 59, 59, 999).

For any other type, attempting to invoke maximum results in an error.

The following examples illustrate the behavior of the maximum operator:

Signature:

Description:

The minimum operator returns the minimum representable value for the given type.

The minimum operator is defined for the Integer, Decimal, Date, DateTime, and Time types.

For Integer, minimum returns the minimum signed 32-bit integer, -2³¹.

For Decimal, minimum returns the minimum representable decimal value, (-10²⁸ + 1) / 10⁸ (-99999999999999999999.99999999).

For Date, minimum returns the minimum representable date value, DateTime(1, 1, 1).

For DateTime, minimum returns the minimum representable date/time value, DateTime(1, 1, 1, 0, 0, 0, 0).

For Time, minimum returns the minimum representable time value, Time(0, 0, 0, 0).

For any other type, attempting to invoke minimum results in an error.

The following examples illustrate the behavior of the minimum operator:

Signature:

Description:

The mod operator computes the remainder of the division of its arguments.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

If either argument is null, the result is null.

The following examples illustrate the behavior of the mod operator:

Signature:

Description:

The multiply (*) operator performs numeric multiplication of its arguments.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

When invoked with mixed Decimal and Quantity arguments, the Decimal argument will be implicitly converted to Quantity.

For multiplication operations involving quantities, the resulting quantity will have the appropriate unit. For example:

In this example, the first result will have a unit of 'cm2', and the second result will have a unit of 'cm3'. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

If either argument is null, the result is null.

Signature:

Description:

The negate (-) operator returns the negative of its argument.

When negating quantities, the unit is unchanged.

If the argument is null, the result is null.

The following examples illustrate the behavior of the negate operator:

Signature:

Description:

The predecessor operator returns the predecessor of the argument. For example, the predecessor of 2 is 1. If the argument is already the minimum value for the type, a run-time error is thrown.

The predecessor operator is defined for the Integer, Decimal, Quantity, Date, DateTime, and Time types.

For Integer, predecessor is equivalent to subtracting 1.

For Decimal, predecessor is equivalent to subtracting the minimum precision value for the Decimal type, or 10^-08.

For Date, DateTime, and Time values, predecessor is equivalent to subtracting a time-unit quantity for the lowest specified precision of the value. For example, if the DateTime is fully specified, predecessor is equivalent to subtracting 1 millisecond; if the DateTime is specified to the second, predecessor is equivalent to subtracting one second, etc.

For Quantity values, the predecessor is equivalent to subtracting 1 if the quantity is an integer, and the minimum precision value for the Decimal type if the quantity is a decimal. The units are unchanged.

If the argument is null, the result is null.

The following examples illustrate the behavior of the predecessor operator:

Signature:

Description:

The power (^) operator raises the first argument to the power given by the second argument.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

If either argument is null, the result is null.

The following examples illustrate the behavior of the power operator:

Signature:

Description:

The Round operator returns the nearest whole number to its argument. The semantics of round are defined as a traditional round, meaning that a decimal value of 0.5 or higher will round to 1.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

Precision determines the decimal place at which the rounding will occur. If precision is not specified or null, 0 is assumed.

The following examples illustrate the behavior of the Round operator:

Signature:

Description:

The subtract (-) operator performs numeric subtraction of its arguments.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

When subtracting quantities, the dimensions of each quantity must be the same, but not necessarily the unit. For example, units of 'cm' and 'm' can be subtracted, but units of 'cm2' and 'cm' cannot. The unit of the result will be the most granular unit of either input. Attempting to operate on quantities with invalid units will result in a null. When a quantity has no units specified, it is treated as a quantity with the default unit ('1').

If either argument is null, the result is null.

The following examples illustrate the behavior of the subtract operator:

Signature:

Description:

The successor operator returns the successor of the argument. For example, the successor of 1 is 2. If the argument is already the maximum value for the type, a run-time error is thrown.

The successor operator is defined for the Integer, Quantity, Decimal, Date, DateTime, and Time types.

For Integer, successor is equivalent to adding 1.

For Decimal, successor is equivalent to adding the minimum precision value for the Decimal type, or 10^-08.

For Date, DateTime and Time values, successor is equivalent to adding a time-unit quantity for the lowest specified precision of the value. For example, if the DateTime is fully specified, successor is equivalent to adding 1 millisecond; if the DateTime is specified to the second, successor is equivalent to adding one second, etc.

For Quantity values, the successor is equivalent to adding 1 if the quantity is an integer, and the minimum precision value for the Decimal type if the quantity is a decimal. The units are unchanged.

If the argument is null, the result is null.

The following examples illustrate the behavior of the successor operator:

Signature:

Description:

The Truncate operator returns the integer component of its argument.

When invoked with an Integer argument, the argument will be implicitly converted to Decimal.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Truncate operator:

Signature:

Description:

The div operator performs truncated division of its arguments.

When invoked with mixed Integer and Decimal arguments, the Integer argument will be implicitly converted to Decimal.

If either argument is null, the result is null.

The following examples illustrate the behavior of the div operator:

Signature:

Description:

The Combine operator combines a list of strings, optionally separating each string with the given separator.

If either argument is null, or any element in the source list of strings is null, the result is null.

The following examples illustrate the behavior of the Combine operator:

Signature:

Description:

The concatenate (+ or &) operator performs string concatenation of its arguments.

When using +, if either argument is null, the result is null.

When using &, null arguments are treated as an empty string ('').

The following examples illustrate the behavior of the concatenate operator:

Signature:

Description:

The EndsWith operator returns true if the given string ends with the given suffix.

If the suffix is the empty string, the result is true.

If either argument is null, the result is null.

The following examples illustrate the behavior of the EndsWith operator:

Signature:

Description:

The indexer ([]) operator returns the character at the indexth position in a string.

Indexes in strings are defined to be 0-based.

If either argument is null, the result is null.

If the index is greater than the length of the string being indexed, the result is null.

The following examples illustrate the behavior of the indexer operator:

Signature:

Description:

The LastPositionOf operator returns the 0-based index of the last appearance of the given pattern in the given string.

If the pattern is not found, the result is -1.

If either argument is null, the result is null.

The following examples illustrate the behavior of the LastPositionOf operator:

Signature:

Description:

The Length operator returns the number of characters in a string.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Length operator:

Signature:

Description:

The Lower operator returns the given string with all characters converted to their lower case equivalents.

Note that the definition of lowercase for a given character is a locale-dependent determination, and is not specified by CQL. Implementations are expected to provide appropriate and consistent handling of locale for their environment.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Lower operator:

Signature:

Description:

The Matches operator returns true if the given string matches the given regular expression pattern. Regular expressions should function consistently, regardless of any culture- and locale-specific settings in the environment, should be case-sensitive, use single line mode, and allow Unicode characters.

If either argument is null, the result is null.

Platforms will typically use native regular expression implementations. These are typically fairly similar, but there will always be small differences. As such, CQL does not prescribe a particular dialect, but recommends the use of the dialect defined as part of XML Schema 1.1 as the dialect most likely to be broadly supported and understood.

The following examples illustrate the behavior of the Matches operator:

Signature:

Description:

The PositionOf operator returns the 0-based index of the given pattern in the given string.

If the pattern is not found, the result is -1.

If either argument is null, the result is null.

The following examples illustrate the behavior of the PositionOf operator:

Signature:

Description:

The ReplaceMatches operator matches the given string using the given regular expression pattern, replacing each match with the given substitution. The substitution string may refer to identified match groups in the regular expression. Regular expressions should function consistently, regardless of any culture- and locale-specific settings in the environment, should be case-sensitive, use single line mode, and allow Unicode characters.

If any argument is null, the result is null.

Platforms will typically use native regular expression implementations. These are typically fairly similar, but there will always be small differences. As such, CQL does not prescribe a particular dialect, but recommends the use of the dialect defined as part of XML Schema 1.1 as the dialect most likely to be broadly supported and understood.

The following examples illustrate the behavior of the ReplaceMatches operator:

Signature:

Description:

The Split operator splits a string into a list of strings using a separator.

If the stringToSplit argument is null, the result is null.

If the stringToSplit argument does not contain any appearances of the separator, the result is a list of strings containing one element that is the value of the stringToSplit argument.

The following examples illustrate the behavior of the Split operator:

Signature:

Description:

The SplitOnMatches operator splits a string into a list of strings using a separator that is defined by a regular expression pattern.

If the stringToSplit argument is null, the result is null.

The separatorPattern argument is interpreted with the same regular expression semantics as defined for the Matches operator.

If the stringToSplit argument does not contain any matches for the separatorPattern, the result is a list of strings containing one element that is the value of the stringToSplit argument.

Signature:

Description:

The StartsWith operator returns true if the given string starts with the given prefix.

If the prefix is the empty string, the result is true.

If either argument is null, the result is null.

The following examples illustrate the behavior of the StartsWith operator:

Signature:

Description:

The Substring operator returns the string within stringToSub, starting at the 0-based index startIndex, and consisting of length characters.

If length is omitted, the substring returned starts at startIndex and continues to the end of stringToSub.

If stringToSub or startIndex is null, or startIndex is out of range, the result is null.

The following examples illustrate the behavior of the Substring operator:

Signature:

Description:

The Upper operator returns the given string with all characters converted to their upper case equivalents.

Note that the definition of uppercase for a given character is a locale-dependent determination, and is not specified by CQL. Implementations are expected to provide appropriate and consistent handling of locale for their environment.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Upper operator:

Signature:

Description:

The add (+) operator returns the value of the given date/time, incremented by the time-valued quantity, respecting variable length periods for calendar years and months.

For Date values, the quantity unit must be one of: years, months, weeks, or days.

For DateTime values, the quantity unit must be one of: years, months, weeks, days, hours, minutes, seconds, or milliseconds.

For Time values, the quantity unit must be one of: hours, minutes, seconds, or milliseconds.

Note that the quantity units may be specified in singular, plural, or UCUM form.

The operation is performed by converting the time-based quantity to the most precise value specified in the date/time (truncating any resulting decimal portion) and then adding it to the date/time value. For example, the following addition:

DateTime(2014) + 24 months

This example results in the value DateTime(2016) even though the date/time value is not specified to the level of precision of the time-valued quantity.

Note also that this means that if decimals appear in the time-valued quantities, the fractional component will be ignored. For example, the following addition:

DateTime(2014) + 18 months

This example results in the value DateTime(2015)

If either argument is null, the result is null.

Signature:

Description:

The after-precision-of operator compares two date/time values to the specified precision to determine whether the first argument is the after the second argument. The comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is greater than the second, the result is true; if the first value is less than the second, the result is false; if either input has no value for the precision, the comparison stops and the result is null; if the specified precision has been reached, the comparison stops and the result is false.

If no precision is specified, the comparison is performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime values as defined by the ToDateTime operator.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

The following examples illustrate the behavior of the after-precision-of operator:

This operator is also defined for intervals, see the After (Intervals) operator for more information.

Signature:

Description:

The before-precision-of operator compares two date/time values to the specified precision to determine whether the first argument is the before the second argument. The comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is less than the second, the result is true; if the first value is greater than the second, the result is false; if either input has no value for the precision, the comparison stops and the result is null; if the specified precision has been reached, the comparison stops and the result is false.

If no precision is specified, the comparison is performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime values as defined by the ToDateTime operator.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

The following examples illustrate the behavior of the before-precision-of operator:

This operator is also defined for intervals, see the Before (Intervals) operator for more information.

Signature:

Description:

The Date operator constructs a date value from the given components.

At least one component must be specified, and no component may be specified at a precision below an unspecified precision. For example, month may be null, but if it is, day must be null as well.

The following examples illustrate the behavior of the Date operator:

Signature:

Description:

The DateTime operator constructs a date/time value from the given components.

At least one component other than timezoneOffset must be specified, and no component may be specified at a precision below an unspecified precision. For example, hour may be null, but if it is, minute, second, and millisecond must all be null as well.

If timezoneOffset is not specified, it is defaulted to the timezone offset of the evaluation request.

The following examples illustrate the behavior of the DateTime operator:

Signature:

Description:

The component-from operator returns the specified component of the argument.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, extraction of a week component is not supported.

If the argument is null, or is not specified to the level of precision being extracted, the result is null.

The following examples illustrate the behavior of the component-from operator:

Signature:

Description:

The difference-between operator returns the number of boundaries crossed for the specified precision between the first and second arguments. If the first argument is after the second argument, the result is negative. The result of this operation is always an integer; any fractional boundaries are dropped.

As with all date/time calculations, difference calculations are performed respecting the timezone offset depending on the precision.

For Date values, precision must be one of: years, months, weeks, or days.

For DateTime values, precision must be one of: years, months, weeks, days, hours, minutes, seconds, or milliseconds.

For Time values, precision must be one of: hours, minutes, seconds, or milliseconds.

For calculations involving weeks, Sunday is considered to be the first day of the week for the purposes of determining the number of boundaries crossed.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime as defined by the ToDateTime operator.

If either argument is null, the result is null.

The following examples illustrate the behavior of the difference-between operator:

Signature:

Description:

The duration-between operator returns the number of whole calendar periods for the specified precision between the first and second arguments. If the first argument is after the second argument, the result is negative. The result of this operation is always an integer; any fractional periods are dropped.

For Date values, duration must be one of: years, months, weeks, or days.

For DateTime values, duration must be one of: years, months, weeks, days, hours, minutes, seconds, or milliseconds.

For Time values, duration must be one of: hours, minutes, seconds, or milliseconds.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime as defined by the ToDateTime operator.

If either argument is null, the result is null.

The following examples illustrate the behavior of the duration-between operator:

Signature:

Description:

The Now operator returns the date and time of the start timestamp associated with the evaluation request. Now is defined in this way for two reasons:

Signature:

Description:

The on or after operator for date/time values is a synonym for the same or after operator and is supported to enable natural phrasing. See the description of the Same Or After (Date/Time) operator.

Note that this operator can be invoked using either the on or after or the after or on syntax.

In timing phrases, the keyword same is a synonym for on.

Signature:

Description:

The on or before operator for date/time values is a synonym for the same or before operator and is supported to enable natural phrasing. See the description of the Same Or Before (Date/Time) operator.

Note that this operator can be invoked using either the on or before or the before or on syntax.

In timing phrases, the keyword same is a synonym for on.

Signature:

Description:

The same-precision-as operator compares two date/time values to the specified precision for equality. The comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the values are different, the comparison stops and the result is false; if either input has no value for the precision, the comparison stops and the result is null; if the specified precision has been reached, the comparison stops and the result is true.

If no precision is specified, the comparison is performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime as defined by the ToDateTime operator.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

The following examples illustrate the behavior of the same-precision-as operator:

This operator is also defined for intervals, see the Same As (Intervals) operator for more information.

Signature:

Description:

The same-precision-or after operator compares two date/time values to the specified precision to determine whether the first argument is the same or after the second argument. The comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is greater than the second, the result is true; if the first value is less than the second, the result is false; if either input has no value for the precision, the comparison stops and the result is null; if the specified precision has been reached, the comparison stops and the result is true.

If no precision is specified, the comparison is performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime as defined by the ToDateTime operator.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

Note that in timing phrases, the keyword on may be used as a synonym for same for this operator.

The following examples illustrate the behavior of the same-precision-or after operator:

This operator is also defined for intervals, see the Same Or After (Intervals) operator for more information.

Signature:

Description:

The same-precision-or before operator compares two date/time values to the specified precision to determine whether the first argument is the same or before the second argument. The comparison is performed by considering each precision in order, beginning with years (or hours for time values). If the values are the same, comparison proceeds to the next precision; if the first value is less than the second, the result is true; if the first value is greater than the second, the result is false; if either input has no value for the precision, the comparison stops and the result is null; if the specified precision has been reached, the comparison stops and the result is true.

If no precision is specified, the comparison is performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date values, precision must be one of: year, month, or day.

For DateTime values, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time values, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with both Date and DateTime inputs, the Date values will be implicitly converted to DateTime as defined by the ToDateTime operator.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

Note that in timing phrases, the keyword on may be used as a synonym for same for this operator.

The following examples illustrate the behavior of the same-precision-or before operator:

This operator is also defined for intervals, see the Same Or Before (Intervals) operator for more information.

Signature:

Description:

The subtract (-) operator returns the value of the given date/time, decremented by the time-valued quantity, respecting variable length periods for calendar years and months.

For Date values, the quantity unit must be one of: years, months, weeks, or days.

For DateTime values, the quantity unit must be one of: years, months, weeks, days, hours, minutes, seconds, or milliseconds.

For Time values, the quantity unit must be one of: hours, minutes, seconds, or milliseconds.

Note that the quantity units may be specified in singular, plural or UCUM form.

The operation is performed by converting the time-based quantity to the most precise value specified in the date/time (truncating any resulting decimal portion) and then subtracting it from the date/time value. For example, the following subtraction:

DateTime(2014) - 24 months

This example results in the value DateTime(2012) even though the date/time value is not specified to the level of precision of the time-valued quantity.

Note also that this means that if decimals appear in the time-valued quantities, the fractional component will be ignored. For example, the following subtraction:

DateTime(2014) - 18 months

This example results in the value DateTime(2013)

If either argument is null, the result is null.

Signature:

Description:

The Time operator constructs a time value from the given components.

At least one component other than timezoneOffset must be specified, and no component may be specified at a precision below an unspecified precision. For example, minute may be null, but if it is, second, and millisecond must all be null as well.

If timezoneOffset is not specified, it is defaulted to the timezone offset of the evaluation request.

The following examples illustrate the behavior of the Time operator:

Signature:

Description:

The TimeOfDay operator returns the time of day of the start timestamp associated with the evaluation request. See the Now operator for more information on the rationale for defining the TimeOfDay operator in this way.

Signature:

Description:

The Today operator returns the date of the start timestamp associated with the evaluation request. See the Now operator for more information on the rationale for defining the Today operator in this way.

Signature:

Description:

The after operator for intervals returns true if the first interval starts after the second one ends. In other words, if the starting point of the first interval is greater than the ending point of the second interval.

For the point-interval overload, the operator returns true if the given point is greater than the end of the interval.

For the interval-point overload, the operator returns true if the given interval starts after the given point.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the after operator:

Signature:

Description:

The before operator for intervals returns true if the first interval ends before the second one starts. In other words, if the ending point of the first interval is less than the starting point of the second interval.

For the point-interval overload, the operator returns true if the given point is less than the start of the interval.

For the interval-point overload, the operator returns true if the given interval ends before the given point.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the before operator:

Signature:

Description:

The collapse operator returns the unique set of intervals that completely covers the ranges present in the given list of intervals. In other words, adjacent intervals within a sorted list are merged if they either overlap or meet.

Note that because the semantics for overlaps and meets are themselves defined in terms of the interval successor and predecessor operators, sets of date/time-based intervals that are only defined to a particular precision will calculate meets and overlaps at that precision. For example, a list of DateTime-based intervals where the boundaries are all specified to the hour will collapse at the hour precision, unless the collapse precision is overridden with the per argument.

The per argument determines the precision at which the collapse will be performed, and must be a quantity value that is compatible with the point type of the input intervals. For numeric intervals, this means a default unit ('1'). For date/time intervals, this means a temporal duration.

If the list of intervals is empty, the result is empty. If the list of intervals contains a single interval, the result is a list with that interval. If the list of intervals contains nulls, they will be excluded from the resulting list.

If the list argument is null, the result is null.

If the per argument is null, the default unit interval for the point type of the intervals involved will be used (i.e. the interval that has a width equal to the result of the successor function for the point type).

The following examples illustrate the behavior of the collapse operator:

Signature:

Description:

The contains operator for intervals returns true if the given point is greater than or equal to the starting point of the interval, and less than or equal to the ending point of the interval. For open interval boundaries, exclusive comparison operators are used. For closed interval boundaries, if the interval boundary is null, the result of the boundary comparison is considered true.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the contains operator:

Signature:

Description:

The End operator returns the ending point of an interval.

If the high boundary of the interval is open, this operator returns the predecessor of the high value of the interval. Note that if the high value of the interval is null, the result is null.

If the high boundary of the interval is closed and the high value of the interval is not null, this operator returns the high value of the interval. Otherwise, the result is the maximum value of the point type of the interval.

If the argument is null, the result is null.

The following examples illustrate the behavior of the End operator:

Signature:

Description:

The ends operator returns true if the first interval ends the second. More precisely, if the starting point of the first interval is greater than or equal to the starting point of the second, and the ending point of the first interval is equal to the ending point of the second.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the ends operator:

Signature:

Description:

The equal (=) operator for intervals returns true if and only if the intervals are over the same point type, and they have the same value for the starting and ending points of the intervals as determined by the Start and End operators.

If either argument is null, the result is null.

The following examples illustrate the behavior of the equal operator:

Signature:

Description:

The equivalent (~) operator for intervals returns true if and only if the intervals are over the same point type, and the starting and ending points of the intervals as determined by the Start and End operators are equivalent.

The following examples illustrate the behavior of the equivalent operator:

Signature:

Description:

The except operator for intervals returns the set difference of two intervals. More precisely, this operator returns the portion of the first interval that does not overlap with the second. Note that to avoid returning an improper interval, if the second argument is properly contained within the first and does not start or end it, this operator returns null.

If either argument is null, the result is null.

The following examples illustrate the behavior of the except operator:

Signature:

Description:

The expand operator returns the set of intervals of width per for all the intervals in the input.

The per argument must be a quantity value that is compatible with the point type of the input intervals. For numeric intervals, this means a default unit ('1'). For date/time intervals, this means a temporal duration.

For example:

The following is the result of the example:

Note that if the values in the intervals are more precise than the per quantity, the more precise values will be truncated to the precision specified by the per quantity.

If the list of intervals is empty, the result is empty. If the list of intervals contains nulls, they will be excluded from the resulting list.

If the list argument is null, the result is null.

If the per argument is null, the default unit interval for the point type of the intervals involved will be used (i.e. the interval that has a width equal to the result of the successor function for the point type).

Signature:

Description:

The in operator for intervals returns true if the given point is greater than or equal to the starting point of the interval, and less than or equal to the ending point of the interval. For open interval boundaries, exclusive comparison operators are used. For closed interval boundaries, if the interval boundary is null, the result of the boundary comparison is considered true.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the in operator:

Signature:

Description:

The includes operator for intervals returns true if the first interval completely includes the second. More precisely, if the starting point of the first interval is less than or equal to the starting point of the second interval, and the ending point of the first interval is greater than or equal to the ending point of the second interval.

For the point overload, this operator is a synonym for the [.kw]#contains operator.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the includes operator:

Signature:

Description:

The included in operator for intervals returns true if the first interval is completely included in the second. More precisely, if the starting point of the first interval is greater than or equal to the starting point of the second interval, and the ending point of the first interval is less than or equal to the ending point of the second interval.

For the point overload, this operator is a synonym for the in operator.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

Note that during is a synonym for included in and may be used to invoke the same operation wherever included in may appear.

The following examples illustrate the behavior of the included in operator:

Signature:

Description:

The intersect operator for intervals returns the intersection of two intervals. More precisely, the operator returns the interval that defines the overlapping portion of both arguments. If the arguments do not overlap, this operator returns null.

If either argument is null, the result is null.

The following examples illustrate the behavior of the intersect operator:

Signature:

Description:

The meets operator returns true if the first interval ends immediately before the second interval starts, or if the first interval starts immediately after the second interval ends. In other words, if the ending point of the first interval is equal to the predecessor of the starting point of the second, or if the starting point of the first interval is equal to the successor of the ending point of the second.

The meets before operator returns true if the first interval ends immediately before the second interval starts, while the meets after operator returns true if the first interval starts immediately after the second interval ends.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

Note that date/time-based intervals with partially specified boundaries will "meet" at the precision of the boundaries, not the finest precision for the point type. For example:

The MeetsAtHours expression returns true because the meets operation is performed at the hour precision.

The following examples illustrate the behavior of the meets, meets before, and meets after operators:

Signature:

Description:

The not equal (!=) operator for intervals returns true if its arguments are not the same value.

The not equal operator is a shorthand for invocation of logical negation (not) of the equal operator.

The following examples illustrate the behavior of the not equal operator:

Signature:

Description:

The not equivalent (!~) operator for intervals returns true if its arguments are not equivalent.

The not equivalent operator is a shorthand for invocation of logical negation (not) of the equivalent operator.

The following examples illustrate the behavior of the not equivalent operator:

Signature:

Description:

The on or after operator for intervals is a synonym for the same or after operator and is supported to enable natural phrasing. See the description of the Same Or After (Intervals) operator.

Note that this operator can be invoked using either the on or after or the after or on syntax.

In timing phrases, the keyword same is a synonym for on.

Signature:

Description:

The on or before operator for date/time-based intervals is a synonym for the same or before operator and is supported to enable natural phrasing. See the description of the Same Or Before (Intervals) operator.

Note that this operator can be invoked using either the on or before or the before or on syntax.

In timing phrases, the keyword same is a synonym for on.

Signature:

Description:

The overlaps operator returns true if the first interval overlaps the second. More precisely, if the ending point of the first interval is greater than or equal to the starting point of the second interval, and the starting point of the first interval is less than or equal to the ending point of the second interval.

The operator overlaps before returns true if the first interval overlaps the second and starts before it, while the overlaps after operator returns true if the first interval overlaps the second and ends after it.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the overlaps, overlaps before, and overlaps after operators:

Signature:

Description:

The point from operator extracts the single point from a unit interval. If the argument is not a unit interval, a run-time error is thrown.

If the argument is null, the result is null.

The following examples illustrate the behavior of the point from operator:

Signature:

Description:

The properly includes operator for intervals returns true if the first interval completely includes the second and the first interval is strictly larger than the second. More precisely, if the starting point of the first interval is less than or equal to the starting point of the second interval, and the ending point of the first interval is greater than or equal to the ending point of the second interval, and they are not the same interval.

For the point overload, this operator returns true if the interval contains (i.e. includes) the point, and the interval is not a unit interval containing only the point.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the properly includes operator:

Signature:

Description:

The properly included in operator for intervals returns true if the first interval is completely included in the second and the first interval is strictly smaller than the second. More precisely, if the starting point of the first interval is greater than or equal to the starting point of the second interval, and the ending point of the first interval is less than or equal to the ending point of the second interval, and they are not the same interval.

For the point overload, this operator returns true if the point is in (i.e. included in) the interval, and the interval is not a unit interval containing only the point.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

Note that during is a synonym for included in.

The following examples illustrate the behavior of the properly included in operator:

Signature:

Description:

The same-precision-as operator for intervals returns true if the two intervals start and end at the same value, using the semantics described in the Start and End operators to determine interval boundaries, and for date/time value, performing the comparisons at the specified precision, as described in the Same As operator for date/time values.

If no precision is specified, comparisons are performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date-based intervals, precision must be one of: year, month, or day.

For DateTime-based intervals, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time-based intervals, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with a mixture of Date- and DateTime-based intervals, the Date values will be implicitly converted to DateTime values as defined by the ToDateTime operator.

For comparisons involving date/time or time values with imprecision, note that the result of the comparison may be null, depending on whether the values involved are specified to the level of precision used for the comparison.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

Signature:

Description:

The same-precision-or after operator for intervals returns true if the first interval starts on or after the second one ends, using the semantics described in the Start and End operators to determine interval boundaries, and for date/time values, performing the comparisons at the specified precision, as described in the Same or After (Date/Time) operator for date/time values.

If no precision is specified, comparisons are performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date-based intervals, precision must be one of: year, month, or day.

For DateTime-based intervals, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time-based intervals, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with a mixture of Date-based and DateTime-based intervals, the Date values will be implicitly converted to DateTime values as defined by the ToDateTime operator.

When this operator is called with a mixture of point values and intervals, the point values are implicitly converted to an interval starting and ending on the given point value.

For comparisons involving date/time or time intervals with imprecision, note that the result of the comparison may be null, depending on whether the values involved are specified to the level of precision used for the comparison.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

Note that in timing phrases, the keyword on may be used as a synonym for same for this operator.

Signature:

Description:

The same-precision-or before operator returns true if the first interval ends on or before the second one starts, using the semantics described in the Start and End operators to determine interval boundaries, and for date/time values, performing the comparisons at the specified precision, as described in the Same or Before (Date/Time) operator for date/time values.

If no precision is specified, comparisons are performed beginning with years (or hours for time values) and proceeding to the finest precision specified in either input.

For Date-based intervals, precision must be one of: year, month, or day.

For DateTime-based intervals, precision must be one of: year, month, day, hour, minute, second, or millisecond.

For Time-based intervals, precision must be one of: hour, minute, second, or millisecond.

Note specifically that due to variability in the way week numbers are determined, comparisons involving weeks are not supported.

When this operator is called with a mixture of Date- and DateTime-based intervals, the Date values will be implicitly converted to DateTime values as defined by the ToDateTime operator.

When this operator is called with a mixture of point values and intervals, the point values are implicitly converted to an interval starting and ending on the given point value.

For comparisons involving date/time or time values with imprecision, note that the result of the comparison may be null, depending on whether the values involved are specified to the level of precision used for the comparison.

As with all date/time calculations, comparisons are performed respecting the timezone offset.

If either or both arguments are null, the result is null.

Note that in timing phrases, the keyword on may be used as a synonym for same for this operator.

Signature:

Description:

The Start operator returns the starting point of an interval.

If the low boundary of the interval is open, this operator returns the successor of the low value of the interval. Note that if the low value of the interval is null, the result is null.

If the low boundary of the interval is closed and the low value of the interval is not null, this operator returns the low value of the interval. Otherwise, the result is the minimum value of the point type of the interval.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Start operator:

Signature:

Description:

The starts operator returns true if the first interval starts the second. More precisely, if the starting point of the first is equal to the starting point of the second interval and the ending point of the first interval is less than or equal to the ending point of the second interval.

This operator uses the semantics described in the Start and End operators to determine interval boundaries.

If precision is specified and the point type is a date/time type, comparisons used in the operation are performed at the specified precision.

If either argument is null, the result is null.

The following examples illustrate the behavior of the starts operator:

Signature:

Description:

The union operator for intervals returns the union of the intervals. More precisely, the operator returns the interval that starts at the earliest starting point in either argument, and ends at the latest starting point in either argument. If the arguments do not overlap or meet, this operator returns null.

If either argument is null, the result is null.

The following examples illustrate the behavior of the union operator:

Signature:

Description:

The width operator returns the width of an interval. The result of this operator is equivalent to invoking: (start of argument – end of argument) + point-size.

Note that because CQL defines duration and difference operations for date/time and time valued intervals, width is not defined for intervals of these types.

If the argument is null, the result is null.

The following examples illustrate the behavior of the width operator:

Signature:

Description:

The contains operator for lists returns true if the given element is in the list using equality semantics.

If either argument is null, the result is null.

The following examples illustrate the behavior of the contains operator:

Signature:

Description:

The distinct operator returns the given list with duplicates eliminated using equality semantics.

If the argument is null, the result is null.

The following examples illustrate the behavior of the distinct operator:

Signature:

Description:

The equal (=) operator for lists returns true if and only if the lists have the same element type, and have the same elements by value, in the same order.

If either argument is null, or contains null elements, the result is null.

The following examples illustrate the behavior of the equal operator:

Signature:

Description:

The equivalent (~) operator for lists returns true if and only if the lists contain elements of the same type, have the same number of elements, and for each element in the lists, in order, the elements are equivalent.

The following examples illustrate the behavior of the equivalent operator:

Signature:

Description:

The except operator returns the set difference of two lists. More precisely, the operator returns a list with the elements that appear in the first operand that do not appear in the second operand.

This operator uses equality semantics to determine whether two elements are the same for the purposes of computing the difference.

The operator is defined with set semantics, meaning that each element will appear in the result at most once, and that there is no expectation that the order of the inputs will be preserved in the results.

If either argument is null, the result is null.

The following examples illustrate the behavior of the except operator:

Signature:

Description:

The exists operator returns true if the list contains any non-null elements.

If the argument is null, the result is false.

The following examples illustrate the behavior of the exists operator:

Signature:

Description:

The flatten operator flattens a list of lists into a single list.

If the argument is null, the result is null.

The following examples illustrate the behavior of the flatten operator:

Signature:

Description:

The First operator returns the first element in a list. The operator is equivalent to invoking the indexer with an index of 0.

If the argument is null, the result is null.

The following examples illustrate the behavior of the First operator:

Signature:

Description:

The in operator for lists returns true if the given element is in the given list using equality semantics.

If either argument is null, the result is null.

The following examples illustrate the behavior of the in operator:

Signature:

Description:

The includes operator for lists returns true if the first list contains every element of the second list using equality semantics.

For the singleton overload, this operator returns true if the list includes (i.e. contains) the singleton.

If either argument is null, the result is null.

Note that the order of elements does not matter for the purposes of determining inclusion.

The following examples illustrate the behavior of the includes operator:

Signature:

Description:

The included in operator for lists returns true if every element of the first list is in the second list using equality semantics.

For the singleton overload, this operator returns true if the singleton is included in (i.e. in) the list.

If either argument is null, the result is null.

Note that the order of elements does not matter for the purposes of determining inclusion.

The following examples illustrate the behavior of the included in operator:

Signature:

Description:

The indexer ([]) operator returns the element at the index^th position in a list.

Indexes in lists are defined to be 0-based.

If the index is less than 0, or greater than the number of elements in the list, the result is null.

If either argument is null, the result is null.

The following examples illustrate the behavior of the indexer operator:

Signature:

Description:

The IndexOf operator returns the 0-based index of the given element in the given source list using equality semantics.

If the list is empty, or no element is found, the result is -1.

If either argument is null, the result is null.

The following examples illustrate the behavior of the IndexOf operator:

Signature:

Description:

The intersect operator for lists returns the intersection of two lists. More precisely, the operator returns a list containing only the elements that appear in both lists.

This operator uses equality semantics to determine whether or not two elements are the same.

The operator is defined with set semantics, meaning that each element will appear in the result at most once, and that there is no expectation that the order of the inputs will be preserved in the results.

If either argument is null, the result is null.

The following examples illustrate the behavior of the intersect operator:

Signature:

Description:

The Last operator returns the last element in a list. In a list of length N, the operator is equivalent to invoking the indexer with an index of N - 1.

If the argument is null, the result is null.

The following examples illustrate the behavior of the Last operator:

Signature:

Description:

The Length operator returns the number of elements in a list.

If the argument is null, the result is 0.

The following examples illustrate the behavior of the Length operator:

Signature:

Description:

The not equal (!=) operator for lists returns true if its arguments are not the same value.

The not equal operator is a shorthand for invocation of logical negation (not) of the equal operator.

The following examples illustrate the behavior of the not equal operator:

Signature:

Description:

The not equivalent (!~) operator for lists returns true if its arguments are not equivalent.

The not equivalent operator is a shorthand for invocation of logical negation (not) of the equivalent operator.

The following examples illustrate the behavior of the not equivalent operator:

Signature:

Description:

The properly includes operator for lists returns true if the first list contains every element of the second list, and the first list is strictly larger than the second list.

For the element overload, this operator returns true if the list contains (i.e. includes) the element, and it is not the only element in the list.

This operator uses equality semantics to determine whether or not two elements are the same.

If either argument is null, the result is null.

Note that the order of elements does not matter for the purposes of determining inclusion.

The following examples illustrate the behavior of the properly includes operator:

Signature:

Description:

The properly included in operator for lists returns true if every element of the first list is in the second list and the first list is strictly smaller than the second list.

For the element overload, this operator returns true if the element is in (i.e. included in) the list and it is not the only element in the list.

This operator uses equality semantics to determine whether or not two elements are the same.

If either argument is null, the result is null.

Note that the order of elements does not matter for the purposes of determining inclusion.

The following examples illustrate the behavior of the properly included in operator:

Signature:

Description:

The singleton from operator extracts a single element from the source list. If the source list is empty, the result is null. If the source list contains one element, that element is returned. If the list contains more than one element, a run-time error is thrown.

If the source list is null, the result is null.

The following examples illustrate the behavior of the singleton from operator:

Signature:

Description:

The Skip operator returns the elements in the list, skipping the first number elements. If the list has less number elements, the result is empty.

If the source list is null, the result is null.

If the number of elements is null, the result is the entire list, no elements are skipped.

If the number of elements is less than zero, the result is an empty list.

The following examples illustrate the behavior of the Skip operator:

Signature:

Description:

The Tail operator returns all but the first element from the given list. If the list is empty, the result is empty.

If the source list is null, the result is null.

The following examples illustrate the behavior of the Tail operator:

Signature:

Description:

The Take operator returns the first number elements from the given list. If the list has less than number elements, the result only contains the elements in the list.

If the source list is null, the result is null.

If number is null, or 0 or less, the result is an empty list.

The following examples illustrate the behavior of the Take operator:

Signature:

Description:

The union operator for lists returns a list with all elements from both arguments. Note that duplicates are eliminated during this process; if an element appears in both sources, that element will only appear once in the resulting list. In addition, there is no expectation that the order of elements in the inputs will be preserved in the results.

If either argument is null, the result is null.

Note that the union operator can also be invoked with the symbolic operator (|).

The following examples illustrate the behavior of the union operator:

Signature:

Description:

The AllTrue operator returns true if all the non-null elements in the source are true.

If the source contains no non-null elements, true is returned.

If the source is null, the result is true.

The following examples illustrate the behavior of the AllTrue operator:

Signature:

Description:

The AnyTrue operator returns true if any non-null element in the source is true.

If the source contains no non-null elements, false is returned.

If the source is null, the result is false.

The following examples illustrate the behavior of the AnyTrue operator:

Signature:

Description:

The Avg operator returns the average of the non-null elements in the source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Avg operator:

Signature:

Description:

The Count operator returns the number of non-null elements in the source. If the list contains no non-null elements, the result is 0. If the list is null, the result is 0.

The following examples illustrate the behavior of the Count operator:

Signature:

Description:

The GeometricMean operator returns the geometric mean of the non-null elements in the source. Geometric mean is defined as the N^th root of the geometric product of the elements. In other words:

If the source contains no non-null elements, the result is null.

If the source is null, the result is null.

The following examples illustrate the behavior of the GeometricMean operator:

Signature:

Description:

The Max operator returns the maximum element in the source. Comparison semantics are defined by the Comparison Operators for the type of value being aggregated.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Max operator:

Signature:

Description:

The Min operator returns the minimum element in the source. Comparison semantics are defined by the Comparison Operators for the type of value being aggregated.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Min operator:

Signature:

Description:

The Median operator returns the median of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Median operator:

Signature:

Description:

The Mode operator returns the statistical mode of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Mode operator:

Signature:

Description:

The PopulationStdDev operator returns the statistical standard deviation of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the PopulationStdDev operator:

Signature:

Description:

The PopulationVariance operator returns the statistical population variance of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the PopulationVariance operator:

Signature:

Description:

The Product operator returns the geometric product of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Product operator:

Signature:

Description:

The StdDev operator returns the statistical standard deviation of the elements in source.

If the source contains no non-null elements, null is returned.

If the list is null, the result is null.

The following examples illustrate the behavior of the StdDev operator:

Signature:

Description:

The Sum operator returns the sum of non-null elements in the source.

If the source contains no non-null elements, null is returned.

If the list is null, the result is null.

The following examples illustrate the behavior of the Sum operator:

Signature:

Description:

The Variance operator returns the statistical variance of the elements in source.

If the source contains no non-null elements, null is returned.

If the source is null, the result is null.

The following examples illustrate the behavior of the Variance operator:

Signature:

Description:

The Age operators calculate the age of the patient as of the current date/time in the precision named in the operator.

If the patient’s birthdate is null, the result is null.

The Age operators are defined in terms of a date/time duration calculation. This means that if the age of the patient is not specified to the level of precision corresponding to the operator being invoked, the result will be an uncertainty over the range of possible values, potentially causing some comparisons to return null.

Note that for AgeInYears and AgeInMonths, the birthDate is specified as a Date and Today() is used to obtain the current date; whereas with the other precisions, birthDate is specified as a DateTime, and Now() is used to obtain the current date/time.

Signature:

Description:

The AgeAt operators calculate the age of the patient as of the given date/time in the precision named in the operator.

If the patient’s birthdate is null, or the asOf argument is null, the result is null.

The AgeAt operators are defined in terms of a date/time duration calculation. This means that if the age of the patient or the given asOf value are not specified to the level of precision corresponding to the operator being invoked, the will be an uncertainty over the range of possible values, potentially causing some comparisons to return null.

Signature:

Description:

The CalculateAge operators calculate the age of a person born on the given birth date/time as of today/now in the precision named in the operator.

If the birthdate is null, the result is null.

The CalculateAge operators are defined in terms of a date/time duration calculation. This means that if the given birthDate is not specified to the level of precision corresponding to the operator being invoked, the result will be an uncertainty over the range of possible values, potentially causing some comparisons to return null.

Signature:

Description:

The CalculateAgeAt operators calculate the age of a person born on the given birth date/time as of the given date/time in the precision named in the operator.

If the birthDate is null or the asOf argument is null, the result is null.

The CalculateAgeAt operators are defined in terms of a date/time duration calculation. This means that if the given birthDate or asOf are not specified to the level of precision corresponding to the operator being invoked, the result will be an uncertainty over the range of possible values, potentially causing some comparisons to return null.

The following examples illustrate the behavior of the CalculateAgeAt operator:

Signature:

Description:

The equal (=) operator for Codes and Concepts uses tuple equality semantics. This means that the operator will return true if and only if the values for each element by name are equal.

If either argument is null, or contains any null components, the result is null.

The following examples illustrate the behavior of the equal operator:

Signature:

Description:

The equivalent (~) operator for Code values returns true if the code and system elements are equivalent. The version and display elements are ignored for the purposes of determining Code equivalence.

For Concept values, equivalence is defined as a non-empty intersection of the codes in each Concept. The display element is ignored for the purposes of determining Concept equivalence.

Note that this operator will always return true or false, even if either or both of its arguments are null, or contain null components.

Note carefully that this notion of equivalence is not the same as the notion of equivalence used in terminology: “these codes represent the same concept.” CQL specifically avoids defining terminological equivalence. The notion of equivalence defined here is used to provide consistent and intuitive semantics when dealing with missing information in membership contexts.

The following examples illustrate the behavior of the equivalent operator:

Signature:

Description:

The in (Codesystem) operators determine whether or not a given code, or any of a list of codes, is in a particular codesystem. Note that these operators can only be invoked by referencing a defined codesystem.

For the String overload, if the given code system contains a code with an equivalent code element, the result is true.

For the Code overload, if the given code system contains an equivalent code, the result is true.

For the Concept overload, if the given code system contains a code equivalent to any code in the given concept, the result is true.

For the List<Code> overload, if the given code system contains a code equivalent to any code in the given list, the result is true.

If the code argument is null, the result is false.

If the code system reference cannot be resolved, a run-time error is thrown.

The following examples illustrate the behavior of the in (Codesystem) operator:

Signature:

Description:

The in (Valueset) operators determine whether or not a given code, or any of a list of codes, is in a particular valueset. Note that these operators can only be invoked by referencing a defined valueset.

For the String overload, if the given valueset contains a code with an equivalent code element, the result is true. Note that for this overload, because the code being tested cannot specify code system information, if the resolved value set contains codes from multiple code systems, a run-time error is thrown because the operation is ambiguous.

For the Code overload, if the given valueset contains an equivalent code, the result is true.

For the Concept overload, if the given valueset contains a code equivalent to any code in the given concept, the result is true.

For the List<Code> overload, if the given valueset contains a code equivalent to any code in the given list, the result is true.

If the code argument is null, the result is false.

If the value set reference cannot be resolved, a run-time error is thrown.

The following examples illustrate the behavior of the in (Valueset) operator:

Signature:

Description:

The Message operator provides a run-time mechanism for returning messages, warnings, traces, and errors to the calling environment.

The source operator is any type and the result of the operation is the input source; the operation performs no modifications to input. This allows the message operation to appear at any point in any expression of CQL.

The condition is used to determine whether the message is generated and returned to the calling environment. If condition is true, the message is generated. Otherwise, the operation only returns the results and performs no processing at all.

The code provides a coded representation of the error. Note that this is a token (like a string or integer), not a terminology Code.

The severity determines what level of processing should occur for the message that is generated:

If no severity is supplied, a default severity of Message is assumed.

The message is the content of the actual message that is sent to the calling environment.

Note that for Trace severity, the implementation should output the contents of the source parameter as part of the trace message. Because the logic may be operating on patient information, the utmost care should be taken to ensure that appropriate safeguards are in place to avoid logging sensitive information. At a minimum, all PHI should be redacted from these trace messages.

The following examples illustrate the behavior of the Message operator: