StreamBase Expression Language Features

StreamBase provides two types of built-in functions in the expression language:

For a complete, categorized list of StreamBase functions and their syntaxes, see StreamBase Expression Language Functions.

StreamBase provides sample applications that feature custom functions for you to load into StreamBase Studio to see how they are built and configured. The custom sample applications are listed in Extending StreamBase Samples.

Back to Top ^

StreamBase Studio provides the following user assistance features to aid in writing expressions:

The following features are described in more depth on the Properties View page.

Back to Top ^

You can define custom expression language functions using a constructor for the function data type, as described in Using the Function Data Type.

Expression language custom functions generally combine built-in expression language functions and math operators. If you need to call Java classes in a custom function, create a custom Java function as described next.

Certain built-in functions called higher-order functions take user-defined functions as arguments. These include list manipulation functions such as filterlist and maplist. See Functions That Require Function Arguments.

Back to Top ^

You can use the custom function APIs in the StreamBase Java Client API to implement your own functions. For details on writing your own functions, see these topics in the API Guide:

You can call your custom functions in expressions by means of the calljava() function, or by defining and calling a function alias you have declared in a configuration file.

You define aliases for your custom functions using the streambase > pluginFunctions > java object of a configuration file of type com.tibco.ep.streambase.configuration.sbengine.

Back to Top ^

Expressions often need quotes around string values to designate those values as strings. The StreamBase expression language is agnostic about whether to use double or single quotes in expressions. For example, StreamBase interprets the following expressions identically when used in an expression in an operator or adapter in StreamBase Studio:

strftime("Traded on %b %d, %Y at %H:%M", now())
strftime('Traded on %b %d, %Y at %H:%M', now())

The only rule is that you must escape any instance of the same quote mark if you need to use it again inside a pair of quote marks. You can escape a quote mark with a preceding backslash, or you can surround it with the opposite quote mark. For example, StreamBase interprets the following lines identically in Studio:

strftime('Traded at Miller\'s Crossing on %b %d, %Y at %H:%M', now())
strftime("Traded at Miller's Crossing on %b %d, %Y at %H:%M", now())

Back to Top ^

Expressions use the StreamBase static data types:

In addition, the name of any named schema serves as a constructor for a data type of that name.

These data types are described in more detail in StreamBase Data Types.

Back to Top ^

To recast data types, use one of the StreamBase type conversion functions. For example, to cast a value to a double in an expression, use the double() function. To cast a value to a string, use the string() function, and so on.

Casting may not be necessary if type coercion is supported for the data types, as described in the next section.

Back to Top ^

Data type coercion is the implicit conversion of a value from one data type to another. For example, the + (concatenation) string operator performs coercion from numeric and boolean values to strings, as in:

"This is " + (2 > 1) => (string) “This is true”
"1" + 2 + 3 => (string) "123"

Evaluation proceeds from left to right, so that order matters:

1 + 2 + "3" => (string) "33"

Arithmetic operators coerce values when evaluating expressions with mixed numeric data types, as in:

1 + 2L + 3.0 => (double) 6.0

StreamBase math functions that take arguments and return doubles accept int, long or double input arguments. For example, the sqrt() function accepts one int, long, or double input and returns a double result (or NaN).

The following are the supported data type coercions and conversions:

The following rules apply to data type coercions:

Back to Top ^

Expressions are case sensitive. Function names are usually all lowercase, with a few exceptions. If you add custom functions, follow the lowercase convention.

Back to Top ^

StreamBase identifier naming rules apply to the name you assign to any StreamBase component, including schemas, fields, operators, tables, modules, containers, data source names, custom function names, and custom function aliases. Specifically, identifiers you create should:

For clarity in your application modules and to make debugging easier, follow the rules below when choosing names for your StreamBase components. Wherever possible, these rules are enforced by typechecking in StreamBase Studio.

Identifier names can include Unicode characters as long as Unicode support is enabled for both Studio and Server, as described in Unicode Support.

Back to Top ^

StreamBase supports an escaped identifier syntax to enable the use of arbitrary naming conventions for fields and identifiers. When you provide a name for a component of a StreamBase expression that violates the rules described in the previous section, StreamBase Studio automatically stores the name as an escaped identifier, which wraps the invalid identifier in a syntax that enables its use.

However, Studio does not automatically rename fields that violate the naming rules; you must explicitly enter escaped identifier syntax for the name of any field that would otherwise cause Studio to report an error.

The escaped identifier syntax is #"name" — a pound or hash symbol, followed by the otherwise-violating identifier you want to use within double quotes. Escaped identifiers work throughout StreamBase for the names of all components and fields.

You can use this syntax to name a field the same as a StreamBase reserved word, such as #"AS".

Back to Top ^

When you name fields and expression components, do not use the following words, which are reserved for use in the expression language:

LiveView fragments have an additional list of reserved words described in LiveView Reserved Words.

In EventFlow modules, StreamBase Studio does not prevent you from naming a field with a reserved word in an input stream's Properties view. However, a schema that contains a reserved word causes one or more typecheck errors in downstream components. The error message in the Typecheck view identifies the offending field's name. To correct the typecheck error, rename the field in the input stream's Properties view.

Although the names of StreamBase data types are not reserved words, It is a best practice that you do not use data type names as field names, for clarity when developing and debugging your applications. The data type names are listed in Data Types.

Back to Top ^

If a name conflict occurs when referencing a field name used in an expression in an operator, you can qualify the name to clarify the inbound stream you mean.

For example, in the Properties view for a Gather operator, you can qualify the fields as input[port-number].field-name.

Example: input1.is_alarm, input2.is_alarm, input3.is_alarm.

In the Properties view for a Join operator, you can qualify the fields in the two input streams as input1.field-name and input2.field-name. The input1.field-name refers to a field in the stream arriving at the top port (#1). The input2.field-name refers to a field in the stream arriving at the bottom port (#2).

Examples:

input1.SKU
input2.SKU

In the Properties view for a Query operator, you can qualify the fields in the two input streams as input.field-name and old.field-name. The input.field-name refers to the current input tuple, while old.field-name refers to the field's prior value.

Examples:

input.Symbol
old.Symbol

Back to Top ^

You can use +, –, *, /, and %. The ^ expression is not supported.

The following example shows the arithmetic operators in use. (This expression is shown on two lines for clarity.):

((((sector_in_fund_value_t + (shares_traded * price_at_trade)) * 100) / 
   fund_value_t) > 25)

This expression is designed to run the 25% sector test, where one sector is not allowed to be more than 25% of the total fund value. is_alarm is set to true if the test fails.

You can also use the + operator to concatenate strings; see Concatenation in Expressions for details.

You can also use the * operator to repeat a string multiple times; see String Repetition for details.

Back to Top ^

The modulus operator (%) finds the remainder of a division operation. Division and modulus are always related such that a/b*b+(a%b) == a, where a/b is an integer division. For example, 15%4 can be resolved as follows: as:

15 / 4 * 4 + MOD == 15
3 * 4 + MOD = 15
12 + MOD = 15
MOD = 3

This relationship is preserved with negative divisors. As a result, whenever the quotient is negative, the modulus is negative. For example:

15 % 4 = 3
15 % -4 = 3
-15 % 4 = -3
-15% -4 = -3

Also note that if you divide a smaller number by a larger number, the modulus is always the smaller number. For example:

4 % 15 = 4

This behavior may be different than modulus operators in some programming languages.

Back to Top ^

Use the between-and operator in expressions using the following syntax:

test-expr between expr1 and expr2

where expr1 and expr2 resolve to instances of the same data type to which test-expr resolves. That is, the data type of test-expr, expr1, and expr2 must be the same, or must be coercibly the same, using the rules described in Data Type Coercion.

This construction returns Boolean true or false, and is thus ideally suited for use in an if-then-else construction:

if test-value between boundary1 and boundary2 then expr-if-true else expr-if-false

For example, using the current value of fieldname in the incoming tuple:

if fieldname between 100 and 200 then true else false

The between-and operator can be negated with the ! or NOT operator:

if fieldname not between 100 and 200 then true else false

The between-and operator is inclusive, which means if test-value exactly matches either boundary1 or boundary2, the operator returns true. Use this operator as a more readable version of the following equivalent expression. Using between-and has the advantage of only specifying test-value once.

if (test-value >= boundary1 and test-value <= boundary2) then expr-if-true 
    else expr-if-false

The between-and operator works with any StreamBase data type, including list and tuple, using the relational comparison algorithms described for each operator on StreamBase Data Types.

Back to Top ^

Use the infix operator IN to test for list or string containment, returning Boolean true or false. For example, the following expressions each return true:

2 in [1, 2, 3]
2 in list(1, 2, 3)

For strings, IN returns true if the string on the left is a substring of the string on the right. For example,

'foo' in 'there is food here'

returns true. However, if the right side argument is a list of strings, a list element must exactly match the left side argument. For example:

'foo' in ['there','is','food','here']

returns false.

The IN operator is syntactic sugar for the contains() function.

Notice that IN is not among the reserved words for the expression language, and the string IN can still be used as an identifier in other contexts. The IN operator only becomes an operator in the context of a list containment expression as shown above, with the test value on its left and the queried list on its right. The queried list can be expressed in simple bracket format, or can be any function or expression that resolves to a list, including the list() and range() functions.

Back to Top ^

Unary operators act on only one operand in an expression. –a is valid for integer, double, and long types. !a or NOT a is valid for the bool type. +a is not supported.

Back to Top ^

You can use the following relational operators: <, <=, =, ==, >, >=, !=

The relational operator <> is not supported.

StreamBase data types are comparable with relational operators in different ways, as listed in the entry for each data type on StreamBase Data Types.

Back to Top ^

You can use the following logical operators: &&, AND, ||, OR, !, NOT.

For related information on Boolean logic and nulls, see Using Nulls.

Back to Top ^

You can apply operators and functions to all fields in a tuple, using wildcards (*) in EventFlow expressions. The resulting values can replace the current field values, be assigned as new fields, or evaluated as a collection as arguments to EventFlow or custom functions, according on the syntax you use to expand values.

You can use wildcards to produce lists of expressions when passing arguments to functions. A simple wildcard expression such as input.* replaces input field values with evaluation results. To assign the results to fields at a lower level, use the AS keyword. The following table illustrates several syntaxes that illustrate the effect of using AS in wildcard expansions.

Expressions such as (input.x AS *) are not legal. You must specify field names with wildcards when using AS *.

For example, to determine whether all fields in a tuple are null, you could use the following expression:

andall(isnull(input.*) AS *)

The isnull function is applied to all input fields, the results are collected into boolean fields with the same names, and the resulting list is evaluated by andall, which only returns true if every field is null. In this example, the fields do not have to be of the same type.

Back to Top ^

The precedence of mathematical operators in expressions, from highest to lowest, is as follows:

For example, the expression "2 in if 2 > 1 then [1,3,4] else [2,6,7]" returns false because the > operator and the if-then-else conditional expression are evaluated first.

You can use parentheses in expressions to override the default precedence.

Back to Top ^

The StreamBase parser ignores any spaces, new lines, and tab characters in expressions.

Back to Top ^

You can add comments to your expressions using either C-style comments or legacy StreamBase comments:

The following sample expression illustrates several uses of comments:

/* handle special APPL case */
if (input1.symbol=="APPL.N") then input2.symbol == "APPL" 
/* handle special 
   IBM case */
  else if (input1.symbol=="IBM.L") then input2.symbol == "IBM"
  else input2.symbol == input1.symbol -- accept the rest as given

Back to Top ^

This section describes how to specify literals in expressions, for each data type. (For information about the data types themselves, see StreamBase Data Types.)

Back to Top ^

You can use nulls in the StreamBase expression language, one for each of the simple data types:

blob(null)
bool(null)
double(null)
int(null)
long(null)
string(null)
timestamp(null)

The data type of a null is never implicit. You must specify the data type of any null you are using in the expression.

In general, when you apply any arithmetic operator or function with data-type(null) as one of the arguments, the result is null. Three exceptions are the isnull() and notnull() functions, which test whether an expression evaluates to null, and the coalesce() and coalesce_tuples() functions, which select a non-null value from a set of potentially null arguments.

To specify a null list, use the nulllist() function. See Null Lists for a discussion of null lists compared to empty lists.

To specify a null tuple that uses a named schema, specify the name of the schema with empty parentheses. For example, for the schema named nyse_data, the expression nyse_data() creates a null tuple. See Null Tuples for a discussion of null tuples compared to empty tuples.

For more detailed information, see Using Nulls.

Back to Top ^

In an expression such as: if p then e1 else e2, p must be a valid boolean expression, and both e1 and e2 must be expressions that have the same type. If p is true, then e1 is evaluated and the result returned. If p is false, e2 is evaluated and the result returned. In either case, the other sub-expression is not evaluated.

Back to Top ^

You can use combinations of if-then and else-if-then statements to form compound conditional expressions. For example:

if i==0 then "Buy" else if i==1 then "Sell" else if i==2 then "Hold" else "None of the above"

Here is a second example, indented for clarity, where we nest an if then else in a then clause:

if p1
  then
    if p2
      then A
      else B
else
  if p3
    then C
    else D

Notice how each if clause contains a then clause and an else clause.

Back to Top ^

You can enter an expression that concatenates a string with any StreamBase data type. For any such concatenation, a string must be the first value. For two string variables, the concatenation expression is:

stringvar1 + stringvar2

For a numeric type with a static string, the concatenation expression is:

"staticstring" + number

For example:

"square root of 16 = " + sqrt(16)

displays as

square root of 16 = 4 

For a string and a numeric variable, the concatenation expression is:

stringvar + numvar

For example, where month = "September" and day = 16:

month + day

displays as

September 16

Back to Top ^

Use the * operator to repeat a string n times, using the syntax:

"staticstring" * n

where n is a positive integer or an expression that evaluates to one. For example:

"abc." * 3 -> abc.abc.abc.

The * operator simplifies creating fixed-length fields. For example, if a string field needs to be 32 characters long, use an expression like the following to pad its contents with blanks:

stringvar + ' ' * (32-length(stringvar))

This use of the * operator is also known as string multiplication.

Back to Top ^

When used with comparison operators ( == != > < <= >= ) you must compare time fields interval-to-interval, or timestamp-to-timestamp. You cannot use the comparison operators to forma an interval-to-timestamp comparison.

To express constant intervals, you can use the seconds() and minutes() functions. For example, if you want to add 60 seconds to a timestamp, enter expressions such as:

t + seconds(60)
t + minutes(1)

For more on comparing timestamp expressions, see timestamp Data Type.

Back to Top ^

You can declare operator parameters in configuration files, and can define module parameters in configuration files and in the Parameters tab of the EventFlow Editor. You can reference either parameter type in StreamBase expressions. See Constants, Variables, and Parameters for more on the difference between global and module parameters.

To reference a parameter in an expression, wrap the parameter name in braces and prefix the open brace with a dollar sign: ${parameter}. If you are referencing a parameter that is defined as a string, use quotes around the entire reference: "${parameter}".

See StreamBase Engine Configuration to understand the difference between operator (global) parameters and module parameters.

Back to Top ^