Expression Builder Overview

The expression builder is made up of two areas:

• The Palette allows you to select fields to insert into the expression.
• The Editor enables you to compose the expression.

Terminology

The following concepts are helpful to understand when using the expression builder:

• An expression consists of one or more lines of logic, called statements.
• Statements are discrete pieces of instruction that control the logic of an expression. There are three types of statements:
  • Return statements return a value.
  • If statements specify a list of statements to be performed when its condition is true. You can add Else and Else If statements to If statements to expand on the condition.
  • Comments enable you to annotate portions of the expression (for example, to identify where a change was made). They are informational only, and they do not get evaluated when the expression is run.

• Expression terms are made up of objects and operators that get evaluated to a value. In this example, an expression derives the value of an Alias property by concatenating the node name, plus a hyphen, and then the node's description:

  
  
  

  This expression has three expression terms (plus an optional placeholder to add a fourth), each indicated by a icon:

  • Node.name.concat(
  • - (hyphen character)
  • Node.properties.Core.Description

  Expression terms are indicated with yellow backgrounds in the expression builder, and each expression term can be moved or deleted within the statement. You can also copy and paste expression terms within an expression. See Copying and Pasting in Expressions.

• Objects are the elements in an expression that represent values. Each object has a data type that determines what additional objects, methods, and attributes are available for that object. For example, if you select the sourceNode object in an expression, the expression builder will display only the fields that are applicable to node data type, such as dimension or name. See Data Types for Expression Terms.

  After you select an object in an expression, you can further refine your expression by selecting attributes and methods for that object.

  • Attributes describe an aspect of an object. For example, the dimension object has an attribute called name.
  • Methods perform actions on an object. For example, the concat method concatenates strings together, and the length method returns the length of a string. Some methods have arguments, which are input parameters for the method. A label describes the required input (for example, String Value).
• Operators perform logical comparisons in an expression. The expression builder supports the operators AND and OR.
• Literals are constant values that you manually enter in an expression. For example, in the statements If Account.Type = E, return Expense, both "E" and "Expense" are literals.

Let's look at an example of an expression to get familiar with the terminology:

This is an expression on a node type converter that maps between a Corporate Planning account dimension and a Financials Cloud GL account dimension. Written out, this expression says:

For the PLN.Variance Reporting property, if the source node property FCGL.Account Type equals "E", return "Expense". If not, return "Non-Expense".

This expression in the screenshot contains these elements:

1. Three statements:
   • If FCGL.Account Type equals "E"
   • Return "Expense"
   • Return "Non-Expense"

   Note:

   When building the expression, you do not have to add an Else If statement. When the expression is run, if the IF statement is not true, the logic moves to the next statement. See Building Expressions.
2. Four expression terms:
   • FCGL.Account Type equals
   • "E"
   • "Expense"
   • "Non-Expense"
3. One object: sourceNode.
4. Two attributes: FCGL.Account Type and properties.
5. One method: equals.
6. Three literals: E, Expense, Non-Expense.