- Index

## StreamBase Glossary

### A

adapter

  Code that converts third-party data to the StreamBase protocol, and vice versa. For example, StreamBase provides an adapter that converts TIBCO® Rendezvous™ messages into tuples that use the data types supported by StreamBase. The adapter also supports converting StreamBase tuples into the data types used by Rendezvous messages. You can create a configuration file that specifies the source and destination message subjects (Rendezvous) and streams (StreamBase).

Aggregate operator

  Applies one or more aggregating functions to windows of incoming tuples. Windows can be defined over attribute values or numbers of tuples, and can be grouped by one or more input fields. You can define several parameters, including the size of each window, how much to advance the window after each window's computation completes, and a condition that must hold for aggregation to begin.

aggregate function

  A function that is used to return a single result within the context of an aggregate window or a query table. Aggregate functions can only be used in Aggregate or Query operators.

aggregate window

  A view on a subset of input data, as defined in the Aggregate operator’s Dimensions options. Tuples held in an aggregate window may be evaluated using aggregate functions. Windows open and close based on the options selected in the Dimensions options.

application

  A set of processing units (input streams, operators, output streams, and other components) that may be designed in StreamBase Studio and loaded by a StreamBase Server. The units define the runtime business logic that will occur on streaming input data. The design that you create and update in StreamBase Studio is known as an EventFlow. An application is also comprised of configuration files that set the location of application resources and declare memory parameters. A StreamBase application may also contain user-defined client programs that interact with the StreamBase components, and user-defined plug-ins to implement custom functions.

application module

  A collection of components that can be referenced as a single component within a StreamBase application. Developing with modules enables you to reuse the same functionality in multiple applications. Any StreamBase application can be used as an application module, as long as its schema matches and its functions are compatible with the containing application.

arc

  A directed line on the EventFlow canvas that connects two components. Tuples flow along arcs. Arcs that connect components to query tables or other data constructs are called data arcs.

AuthN

  A shorthand version of the term authentication, which refers to the verification of the identity of clients attempting to access requested resources.

AuthZ

  A shorthand version of the term authorization, which refers to ensuring that authenticated clients have permission to access the resources to which they request access.

### B

boundary crossing

  The exchange of data between two or more separate software applications, to accomplish a single business task.

breakpoints

  In a debugger, breakpoints are a way of letting the processing engine pause for you when a certain condition on any queue is met.

BSort operator

  Performs an approximate "buffered" sort of its input stream. Because a complete sort is not possible over an unlimited stream of data, you indicate the desired degree of approximation by specifying the buffer size. You can also specify that sorting should be performed over groups specified by input data fields.

### C

canvas

  The drawing surface in StreamBase Studio, to which you "drag and drop" components from the Palette.

capture field

  Opaque fields that shield a module's logic from input schema fields that are irrelevant to the module's operation.

concurrency

  See entries for multiplicity and parallel region. Also see data parallelism.

container

  A building block for organizing and connecting multiple StreamBase applications. There is one StreamBase application per container, and each container name serves as a handle for that application's resources. Multiple containers/applications can be run in a single StreamBase Server (sbd) process, and you can share selected resources between applications.

custom function

  StreamBase expression language functions written using the StreamBase Client API, usually in C++ or Java.

### D

data construct

  A StreamBase component that stores information used by an associated StreamBase operator. For example, Query operators are associated with Query Table data constructs.

data directory

  The location for storing persistent, disk-based Query Tables. The data directory location can be specified with the dataAreaPath property in a configuration file of type sbengine with root object StreamBaseEngine.

data parallelism

  An option for operators and modules that enables concurrent processing, where you specify the number of threads that should be instantiated. Each instance runs in a separate thread. You also specify a key field expression, which causes all tuples with the same value in the specified field to be sent to the same instance.

Decision Table operator

  Provides a way to express a complex set of business rules as a table of conditions that apply to incoming tuple fields, with one or more specified actions for each row of conditions.

Distributed Router operator

  Used to route tuples to other nodes in the same cluster. This operator is unusual among other Palette view operators because you use it at authoring time to specify an operation that can only occur at runtime between two or more nodes.

dynamic variable

  A variable you can define for an operator that can then be used in one of that operator's expressions. A dynamic variable can be updated as a consequence of enqueuing tuples onto an input stream or emitting tuples on an output stream.

data type

  StreamBase has a set of native data types, such as int, string, and boolean, as described on StreamBase Data Types.

dequeue

  To read tuples being sent on a stream. The opposite of enqueue.

distinguished name (DN)

  A naming specification used by LDAP to uniquely name, for example, user and role objects in an LDAP database.

downstream

  Any operations that occur after the current operator in the stream of data flow. See upstream.

### E

Eclipse

  An open-source, Java-based integrated development environment. StreamBase Studio is based on Eclipse.

embedded adapter

  An adapter that runs in the same server process (sbd) that is hosting and processing your StreamBase application's requests. Embedded adapters offer less client/server communication overhead and simpler administration than some external adapters. StreamBase installs a number of embedded adapters.

enqueue

  To inject tuples into a stream for later downstream processing. The opposite of dequeue.

Error Log view

  Captures warnings and errors logged by various StreamBase and Live Datamart component subsystems. Invoke the Error Log view by selecting Window → Show View → Other → General → Error Log.

event

  A message flowing through a stream at a particular time. The value of an event is always a tuple. While a tuple is simply a data structure, an event corresponds to something in the real world. For example, if a blue car is observed at location (100, 100), then the tuple (object-type: car, color: blue, x: 100, y:100) might be a good representation for that event.

  Events are transient, although their tuples can be stored, either temporarily in operators and data constructs, or persistently in disk-based or external tables.

EventFlow

  The graphical form of a StreamBase application that is created in the StreamBase Studio EventFlow Editor. An EventFlow is saved in an XML `sbapp` file and, optionally, an `associated sblayout` file.

EventFlow fragment

  Consists of one or more modules that describe the flow and processing of streams of incoming data using the TIBCO StreamBase EventFlow graphical language.

expression

  In the StreamBase expression language, one or more symbols (arithmetic operators, function calls, constants, field names) that may be evaluated to a single-typed value given some (optional) evaluation context in which to resolve field names and other variables. For example, an EventFlow expression that evaluates to a Boolean (true/false) value (such as: price > 100) is often used as a predicate for choosing an action to take.

external adapter

  An adapter that is installed separately from the StreamBase kit and runs in separate processes from the sbd daemon.

### F

feed simulation

  A tool used to send test data to a running StreamBase application.

field

  In a schema, a field refers to a specific name-value pair of a particular data type that is a named component of a tuple. Fields in a schema can be looked up by name and can be used to retrieve a value from a tuple. A field name must start with an alphabetic character or an underscore. It may contain alphabetic characters, numbers, and underscores.

Filter operator

  Accepts a single input stream and applies one or more predicates (tests) to the arriving tuples. A predicate returns TRUE or FALSE. If a tuple's data matches a TRUE condition in a predicate, it is moved onto a designated output stream. You can define a Filter operator so that tuples not matching any of the predicates are dropped.

Focus Selector

  In the StreamBase Studio, the Focus Selector allows you to click within a scaled-down version of the application's drawing, which then centers the larger-size drawing on the main canvas.

### G

Gather operator

  Concatenates tuples that share the same key value (such as a common stock symbol) from its input streams. It accepts two or more input streams, and releases a new single tuple that can be a function of any of the input tuple fields. The release happens when the Gather operator has seen a tuple with that key on each of the input streams.

Generic Security Services API (GSSAPI)

  An API implemented by the JRE that, among other things, provides Kerberos client and server authentication services.

### H

hashing algorithm

  A calculation based on a primary key field value (and optionally including secondary keys) that results in a storage scheme; on a subsequent read operation, the hashing algorithm can be applied again to quickly find the matching data. For example, StreamBase uses a hashing algorithm to index query tables, each of which is a container for shared data (and to maintain state) in a StreamBase application.

heartbeat operator

  Emits timer tuples at predictable intervals, on the same stream with your data tuples. This enables you to ensure that critical downstream operations occur even if there is a lull in the input stream.

HOCON

  Human-Optimized COnfiguration Notation. A set of extensions to the JSON specification that make it more readable, and used in StreamBase and Live Datamart configuration files.

### I

input stream

  In StreamBase Studio, an input stream is shown on the left side of the diagram as an entry point into the application. The name and schema you assign to an input stream is used by the StreamBase Server (on UNIX, sometimes called the StreamBase Daemon) to determine whether data from clients and external sources should be enqueued onto that stream. The StreamBase Server can listen for requests from a client source, such as an sbc enqueue command or sbfeedsim. The data can also arrive via an adapter that converts third-party protocols into the StreamBase protocol. Note that tuple output produced by an operator, if then consumed as input to another operator, is also considered an input stream that was generated within the application at runtime.

interface

  A set of definitions of input streams, output streams, Query Tables, constants, named schemas, and table schemas. An interface can consist of only schema definitions, or of any combination of streams, tables, and schemas.

intermediate stream

  Tuple output produced by one operator and consumed as input to another operator.

### J

Java Authentication and Authorization Service (JAAS)

  A collection of APIs implemented by the JRE for authentication and authorization.

Java object fragment

  Pure Java fragments that are independent of EventFlow and LiveView fragments.

JDBC data source

  An external database that is referenced in EventFlow logic using the JDBC (Java Data Base Connectivity) Data Construct.

Join operator

  Pairs tuples from two input streams that are within a specified distance on their respective order fields, and that satisfy an input predicate you defined.

jsbmonitor command

  Displays information, in graphical format, about the status and performance of a StreamBase application. It includes the same information as the sbmonitor command, with added dynamic graphs of CPU and memory usage.

JSON Web Token (JWT)

  Used by OpenID Connect or TIBCO Subscriber Cloud to carry information about an authenticated user.

### K

Kerberos

  A Single Sign-On specification. StreamBase and Live Datamart use is HTTP-based only.

Kerberos Key Distribution Center (KDC)

  A Kerberos Key Distribution Center, with which Kerberos clients communicate when requesting and validating Kerberos tickets.

### L

latency

  The time between the start and end times of processing a tuple during stream combination.

layout element

  In an EventFlow sbapp source file, an element that describes the dimensions or position of a component in the EventFlow Editor canvas. Contrast with semantic element.

### M

Map operator

  Accepts a single input stream, applies an expression to the tuple values, and generates a single output stream that contains output fields whose values were determined after StreamBase evaluated the expressions. For example, an input stream might contain an item's prices in U.S. dollars (USD). A Map operator can perform the calculation to convert the prices to Euros (EUR) by applying the current conversion rate. The prices in the output stream are in EUR currency. You can also use Map operators to drop fields within a tuple.

Merge operator

  Combines the tuples of two input streams — which must have schemas with the same fields, field names, and data types — generating a single output stream that is ordered on the same field.

metronome operator

  Emits output tuples periodically based on the system clock, enabling you to control the timing of downstream components. Unlike the Heartbeat operator, Metronome does not have an input stream, and emits no other data - just a timer tuple.

module parameter

  A variable that can be used within an EventFlow expression in a StreamBase application module. The parameter's value can be set for each module reference that uses the application.

module reference

  A reference to an application module that is inserted into a StreamBase Application. The module reference is treated as a single component that can be connected to other components.

multiplicity

  Refers to the number of instances of an operator, module, or module reference.

### N

node

  A StreamBase Runtime container for one or more engines. For StreamBase and Live Datamart, a node is a container for one or more JVM instances.

### O

OpenID Connect (OIDC)

  An HTTP-based standard for single sign-on using third-party identity providers.

operator

  Code that performs pre-defined work on streaming data, such as aggregating tuples, or merging tuples, or retrieving data from a Query Table. Each operator performs the work that you specify in its Properties view.

Outline view

  In StreamBase Studio, the portion of the UI that shows the entities that comprise the application. An expanded list identifies each operator, data construct, input stream and output stream.

output stream

  In StreamBase Studio, an output stream is shown on the right side of the application's diagram as a named exit point. Note that tuple output produced by an operator at runtime is also considered an output stream.

overlapping windows

  Windows in an Aggregate operator whose open (advance) value is less than its close (size) value. Sometimes called sliding windows.

### P

page pool

  The memory pool used to hold tuples that are flowing on streams between operators.

Palette view

  In StreamBase Studio, the portion of the user interface containing StreamBase components that you can drag and drop into the EventFlow Editor.

parallel region

  A collection of running StreamBase code, rooted at a particular instance of a module, that is guaranteed to process one tuple at a time, and to do so asynchronously from other parallel regions.

parameter

  Used to pass in configuration values to a StreamBase application. These are useful when certain configuration properties for adapters/operators are not known at design time.

pass through field

  In certain operators and adapters, an option to copy unchanged the schema and values of fields from an input stream to an output stream.

pattern query

  A query that detects differences in data across one or more input streams, using the StreamBase pattern language. You can perform a pattern query in an EventFlow by using the Pattern operator; in a StreamSQL application using the SELECT statement with a FROM PATTERN clause.

perspective

  In StreamBase Studio, a perspective is a window that contains several smaller windows, arranged in a certain way to facilitate the completion of a specific task. Every perspective has one window for editing files (called an editor) and one or more windows that support the editing of those files (called views). StreamBase Studio has three perspectives: the SB Authoring, SB Test/Debug, and SB Demos perspectives.

Placeholder Query Table

  See Query Table, placeholder

predicate

  In a StreamBase operators, for example Aggregate, Gather, Filter and Join, a Boolean EventFlow expression that evaluates to `TRUE` or `FALSE`. Example: `TRADE_ID < 7000`. When used in a Filter operator, if the predicate returns `TRUE`, the tuple is sent out on the output port associated with the predicate. If the predicate returns `FALSE`, the next predicate (if any) is evaluated. If no predicates remain, the tuple is dropped from the streaming data.

project

  A folder in the Studio workspace that contains one or more StreamBase application files and associated files.

Properties tab

  In StreamBase Studio, the portion of the user interface that shows the parameter settings for the currently selected operator, data construct, or stream.

### Q

Query operator

  An operator that performs read, write, update, and delete operations on a Query Table or JDBC Data Source. This allows you to maintain state and share data both within a single EventFlow fragment, and between nodes across a winder StreamBase application.

Query Table

  A container for shared data and to maintain state in a StreamBase application. At runtime, a Query Table can have its values read from or updated by one or more Query operators. Query Tables can be declared to reside in-memory, or on-disk. In the case of memory-resident Query Tables, any data stored in the table at runtime is not saved after the StreamBase Server is shut down. In the case of disk-based Query Tables, the data stored in the tables can persist between StreamBase Server sessions, provided that you defined a dataAreaPath in your StreamBase engine configuration.

Query Table, Placeholder

  In a module, a table defined without content as a pointer to an actual Query Table in another module, associated with that Query Table by specifying a Connection Path.

### R

row

  A row is an entry in a relational table within a data construct (such as a Query Table or JDBC Data Source). The value of a row is always a tuple.

### S

sbadmin

  The command to invoke the StreamBase Administration Client.

sbapp

  XML source file for an EventFlow application.

sbc

  The command to invoke the StreamBase Client.

sbd

  In releases before StreamBase 10, the command that invoked the StreamBase Server. The sbd command is no longer a part of StreamBase 10 releases.

sbd.sbconf

  The default name for the StreamBase Server configuration file used in StreamBase releases before release 10.

sbfeedsim

  The command to invoke the StreamBase Feed Simulator (sbfeedsim).

sbprofile

  The command line facility used to produce formatted statistical profile information about operators, queues, threads, and system information in a given run of StreamBase Server.

sbstudio

  The command to invoke StreamBase Studio (sbstudio) on Linux systems, or as an alternative method to invoke Studio on macOS using Terminal windows or on Windows systems using the StreamBase Command Prompt.

sb-config

  The command to invoke the StreamBase Configuration Tool (sb-config).

schema

  A description of valid fields in a tuple, defining acceptable names and data types.

semantic element

  In an EventFlow source file, an element that defines an application component or functionality. Contrast with layout element.

SPNEGO

  An HTTP-based protocol for negotiating authentication protocols. StreamBase and Live Datamart use it to provide Kerberos authentication services. The acronym derives from Simple and Protected NEGOtiation.

Single Sign-On

  An authentication mechanism that allows users to identify themselves once and then use that identification in many places without needing to provide credentials again.

SIOMSO

  A type of EventFlow module that represents the simplest possible EventFlow construction, using a single Input Stream, a Map operator, and an Output Stream. The name derives from the keyboard shortcuts you can use to create such an application on the EventFlow Editor canvas: Stream Input, Operator Map, Stream Output.

sliding window

  See overlapping windows.

Split operator

  The Split operator allows you to explicitly indicate the order in which the outputs should be processed (to completion) by each set of downstream components, in cases where you have a single input port and multiple output ports.

SSO

  See Single Sign-On.

stream

  An ordered and potentially unlimited collection of tuples that share the same schema and arrive at the same processing input. A stream has one producer, which is either an operator in the application or an external data source. A stream may also have zero or more consumers, which may be operators or output streams.

StreamBase Administration Client

  A tool invoked with the sbadmin command to perform administration tasks on a running StreamBase Server instance, including pause, resume, shutdown, and many other tasks.

StreamBase Client

  A command-line tool that sends requests to a running EventFlow fragment. Any StreamBase user can submit sbc commands, which do not require authentication. jsbc is the Java implementation of the same command, and provides several additional subcommands, including a way to specify JVM options.

StreamBase Configuration Tool (sb-config)

  On UNIX, lets you determine the compiler and linker flags that should be used when compiling and linking client programs against the StreamBase libraries, for C++ or Java.

StreamBase Feed Simulator (sbfeedsim)

  A feature that connects to a running StreamBase application and submits data to it. This feature can help you quickly test the validity and performance of your application.

StreamBase Processing Engine

  The core StreamBase Server.

StreamBase Server

  In releases before StreamBase 10, a server process that listens for, and acts upon, client requests for commands or data in a StreamBase application. The name of the executable is sbd, which derives from StreamBase Daemon. This process is the primary server for StreamBase, accepting the incoming streaming data, managing the execution queues, and performing the real-time processing work as defined in the operators that comprise your application.

StreamBase Studio (sbstudio)

  A graphical tool to create and test StreamBase applications. Started on Windows by clicking the StreamBase Studio desktop icon, or on Linux with the sbstudio command. You can "drag and drop" different types of StreamBase entities, such as an Input Stream or a Join operator, onto a drawing canvas. Once placed on the canvas you can draw arrows between related items, indicating that data will flow from one operator to the other, when one or more conditions are met. StreamBase Studio provides a quick and easy way to define or change each operator's properties. Behind the scenes, the Studio creates the corresponding XML definitions for your application.

StreamSQL

  A SQL-like text language for coding StreamBase applications that are functionally equivalent to graphical EventFlow applications. StreamBase Studio includes a StreamSQL editor that facilitates writing StreamSQL applications.

### T

TIBCO Subscriber Cloud (TSC)

  A collection of services that manage authentication and authorization of TIBCO cloud offering subscribers.

Tropos

  TIBCO's cloud service layer, responsible for mediating between TIBCO cloud offering tenants and third-party cloud platforms such as Microsoft Azure and Amazon AWS.

tuple

  A set of data, associated with an event message, that is allowed to flow through a stream. A tuple is composed of one or more fields; each field is a name-value pair. Each tuple must conform to the stream's schema, which specifies permissible names and data types.

tuple expression

  A StreamBase expression that constructs a tuple. For example, `tuple("New York" as City, 72.8 as temperature, 50 as humidity)`. Named schema constructors take tuple expressions.

tumbling window

  Windows in an Aggregate operator whose open (advance) and close (size) values are the same; tumbling windows do not overlap.

typecheck

  A determination that tuples output by one operator have the schema required to be processed by the operators to which they are routed. Typechecking also includes validation of the operator's properties, including the syntax of the XML elements that define the properties. This validation is done because a user may have edited the EventFlow file's XML directly.

type coercion

  Type coercion can occur when a function expects an argument of one data type but is given a value of a different data type. The given value is automatically converted to the expected type. Coercion occurs only between specific types. For example, all types can be coerced to string, and some numeric types can be coerced into one another. The value `null` can be coerced into any type.

type conversion

  Type conversion is an explicit action by a user to convert from one type to another, using a type-constructor (in the API) or a StreamBase function (in expressions). For example, the expression

      string(42.67)

  creates a string with the value `42.67`. Type conversion is legal for many more pairs of types.

type supersetting

  Type supersetting occurs when the system is presented with two types, and comes up with a common supertype. This occurs in the Union operator, for example.

### U

UDA

  User Defined Aggregate, an aggregate function that you can define and use in an Aggregate operator.

UDF

  User Defined Function, a function that you can define and use in any EventFlow expression in StreamBase, such as in a Map or Filter operator.

Union operator

  An operator that merges two or more input streams of tuples - which must have the same schema - into a single stream in the order they arrived.

upstream

  Any operations that occur before the current operator in the stream of data flow. See downstream.

### V

view

  In StreamBase Studio, a view is one of the smaller windows within a perspective that facilitates the completion of a specific task.

### W

window

  A sampling of tuples from an input stream that provides a tailored view of the data. Several operators, including Aggregate and Join, perform their operations on windows, and provide parameters that you can use to control the behavior of windows. Windows can be defined over attribute values or numbers of tuples, and can be grouped by one or more input fields. To determine the rate at which windows advance over a data stream, they can be bounded by a maximum number of tuples, by time, or by a range of values in a field.

workspace

  An area of the file system containing projects, application files, and metadata used to manage StreamBase projects and sessions. You can have multiple workspaces, each focusing on a different area of development.