Expressions are strings that embed formulas, which the pivot engine evaluates when it processes the design pivot to build the runtime pivot. Expressions are hence only available at design time - at runtime you get the result of their evaluation either as property values or as runtime pivot structure (because expressions are used to control the generation of runtime data members for design time data groupings).

Expressions start with '=' (Equals) character and are followed by a formula. A valid expression is such a string, which is lexically and grammatically correct. Expressions are constructed from tokens. Tokens are such substrings from the initial expression, which cannot be broken into other tokens.

A lexically correct expression consists of the following set of tokens:

• Parenthesis - the '(' and ')' characters, which can be used to change the operators privilege, and enclose the functions arguments.
  
• Operator - the predefined operators, which you can use (+,-,*,\,<,> etc.)
  
• Comma - the ',' character
  
• Constant - this is a constant value embedded in the expression. It can be a number, boolean value or string.
  
• Function - this is an identifier, which references a function
  
• Variable - this is an identifier, which references a dynamic (variable) value.

Each grammatically correct expression can be represented as a tree with items from one of the following types:

• Numbers - these are integer and floating point number constants. Following are some correctly formatted numbers:
  =12; =0.1; =145.23; =7.5E-17; =8.234E+13
  
• Booleans - these are the true and false boolean constants. Following are some correctly formatted boolean values:
  =true; =false; =True; =False; =TRUE; =FALSE
  
• Strings - these are substrings of the expression, which are enclosed in " (quote) characters. Following are some correctly formatted strings:
  ="hello"; ="world"
  
• Operators - supported is a common set of binary and unary operators (+. -, *, \, ^, =, <, >, <=, >=, <> and &) (see Operators below).
  
• Parenthesis - the '(' and ')' characters can be used to change the operators precedence. For example:
  =(10 + 20) * 2 - evaluates to 60; =10 + 20 * 2 - evaluates to 50
  
• Functions - supported is a large set of mathematical, trigonometric, logical, text, date-time and bitwise functions. Function arguments must be enclosed in parenthesis and divided by commas (see Functions). For example:
  =MIN(10, 20) - evaluates to 10; =COS(0) - evaluates to 1.
  
• Variables - variables are valid identifiers to which a value is provided at runtime. Variables are automatically created for the values of the current scope recordset fields (see Variables).

The expression evaluation works with variants. The result of each expression evaluation is a variant too (e.g. a value of certain type - see Variants below).

You can use operators in expressions to perform arithmetic operations (+, -, *, / and ^) or logical comparisons (<, >, =, <=, >= and <>). You can also control the order of evaluation in a formula by enclosing expressions in parentheses. The ampersand (&) operator is used for the concatenation of character strings.

Arithmetic operators mainly perform operations on numbers, but can also be used for date-time/time-span arithmetic. The following table summarizes the arithmetic operators:

Comparison operators are used in logical statements to determine equality or difference between variables or values. Comparison operators always evaluate to true or false. The following table summarizes the comparison operators:

Logical operators are used to determine the logic between variables or values.

The ampersand operator (&) is used to concatenate its arguments. You can use this operator to create new words and phrases. For example:

"hello" & " " & "world"

evaluates to: "hello world"

It is important to know that there is a priority assigned to each operator. If an expression contains several operators, which are not enclosed in parentheses, the operator with the highest priority is evaluated first. For example:

10 + 20 * 2

evaluates to 50, because the multiplication operator will be evaluated first (it has a higher priority than the addition operator).

(10 + 20) * 2

evaluates to 60, since the parentheses override the default way in which the expression is evaluated. The following table summarizes the operators priority:

Variants are value-type pairs, which facilitate the type conversion of values, as well as mathematical and logical operations with values of different type. The result of an expression evaluation is always a variant too (e.g. a value of certain type). When variants are consumed or used in functions or operators that require a value of a certain type, variants are automatically casted to a value of this type.

Variant casting however cannot be always performed - for example you cannot cast "hello world" to a double. In cases when automatic casting cannot be performed the pivot will raise an error. There are seven main types of variants:

• Empty - an empty variant holds no value. It is equivalent to DBNull. Empty fields values are represented by empty variants.
• Boolean - holds a boolean (true/false) value. Boolean values can be converted to string. See Logical Functions.
• Number - holds a floating point or integer number, with some precision (for example an Int32 number variant holds an integer value in 32 bits). When performing arithmetic operations numbers automatically change their type to ensure that they can hold the resulting value. Casting floating point numbers to integer numbers removes the decimal portion of the value. Numbers can be converted to string and you can format numbers with the FORMAT function. See Mathematical Functions and Trigonometric Functions.
• Text - holds a text string. See Text Functions.
• Date Time - holds a date time value. Date-time variants can be converted to string and can be formatted with the FORMAT function. See Date Time Functions.
• Time Span - a time span value. Time-span variants can be converted to string (see Time Span Functions).
• Array - holds an array of arbitrary variant values (see Array Functions).

A set of Type Functions is available, which lets you manage variant types.