Values

All expressions will use values of some kind. These values may be added and used as part of the expression, or may be read from the attribute or attributes that are input to the Expression processor.

Values in expressions may be Strings, Numbers or Arrays of Strings or Numbers. Numbers are stored in IEEE double precision format, with a maximum value of around 1.8 x 10308. Where date values are used in an expression, these values are represented by the equivalent Java timestamp (the number of milliseconds since 00:00 on January 1, 1970).

Expressions

Expressions are made up of Items combined by Operators. The supported Items are as follows:

• Numbers: Numbers may be represented as simple integers, or more complex numbers may be written using the floating point system, with an optional exponent.

  Examples:

  1000
  2.1212
  0.1
  1.2321e-20
  1e10
  

• Null: The special name null represents an undefined value.

• String Constants: String constants are enclosed in ' or " quotes. Java style back slash (\) escapes may be used within a string for special characters, as follows:

  • \n or \nn or \nnn: Character with octal code N

  • \n: Line feed (code 10)

  • \r: Carriage return (code 13)

  • \a: Bell character (code 7)

  • \t: Tab (code 9)

  • \b: Backspace (code 8)

  • \f: Formfeed (code 12)

  • \v: Vertical tab (code 11)

  Examples:

  "the cat slept on the mat"
  "this is a line feed: \n"
  'this is also a string'
  

• Attribute Names: A name used in an expression must contain letters, digits, $, _ or . and must not start with a digit. If it is necessary to use a name which contains other characters, it may be entered in an expression using the special syntax @'name' or @"name". For example if the name contains spaces, it must be entered as:

  @"a name with spaces"
  

• Array Values: An array value may be entered as a list of values enclosed in curly brackets: { }.

  Examples:

  {1, 2, 3}
  {a+2, b-5}
  

• Array Selections: An array element may be selected using an index expression in square brackets: [ ]. The first element is index 1. A subarray may be selected using an array slice, where a slice is indicated by a colon: [lwb:upb].

  Examples:

  arr[1]
  arr[x+1]
  z[2:3+m]
  {1,2,3}[2]
  

The following Operators are available, in descending order of priority:

Comparison operators evaluate to 1 if the comparison succeeds, and 0 if it does not.

Operators with higher priority bind more 'tightly' than operators with lower priority. For example:

a = b + c * d ^ e

is equivalent to:

a = (b + (c * (d ^ e)))

Functions

The following functions are supported in the expression language:

Expression Contexts

Expressions are used in a number of different contexts within EDQ. Each context has a different set of names available. A select few of the contexts are listed here.

1. The Expression and Expression Filter processors: Each name used in the expression must match an attribute selected as an input for the processor. Matching is case sensitive; if an attribute name includes a suffix (that is, part of the attribute name after a full stop), the suffix is ignored.

   If an attribute name is not a valid expression name, for example because it contains spaces, it must be entered using the @"name" syntax. For example if the attribute is address line 1 (street), it must be entered as:

   @"address line 1 (street)"

2. Calculator Processors: A number of standard processors are implemented using the com.datanomic.director.runtime.widgets.common.Calculator class. This takes an expression from a processor parameter (from the XML) and evaluates it using the input attributes.

   An expression parameter must be defined for each of the outputs in the processor. The parameter name for the output with ID N is expr.N. If there is a single output only, the simpler name expr may be used instead.

   Within an expression, an input attribute is referred to as iN where N is the input ID from the XML. If the input may be associated with multiple attributes then the name may be used in 'aggregating' contexts only.

   The outputs are evaluated in ID order and an earlier output may be referred to as oN where N is the output ID from the XML.

   In addition, 'working' expressions may be defined to store values which may be used in more than one place in the output expressions. These working expressions are evaluated before any of the output expressions. The parameter names for working expressions are expr.t1, expr.t2, etc.

   Processor options may also be used in calculator expressions - just use the name of the option.

Examples:

• The expression for the Upper Case processor is defined with:

          <parameters>
            <parameter name="expr">upper(i1)</parameter>
          </parameters>
  

• The expression for the Concatenate processor is defined with:

          <parameters>
            <parameter name="expr">concat2(separator, i1)</parameter>
          </parameters>
  

  Note the use of the separator property.

• The expression for the Trim Characters processor is defined with:

          <parameters>
            <parameter name="expr.o1">side == 'l' ? trimleft(i1, start, length) : trimright(i1, start, length)</parameter>
          </parameters>
  

• The expression for the Select Array Element processor is defined with:

          <parameters>
            <parameter name="expr.t1">fromend ? (length(i1) - index) + 1 : index</parameter>
            <parameter name="expr.o1">i1[t1]</parameter>
          </parameters>
  

• The expressions for the Regex Replace processor are defined with:

         <parameters>
           <parameter name="expr.o1">regexreplace(i1, regex, replace)</parameter>
           <parameter name="expr.o2">o1 != i1 ? 'Y' : 'N'</parameter>
         </parameters>
  

  In this case, the first expression does the replacement and the second computes the 'success' flag.

Advanced Features

• Conditional Expressions: Conditional expressions may be specified using the following syntax:

  a ? b : c
  

  The result is 'b' if 'a' is true and 'c' otherwise.

• Iterator Expressions: An iterator expression is a special feature for use in 'aggregating' functions like Sum or Concatenate. The syntax is as follows:

  {a : expr}
  

  Here a is an array or multi-attribute name (an input attribute which may have any number of actual attributes assigned to it), and expr is an expression which will contain a. The expression is evaluated with a replaced by each successive value in the name, and the results are fed to the aggregating function.

  The best way to illustrate this is with examples:

  Example 1

  sum({ a : a ^ 2 })
  

  This sums the squares of all the elements in a.

  Example 2

  sum( { a :  a < 0 ? 1 : 0 })
  

  This counts all the elements of a which are negative.

  Example 3

  sum({ i1 : nodatacheck(i1) = '-'}) > 0 ? 'Y' : 'N'
  

  Count the elements of i1 (input attribute 1) which are populated and evaluate to Y if any have data and N if all have 'No Data'.