QPR ProcessAnalyzer Expressions
QPR ProcessAnalyzer expression language is a versatile query engine for all the QPR ProcessAnalyzer data and models. The expression language can perform variety of calculation operations, such as aggregations, dimensioning and following relations between objects.
Basic syntax and operators
Several expressions can be separated using semicolon (;). Example:
let var1 = 2; let var2 = 3; var1 + var2; Returns: 5
Expression can contain linebreaks without affecting the result.
Following basic arithmetic and logical operations are available:
- Addition (+) can be performed on numeric types, strings (concatenate two strings) and TimeSpans (addition of two TimeSpans).
- Subtraction (-) can be performed on numeric types, DateTimes (calculating TimeSpan between two DateTimes) and TimeSpans (difference between two TimeSpans).
- Multiplication (*) can be performed on numeric types, and between a TimeSpan and a numeric type (multiplying TimeSpan by number which results in TimeSpan),
- Division (/) can be performed on numeric types, between a TimeSpan and a numeric type (dividing a TimeSpan where TimeSpan must be the left hand side operand).
- Remainder (%): can be performed on numeric types.
- Comparison operators: ==, <, <=, >, >=, !=.
- Logical operands: && (AND), || (OR), ! (NOT)
Quick syntax for condition statement: condition ? trueValue : falseValue. Example:
var1==4 ? "Value is 4" : "Value is other than 4"
Literals
Literals (i.e. static values defined in the expressions) can be written as follows:
| Data type | Examples |
|---|---|
| number |
|
| boolean |
|
| string |
|
In string literals, characters " (double quote) and \ (backslash) need to be escaped using the \ (backslash) character. Linebreaks can be added with \n and tabulator with \t. Unicode characters can be added with \uXXXX where the last four characters are the unicode character code, e.g. \u001f.
For writing date and timespan value literals, use the DateTime and TimeSpan functions.
Arrays
Arrays (sequence of items) can be created either using the Array function or brackets (see the examples below).
Examples:
Array(1, 2, 3) Returns: An array having three elements which are 1, 2 and 3. [1, 2, 3] Returns: Same as the previous example. ["Dallas", "New York", "Los Angeles"] Returns: Array of strings (region names). Array() Returns: An empty array.
Lookup operator ([ ])
Lookup operator (brackets after an array) is used to get one or several items from an array. The loopup expression (the expression inside brackets) defines either:
- a single integer, which fetches a single item in the array, or
- an array of integers: fetches multiple items in the array.
Note that the indexes start from the zero. Note also that using an index which is not in the array will throw an exception.
The lookup expression is evaluated in the context of the array where items are to be fetched.
Examples:
[1, 2, 3, 4][1] Returns: 2 [1, 2, 3, 4][Count(_) - 1] Returns: 4 ["a", "b", "c", "d"][[0, Count(_) - 1]] Returns: ["a", "d"] [[1, 2], 3, [4, [5, 6]]][2][1][0] Returns: 5
The lookup operator also works for dictionaries:
Examples:
{"a": 1, "b": 2, "c": 3}["b"]
Returns: 2
{1: "number", "Hello!": "text", DateTime(2020): "datetime"}[[DateTime(2020), "Hello!", 1]]
Returns: ["datetime", "text", "number"]
Also this kind of lookup can be used:
{"a": 1, "b": 2, "c": 3}.b
Returns: 2
{"a": 1, "b": 2, "c": 3}.(a+b+c)
Returns: 6
Define variables and assign variable values
let myVariable = "myValue"; myVariable = "Another value";
If operator
if (condition) {
} else {
}
While operator
while (condition) {
}
Return operator
Null conditional operator (?. and ?:)
The null conditional operator (one question mark) is useful in chaining operations where there might appear null values in the middle of the chain. If not handled correctly, e.g. trying to get a property from a null value, will throw an exception. In the null conditional operator, if the result of the left-hand side expression is a null value, the next step in the chaining operation is not executed, but a null value is returned instead.
For example, the following expression throws an exception if StartTime is null:
StartTime.Truncate("month")
The null conditional operator can be used to take into account the null situation, and the following expression returns null if StartTime is null:
StartTime?.Truncate("month")
In the null conditional operator, if the left-side expression is an array or a hierarchical array, the chaining operator does not chain null values in that array (see the examples). Null conditional chaining can be applied to both contextless and hierarchical chaining operations by prefixing the chaining operator with ? character.
The null conditional operator is faster to calculate and syntax is easier to read than using if condition.
Examples:
null?.(_ + 1)
Returns: null
[1, null, 3]?.(_ + 1)
Returns: [2, null, 4]
StartTime?.Truncate("month")
Returns: null (if StartTime is null).
[1, _remove, 3]?.(_ + 1)
Returns: [2, 4]
[1, null, 3]?:(_ + 1)
Returns: [1: [2], null, 3: [4]]
There is also a null conditional lookup operator which can be applied to the lookup operation by adding ? character in the front of the lookup operator. If used, and there is a null value instead of an array, the result of the lookup operation is null (an exception would be thrown without the null conditional lookup).
Examples:
null?[3] Returns: null [[1, 2], null, [3]].(_?[0]) Returns: [1, null, 3]
Null coalescing operator (??)
The null coalescing operator (two question marks) can be used to replace null values with something else. The null coalescing operator works as follows:
- If the left-hand side expression is null, the right-hand side value is returned.
- If the left-hand side expression is not null, the left-hand side value is returned.
The null coalescing operator combined with the _remove operator is a handy way to remove null values from an array (see the examples below).
Examples:
null ?? "foo" Returns: "foo" 1 ?? "foo" Returns: 1 [1, null, 3].(_ ?? "foo") Returns: [1, "foo", 3] [1, null, 3].(_ ?? _remove) Returns: [1, 3] [1, null, 3]:(_ ?? _remove) Returns: [1: [1], 3: [3]]
Key-value pairs collection
JSON style of formatting can be used to express collection of key-value pairs. These can be used to pass named settings to functions supporting this, e.g. conformance checking functions.
Example:
In the following example, the second parameter of the IsConformant function is a hierarchical objects used as key-value pair collection: EventLog.Cases:IsConformant(myDesignModel, ["IgnoreEventTypesMissingInModel": false, "IgnoreIncompleteCases": true])
Dictionary literals
Dictionary objects can be defined in the expressions also as literals using notation
{ ((logicalExpression ':' logicalExpression) (',' (logicalExpression ':' logicalExpression)) )?
Examples:
{"number": 1, "text": "Hello!", "datetime": DateTime(2020)}
Result: Creates a simple object having numeric, textual and datetime values.
{1: "number", "Hello!": "text", DateTime(2020): "datetime"}
Result: Creates a simple object having numeric, textual and datetime keys.
Let("o", {"value": 1, "inc": Def("", "amount", Set("value", value + amount))});
Result: Creates object o which wraps a number in its value-property and it can be increased by given amount by calling Inc-function for the o-object.
Line comments
Line comments can be added to code using // syntax. Line comment spans to the next line break.
Let("var1", 123); //This is comment which is ignored by the calculation