Clinical Quality Language Specification
2.0.0-ballot - R2 STU 1 (Ballot)
Clinical Quality Language Specification
2.0.0-ballot - R2 STU 1 (Ballot)
This page is part of the Clinical Quality Language Specification (v2.0.0-ballot: R2 STU 1) based on FHIR (HL7® FHIR® Standard) R4. This version is a pre-release. The current official version is 1.5.3. For a full list of available versions, see the Directory of published versions
| Page standards status: Normative | Maturity Level: N |
This appendix provides detailed mappings for each FHIRPath function in terms of the ELM output produced.
In addition to the function mappings below, the $index accessor can be used within the FHIRPath iteration functions (i.e. FHIRPath functions that take an expression as an argument) to access the 0-based index of the current iteration.
X.aggregate(<iteration>, <init>) === Aggregate(<iteration>, <init>)
In addition, the $total accumulator can be used within the iteration and init expressions to access the current value of the accumulator.
X.abs() === Abs(X)
X.all(<condition>) === AllTrue(X $this let a: <condition> where a return a)
X.allFalse() === AllTrue(X A return not A)
X.allTrue() === AllTrue(X)
X.anyFalse() === AnyTrue(X A return not A)
X.anyTrue() === AnyTrue(X)
X.as(T) === X as T
Note that the type argument T is expected to be a literal string and must resolve to the name of a type.
X.ceiling() === Ceiling(X)
.children(X) === Children(X)
X.combine(Y) === Flatten(\{ X, Y })
X.conformsTo(Y) === FHIRSupport.ConformsTo(Y)
Note that this mapping relies on an external library, FHIRSupport to provide conformance validation checking.
X.contains(Y) === PositionOf(Y, X) >= 0
X.convertsToBoolean() === ConvertsToBoolean(X)
X.convertsToDate() === ConvertsToDate(X)
X.convertsToDateTime() === ConvertsToDateTime(X)
X.convertsToDecimal() === ConvertsToDecimal(X)
X.convertsToInteger() === ConvertsToInteger(X)
X.convertsToQuantity() === ConvertsToQuantity(X)
X.convertsToTime() === ConvertsToTime(X)
X.count() === Count(X)
X.dateOf() === date from X
X.dayOf() === day from X
X.decode(format) === Decode(X, format)
Because the defineVariable function is introducing a named alias, all subsequent fluent function invocations must be evaluated within the query.
In addition, the name argument must be compile-time evaluable.
X.defineVariable(name) === { input: X } alias let name: alias.X return X
X.defineVariable(name, expression) === X alias let name: expression
.descendants(X) === Descendants(X)
X.distinct() === distinct X
X.empty() === not exists X
X.encode(format) === Encode(X, format)
X.endsWith(Y) === EndsWith(X, Y)
X.escape(target) === Escape(X, target)
X.exclude(Y) === X except Y
X.exists() === exists X
X.exists(<condition>) === exists (X $this where <condition>)
X.exp() === Exp(X)
X.first() === First(X)
X.floor() === Floor(X)
X.hasValue() === X is not null
X.highBoundary(precision) === HighBoundary(X, precision)
X.hourOf() === hour from X
iif(X, Y) === if X then Y else null
iif(X, Y, Z) === if X then Y else Z
X.indexOf(Y) === PositionOf(Y, X) // Note carefully the order of arguments here, it’s the opposite of IndexOf
X.intersect(Y) === X intersect Y
X.is(T) === X is T
Note that the argument T is expected to be a literal string and must resolve to the name of a type.
X.isDistinct() === Count(X) = Count(distinct X)
X.join(separator) === Combine(X, separator)
X.last() === Last(X)
X.lastIndexOf(Y) === LastPositionOf(Y, X) // Note carefully the order of arguments here, it’s the opposite of lastIndexOf.
X.length() === Length(X)
X.ln() === Ln(X)
X.log(B) === Log(X, B)
X.lowBoundary(precision) === LowBoundary(X, precision)
X.lower() === Lower(X)
X.matches(Y) === Matches(X, Y)
X.matchesFull(Y) === Matches(X, '^' + Y + '$')
X.memberOf(Y) === InValueSet(X, Y) // where Y is required to be a ValueSetRef
X.millisecondOf() === millisecond from X
X.minuteOf() === minute from X
X.monthOf() === month from X
X.ofType(T) === X $this where $this is T return $this as T
Note that the argument T is required to be a literal string, and is interpreted as the name of a type. For non-named-types, type specifier syntax applies.
X.not() === not X
now() === Now()
X.power(Y) === Power(X, Y)
X.precision() === Precision(X)
X.repeat(<element>) === Repeat(X, <element>)
The type of X.repeat(
X.select(<element>).select(<element>)
X.replace(Y, Z) === Replace(X, Y, Z)
X.replaceMatches(Y, Z) === ReplaceMatches(X, Y, Z)
X.round() === Round(X)
X.round(Y) === Round(X, Y)
X.secondOf() === second from X
If the result type of
X.select(<element>) === X $this let a: <element> where a is not null return a
If the result type of
X.select(<element>) === Flatten(X $this let a: <element> where a is not null return a)
X.single() === singleton from X
X.skip(Y) === Slice(X, Y, null)
X.split(separator) === Split(X, separator)
X.sqrt() === Power(X, 0.5)
X.startsWith(Y) === StartsWith(X, Y)
X.subsetOf(Y) === X included in Y
X.substring(Y) === SubString(X, Y)
X.substring(Y, Z) === SubString(X, Y, Z)
X.subsumes(Y) === Subsumes(X, Y)
X.subsumedBy(Y) === SubsumedBy(X, Y)
X.supersetOf(Y) === X includes Y
X.tail() === Slice(X, 1, null)
X.take(Y) === Slice(X, 0, Coalesce(Y, 0))
X.timeOf() === time from X
timeOfDay() === TimeOfDay()
X.timezoneOffsetOf() === timezoneoffset from X
X.toBoolean() === ToBoolean(X)
X.toChars() === ToChars(X)
X.toDate() === ToDate(X)
X.toDateTime() === ToDateTime(X)
today() === Today()
X.toDecimal() === ToDecimal(X)
X.toInteger() === ToInteger(X)
X.toQuantity() === ToQuantity(X)
X.toString() === ToString(X)
X.toTime() === ToTime(X)
X.trace(Y) === Message(X, true, Y, 'Trace', ToString(X)))
X.trim() === Trim(X)
X.truncate() === Truncate(X)
X.unescape(target) === Unescape(X, target)
X.union(Y) === X union Y
X | Y === X union Y
X.upper() === Upper(X)
X.where(<condition>) === X $this where <condition>
X.yearOf() === year from X