About Operators
•Boolean and Bitwise Operators
•About the In and Not In Operators
•About Conditional Expressions
•Conditional Expression Examples
Supported Operators
The following categories of operators are supported:
•Arithmetic Operators: These operators are strictly used with numeric operands.
•Boolean Operators: These operators are used for operands that yield Boolean values (for example, values from logical fields, values from relational comparisons, etc.).
•Relational Operators: These operators are used with numeric operands for numerical comparisons. If one or both of the operands contain a string value, the type of comparison is instead based on lexicographical ordering.
•Equality Operators: These operators are used for testing for (non)equivalence for Boolean, DateTime, numeric, and text values.
•Bitwise Operators: These operators are used to perform Boolean operations on each bit of an integer.
•DateTime Interval Operators: These operators are used with the DateTime functions.
The operators supported in Neurons for ITSM are:
| Category | Name | Operator |
|---|---|---|
| Arithmetic | Addition | + |
| Arithmetic | Subtraction | - |
| Arithmetic | Multiplication | * |
| Arithmetic | Division | / |
| Arithmetic | Remainder | % |
| Boolean | NOT | ! |
| Boolean | AND | && or AND |
| Boolean | OR | || or OR |
| Relational | Less Than | < |
| Relational | Greater Than | > |
| Relational | Less Than or Equal | <= |
| Relational | Greater Than or Equal | >= |
| Equality | Equal | == or = or <> |
| Equality | Not Equal | != |
| Bitwise | AND | & |
| Bitwise | OR | | |
| Bitwise | Exclusive OR | ^ |
| Bitwise | Complement | ~ |
| Bitwise | Left shift | << |
| Bitwise | Right shift | >> |
| DateTime Interval | before | |
| DateTime Interval | not before | |
| DateTime Interval | during | |
| DateTime Interval | not during | |
| DateTime Interval | after | |
| DateTime Interval | not after |
About Relational Operators
Relational operators are used to compare two expressions or values and return a Boolean result. Use the correct variable types, combinations of variables, and numbers to perform comparisons using relational operators.
Example 1: In this example, the Equal to Operator (represented as ‘==’) checks whether the two given operands are equal or not. If so, it returns true. Otherwise, it returns false. Here, values of the same type are compared and hence
6==6 will return true.
Example 2: In this example, both operands on either side of the operator are of a different type. The right hand side value is string and the left hand side is a number. Therefore, the number will be converted to string and the return value is false.
number(“6”)>=5
6>=number(“5”)
If the Relational and Equality operators both operands on either side of the operator are of a different type, then implicit conversion may yield unexpected results. It is recommended to use type conversion explicitly to ensure an accurate comparison.
The relational operators can be used with data types. For information about the supported data types, see About Type Conversions
Operator Precedence
The following table illustrates the order of precedence of the operators, from highest to lowest precedence.
Operators in the same row have the same precedence, which are evaluated from left to right, based on the appearance of the operators in the expression.
| Category | Operators |
|---|---|
| Boolean NOT |
! + (unary) - (unary) ~ NOTE: The + (unary) and - (unary) operators are not the same as the + (additive) and - (additive) operators. |
| Membership and DateTime interval |
in not in before not before during not during after not after |
| Multiplicative |
* / % |
| Additive |
+ - |
| Left and right shift |
<< >> |
| Relational / Equality |
< > <= >= == != |
| Bitwise AND |
& |
| Bitwise OR |
| |
| Bitwise exclusive OR |
^ |
| Boolean AND |
&& |
| Boolean OR |
|| |
You can use parentheses to control precedence and associativity. When you save an expression, if you did not specify parentheses, the application automatically adds additional parentheses.
For example, if you enter the following expression:
$(3 + 4 * 5)
When you save it, the application displays the expression as:
$(3 + (4 * 5))
This is consistent with the order of precedence as shown in the previous table.
The Boolean operators (||, &&) are short circuiting:
•For expressions like $(Expr1 || Expr2), if Expr1 evaluates to true, then Expr2 is not evaluated.
•For expressions like $(Expr1 && Expr2), if Expr1 evaluates to false, then Expr2 is not evaluated.
For the Boolean AND (&&) and Boolean OR (||) operators, while defining the expression, you can opt to specify the operators as AND or OR, respectively. The application automatically converts them to && or || when you save the expression.
For example, if you define the if expressions as:
$(if Expr1 AND Expr2
then
...
else
if Expr1 OR Expr2
then
...
else
...
)
The application saves the respective expressions as:
$(if Expr1 && Expr2
then
...
else
if Expr1 || Expr2
then
...
else
...
)
Binary Operators
Neurons for ITSM recognizes the following binary operators:
in, not in, before, not before, during, not during, after, not after, *, /, %, +, -, <<, >>, <, >, <=, >=, ==, !=, &, |, ^, &&, and ||
You can also use AND and OR instead of && and ||.
For example:
$(Status == "Closed" || Status == "Denied")
This conditional expression can be found as a read-only condition in the Layout Editor. If the value returned is true, then the status is closed and the form field becomes read-only. If the value returned is false, then the status is denied.
Prior to Neurons for ITSM Release 2015.2, you could use & instead of && and you could use | instead of ||.
Starting in Neurons for ITSM Release 2015.2, you can no longer use & and | in place of && and ||, as & and | are now used as bitwise operators.
If you have existing expressions that use & and | in place of && and ||, you must update them to use && and ||
For example, when constructing an operator in the If block of the Workflow Designer, you can use binary operators:
1.Enter a title in an If block. An example is Need additional approval.
2.Select the OR radio button.
3.Select a field as an operand. An example is Type of change.
4.Apply an additional operator. An example is Not equal to (<>).
5.Select a value. An example is Standard.
Based on the outcome of this expression, the exit port of the If block can connect to a different block, creating a different path within the workflow.
Boolean and Bitwise Operators
The && (AND), || (OR), and ! (NOT) operators have Boolean operands and evaluate to a single Boolean value. && and || operators are short-circuiting, meaning that the right operand is not evaluated if the left operand determines the value result of the operator. This is only important if the right side expression has side effects, for example, in the case $(x && Prompt(...)).
The Prompt function is executed only when x is true. If x is false, the result of the && operator is always false regardless of the value of the Prompt function, and therefore the right operand is not executed in this case.
There are several new bitwise operators. Unlike the Boolean operators, these work on the individual bits of an integer value, treating a 0 it as false and 1 as true.
The bitwise operators are often useful in conjunction with hexadecimal literals, since the bit pattern of the resulting value is more apparent, for example, $(m & 0#f0f7).
| Operator | Example | Description |
|---|---|---|
| | | $(m | n) |
Applies the OR Boolean operation to each bit of m with the corresponding bit of n. |
| & | $(m & n) |
Applies the AND Boolean operation to each bit of m with the corresponding bit of n. |
| ^ | $(m ^ n) |
Applies the exclusive-OR Boolean operation to each bit of m with the corresponding bit of n. The exclusive-OR operation yields true if either of its left and right operands is true, but not both. |
| ~ | $(~m) |
Applies the NOT Boolean operation to each bit of m. |
| << | $(m << j) |
Shifts the value of m left i bits. If j is greater than the length of m, it will yield zero. |
| >> | $(m >> j) |
Shifts the value of m right i bits. If j is greater than the length of m, it yields zero. |
DateTime Interval Operators
DateTime interval operators consist of a pair of DateTime values that represent the start and end. They are often a calendar interval but do not have to be.
•after means after the end of the interval.
•not after means not after the end of the interval.
•before means before the beginning of the interval.
•not before means not before the beginning of the interval.
•during means during the interval.
•not during means not during the interval.
See Interval, Day, Week, Month, Quarter, and Year for information about built-in functions that use these DateTime interval operators.
About the In and Not In Operators
The in and not in operators can function on the server, on the client, and in Microsoft SQL queries.
The syntax is as follows:
•Text1 in ("one","two","three",...)
•Int2 in (3,33,333, ...)
The right side of the operator is a comma-separated list of values surrounded by parentheses. Starting in Neurons for ITSM Release 2015.2, the values do not need to be constants. Therefore, the following example is valid: Status in ("Open","Log"+"ged",Status).
You cannot include null in the list. For example, Status in (null,"Open") is not valid.
The right side of the in and not in operator expressions can also be any built-in function that computes a list. Currently, the only ways to compute a list are by using the built-in functions called CurrentUserTeamNames and CurrentUserTeamIds.
•The CurrentUserTeamNames function is now implemented on the client, on the server, and in Microsoft SQL queries, including in data segregation and in read-only and required rules. It appears in the function list in the expression editor for each of these kinds of expressions.
•The CurrentUserTeamIds function is only implemented on the server.
Therefore, expressions like $(OwnerTeam in CurrentUserTeamNames()) now work.
About Conditional Expressions
A conditional expression is a tool that lets you evaluate alternatives depending if a condition is true or false. You can enter conditional expressions using the if statement in the following syntax:
$(if condition then whenTrue else whenFalse)
This expression has three parameters:
•condition: The condition for which to test.
•whenTrue: The value to return if the condition is true.
•whenFalse: The value to return if the condition is false.
Neurons for ITSM only evaluates either the whenTrue or whenFalse value, based on the outcome of the condition.
You can nest if expressions within one another, so that the return value of one if expression feeds into another expression. It is most common to nest an if expression in the else part of another if expression. It is also possible to nest in the then and if parts of the expression, but that is less common. In all cases, note that the Neurons for ITSM expression syntax $() applies to the outermost expression. You do not need to use the $() syntax anywhere within the nested expression.
Conditional Expression Examples
The following expression return false if the incident status has a value of logged; otherwise, it returns a value of true:
$(if Status == "Logged" then false else true)
The return value of this conditional expression can then be used, for example, to determine when the Owner field in the Incident business object is mandatory (that is, when the status has a value other than logged):
Owner is required when $(if Status == "Logged" then false else true)
The following is a more complex example of a conditional expression. It is in a default incident editing rule and specifies the priority change to make when the urgency and impact fields are changed:
$(if Urgency == "High" && Impact == "High"
then "1"
else
if Urgency == "High" && Impact == "Medium" || Urgency == "Medium" && Impact == "High"
then "2"
else
if Urgency == "High" && Impact == "Low" || Urgency == "Medium" && Impact == "Medium" || Urgency == "Low" && Impact == "High"
then "3"
else
if Urgency == "Medium" && Impact == "Low" || Urgency == "Low" && Impact == "Medium"
then "4"
else "5"
)
In this case, each combination of urgency and impact field values specifies the priority level from 1 to 5.
Using the Case Expression
There are two types of case expressions: Boolean and value.
Boolean Case
The Boolean case expression is similar to an if-then-else statement.
For example, this statement:
case
when a > 0
then 44
when a < 0
then 22
else 11
is equivalent to this statement:
if a > 0 then 44 else if a < 0 then 22 else 11
The application executes the case statements in order. You can also nest case expressions, as in this example:
case
when a > 0 then case
when b > 0 then 11
when b < 0 then 22
else 33
when a < 0 then case
when b > 0 then 44
when b < 0 then 55
else 66
else case
when b > 0 then 44
when b < 0 then 55
else 66
Value Case
The following is an example of a value case expression:
$(if ViewType == "frsHelpDesk"
then helpdesk_Priority
else case Urgency
when "High", "Higher"
then (case Impact
when "High" then "1"
when "Medium" then "2"
when "Low" then "3" )
when /^Med*i+um$"/
then (case Impact
when "High" then "2"
when "Medium" then "3"
when "Low" then "4" )
when "Low"
then (case Impact
when "High" then "3"
when "Medium" then "4"
when "Low" then "5" )
else "5")
This case expression is a modified form of the expression in an editing rule for an incident, change, or problem that calculates the priority based on the impact and urgency.
The expression after the case clause computes a value and then the application matches the when expressions for equality. In this case, the when can also have a list of values as in the first when clause above.
If there is more than one when clause with the same value, the application only evaluates one of the then expressions; however, it is not necessarily done in order.
You can omit the else clause, but then the expression generates an error if there is no selected when clause. The when values do not have to have constant values, which means that you can use "when a/b then...". If a when value does not have the same type as the case value, the usual implicit conversions apply to the when value to make it have the same type.