StreamBase New and Noteworthy Archives

As a consequence of a third-party software update that improves database performance, the on-disk format for disk-based Query Tables was changed for release 7.5.0.

In previous release, if the schema of a stream in a hygienic inner module did not match that of the containing outer module, StreamBase would attempt to rectify the mismatch and proceed without issuing an error. In some situations, however, this could cause ArrayIndexOutOfBounds exceptions. Starting with release 7.5.0, if the schemas do not match, you receive a typecheck error saying so.

The default time format for the CSV File Reader, CSV File Writer, CSV Socket Reader, and Bi-Directional CSV Socket Reader adapters was changed to use 24 hour time instead of 12 hour time. The former default format was:

yyyy-MM-dd hh:mm:ss.SSSZ

The new default format is the following, with the hours field now uppercase:

yyyy-MM-dd HH:mm:ss.SSSZ

This change only affects new instances of these adapters.

The StreamBase Studio authoring preference Hide Control to toggle to/from text fields in Java Operator Properties, introduced in release 7.4.2, is now disabled by default. This enables by default the small T icon () that appears next to controls that can accept a parameter, including check boxes, radio buttons, and drop-down menus in the Properties view of Java adapters and custom Java operators.

A Framework is a package of StreamBase modules, interfaces, and schemas that simplifies creating and deploying StreamBase solutions for a specific vertical market. In previous releases, Frameworks were delivered as a separate download with a separate installer that integrated the Framework into StreamBase Studio.

Starting with release 7.5.0, Frameworks now ship as a fully integrated part of the base TIBCO StreamBase® package. As before, you load a Framework into StreamBase Studio much like loading a sample, using File → Load StreamBase Framework.

UPDATE: In release 7.6.5 and later, documentation relating to the Trading Components Framework was moved from the StreamBase documentation to the TIBCO Component Exchange.

The first Framework to be integrated into the base StreamBase package is the TIBCO StreamBase® Trading Components Framework, which simplifies the creation of foreign exchange (FX) trading applications. This Framework provides a set of modules and schemas that include market data handlers for 15 FX venues, and execution handlers for 13 FX venues. This Framework greatly simplifies the configuration of FX handlers by providing uniform interfaces and schemas, and providing appropriate defaults for as many properties as possible. The Trading Components Framework includes documentation integrated into Studio Help, a full set of samples, one for each venue, and a command line administrative tool to manage handlers at runtime.

For convenience in the SB Test/Debug perspective, a Create StreamBase Unit Test link was added just left of the Clear button in the Application Output and Application Input view. Like the New StreamBase Unit Test button (), clicking the link starts the StreamBase Unit Test Class wizard with defaults set to include tuples currently in those views as the starting point for your new unit test.

An updated TIBCO ActiveSpaces connectivity solution provides a set of operators to connect to a TIBCO ActiveSpaces® Metaspace and Space and to allow your StreamBase application to exchange tuples seamlessly with the Space. The updated TIBCO ActiveSpaces operator consists of seven separate operator actions:

Noteworthy enhancements include:

For more information, see Using the TIBCO ActiveSpaces Operators in the Authoring Guide. The previously-existing ActiveSpaces operator, now called the TIBCO ActiveSpaces Legacy operator, is deprecated as of this release, but is still available.

In Map and other operators with field grids, it is now possible to reference a field that you add to an output grid in subsequent output expressions, using the modifier output.fieldname. Previously, doing this caused the typecheck error "the field <added-name> is not available from any stream". Now, added fields are treated much like included fields and declared variables in expressions.

In previous releases, the EventFlow debugger did not support conditional breakpoint expressions that included constants and dynamic variables. You can now use dynamic variables, named schemas, and other module constants in a conditional breakpoint expression.

You can now override an existing input field in an output grid with a declared variable of the same name. Studio warns you about the ambiguity, but uses the declared value as specified. To refer in an expression to the existing field, instead of to a declared variable with the same name, qualify the existing field name with either an input.name or input1.name prefix.

In the Aggregate Functions tab of an Aggregate operator, you can now specify a local variable name for aggregate expressions as well as simple expressions, using the Declare action in the Action column's drop-down list. The DECLARE keyword in StreamSQL also now accepts aggregate expressions.

The schema for StreamBase Server configuration files has a new element, <constants-overwrite>, which is an optional container for one or more <constant-overwrite> child elements. Use these elements to specify new values at run time for constants defined in an application's modules. The values so specified are initialized at run time. For example, you can replace the value of a constant that specifies the name of a file that an adapter or Java operator uses during development with a file name to be used when the application is deployed.

For details, see <constants-overwrite> in the StreamBase Server Configuration File XML Reference.

In addition, a new Java system property, streambase.sbd.allow-overwrite-constants, with a default value of true, provides control over whether constants are allowed to be overwritten at runtime.

The StreamBase Server configuration file schema has another new element, <adapter-configuration> described, with an example, in the Server Configuration File XML Reference. This element can contain arbitrary child elements and values, as long as they are valid XML. Use this element in conjunction with the new Java class ConfigurationChooserPropertyDescriptor described below to allow developers to provide variable, menu-based configuration options in the Properties view of custom adapters and operators. The property descriptor allows developers to specify an Xpath expression that retrieves the contents of child elements placed in an <adapter-configuration> element, and to build a property choice menu at run time from the retrieved elements.

Use this feature to provide adapter and Java operator property settings that can be configured globally across a project to have sets of specific default values that are easily modified by the end-user. By including appropriate Java code and configuration file elements in a project, developers of a custom adapter or operator can allow end-users to select configured property values from choice menus and, once selected, a property can constrain the choices available for other properties. Run the Configuration File Access Sample to see how to add a property chooser that works this way.

You can now determine whether two lists have values in common and which items they are:

The input lists can be of different lengths, but must contain the same data type.

To enable use of the join() function in StreamSQL or LiveView LiveQL contexts without using escaped identifier syntax, the alias joinlist() was added to the expression language. joinlist() takes the same arguments as join() and behaves identically. This change allows joinlist() to be used in LiveView LiveQL contexts without conflicting with the JOIN keyword, which LiveQL inherits as a reserved word by borrowing its parser from StreamSQL. The joinlist() name is an alias for both simple and aggregate versions of join().

When expressing the values of a tuple or list in a tuple literal or list literal expression, or when using the list() or tuple() casting functions, you can now place one (but only one) trailing comma following the last field in a tuple or last item in a list. StreamBase now accepts but ignores such trailing commas. This is a convenience feature that allows you to leave a comma in place so that quickly added new list members or tuple fields are valid whether or not you remember to prepend the new items with a comma. The following examples are now valid in StreamBase expressions.

list(1,2,3,)
tuple("aardvark" as a, "blogosphere" as b,)

The new sb-trading-components-admin command line utility for the Trading Components Framework lets you identify all instances of handlers running on a network, and provides a way to send commands to one or all handlers using JSON over UDP. The tool lets you interactively ping venues, list current connections and subscriptions, subscribe, and unsubscribe, among other common administrative tasks.

Optional timestamp arguments were added for the sbc deq[ueue] and jsbc deq[ueue] commands, which can take a format string as an optional value:

If the format string is omitted, the format defaults to "YYYY-MM-DD HH:mm:ss.SSS[+/-]TTTT (such as 2014-07-02 13:50:50.8-0400).

The new Java class ConfigurationChooserPropertyDescriptor extends SBPropertyDescriptor, and enables applications to extract adapter and Java operator property settings from a server configuration file. See the Javadoc for details about the new class, which allows developers to specify an Xpath expression that retrieves the contents of child elements. This class supports the new feature described above that allows developers to provide variable, menu-based configuration options in custom adapters and operators.

In previous releases, when given null values for arguments that expect a primitive type, custom functions silently returned nulls. As of this release, you can be notified about null arguments via console warnings. You can optionally set a system property to cause the operator that invoked the function to emit a tuple on its error port. For details, see Method Parameter and Return Types on the Creating Custom Java Functions page of the API Guide.

A new property descriptor (setTextWidth(UIHints.TextWidthHints.SIZE), where SIZE can be SHORT, MEDIUM,or LONG) is a UIHints method that lets programmers specify the widths of text fields, drop-down list items, and text in other Properties view controls. Formerly, text fields had a fixed size.

You can now pass arrays and lists to your custom Java aggregate functions, and they can now accept variable argument lists.

The new TIBCO StreamBase® File Monitor adapter monitors the file system for changes to directories and files. When files are created, modified, and deleted within the scope of a specified path, the adapter emits tuples describing the event.

It is now simpler to use StreamBase applications to serve and respond to Web pages. The new TIBCO StreamBase® Web Server Request adapter and the TIBCO StreamBase® Web Server Response adapter work together to service HTTP and HTTPS requests. Using an embedded Jetty web server, the adapter set enables StreamBase applications to respond to HTTP and web socket requests from external HTTP clients. For details, see Web Server Request Adapter and Web Server Response Adapter.

The new TIBCO StreamBase® 29West LBM Subscribe ACK Output Adapter enables a StreamBase application to acknowledge incoming LBM messages based on a topic and sequence number by performing an ACK operation when explicit ACK is enabled.

Because of a change in 29West's ownership, the 29West adapters are now provided as the TIBCO StreamBase® Adapters for Informatica Ultra Messaging:

The new property Set undefined numeric values to zero allows the TIBCO StreamBase® Adapter for Activ Financial to disambiguate unchanged data from missing data.

Previously, when the value of a field in an incoming update message changed from defined to undefined, the adapter set that field's value in the resulting tuple to null. But fields missing in the update message are also set to null to indicate that the field's value has not changed since the last update. To enable applications to differentiate between undefined fields and unchanged fields, the new property was added to the adapter to cause it to set undefined numeric fields to 0 instead of null. By default, the property is not selected, which preserves the adapter's legacy behavior.

The TIBCO StreamBase® Adapter for JMS reader now partially supports CLIENT_ACKNOWLEDGE, TIBCO EMS' EXPLICIT_CLIENT_ACKNOWLEDGE and Apache ActiveMQ's INDIVIDUAL_ACKNOWLEDGE. If one of these modes is selected, the adapter will wait until the tuple is fully processed by the application before acknowledging the message. The StreamBase application cannot trigger an explicit acknowledgment of the message.

The LiveView Query adapter now optionally supports the new LiveView multiconnection failover client API.

Rather than requiring that you type a path for to specify a File Name property, the following adapters now have a file chooser that lets you select a file name from available resources:

The XMLToTuple and TupleToXML Java operators now have an option to disable their status port should that flow of tuples not be of use. By default, the port is enabled, maintaining compatibility with previous releases.

A new set of 16 sample applications demonstrate various ways to use the Trading Components Framework. Each market data handler and execution handler has its own sample, plus one sample that demonstrates connecting to multiple venues. Eight of the samples are packaged with market data emulators that supply fictitious market data, and thus do not require connections to live data feeds to run. See the StreamBase Trading Components Framework Samples in the Samples Guide.

A sample for the new TIBCO ActiveSpaces® operators configures all seven operator actions in one application. For information about the new operators, see Using the TIBCO ActiveSpaces Operators. See TIBCO ActiveSpaces Operator Sample for instructions on running the sample. The same sample contains an application to illustrate the legacy ActiveSpaces operator.

The TIBCO StreamBase® File Monitor adapter sample illustrates using the adapter to watch a user-specified directory. Each time a file is created, modified, or deleted in that directory, the adapter emits a tuple that describes the change.

The Configuration File Access Sample illustrates how custom Java operators and adapters can pull property values from a server configuration file, providing greater flexibility to deploy applications in different environments.

To clarify slight behavior changes in release 7.5.0, the new Field Grids Sample shows how to avoid or resolve conflicts, ambiguities, and typechecking errors related to including and adding fields with name conflicts and related usage of declared local variables.

Taking as input a stream of recorded events from Wikipedia reporting edits made to actual articles, this application tracks the most-edited articles and the most active authors, and issues alerts when the same article is edited more than once within a given period of time.

Illustrates how retailers can analyze customer preferences to stimulate sales by analyzing streams of order data to issue coupons to customers for similar or related items they purchase. Coupons can be added, deleted, and modified according to changes in inventories and buying behavior.

Shows how manufacturing and process industries can use data streaming from multiple sensors to monitor the health of equipment. The application converts units of measurement for temperatures and pressures, outputs the transformed data, and alerts operators if values exceed prescribed thresholds.

This demo uses the same captured, anonymized data from Wikipedia as the Edits Tracker demo above, but then streams that data into TIBCO Live Datamart data tables. The demo goes on to start an instance of LiveView Desktop, which analyzes the incoming data, displaying the results in two tables and on a US state map, showing the state where each anonymous edit is being made. Instructions are provided to connect the demo to a live Wikipedia feed.

This demo has long been a part of StreamBase Studio, but may have only appeared in installations with certain configuration options. As part of the merger of TIBCO StreamBase and TIBCO Live Datamart, this demo now appears for all users.

On all platforms, installing TIBCO StreamBase with integrated TIBCO Live Datamart also installs an embedded copy of Oracle JDK, version 1.7.0_u71, for private use by StreamBase products. 64-bit platforms get a 64-bit JDK; on Windows platforms, installing the 32-bit StreamBase Studio overlay also installs a second JDK, the 32-bit version of 1.7.0_u71.

The embedded JDK is used to launch StreamBase Server, StreamBase Studio, LiveView Server, and all StreamBase and LiveView applications. As before, you can override this installed default to use a different supported JDK, as described in Using an External JDK.

The Java Client Libraries for StreamBase and LiveView are fully compatible with Java 7, and we recommend using Oracle Java 7, preferably 1.7.0_u71 or later, to compile and run your own client applications, custom function, custom adapters, and monitoring applications. The Java Client Libraries themselves are compiled with target set to Java 1.6 to maintain compatibility with certain third-party libraries.

TIBCO Liveview Desktop has independent Java requirements, as described in the TIBCO Live Datamart New and Noteworthy.

As before, TIBCO supports and recommends a customer-installed instance of Azul Zing 5.10.x for deployments of TIBCO LiveView servers on Linux x86_64 platforms when large heap sizes are required. Contact Azul Systems to obtain and license Zing for LiveView. When Zing is installed in its default location, LiveView Server detects and launches with it by default.

For release 7.5.0 and later, StreamBase Studio is now based on Eclipse 4.4.1. When installing Studio in the form of plug-ins for your independent copy of Eclipse, the provided plug-ins are compatible with Eclipse 3.7, 3.8, 4.2, 4.3 or 4.4. We strongly recommend starting with the latest Eclipse 4.4.x.

Eclipse 4.4 uses an upgraded format for workspaces. StreamBase Studio automatically upgrades existing workspaces when you first use them following installation. For this reason, we strongly recommend preserving a separate backup of your existing workspaces, in case you need to open them in an earlier Studio release to maintain an existing application.

Support for running StreamBase Server on Solaris Intel X86_64 now requires Solaris 11, which replaces the former support for Solaris 10.

For development workstations, all TIBCO StreamBase products for Microsoft Windows now require Windows 8.x Professional, Windows 7 Professional, or Windows Vista Business. For Windows Server platforms, StreamBase requires Windows Server 2008 or Windows Server 2012, and their R2 variants. Support for Windows XP and Windows Server 2003 was removed.

The Windows Start menu now lists all installed TIBCO products within a new TIBCO folder. Earlier installed releases of StreamBase software are still listed separately on the Start menu. For more, see The Windows Start Menu.

This release adds support for using Microsoft Visual Studio 2012 to build StreamBase client applications using C++, and support for using Visual Studios 2012 or 2013 when using a .NET language.

This release removes support for using Microsoft Visual C++ 7.1 (part of Visual Studio .NET 2003) or Visual C++ 8.0 (Visual Studio 2005) to build either StreamBase clients or custom functions. To build custom functions, you must now use Visual Studio 2010. For more information, see Configuring Visual C++ in the API Guide.

TIBCO StreamBase 7.5, TIBCO® Live Datamart 2.0, and TIBCO LiveView Desktop 2.0 are all supported on Macintosh OS X versions 10.7 (Lion) through 10.10 (Yosemite). This release removes support for running on OS X 10.6 (Snow Leopard). The support for OS X 10.10 (Yosemite) is provisional because of an installation issue.

Some previous StreamBase releases had an installation incompatibility with 10.10 Yosemite that resulted from an Apple bug that prevented opening certain DMG installation archives, including TIBCO StreamBase installers. Recent StreamBase releases worked around this issue. Contact StreamBase Technical Support if you encounter a long hang when running an older StreamBase installer on MacOS Yosemite.

The OS X installation page now recommends dragging your TIBCO StreamBase product folders from their DMG installers to $HOME/Applications, a folder in your home directory, and not to the system /Applications folder at the root of the disk. This new location avoids the possible permissions problems previously encountered when installing add-on packages such as the Connectivity Package.

The StreamBase and Live Datamart documentation sets were integrated in a way that makes it easy to switch back and forth between them. Two-way cross-references allow links in each set to jump to pages in the other. This linking of both documentation sets occurs in both website and Eclipse Help formats.

Reference pages for the lv-client and lv-server command line utilities are now found with the StreamBase command documentation.

The Javadoc for the StreamBase Client Library now includes pages for the LiveView Client Library as well. Likewise, the .NET documentation describes classes for both libraries. You can still open the Javadoc and .NET documentation from either StreamBase or LiveView starting points, but now the results are the same.

The page Using the Help System was updated to describe related help features and to display images of the latest versions of documentation in Eclipse and online.

The Live Datamart New and Noteworthy describes further changes to the LiveView documentation.

If one EventFlow application references a second EventFlow application in the same subfolder within a project, you must add the subfolder to the module search path in order to run the referencing application. One symptom of failing to do this is receiving a "module not found" message from the debugger when attempting to step into a referenced module. This behavior differs from StreamBase Studio 7.3.x and previous releases, in which the referencing application would start without the subfolder being added to the module search path.

The iterate operator has the following new features

Operators in existing applications still run as expected. For details, see Changes to the Iterate operator.

For details, see Changes to the Aggregate Operator, below.

For details, see Changes to the Gather Operator, below.

For details, see Changes to the Metronome and Heartbeat Operators, below.

For details, see Changes to Query Tables, below.

To make them more transportable, StreamBase projects have a new option, Automatically update/maintain server configuration files, found under Project → Properties → StreamBase → Project Configuration. Under this option, StreamBase Studio automatically updates configuration files containing settings that StreamBase Server may require to run the project. This feature is particularly useful for sharing projects, for example via a source code control system, in a ready-to-run state. New projects use this synchronization feature by default. To apply it to existing projects (highly recommended), select the option in the project properties dialog, as described above. For more information, see How Studio Uses Server Configuration Files.

The Copy Schema wizard, available from Edit Schema tabs and dialogs, now enables you to:

The wizard can infer data types in many cases and defaults to string when it cannot do so. You can always change the resulting field names and data types that the wizard produces. For more information, see Copying Schemas.

You can create feed simulations for an input schema more easily now by right-clicking on an Input stream and choosing Create New Feed Simulation from the context menu. The feed simulation editor initializes with the selected schema in place. If you select more than one input stream, the feed simulation editor will initialize with a separate stream for each selected input schema.

When creating a feed simulation from a CSV file, the Feed Simulation Editor now can match column headers to field names even when they are ordered differently. Fields of type tuple can have subtuple values out of order in the CSV file as long as its column headers use fully qualified names (using dot notation, e.g. Price.Open and Price.Close) that match or closely approximate field names. You can still reassign columns to fields in the Data File Options Dialog if the editor makes matching errors.

The Custom feed simulation option has a new Conditional Generation Method. Selecting it for a field lets you specify generation cases for that field that are based on values generated for another field or a combination of fields. You can base conditional fields on other conditional fields, as long as there are no circular dependencies. For more information, see Using the Feed Simulation Editor.

By appropriately naming feed simulation streams and configuring a .sbdeploy file, you can now direct its streams to different containers, not just the default containers.

Expressions are now allowed as Java operator parameters. Any operator parameter that starts with an = character (equals sign) is parsed as an expression at initialization time. Not "baking in" Java operator parameters enables applications to be deployed into a wider variety of runtime environments.

When you add a field to a schema for a stream or operator in StreamBase Studio, its data type now defaults to string. Previously, new fields defaulted to type int.

You can now undo and redo changes you enter in a module's Parameter Definition tab for the following actions:

The Debug Configuration dialog now includes a Source (Java) tab, which defines the location of source files used to a display source when debugging Java code as part of your StreamBase application. By default, these settings are derived from the current project's Java Build Path. You can override the default settings in the Source tab.

The Open Module Instance item on the Extension Point context menu now has a sub-menu for directly opening any of the associated module instances. You can also access the sub-menu from the EventFlow menu or by pressing Shift+F3 while an extension point is selected.

Use the General tab of the Properties view for an Extension Point operator to specify a custom icon for that operator to appear on the EventFlow canvas. Icon image files must be in PNG, GIF, or JPG format, and must exist in the project's resource search path. Size your image file as appropriate to fit on the canvas without displacing adjacent operators, aiming for a recommended size of no more than about 64x64 pixels. See Extension Point Operator, and the ExtensionPoint.sbapp sample in the operator sample group for an example of an extension point with a custom icon.

When you delete an operator, adapter, stream, arc, note, or module from the EventFlow canvas, you are no longer prompted to confirm the action. You can undo any such removal, whether you have deleted one or multiple objects.

Tooltips shown while hovering over a module reference in StreamBase Studio now show parameter substitutions and how input and output streams are mapped, in addition to the module's name. Previously, you had to open the referenced module to obtain this information.

You can now control the passing of time in EventFlow applications, which is useful when running unit tests of applications that react to time (timeouts or metronomes for example). You can, for example, run a unit test, enqueue events that should all be received by the application within one second, and then tell the server that one second has elapsed, aligning the EventFlow logic more closely with a real-world input stream.

Several Java classes and interfaces and a new enum have been added to provide this control. For more information, see Using the StreamBase JUnit Timeservice in the Test/Debug Guide.

The following updates were made to the Aggregate Operator:

The flexibility and usability of the Gather operator has been enhanced in several respects:

Operation of the timeout feature is demonstrated in an updated Gather sample.

Iterate operators in existing applications should continue to work normally. For more information, see Using the Iterate Operator.

You can now merge data from more than two input streams. The Merge Settings tab now allows you to choose or enter the number of input ports to merge from. You can also drag an arc onto the operator to add an input port.

To prevent the Metronome operator from issuing multiple tuples following delays in servicing it, you can now suppress all but the latest tuple. Select the new check box Drop tuples delayed longer than the output interval in situations where downstream operators or applications that consume output streams are unable to keep pace with the metronome. This can occur when its output interval is very short.

You can now prevent a Metronome operator from firing by setting the value of its output interval to 0.

Both the Metronome and Heartbeat operators can now accept constant expressions in addition to strings and parameters to define their output interval (and the Heartbeat Maximum delay property).

For migration information about data constructs, see EventFlow Editor 7.4 Changes. The Query Table UI is documented in Using the Query Table Data Construct.

When using a Query operator associated with a JDBC Table data construct, if a reconnection to the data source becomes necessary, a tuple is now emitted on the Error Output Port of the Query operator with the message Attempt reconnect to data source. When the reconnection succeeds, another tuple on this port reports Success reconnecting to data source.

The JDBC Table data construct now has a hyperlink labeled configure sources on the Data Source tab of its Properties view. Use the link to open the project's server configuration file. If no configuration file exists for the current project, clicking this link opens the New StreamBase Server Configuration File dialog to create a new, empty configuration file. See Using the JDBC Table Data Construct.

You can now place a Sequence Identifier in any suitable numeric field from the input stream rather than having to declare a new field to hold it.

Starting with this release, when you delete an arc entering a Union operator, or you delete the component immediately upstream of such an arc, the corresponding input port is automatically removed from the Union operator, and the count of input ports on the Union Settings tab of the Properties view is decremented.

Four related properties added to the XML-to-Tuple operator provide greater control over converting XML elements to fields:

See Using the XML to Tuple Operator in the Authoring Guide for more information.

You can now forward declare most arcs, not just those in loops, using the same UI as for Output Streams. As before, you can use this to break loops, but now it also works for other purposes, such as reordering fields.

Version 7.4 gives you a choice of two themes for displaying canvas objects, "Flat" and "Classic". The two Query operator icons below illustrate the difference in appearance between the themes.

Classic	Flat

The new Flat theme is the default. To revert to the Classic theme, navigate to Window → Preferences → StreamBase Studio → Authoring → EventFlow Rendering and click the Classic button under Theme.

For a complete comparison of Studio icons, see EventFlow Editor 7.4 Changes.

There is now a single palette icon for adding a Java operator, .NET operator, Input adapter or Output adapter to an EventFlow canvas. It works the same way as the adapter and Java operator palette icons in earlier releases of StreamBase Studio; you drag it to the canvas and pick a specific operator or adapter from a pick list. The new icon looks like the following:

For further information, see EventFlow Editor 7.4 Changes.

To more clearly depict how Query operators use Query tables, StreamBase Studio now renders all such connecting arcs as follows:

The styles are illustrated in Using the Query Operator.

You can introduce curves into a stream arc by selecting it and dragging a black square handle that appears at the arc's midpoint. Displacing that point adds an inflection point and also two new handles on either side of it, which you can then displace to approximate a curve. To remove an inflection point, click and drag it back to a straight-line position. Moving either object that a curved arc connects removes all inflection points. You can still curve arcs automatically using the Reroute Arcs feature (Ctrl+Alt+L). Both features only affect stream arcs. Data arcs are always straight.

You can now disconnect a note from a component and connect it to other components after the note has been created. In addition, a tool tip displays the content of a note when you hover on a connection to it. See Using Notes for details.

The color chooser for setting group backgrounds now has a more harmonious palette of recommended choices for custom colors. You can still define your own background colors.

You can now implement vararg syntax in custom simple and aggregate Java functions that you invoke with calljava or with a function alias.

EventFlow lists and lists of lists of numeric types are now transparently passed to plug-in Java functions as Java arrays, improving efficiency and interoperability with mathematical libraries. As a result, you can pass a StreamBase list to a Java function. This enhancement also allows you to pass lists of lists to functions expecting array arguments. For example, list(list(int)) can be passed to functions accepting int[][]. Note that array arguments cannot exceed two dimensions. See Method Parameter and Return Types in Creating Custom Java Functions.

In previous versions, StreamBase generated internal names for streams with anonymous (unnamed) schemas, names such as "schema:InputStream". These generated names have been eliminated, and can no longer be relied upon for client API requests of schema by name, such as StreamBaseClient.getSchemaByName(String) (or similar C++, .NET, and Python APIs, and the sbc list schema command). To find the schema of the stream, request the stream properties based on the stream name.

Two new methods in the Operator class have been added that identify schemas that may be appropriate for input and output ports:

String argument mainName specifies the prefix for the top level schema, which should also be used for any sub-field schemas.

The methods check for applicable named schemas and return arrays of type Schema that StreamBase Studio can suggest to the user for configuring input and output ports, respectively. When a custom operator or adapter implements the API, users editing adapter properties can import schemas to a project. When an adapter is so enabled, StreamBase Studio presents a hyperlink labeled Import proposed schemas to allow schemas to be imported into interface or application files. For example, the FileReader input adapter has that link at the top of its properties view, as shown in this illustration.

Click the hyperlink to open the Save Named Schemas dialog displaying the schema(s) you can import from an existing EventFlow or StreamBase Interface file or from a new interface file.

Most embedded input adapters are equipped with this feature.

StreamBase APIs that parse timestamps from strings have new methods that accept a Java DateFormat to assist in parsing. If you find that existing code which worked before no longer parses certain strings, update it to use these new APIs. Specifically, should parsing errors like "Invalid timestamp format" occur, look for methods that accept Java DateFormat arguments and make sure the arguments you are passing conform to that format.

sbcipher, which enciphers text or generates cipher keys for configuration files, has a new command line option:

The --prompt option prevents sensitive text from appearing in your session history. For details, see documentation for sbcipher.

Instead of using sbunit -f config-filename When running unit tests, you can specify the path to the .sbconf file the test should use with either the Java system property streambase.unit-test.server-conf or the environment variable STREAMBASE_UNIT_TEST_SERVER_CONF.

The TIBCO StreamBase® Adapter for TIBCO Enterprise Message Service™ allows a StreamBase application to connect to TIBCO EMS servers and exchange JMS messages. Note that unlike JMS adapters, which can connect to any number of JMS providers, the EMS adapters only enable connections to TIBCO EMS servers.

A Share data transformer option has been added to the TIBCO StreamBase® Bi-Directional Socket Writer adapter, enabling it to use the same data transformer as the socket reader. Sharing maintains the state of the transformer between read and write operations.

Some adapters can only be instantiated once and thus cannot run concurrently. All such adapters now suppress the Concurrency tab in StreamBase Studio to prevent configuring multiple instances of them.

The Results grid in the Thomson Reuters Schema Designer view now has an In Summary column, which for each FID row is either blank or contains Yes. Use this column to help select fields when generating a schema for a summary-only tuple. See Thomson Reuters Schema Designer View.

In addition, the RFA.jar library has been updated to version 7.5.1.

StreamBaseFIX engine is renamed to TIBCO StreamBase® High-Performance FIX Engine and is available for separate download. This engine is required to run FIX adapters using FAST (FIX Adapted for Streaming) protocol.

The FXQuoteDataSchema has been updated to included an extra field named OptionsExtendedData, which is used by the CitiFX Options Vol market data handler. The FXQuoteDataSchema is used by FXTopOfBookSchema and FXDepthOfBookSchema.

StreamBase, LiveView and external adapter installers available from download.tibco.com have new names. See the above note for details. Specific platform file names are described in the Installation Guide.

This release of TIBCO StreamBase CEP fully supports the Windows 8 operating system.

TIBCO StreamBase CEP is no longer distributed for 32-bit Linux.

StreamBase Studio no longer installs libraries for Microsoft Visual Studio 2008. If you use the Python interfaces for ActiveState or the python.org Python implementations, they will include the appropriate libraries. Visual Studio 2008 also installs these libraries.

StreamBase Server now ships with and runs from a Java 7 JRE. For the first time, Java is included with StreamBase on Mac OS X. Java from Apple or Oracle need not be independently installed. On all platforms, the sb-config Java options return paths to the bundled JDK (the /jdk directory under the StreamBase installation directory). For Mac users, this means you no longer need to obtain Java from Apple.

StreamBase Studio now ships with the default Java Compiler Compliance Level set to 1.6, the minimum level when developing Java code for StreamBase projects. If you install Studio as plug-ins to Eclipse, ensure that Java code developed for StreamBase server target Java 1.6. Users of Java 1.5 must upgrade to 1.6, as StreamBase no longer supports JDK 1.5.

You can now use StreamBase Studio with working copies managed by Subversion 1.8 as well as prior Subversions.

The StreamBase .NET API now enables EventFlow functions to be passed to .NET applications. As a result of this update, .NET clients will no longer run under the .NET 4 Client Profile (the "lite" version). You will now need to:

StreamBase Studio ships as a product built and bundled with Eclipse 3.8, but the plug-ins are now compatible with Eclipse 4.3. Install StreamBase Studio into Eclipse 4.3 by following the instructions in the StreamBase Studio Eclipse Update Site page.

The EGit Eclipse plug-in provides seamless access to files managed by the Git version control system, including projects hosted on the Github repository. EGit documentation is now included as part of the Studio Help system. EGit joins CVS and Subversive as the three team provider version control plug-ins included with Studio.

The StreamBase sample Calling an Embedded StreamBase Server from Java demonstrates running a StreamBase embedded in a running Java program, and contains an Eclipse cheat sheet that opens when you import the sample.

The StreamBase sample Shared Tables Across Containers Sample illustrates how you can access a common table from separate containers, both for reading and writing.

To illustrate the new function data type, the StreamBase sample EventFlow Function Sample demonstrates how an application can define functions in the StreamBase expression language in operators and as constants.

The StreamBase sample Feed Simulation Conditional Field Sample shows how to generate fields in feed simulations whose values depend on the contents of one or more other fields.

The StreamBase sample Java Operator Complex Types Sample shows how to use the StreamBase Client API to retrieve fields and values from complicated structures such as nested tuples.