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 writing expressions:

See Properties View for more information on these features.

Back to Top ^

Use the sbd --eval command to evaluate and test your expressions at the command prompt before using them in your StreamBase applications. sbd --eval works with simple functions, but not with aggregate functions. You must evaluate aggregate functions using other methods, such as running a test application and checking the results.

The syntax is either:

sbd --eval "expr to evaluate"
sbd -e "expr to evaluate"

You can use either double or single quotes around the expression to evaluate. You must escape any quotes contained in the expression itself, as discussed below.

On Windows, be sure to run sbd --eval from the StreamBase Command Prompt, not a standard Windows command prompt.

The following examples show how to use sbd --eval. These examples work as shown at the StreamBase Command Prompt on Windows and at the shell prompt on OS X or Linux. See Using Quotes in Expressions for further details on the quoting rules for StreamBase expressions.

Back to Top ^

If you do not find a built-in function that you need, you can define a function in the StreamBase expression language. You can use functions you define with any operator that takes a StreamBase expression. function is a StreamBase data type, and like other data types, it can be passed in streams, specified within output expressions, and defined for modules in a fashion similar to constants. In some cases, EventFlow functions can avoid the need to create custom Java functions.

This example describes creating a new EventFlow application that uses a function in two ways to convert temperatures in Celsius to temperatures in Fahrenheit. In the first section, the function is an expression in an input stream. In the second section, the function is a module definition.

The following sections show how to provide the function to the convert operator in two ways:

Normally, you would use only one of these approaches, depending on your application's purpose and design. Passing functions as fields in streams provides greater flexibility in defining them, but that flexibility may not be needed and can reduce an application's efficiency.

The StreamBase Studio sample EventFlow Function Sample provides an application similar to this example that you can run and modify.

exception: Compilation error preparing function 
"function randomInt (n int) -> int {int(random()*n)}" : 
current security options prevent calling any operation that 
is not purely functional from enqueued or compiled functions"

Starting with release 7.4.0, function is a StreamBase data type and a reserved keyword.

The following simple functions in the expression language, sometimes called higher order functions, allow or require passing in a function as one of their arguments to manipulate single or multiple lists.

In addition, sort() has a syntax that accepts a custom comparison function to sort a single list.

Input functions to these higher order functions must obey certain rules:

You can pass custom functions to these functions using function aliases that you declare in a server configuration file.

For details, see individual function descriptions in StreamBase Expression Language Functions.

Starting with release 7.6.0:

You can use the StreamBase custom function APIs to implement your own function and configure your application to use it. Your custom functions can be written by extending the StreamBase APIs for Java or C++. For details on writing your own functions, see these topics in the API Guide:

You can call your custom functions in expressions by calling a function alias you have declared in the server configuration file, or by using calljava() or callcpp().

myCustomFunction(x, y) 

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 or in a StreamSQL statement:

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 or in StreamSQL:

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())

Works on Windows:
sbd --eval "strftime(\"Traded on %b %d, %Y at %H:%M\", now())"
sbd --eval "strftime('Traded on %b %d, %Y at %H:%M', now())"

Works on Bash under Linux or Cygwin:
sbd --eval "strftime(\"Traded on %b %d, %Y at %H:%M\", now())"
sbd --eval "strftime('Traded on %b %d, %Y at %H:%M', now())"
sbd --eval 'strftime("Traded on %b %d, %Y at %H:%M", now())'

Does NOT work on Bash:
sbd --eval 'strftime(\'Traded on %b %d, %Y at %H:%M\', now())'

Expressions use the StreamBase static data types:

These data types are described in 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, and data source names. 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".

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

In EventFlow applications, 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.

In StreamSQL applications, Studio prevents you from using a reserved word as a field name when defining schemas, or as a field in an index specification, order-by specification, or gather key.

Although the names of StreamBase data types are not reserved words, TIBCO recommends 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.

The StreamSQL language has an additional list of reserved words, as shown in StreamSQL Reserved Words.

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 publication clarity.):

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

This expression is designed to execute 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.

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.

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 in much the same way as in StreamSQL. 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.

For additional information, see Wildcard Rules in StreamSQL SELECT Statements.

Back to Top ^

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

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 StreamSQL-style 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) -> "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 -> "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 global parameters in the StreamBase Server configuration file, usually named sbd.sbconf, and can define module parameters 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}"

StreamBase Server Configuration File XML Reference explains how to declare global parameters. For example, consider a server configuration file that defines the following two global parameters:

<operator-parameters>
    <operator-parameter name="MyInt" value="2"/>
    <operator-parameter name="MyString" value="somestring"/>
</operator-parameters>

You could reference the first parameter (for example, in an output field) using an expression like 35 * ${MyInt}. The expression would evaluate at run time to 70. The following StreamSQL statement references the second parameter:

SELECT * FROM InputStream1 "${MyString}" AS source

Notice the quotation marks, which are needed so that the expression is resolved as a string.

Back to Top ^