StreamBase New and Noteworthy

Documentation updates: some pages in the Adapters Guide, although present in the documentation kit, had incomplete navigation links, and were thereby difficult to locate. This was corrected.

The StreamBase Wombat MAMA Input Adapter was extended with the following features. For the full implementation details on these features, see StreamBase Wombat MAMA Input Adapter in the Adapters Guide, which was updated for the 3.7.10 release.

A new tag for the StreamBase External Adapter for Microsoft Excel: the LOCALFILTER tag performs client-side routing of tuples to spreadsheet cells and should be used instead of the FILTER tag when no real server-side filtering is being done. For more information, see the External Adapter for Microsoft Excel topic in the Adapters Guide.

The following changes were made to the CSV File Reader input adapter:

See the CSV File Reader Input Adapter topic in the Adapters Guide for details about these features.

Previously, the StreamBase-to-StreamBase input adapter did not provide a way to specify port numbers. You can now use adapter properties to specify both upstream and downstream ports, making deployment and maintenance more flexible. See the StreamBase-to-StreamBase Input Adapter topic in the Adapters Guide for details.

This release includes a new embedded input adapter for Opentick data sources. This new adapter is described in the Adapters Guide, and a new sample in $STREAMBASE_HOME/sample/adapter/embedded/opentick shows how to use the adapter.

Support was added in the JDBC Operator to optionally output null tuples when a database query returns an empty result set. For 3.7.7, this option is implemented in EventFlow diagrams in StreamBase Studio, but not in StreamSQL or the StreamSQL Converter.

The new feature is seen in the Property view of a Query Table icon that's associated with a JDBC Table icon. In the Query Settings tab of the Property view, there is a new Options line with a checkbox labeled Output null tuple on empty Result Set.

This option only has meaning when the SQL statement field contains a SELECT query. When this checkbox is cleared (the default setting), empty results from the SELECT are discarded. When checked, empty results from the SELECT generate a tuple with the same schema as the output of the query operator, with null values for each field.

Support was added in the JDBC Operator to control behavior when a JDBC connection between the StreamBase server and the database server is lost. Three new data-source configuration parameters implement this control; in their absence, the default behavior for a connection loss is for the StreamBase server to display an error message and exit with error status.

The new parameters are:

They are used in your project's sbd.sbconf file as shown in the following example:

<streambase-configuration>
  <data-sources>
    <data-source name="msql-dev1" type="jdbc">
      <uri value="jdbc:mysql://dbserver:3306/qa?user=username&password=secret"/>
      <param name="jdbc-reconnect-regexp" value="Communications link failure"/>
      <param name="jdbc-reconnect-regexp" value="Connection reset"/>
      <param name="jdbc-reconnect-attempts" value="5"/>
      <param name="jdbc-reconnect-sleep" value="250"/> 
    </data-source>
  </data-sources>
  </streambase-configuration>

If a connection is lost between the StreamBase server and the database server, the next attempted JDBC operation returns an error. There are no standard error codes (or SQLSTATE) for communications failures, so to detect these errors, we must parse the text of the database-specific error messages. Use the jdbc-reconnect-regexp parameter to specify a regular expression to be compared to any received error messages. If one or more specified string is matched in the text of any error message, the StreamBase server assumes a communications failure has occurred, and attempts to open a new connection to the database server.

You can specify more than one jdbc-reconnect-regexp parameter to specify several error message strings to be considered communications failures. Each specified string is compared in order to the received error message text.

The jdbc-reconnect-attempts parameter controls the number of reconnection attempts a StreamBase server will attempt. If the connection to the database server is lost, the configuration example above attempts to establish a connection to the databse server five times. If five connection attempts fail, an error message is printed and the StreamBase server exits with error status. If a connection is reestablished to the databse server, and then the connection is lost some time thereafter, the reconnection count is reset so that five attempts to reconnect will be made again.

A jdbc-reconnect-attempts value of -1 specifies that the server is to continue reconnection attempts without limits. A value of zero disables reconnection attempts.

If the jdbc-reconnect-sleep parameter is specified, reconnection attempts are delayed by the specified number of milliseconds. If no jdbc-reconnect-sleep parameter is used, there will be no delay between reconnection attempts.

Just like the initial connection to the database, reconnection attempts use the jdbc-timeout parameter to limit how long the StreamBase server waits to establish a connection. The default value for jdbc-timeout is 15000 milliseconds (15 seconds).

Support was added for nested tibrv messages in the StreamBase Adapter for TIBCO Rendevous. This feature is described on the TIBCO Adapter page.

Documentation Update. In the StreamBase API Guide, the Creating C++ Clients page describes the requirements for deploying C++ clients on non-StreamBase systems. The following paragraph supplements the information on that page.

Microsoft occasionally issues service packs for Visual Studio .NET. If you build a C++ client with a particular service pack version of Visual Studio, you must install the correspnding version of the Microsoft Visual C++ Redistributable package on your non-StreamBase deployment system. For example, if you build a C++ client with Visual Studio .NET 2005 SP1 (VC 8.0 SP1), you must install the SP1 version of the Redistributable package for VC 8.0.

The Flex adapter serves one or more internal StreamBase streams to Flex client applications for visualization within Adobe Flex applications.

New support for 64-bit StreamBase on Solaris 10 and Solaris 8. For more information, see the Supported Configurations topic in the Installation Guide.

New support for UTF-16 character data in StreamBase applications. UTF-16 is the 16-bit Unicode Transformation Format. It is a variable-length character encoding for Unicode, capable of encoding the entire Unicode set. The 3.7.1 release adds a new sample, utf16. It includes several short documents that contain non-Latin characters. We chose Hebrew characters, as an example. The StreamBase sample application uses custom java functions that manipulate and search for the Hebrew characters.

For details, see the utf-16_README.html file that is installed in STREAMBASE_HOME/sample/utf-16, or the UTF-16 Sample topic in the Samples Guide.

You can use a source file management product, such as Subversion, to manage the versioning of files in a StreamBase Studio project. As a convenience, starting in the 3.7.1 release, a StreamBase Studio Project view will not display files or directories that start with a period, such as .svn subdirectories, or ones marked as hidden in the file's properties on Windows. More information about this feature will be provided in a technical article on the StreamBase Developer Zone website.

The StreamBase 3.7.0 release introduced the ability to dequeue data from intermediate streams, for debugging purposes. Information about this feature was provided on the StreamBase Developer Zone website. To use the feature, you had to start the StreamBase Server process (sbd) with the -d option. In 3.7.1, you can continue to do that; or you can start the server in its standard (non-debugging) mode, provided that you set the following JVM argument to true:

-Dstreambase.codegen.intermediate-stream-dequeue=true

The default for this JVM argument is false. JVM arguments can be configured in the server's sbd.sbconf.

For details, see Debugging Feature: Dequeuing Data from Intermediate Streams, a new topic in the API Guide.

This 3.7.1 release also fixed a number of product limitations. For details, see the Resolved Limitations section of the Release Notes.

You can define parameters for an application and use them in operator expressions. The parameters can take default values that can be changed in a module reference. This makes module references more powerful, enabling you to reuse modules with different parameter bindings. For more information, see Using Application Modules in the Authoring Guide, and the CREATE PARAMETERS Statement in the StreamSQL Guide.

A new data construct, Materialized Window, has been added for EventFlow applications; for StreamSQL applications, the CREATE MATERIALIZED WINDOW statement is added. A materialized window is a managed view of tuples passing through an input stream. The view can be based on a fixed number of tuples, a time interval, or a field value. It can also be partitioned into multiple windows. You can then directly query the data using one or more (read-only) Query operators. For more information, see Using the Materialized Window Data Construct to View Data in the Authoring Guide, and the CREATE MATERIALIZED WINDOW Statement in the StreamSQL Guide.

Query operator enhancements:

For more information, see Using the Query Operator to Use or Modify Shared Data

StreamBase containers are the new building blocks for organizing and connecting multiple StreamBase applications. There is one StreamBase application per container, and each container name serves as a handle - a unique qualifier - 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.

For example, you can connect the output of one StreamBase container/application to the input(s) or output(s) of one or more other StreamBase containers/applications, all running within the same sbd. New container options exist in the sbd.sbconf configuration file, in the API, and on StreamBase commands such as sbadmin addContainer.

Note: In pre-3.7 StreamBase releases, the sbd.sbconf server configuration file used an <application-file> element. It is still supported. However, if you use containers, edit your sbd.sbconf files to use the <application> element that was introduced with the containers feature. It includes elements to specify one or more containers. For example:

<runtime>
    <application file="app.ssql" container="A"/>
    <application file="app.ssql" container="B">
       <container-connection dest="B.InputStream1" source="A.OutputStream1"/>
       <container-connection dest="B.InputStream2" source="A.OutputStream2"/>
   </application>
</runtime>

For details, start in this topic: Using Containers to Organize and Connect Multiple Applications in the Administration Guide.

There are changes to supported configurations and related areas:

StreamBase Feed Simulations are now functionally equivalent whether they are run in StreamBase Studio or by using the sbfeedsim command with a customized .sbfs configuration file. A feed simulation is no longer tied to a particular application, and a feed simulation can send test data to multiple streams. This release also includes enhancements to the user interfaces for the Feed Simulation Editor and the Feed Simulations view. The editor includes a graphical view and a source XML view of each feed simulation's .sbfs configuration file.

The XML elements used in .sbfs files have changed. Pre-3.7 feed simulations can be upgraded automatically in StreamBase 3.7 by saving the file in StreamBase Studio, or by using the sbfeedsim --convert command. The group-by and switch elements from legacy (pre-3.7) .sbfs configurations are not supported by the new Feed Simulator. However, for compatibility purposes, you have the option of using the sbfeedsim-old command with legacy feed simulations. For details, start in Using the Feed Simulation Editor, a topic in the Test/Debug Guide.

This release introduced a new layout for the Eclipse platform system that is used by StreamBase Studio. This change is incompatible with any prior saved StreamBase Studio configuration. If you see an error that StreamBase Studio (3.7.x) cannot start, go to the directory where the existing configuration data resides, and rename that directory (for example, to StreamBaseConfigurationBackup_3.5.7). You should then be able to open StreamBase Studio.

The default locations for the configuration directories are:

On Windows:
C:\Documents and Settings\<username>\StreamBase Configuration

On Linux:
<your-home-directory>/.streambase/sbstudio-configuration

The StreamBase concurrency feature has been extended. In the Properties view for most components, the option to "Run this component in a separate thread" has been moved from the General tab to a new Concurrency tab. In addition, new "Data Parallelism" options can be selected. If appropriate for your application, you can specify that multiple instances of an operator or module should be created. At runtime, each tuple is dispatched to a particular instance of the component. When configured in this way, all tuples with the same value in a field identified as the Key Expression will be sent to the same operator or module instance. Note that there are important caveats to consider. For details, see StreamBase Execution Order, Concurrency Options, and Data Parallelism, a topic in the Authoring Guide.

Aggregate expressions are more flexible. Previously, aggregate expressions could only be used in Aggregate operators and could only contain a single aggregate function.

For more information, see these Authoring Guide topics: Using the Query Operator to Use or Modify Shared Data, Using the Aggregate Operator to Apply Aggregating Functions, and StreamBase Expression Language and Functions.

A number of StreamSQL statements have been added or updated since the most recent 3.5.x release. Additions include the DECLARE statement for dynamic variables; CREATE PARAMETERS to add parameters to modules; and CREATE MATERIALIZED WINDOW to create a managed view of tuples passing on a stream. Updates include new options (related to the additions and new product features) on APPLY, CREATE INDEX, and SELECT (including the WHERE and HAVING clauses). For details, see the StreamSQL Guide.

The Java API for creating custom embedded adapters has changed. The com.streambase.sb.adapter.Adapter class is replaced by two classes:

com.streambase.sb.adapter.InputAdapter

com.streambase.sb.adapter.OutputAdapter

In any existing embedded adapter source, you must change the class statement from extends Adapter implements InputAdapter to extends InputAdapter, and change extends Adapter implements OutputAdapter to extends OutputAdapter. Then recompile your adapters with this release of StreamBase.

In StreamBase Studio, if you open an application that contains an older embedded adapter's JAR, an error will be reported. Close the IDE, update the class(es), recompile and redeploy the JAR.

For details, see Using the Embedded Adapter API in the API Guide. Also see the Adapters Guide.

Embedded adapters start, pause, resume and shutdown along with the StreamBase application that contains them. It is also possible to suspend and resume embedded adapters independently of their StreamBase application. You can also query the status of embedded adapters. For details, see Using the Embedded Adapter API in the API Guide. In particular, see the section titled "Embedded Adapters and Life Cycle Events."

Similarly, Java operators start, pause, resume and shutdown along with the StreamBase application that contains them. It is also possible to suspend and resume Java operators independently of their StreamBase application. You can also query the status of Java operators. For details, see Using the Java Operator API in the API Guide. In particular, see the section titled "Java Operators and Life Cycle Events."

Each Java Operator or Embedded Adapter changes state along with the server process as a whole. The server waits for each Operator or Adapter to change state before it completes its state change. This release adds the operator-state-change-timeout-ms parameter to the StreamBase Server configuration file, sbd.sbconf. It can be used in the server section of the configuration. The value of operator-state-change-timeout-ms is the amount of time (in milliseconds) the server will wait before timing out the Operator or Adapter. For details, see the StreamBase Server Configuration XML topic in the Reference Guide.

This release introduces some new APIs in both Java and C++. The major change is that the enqueue and dequeue client APIs now have methods that take a StreamProperties object instead of a string stream-name. The new APIs may be faster. The pre-3.7 APIs (using string stream-name) are deprecated. They remain for backwards compatibility. However we recommend that you update your clients.

The StreamBase Client APIs have been extended to support containers.

The StreamProperties (in C++ & Java) class is now much more important because it now has the container name. Here are a few of the important methods on StreamProperties:

There are new APIs for enqueuing and dequeuing using a StreamProperties instead of a stream name. Again, these APIs are the preferred way to enqueue/dequeue to the server as the StreamProperties object contains the container name.

For details, see the StreamBase Java API reference, and StreamBase C++ API reference.

In the Java API, a new DataType factory method has been created, createField(String name, int size). While creating a schema, you can use createField() to create a field of a given DataType and fixed size. See the StreamBase Java API reference for details.

The Palette view has changed in StreamBase Studio, and a new docked Palette is available. If you upgrade, the first time you open StreamBase Studio, you will see a message informing you that the Palette view was not found. You will also notice that no Palette view is displayed at first.

Now, the Palette view is displayed by default only when you open an Application Diagram. In addition, the Palette view now has a special docking function: If an EventFlow application is open and you close the Palette view, a docked Palette appears in the Application Editor. Note that if you upgrade and you previously had the Palette view open, the docked Palette initially appears within each Application Diagram that you open.

You can restore the Palette view at any time by clicking Window → Show View in the StreamBase Studio menu, and finding the Palette view there. The docked Palette is removed and the Palette view is displayed instead. For more information see the help topic, Palette View.

A new view has been added to StreamBase Studio. The Error Log view captures all the warnings and errors logged by plug-ins. The underlying .log file stored in the .metadata subdirectory of the workspace. The Error Log view is available under Window → Show View → Error Log. For details, see the topic, Error Log View.

You can now dequeue tuples from an intermediate stream. That is, from a stream that exists between two connected components, without using an Output Stream. This feature allows you to look at the intermediate processing results from a StreamBase client, before the tuples have been processed to completion in the application. Information about using intermediate streams will be provided in a StreamBase Developer Zone article, and in an update to the StreamBase 3.7.x documentation.

A new command, jsbmonitor, opens a graphical version of the StreamBase Monitor. It contains the same performance data as the character-based sbmonitor display, with the addition of dynamic CPU and memory usage charts. In StreamBase Studio, the graphical StreamBase Monitor is now opened when you click Window → Launch Monitor. See Monitor View and jsbmonitor for details.

You can configure your StreamBase application to use one of two implementations of the now() function. In the <runtime> section of the server configuration file, sbd.sbconf, we added this default parameter:

<param name="now-implementation" value="system"/>

Details about the now() implementations and configuration options are available in StreamBase Server Configuration XML, a topic in the Reference Guide.

Although not part of the StreamBase kit, we want to make sure you are aware of several resources on the StreamBase Developer Zone. It includes an article that explains how to set up the StreamBase Java Toolkit for Eclipse. This is a Java plugin to the Eclipse development environment that lets you quickly create templates for StreamBase Java clients, custom embedded adapters, custom functions, and custom Java operators. You can then modify the "// TODO" commented sections in the .java template sources, saving you time as you learn the StreamBase Java APIs.

See Getting Started with the StreamBase Java Toolkit for Eclipse on the Developer Zone. You do not download the StreamBase Java Toolkit for Eclipse from streambase.com. Instead you go into the Eclipse IDE and specify the StreamBase update site URL in a dialog. Details are in the article noted above.

After you set up Eclipse and get the plugin, there are many related articles on the StreamBase "DevZone" about using the generated templates. See the list of articles in the StreamBase Developer Zone Library.

A number of product limitations are fixed. For more information, see the Resolved Limitations section of the Release Notes.

Oracle 9i

IBM DB2 v9

Microsoft SQL Server 2005

Sybase ASE V12

The SQL-like logical operators AND and OR can be used in place of && and ||. The SQL-like equality operator = can be used in place of ==. These are documented in the Expressions and Functions topic.

The separately installed StreamBase Adapter for JMS/EMS adds support for wildcards. Background information: EMS supports the notion of wildcarding. In EMS you can subscribe to many different destinations. For example, you might create a destination for each stock symbol and subscribe to them all. Also, destinations can be given a hierarchical organization, such as MyCompany.application.symbol. In EMS, you can subscribe to many destinations at once by using a wildcard. For example: MyCompany.application.*, so that you do not have to subscribe to each symbol individually.

StreamBase support this with the EMS enqueue and dequeue features of the external StreamBase Adapter for JMS/EMS. However, this support means different things in each instance. On the enqueue side, we comply with EMS wildcarding. A wildcarded destination (MyCompany.application.*) can be subscribed to by including it in the configuration file. However, EMS wildcarding does not apply in the same way on the dequeue side. Including a wildcarded destination in the dequeue config file will not cause a message to be broadcast to each destination encompassed by the wildcard. On the dequeue side, 'wildcarding' is used to refer to the fact that messages can be sent to individual destinations without having to configure each destination. If an application uses many destinations, then configuring each destination my prove to be onerous. If a destination is not configured in the dequeue adapter, and StreamBase routes a message to it, its configuration is created at runtime using a default configuration. The default values that are specified in the configuration file are used to configure any new destinations. For related information, see this external adapter's documentation, which is installed (by the separate StreamBase Adapter for JMS/EMS kit) in STREAMBASE_HOME/doc/adapter/ems-adapter.html.

StreamSQL, a new text-based language, can be used to query streaming data and create StreamBase applications. StreamSQL applications, which have the file extension, .ssql, can be reused as modules in combination with traditional, graphically designed application diagrams (.sbapp files). StreamBase Studio includes a new document editor for creating StreamSQL applications.

StreamSQL is documented primarily in the new StreamSQL Guide, and in the section entitled Building StreamSQL Applications, in the StreamBase Terms and Components topic of the Getting Started Guide.

A new Java API, com.streambase.sb.adapter.Adapter, can be extended to write custom embedded adapters. Embedded adapters are included in your StreamBase application, and run in the same StreamBase Server (sbd) process. This configuration reduces the client/server communication overhead that is seen with external adapters. Also, embedded adapters start and stop automatically with the StreamBase application, simplifying administration tasks.

This release of StreamBase includes embedded input adapters to get data from CSV files and Regular Expression files, and output adapters to send data as E-mails, or to CSV or XML files.

For more information, start in the new Adapters Guide It contains topics about both the embedded adapters and the external adapters, which have separate installation kits and documentation. Be sure to also see the new API Guide topic, Using the Embedded Adapter API

StreamBase applications can get data from and send data to an external JDBC 2.0 (or later) compliant datasource, such as DB2. In application diagrams, a Query operator can be connected to a JDBC Table data construct. Then SQL statements such as SELECT, INSERT, UPDATE, and DELETE can be sent to an external datasource defined in the sbd.sbconf file. In StreamSQL applications, APPLY JDBC statements can be used to query tables in a datasource.

This feature is available for the StreamBase Enterprise Edition only. For more information, see the Using JDBC Data Sources topic in the Authoring Guide.

The StreamBase server configuration file, sbd.sbconf, includes a new data-sources section that provides configuration and critical run-time parameters for application interaction with external JDBC datasources. The data-sources section is documented in the java-vm section of the StreamBase Server Configuration XML topic.

C++ custom functions used in StreamBase applications must now be declared in the StreamBase Server configuration file, .sbconf. For more information, see the Configuration Steps section in Creating Custom C++ Functions, in the API Guide.

There are some API differences between StreamBase 3.5 and earlier releases.

As noted elsewhere in the documentation, you will need to recompile and relink any existing, pre-3.5 C++ client to work with StreamBase 3.5. If you do not, you will see a "protocol mismatch" error when your client tries to connect to a 3.5 StreamBase server.

In the Tuple class, the methods getStringBytes, getBoolean, getDouble, getInt, getString, getTimestamp all can throw NullValueException in 3.5. In pre-3.5 clients, these methods could only throw TupleException. Existing, pre-3.5 clients that use these methods will need to accommodate this new exception.

The StreamBase adapter for JMS/EMS has the following enhancements:

Three new demos have been added to the Demo perspective, which was introduced in the previous release. Each demo showcases StreamBase capabilities in a different field of interest:

Click Window > Open Perspective > Menu to open the Demo perspective.

killConnection client-id

This tells the server to close (kill) the connection associated with the specified client-id. Client-ids can be determined with the listConnection command.

killAllConnections

This command tells the server to close (kill) all connections currently attached to the server.

In both cases, clients receive notification that their connection has been closed in the same way they would be notified that the server has shut down.

idle-enqueue-client-timeout-ms

idle-dequeue-client-timeout-ms

The .NET Client API, available on Windows only, can be used to program StreamBase client applications using the Microsoft .NET platform, in C#, Visual Basic, or C++. There are also new samples demonstrating .NET client applications. For more information, refer to the Creating Clients topic and the C++ API Documentation documentation (the .NET reference is provided in HTML Help format).

Demo perspective. A new StreamBase Studio Demo perspective provides views and tools for the first-time user, demonstrating important StreamBase capabilities. You can open the Demo perspective directly from the Welcome page when you first open StreamBase Studio, or at any time by clicking Window > Open Perspective, then selecting Demo.

StreamBase is now available in two Editions:

An Expression Quick Reference in the Properties View provides additional help creating expressions in StreamBase operators.

StreamBase for Windows now includes an embedded JDK, which provides all the Java components needed to run StreamBase Studio. It is no longer necessary to install a JDK separately on Windows. For details, refer to the Supported Configurations topic in the Installation Guide.

A new class, TupleCSVWriter, was added to the StreamBase Java Client API, to provide a fast way of outputting data to a Java output stream. For reference information about the class, see the Java API Documentation documentation.

Query table operations were optimized to improve performance.

Sped up the conversion of timestamps to strings in the StreamBase Java Client API.

Changed the default character set in the StreamBase Java Client API from UTF-8 to US-ASCII, to improve performance when getting and setting strings.

The behavior of two methods in the StreamBase Monitor API has changed. In previous releases, OperatorInfo.getProfilerHits() and OperatorInfo.getTotalProfilerHits() returned a cumulative value. They now return an incremental value, the number of miniticks consumed by this operator and in total since the last stats period (defaulting to 1 second). For information about this feature, see Using the Monitor API.

StreamBase 3.0.0 introduced the following new product features and important changes to existing functionality:

Important! Starting in StreamBase 3.0.0, you MUST have the full Sun Java Development Kit (JDK) installed in order to run StreamBase. In prior StreamBase releases, it was sufficient to use the Java Runtime Environment (JRE) to run StreamBase Studio on your development machine; if you wanted to compile StreamBase clients written in Java, of course you needed the JDK.

The full JDK is required because the product compiles StreamBase applications into classes. Remember that the JDK is required for each machine running StreamBase, whether the applications are for development, staging, or production. For information about the supported JDK versions, please refer to the Supported Configurations topic in the Installation Guide.

The StreamBase installation attempts to verify that a JDK is installed that can be used to run StreamBase. If none is found, the installation proceeds, but a message is displayed informing you of the problem. On Linux or Solaris, StreamBase recommends that you assign the JAVA_HOME environment variable to the JDK installation directory. On Windows, the configuration registry is examined to find the best available Sun JDK to use; the JAVA_HOME environment variable overrides the registry setting if different. A copy of the JDK is provided on the StreamBase product CDs for Windows and Linux.

At runtime, when you start a StreamBase Server instance (sbd) to host your application, StreamBase searches for the JVM in the following order:

For related information about the <java-vm> section of the sbd.sbconf file, see java-vm .

By default, a StreamBase Server processes inbound data in a predictable execution sequence. That is, input tuples are each processed individually to completion, from left-to-right through a StreamBase application diagram. At StreamBase Server startup time, the application diagram is converted into Java source code, which is then dynamically compiled to Java bytecode, which in turn is executed by a VM/JIT. For more information, please see Execution Order and Concurrency Options in the Authoring Guide.

If you know that portions of your StreamBase application can run without dependencies on the other streaming data in your application, you may be able to improve the overall throughput by selecting optional concurrency settings. Most StreamBase operators and any module reference have an option to run the component in its own thread. You will notice this option on the General tab of most components' Properties View. Distributing the load automatically across processors on an SMP machine, or optionally across machines in a cluster, may result in faster performance if concurrency is appropriate for your application. For more information, start in the section titled Concurrency Options in Module References and Operators, which is part of the topic noted above.

The StreamBase Studio feature called "regions" is replaced by concurrency options on selected components in your application diagram. Consequently, the Regions View is not presented in StreamBase Studio. If you had pre-3.0 StreamBase applications that used regions, the IDE will display a message about this change. The most common use case is to then organize a former region's components into a module reference, and then enable its concurrency setting: "Run this component in a separate thread." For more information, start in the section titled Concurrency Options in Module References and Operators.

On Windows, the Sun JDK 1.5.0_05 will not work correctly with StreamBase. If you have installed that version of the JDK, you should upgrade to version 1.5.0_06 or later.

StreamBase 3.0.0 introduced a number of changes in the StreamBase Server configuration file, sbd.sbconf.

For details about all the sbd.sbconf parameters, please see the StreamBase Server Configuration XML topic in the Reference Guide. Also see Defining a StreamBase Server Configuration in the Administration Guide.

StreamBase 3.0 introduces a number of changes in the StreamBase Cluster Manager configuration file, sbclusterd.sbconf.

For details about all the sbclusterd.sbconf parameters, please see the StreamBase Cluster Manager Configuration XML topic in the Reference Guide.

Starting in StreamBase 3.0.0, the product's features increased server processing speeds in many cases. Therefore, under certain circumstances, it is possible for applications to experience disconnects from the StreamBase server under this version, even though they ran without this problem under previous versions. Such disconnects can occur when your client cannot dequeue data fast enough to keep up with data rates from the server, and the server buffer fills up.

If you experience this problem with an application, test your application under load. If you observe disconnects from the server when the server buffer is full, consider these two solutions:

If the disconnect events are associated with spikes in data output, you can try modifying the server configuration file's <page-pool> parameters to increase buffering. This might allow the client application to keep up with intermittent output peaks.

However, if you observe sustained high output, increased buffering may not solve the problem. In this case, you might need to modify your client application to make it dequeue data faster.

In Aggregate operator time-based dimensions, timeout events will now trigger based on wallclock time rather than the (now removed) tuple header timestamp. This means that tuples will be emitted after the appropriate time has passed, followed by the arrival of a new tuple. Additionally, there is no longer a concern with out-of-order header timestamps in applications unioning multiple input streams. See the Using the Aggregate Operator topic for details.

In a Query operator defined for read or delete operations, if you chose a Where setting that returns more than one row, you can limit the number of rows read or deleted from the connected Query Table. For example, you might want to retrieve a list of the top n rows, or maintain a query table by deleting n top or bottom values. For more information, please see Using the Query Operator to Use or Modify Shared Data in the Authoring Guide.

In a BSort operator, you can base the sort on the values of a specified input field (if it's numeric). For more information, please see Using the BSort Operator to Perform Approximate Sorts in the Authoring Guide.

This release adds a new Split operator. You can insert a Split operator right after an upstream component that has a single output port and multiple output arcs, to explicitly indicate the order in which the outputs should be processed (to completion) by each set of downstream components. For details, see Using the Split Operator in the Authoring Guide.

The C++ API for custom functions has been changed starting in StreamBase 3.0. To use StreamBase applications written with previous releases, you will need to rewrite any StreamBase C++ custom functions (simple or aggregate), and recompile them. In addition, C++ custom functions are invoked with a new callcpp() function. The changes are described in Creating Custom C++ Functions in the API Guide.

You can use a StreamBase Java API to create custom functions (simple and aggregate). This new API is in addition to the C++ API for custom functions. In the StreamBase expression language, custom functions that you implement in Java are invoked by using the new calljava() function. For more information, please see Creating Custom Java Functions in the API Guide.

In the StreamBase Monitor API, methods in the Snapshot class have changed to reflect the new server architecture. If you used the API in prior releases to create a MonitorListener program, you will need to update your code and recompile. For details, please see the "Snapshot Object" section of Using the Monitor API, a topic in the API Guide.

In addition, the display of performance statistics in the StreamBase Studio Monitor View has changed to reflect the new server architecture. For more information, see these topics in the Test/Debug Guide: Monitor View and Using the StreamBase Performance Monitor.

StreamBase 3.0 has removed direct support for ODBC, while maintaining support for the popular JDBC standard. StreamBase recommends that customer switch to using JDBC wherever possible to get the best performance and support from database vendors.

The ODBC operator and ODBC Table data construct have been removed from the product. Instead we recommend that you use the separately installed StreamBase Adapter for JDBC to access external, JDBC-compliant resources. The StreamBase Adapter for JDBC is documented in an HTML file installed with the separate kit. By default the jdbc.html file is installed in:

/opt/streambase/doc/adapter

C:\Program Files\StreamBase Systems\StreamBase\doc\adapter

Customers who wish to access legacy ODBC data sources where JDBC drivers are not available can use a JDBC to ODBC Bridge. StreamBase recommends the bridge that is shipped as a standard component of the Java platform. For more information, visit http://java.sun.com/j2se/1.5.0/docs/guide/jdbc/getstart/bridge.doc.html

Note that the ODBC-related <data-sources> ... </data-sources> section of the StreamBase Server sbd.sbconf configuration file is no longer provided. If you used this section in prior releases of StreamBase, it is ignored by StreamBase 3.0 and subsequent releases.

Previously in the StreamBase expression language, a field divided by an integer constant resulted in an int data type. Starting in StreamBase 3.0, this division results in a double data type. After you open a pre-3.0 StreamBase application, you may notice that one or more of the operators that formerly passed typechecking now fails (red icon indicator). The Typecheck view may show a message that is similar to the following: "...operator "if" is incompatible with operand types (bool, int, double)". For example, assume you have an int field named Count in a Map operator, and the Output Settings for a new field named RowNumber has this expression:

if Count < 101 then 1 else (Count / 100) + 1

You could correct this data type incompatibility by changing the expression to:

if Count < 101 then 1.0 else (Count / 100) + 1

If you are upgrading from a previous version of StreamBase and you have projects that contain imported Java jar files, check the projects' sbd.sbconf configuration files. In particular, change any references to the Java JRE or unsupported JDK versions, and point instead to one of the supported JDK installations listed in the Supported Configurations topic. If necessary, reinstall your Java software.

Prior versions of StreamBase installed redundant JAR files named sbclient.jar and sbclient-all.jar. These two JARs contained the same set of files. Starting with this release, we no longer install the sbclient-all.jar file. Please check your scripts. If necessary, please change any sbclient-all.jar references to sbclient.jar.

In the StreamBase Studio Test/Debug perspective, the Manual Enqueue View has been renamed to Manual Input. The functionality of the view is unchanged. For more information, please see the Manual Input View topic in the Test/Debug Guide.

There is a new adapter for StreamBase applications on Windows and Linux environments: the StreamBase Adapter for JMS/EMS. It allows StreamBase to integrate with a JMS/EMS compliant message bus. The Java Message Service (JMS) API is a Java Message Oriented Middleware (MOM) API for sending messages between two or more clients. Enterprise Messaging Service (EMS) is a messaging platform offered by TIBCO.

Like other StreamBase adapters, the StreamBase Adapter for JMS/EMS is available in a separate kit. After the installation, the documentation resides in STREAMBASE_HOME/doc/adapter/ems-adapter.html. For information about the StreamBase adapters, or a custom adapter that you may need, please Contact Information your StreamBase representative.

If you upgrade StreamBase to version 3.0, you may need to delete and reimport some sample applications. If in your earlier StreamBase installation you imported any of the sample applications or tutorial modules that includes compiled Java or C++ functions, the sample applications may not typecheck or may not run under StreamBase 3.0 and later versions. For example your application diagram might display red typecheck error indicators, without a clear explanation of the cause.

Before using them, you should delete any of the following sample projects in StreamBase Studio that were imported in a previous release: Then import them normally, using the Import+Samples command.

A new StreamBase command, sbhelp, supports the new StreamBase Help Viewer, described in the next item. The command is documented in the sbhelp topic in the Command Reference.

A new Help viewer is now available that you can run independently of StreamBase Studio. The StreamBase Help Viewer is a full-featured help browser that closely resembles the Dynamic Help tool in StreamBase Studio. To open the StreamBase Help Viewer:

Please see the Using the StreamBase Documentation topic for details.

The StreamBase 2.5.1 release adds support for Solaris 8, in addition to Solaris 9. For more information, please see Supported Configurations and Installing StreamBase on Solaris.

The StreamBase installations for UNIX systems now provide streambase-*.tar.gz tarfiles, making it easier for you to install the product in your preferred location. For Linux systems, StreamBase also provides streambase-*.rpm Red Hat Package Manager (RPM) files, where the default installation directory is /opt/streambase. For details, please see Installing StreamBase on Linux, or Installing StreamBase on Solaris.

In releases prior to StreamBase 2.5.0, an Evaluation license only permitted StreamBase Studio to connect to a local StreamBase Server. Now the Enterprise Edition can connect to a local or remote StreamBase Server. For more information about licensing, please see Installing StreamBase on Linux, and Installing StreamBase on Windows.

StreamBase Studio now provides a default server configuration file named sbd.sbconf, per project. You can modify the configuration by using a new text editor in StreamBase Studio, to reflect the needs of one or more StreamBase applications (*.sbapp) in a project. The configuration settings are then used when you start (Run) a server process in the IDE for the current application. For details, please see Defining a StreamBase Server Configuration in the Administration Guide.

For disk-based Query Tables, StreamBase adds new configuration parameters in the <server> section of an sbd.sbconf file. The parameters control the transaction mode of update operations for disk-based Query Tables.

The use of disk-based Query Tables requires a special license agreement with StreamBase Systems; however, it does not require a different streambase-license.xml file. For details about the configuration options, please see Defining a StreamBase Server Configuration. For details about the disk-based Query Table license agreement, please Contact Information your StreamBase representative.

StreamBase allows you to narrow the results set from a dequeue operation, by using a feature called Filtered Subscribe in the Java or C++ client API. In your client, you can now use a predicate on the subscription to an output stream. The predicate is applied to the data output from the stream before it is delivered to the client. For details, please see Narrowing Dequeue Results with Filtered Subscribe in the Creating Clients topic, which is part of the API Guide.

StreamBase Studio provides new dialogs that allow you to copy, save, import, and export the schemas that define Input Streams and intermediate streams, for use or subsequent use in other StreamBase application diagrams. For details, please start in Defining Input Streams and Schemas in the Authoring Guide.

The StreamBase Adapter for Microsoft Excel can now be used to enqueue tuples from an Excel spreadsheet to a StreamBase application. Previously, the adapter only dequeued tuples from StreamBase to Excel. For details, please read the documentation that is installed with this adapter; by default, in STREAMBASE_HOME/doc/adapter. (Each StreamBase adapter has a separate installation procedure.) For more information about the StreamBase adapters, please Contact Information your StreamBase representative.

StreamBase Studio's Application Diagram Editor now provides context-sensitive "tooltips" that display summary information about the current component on the canvas. With your mouse pointer, you can hover or "mouseover" a stream, operator, port, data construct, or module reference on the canvas. When tooltips are enabled (see the Window > Preferences... dialog), StreamBase Studio displays information about the component. For a description of this convenience feature, please see the Application Diagram Editor topic in the Authoring Guide.