StreamBase New and Noteworthy

This release introduces the StreamBase interface, which is a defined set of input streams, output streams, Query Tables, constants, and schemas that application modules can implement and extend. Implementing an interface enforces the stream and table definitions in the interface. This lets you design an interface with a known set of components that several modules can implement in different ways. Interfaces can implement other interfaces, which lets you nest a set of definitions in layers and use them in the combinations most appropriate for your applications.

Interfaces are stored in a new StreamBase file type with .sbint extension. Interfaces are edited in the new Interface Editor. See Using Interfaces for an overview.

StreamBase interfaces can serve in two ways: as templates to enforce streams, tables, and schemas when creating or adding to an application, and in conjunction with the new Extension Point operator. This operator is much like a Module Reference for interfaces; when you drag an .sbint file from the Package Explorer to the canvas, it creates an Extension Point. Tuples flowing into an Extension Point can be directed for processing by one or more modules that implement the referenced interface. For example, an Extension Point that references a Multiplier interface can direct tuples to either a Doubler or Tripler module, both of which implement the Multiplier interface.

This new view shows a tree view of all Extension Point operators in use in any EventFlow or StreamSQL module in the current workspace, along with each module that implements the interface referenced in each Extension Point. The view is placed in the same pane as the Properties view at the bottom of the SB Authoring perspective. See StreamBase Extension Points View.

The Concurrency tab provided in the Properties view of most operators and adapters now offers a revised set of options. The option set formerly grouped as Data Parallelism was replaced with a group of related Multiplicity options. The separate thread option serves the same purpose as before, but can now be set independently of the Multiplicity options. The settings for these options are described on Concurrency Options, while the background information that describes why you might use concurrency settings is in Execution Order and Concurrency.

One aspect of the new Multiplicity concurrency options is a new set of module dispatch styles. In previous releases, when a module or component was marked to run with multiple instances using the data parallelism options in the Concurrency tab of the Properties view, tuples could be routed to different instances based on an expression that resolved to an integer. This is now known as the Numeric style of dispatching tuples. If you did not specify an expression, tuples were routed in round-robin fashion to all instances.

This release introduces alternate dispatch styles for sending tuples to multiple instances of an operator or to multiple modules. The Broadcast style, the default setting for both EventFlow and StreamSQL applications, routes incoming tuples equally to all operator or module instances. For multiple module instances in a Module Reference, or for multiple operator instances, you can optionally specify the Numeric or Round Robin dispatch styles. For multiple modules referenced in an Extension Point operator, you can specify that tuples are dispatched in the Broadcast or Name styles. See Dispatch Styles.

The new concurrency settings include support for setting the dispatch style independently for different input streams. This applies to Module References where the referenced module has more than one input stream, to Extension Points, and to operators with more than one input stream, including Join, Gather, Merge, and Pattern.

Starting with this release, the Union and Split operators support only separate thread concurrency, and not multiplicity concurrency. The Union and Split operators join the Metronome and Iterate operators in this category of operators that support only separate thread concurrency.

This release adds the new StreamBase JUnit test mechanism. A StreamBase JUnit test is a Java program that starts StreamBase Server, loads the application module to be tested, sends tuples to the module's input streams, and compares the output emitted from the module's output streams to an expected set of tuples. StreamBase Studio includes a new wizard that generates JUnit test code for your modules, ready for you to edit and complete. StreamBase JUnit test are described in StreamBase JUnit Tests.

StreamBase Tests remain in the product as a separate macro-like recording and playback mechanism that does not require writing Java code. StreamBase Tests are described in StreamBase Tests (sbtest).

This release includes a new command line utility, sbunit, used to run StreamBase JUnit test classes from the command line. (The sbtest command remains in the product as the way to run StreamBase Tests and Test Suites.)

The SB Authoring perspective has a new default layout that provides more room to work on large applications, especially on small laptop screens. Editors, including the EventFlow Editor, are now placed in the top right corner of the perspective, with the Properties and Reuters Schema Designer views now below in the bottom right pane. The Outline view was moved to the top left, sharing a pane with the Package Explorer. The Saved Schemas view is no longer displayed by default; when opened, it shares the bottom right pane. The new Extension Points and Module Hierarchy views share the bottom right pane with the Properties and Console views. See SB Authoring Perspective.

The Palette view was greatly simplified and made easier to use:

See Palette View for further information.

Adapters and Global Java operators are now selected by dragging one of the following icons from the Operators and Adapters drawer: Input Adapter, Output Adapter, or Java Operator. Dragging one of these icons opens a dialog that lists the available adapters and operators in each category, including any project-specific custom adapters or operators. You can narrow the list with a search string. When you make a selection and double-click or press Enter, the selected adapter or operator is dropped onto the current canvas location. You can invoke the same dialogs with the keyboard shortcuts A I, A O, and O V, respectively. See Using the Adapter and Java Operator Dialogs for further details.

This new view replaces the Module drawer of the Palette view of previous releases. Placed in the same pane as the Palette view, it provides a tree view of all EventFlow and interface files in the module search path for the currently active EventFlow or StreamSQL application. The currently active Editor session is not included in the view. See Module Explorer View.

In the Project Properties dialog, in the StreamBase → Module Search Path panel, you can now designate referenced module folders as hidden. Use this feature to prune folders from the Module Explorer view to de-clutter the view.

This new view shows the module call order for the currently active EventFlow module, in tree view by default, with a graphical view option. This view is not automatically maintained and does not refresh when you switch to a different application's Editor view. Use the keyboard shortcut, Ctrl+Alt+H, to generate a new Module Call Hierarchy view on demand for the currently active EventFlow module. See Module Call Hierarchy View.

See  StreamBase Interfaces  above for a description of the new StreamBase Extension Points view.

This release implements a new typechecking algorithm that results in a considerable speedup when making small changes in large EventFlow applications.

The new StreamBase Admin operator is used to send sbadmin commands to a running StreamBase Server, without having to invoke sbadmin from a shell by means of the External Process operator. Use the StreamBase Admin operator for container control or control between primary and secondary servers in a high availability pattern. Invoke the new operator by dragging the Java Operators icon from the Operators and Adapters drawer in the Palette view. See Using the StreamBase Admin Operator.

When editing a Studio launch configuration, you can now specify the start order for multiple containers by using the Move Up and Move Down buttons on the Containers tab. It may be necessary to adjust container start order when specifying container connections, so that the container with the outgoing stream is started before another container with the incoming stream.

As a consequence of this change, the container named default is now always listed in the Containers tab of the launch configuration editor. In previous releases, you specified module parameters for the top-level application on the Main tab. Now you select the default line in the Containers tab, and specify module parameters for the top-level application there.

You can now double-click .sblayout files in the Package Explorer. Studio automatically opens an Editor session for the associated .sbapp EventFlow module.

When working with Java code, the Eclipse Quick Fix feature now suggests a fix to include StreamBase Client and Test Libraries in the Project Build Path.

In the Query operator associated with Query Tables or Materialized Windows, for read and delete operations, you can specify an integer as the maximum number of rows that can be returned by your query. Starting with this release, you can specify the row limit as a StreamBase expression that evaluates to a positive integer. This allows you to specify the row limit with an expression calculated based on conditions upstream, or to use a module parameter such as ${RowLimit} that you can specify at runtime.

When Studio launches StreamBase Server, it now compares the Studio and server version numbers and reports any mismatch. This is only likely to occur when Studio is configured to launch on a remote server.

The obscure "show asynchronous ports" option in Studio Preferences was removed. It is not feasible to determine the synchronous state of an Extension Point operator's ports, which rendered the feature unmaintainable.

When creating an application bundle in Studio, you can now base the bundle on a Studio launch configuration instead of specifying the top-level application file. The bundler parses the launch configuration to determine the top-level application name and extracts any containers, container start order, container connections, and container parameters specified on the configuration's Containers tab. All other configuration information is ignored for purposes of the bundle. See Creating a Bundle in StreamBase Studio for details.

For several releases, the sbbundle command has offered a –i option, which allows you to specify a comma-separated list of files or directories in an application's project folder that you want to exclude from the bundle. Starting with this release, the application bundling dialog in Studio provides the same option. For example, you can use the Ignore directories and files field to exclude the state files for your version control system; for Subversion, enter .svn. See Application Bundling.

Starting with 6.6.0, StreamBase samples that include Java source code for client enqueuer and dequeuer programs have a new way to launch the client programs in StreamBase Studio. New Studio launchers for the client programs are automatically placed in Studio's Run History list. You now run the sample's EventFlow application, then run one or more client launchers to run the client program alongside the EventFlow application in Studio. The new Studio launchers are part of the following samples: Client, Buffering, FeedProc, and Output Filtering.

Java source code delivered as part of a StreamBase sample is now placed in the sample's java-src folder. When you load the sample in Studio, Java code is automatically built. For this reason, JAR files containing the compiled Java code are no longer necessary and are no longer included with the samples. You can, of course, generate your own JAR files from the provided source files.

When a Makefile or Visual Studio project file is delivered as part of a sample, it no longer includes targets to build the Java source code at the command prompt. These files are now provided only as a guide to building C++ sample code.

Most StreamBase samples were reviewed and updated for 6.6.0 to promote current recommended practices. Obsolete samples were removed from the distribution and are no longer shipped.

This release adds support for installing and hosting StreamBase Server on Solaris 10 on 64-bit Intel hardware. See Installing StreamBase on Solaris. As with the SPARC version of Solaris 10, StreamBase Studio is not supported. On this platform, StreamBase supports using the GCC tools from /usr/sfw/bin to write native clients and plug-ins.

StreamBase Studio is now based on Eclipse 3.5.2, which resolves an issue of non-responding Studio buttons on certain Linux systems. If you add third-party Eclipse plug-ins to Studio, make sure they are compatible with Eclipse 3.5.2.

The Sun JDK installed for private use by StreamBase was updated to release 1.6.0_18. As before, you can override this installed default to use a different supported JDK as described in Using an External JDK. The supported JDK versions are listed in Supported Configurations.

The sbc and jsbc command now have a –w option, which takes a wait time argument in milliseconds, plus an optional retry time separated by a colon. The option specifies the amount of time to wait while continually retrying to connect to the specified StreamBase Server. The following example waits 20 seconds before giving up on connecting to the server, retrying every half second: sbc -w 20000:500 dequeue Use this command to start sbc enqueue and dequeue commands before starting StreamBase Server. The sbc command waits for the specified time until the server is ready.

StreamBase release 6.6.0 included the following documentation updates, corrections, and new pages that were incorporated independent of the new features discussed above:

The on disk format for Query Tables has been updated for release 6.5.0. Before migrating your application to 6.5, move all files in your Query Table data directory to a backup location. Then proceed as follows, depending on how you use Query Tables:

StreamBase Studio now respects and preserves the layout status it detects for each individual EventFlow application or module. That is:

As before, you can create separate layout files for one or more application files using StreamBase → EventFlow Layout → Extract to Layout File. The Studio Preference setting to manage layout status now affects only newly created application files going forward. For details, see the rewritten EventFlow Layout Options page.

As of release 6.5.0, Studio no longer gives any special treatment to DLL or .so files stored at the root of a Studio workspace project. In previous releases, such files were presumed to be native library files that implement a custom C++ plugin. The removal of special treatment based on folder location means you must now add an explicit plugin or library element in the server configuration file for each DLL or .so file that you explicitly want to load as part of your StreamBase application.

In previous releases, StreamBase Server supported only the protocol specific to its own StreamBase release, and StreamBase clients built with previous releases had to connect to newer servers by means of the StreamBase Proxy Server, sbproxy. This limitation was lifted, and StreamBase Server now directly supports the protocols of previous StreamBase releases back through 3.7.

You no longer need to run sbproxy for the purpose of protocol matching, but sbproxy is still required to support SSL or LDAP secure connections to StreamBase Server. Clients can still connect to the server through sbproxy, which now passes protocol handling through to the server and displays an informational warning on the console.

You can now include a precompiled application archive (.sbar) version of the primary application file when creating a StreamBase bundle for deployment, if the archive file is present in the project folder. This works both when creating a bundle in Studio and at the command prompt, where you can now use the sbbundle -c command.

StreamBase Server was updated to start an application bundle using an .sbar file if it finds one in the bundle, and if the .sbar and server are from the same release. If the releases do not match, the server skips the .sbar file and starts the top-level EventFlow file in the bundle.

In previous releases, the CSV File Reader Adapter had the empty string as the default setting for its NULL string property. Starting with 6.5.0, this adapter has null as the default setting for the NULL string property, which aligns the CSV File Reader adapter more closely with the default null string used by the CSV File Writer adapter and with other StreamBase adapters.

In release 6.4.3, the External Process operator gained the ability to specify string instead of blob as the data type of fields added to the output tuple by the operator. As of release 6.5.0, string is the default type for such fields. See Using the External Process Operator.

Release 6.5.0 provides a unified installer for supported 64-bit Windows platforms. In previous releases, installing StreamBase on these platforms required running the standard 32-bit installer and then a second installer that overlaid the 64-bit programs and libraries. The installer for 64-bit Windows now performs in one pass all the actions of the former two-stage installation. Installing and using StreamBase on 64-bit Windows is described in Installing and Running StreamBase on 64-Bit Windows.

As is standard with StreamBase releases, the XML syntax of EventFlow files was updated to support the new features described on this page. When you use Studio 6.5 to open and save a module defined in a previous release, the file's format is automatically updated.

StreamBase Studio is now based on, and requires, Eclipse 3.5.1. This allows you to install third-party Eclipse plug-ins that support or require Eclipse 3.5, including plug-ins that add version control to Studio.

The Welcome page for StreamBase Studio uses a new layout that explains the available options without requiring the use of a mouse to hover over each button.

In the EventFlow Editor in StreamBase Studio, the tabs at the bottom (other than the Editor tab) are now shown in boldface if that tab has any content. The following example shows the Editor tab active, but the bold font tells you at a glance that there is at least one constant, named schema, or table schema defined in the Definitions tab, and there is either a module description or a custom icon specified in the Metadata tab.

The icon for the Chronicle Connection data construct was removed from the Data Construct drawer of the Palette view, and the former Chronicle adapters were reconfigured to work as standard StreamBase adapters. No functionality is lost with this change, and the databases formerly supported as Chronicle Connections are still supported, including the native library fast-load features for certain databases. If your StreamBase application accesses or loads a database formerly supported with a Chronicle Connection, that connection is automatically migrated when you open and save the application in release 6.5. If your server configuration file specified type="chronicle" in a data-source element, it is automatically migrated to type="jdbc".

StreamBase 6.5.0 introduces a new and clarified way to assemble the fields of the outgoing tuple in Query and Map operators, and to apply aggregate functions in the Aggregate operator. In the new interface, you specify field changes as a group, or one field at a time in separate tables. The separate tables apply to fields from the input stream, fields from the associated Query Table, and fields additional changes determined by expressions. The changes you specify are applied in top-down order, both in the order of tables in the tab, and in the order of field expressions in each table. See Output Settings Tab for a discussion of the new user interface.

You can now directly specify subfields for output by writing a fully qualified path using standard dot notation. For example, if the incoming schema for a Map operator has a field NYSEFeed of type tuple, with a subfield named symbol, you can use NYSEFeed.symbol in the Field Name column to directly add, replace, remove, or include the field in the output of the Map operator. You can use these fully qualified paths in the Field Name column of any table in the Output Settings tab of Map and Query operators, and in the Aggregate Functions tab of Aggregate operators.

In the same places you can use subfield path names, you can now use an asterisk wildcard to specify all fields of the incoming stream, or to specify all subfields of a tuple field. In the following example, the output settings for a Map operator specifies adding a new field of type tuple, OrigStream, to the output of the operator. Each field of the input stream is mapped to the same-named subfield of the OrigStream field. When using a wildcard in the Expression column, you must also use an asterisk in the Field Name column.

In the Output Settings tab for the Query operator in previous releases, for Insert operations, the Expressions option was unavailable. Using the new interface for the Output Settings tab, you can now add, replace, or remove fields based on expressions by using the Additional Expressions table.

In previous releases, when using the Query operator's Output Settings tab, Studio provided the default prefix input_ for fields from the input stream, _table for fields the current table, and, for updates, _old, for fields from the table before the update. When using the Aggregate operator, in the Aggregate Functions tab, Studio provided the default prefix input_. In release 6.5, Studio now defaults to no prefix. You can still specify a prefix in all the same cases.

Previous releases required you to use input1 as the qualifier of a field name (such as input1.fieldname), even though the Map operator has only one input. You can now specify input as the qualifier for fields in a Map operator's input stream.

The output stream gained the ability to specify a declared schema for outgoing tuples. The default configuration, as in previous releases, is that the schema for these components is inherited from upstream components and is shown read-only in the Properties view. However, you can now instead specify the exact schema you expect outgoing tuples to have, which allows StreamBase to apply typechecking to confirm or report departures from your declared schema.

The Union operator also gains the ability to specify a declared schema for outgoing tuples. In this case, the Require this schema option supplements the existing options to specify loose and strict typechecking of the schemas of the operator's input ports. As with output streams, specifying a declared schema allows StreamBase to apply typechecking to confirm or report departures from your declared schema.

This release introduces the table schema, which is a form of named schema for a set of Query Tables that completely defines the structure of those Query Tables, and ensures that all Query Tables in the set are identically defined. A table schema includes not only the table structure of a Query Table, but its primary and secondary indices as well. You can apply a table schema by name to two or more on-disk or in-memory Query Tables to quickly assign the same structure to those Query Tables, and you can import table schemas from modules in the module search path. Table schemas are described in Using Table Schemas.

This release includes the new Drools operator in the Global Operators & Adapters drawer of the Palette view in StreamBase Studio. The Drools operator is a global Java operator that provides a way for StreamBase applications to implement rule-based decision-making in the course of an EventFlow application. This operator embeds version 5 of the Drools Expert rules engine, also known as JBoss Rules. You implement the operator by providing a rules file and a Java Interface file that describes the fields of interest in the operator's incoming tuple. See Using the Drools Operator and Drools Operator Sample.

When defining a dynamic variable, your updating expression might need to refer to more than one field in the updating stream to build your expression. Starting with release 6.5.0, you can qualify such field names with input. instead of repeating the updating stream's name. Thus, for a dynamic variable that updates from the sum of two fields, alpha and beta, in an updating input stream named UpdateVariable, you can specify either of the following as your updating expression:

UpdateVariable.alpha + UpdateVariable.beta

input.alpha + input.beta

You can now use the standard Eclipse Java Build Path mechanism to specify the location of a native library (DLL or .so file) called by Java source files or by a JAR file in a StreamBase project. In previous releases, the only way to specify such locations was with the library child element of the java-vm element of the server configuration file, and that method is still supported. See Java Build Path in the Project Properties page for instructions.

This release provides a new Container Connections field on the Advanced tab of the Properties view for both input and output streams. The field accepts a StreamBase expression that resolves to the qualified name of a stream in another container. There are some restrictions on container start order when using this feature, as described on Container Connections. This feature supplements and does not replace the other methods of establishing container connections, which remain available.

Application launches from Studio are simplified and no longer require two dialog boxes. Launch failures are now reported using the standard Eclipse mechanism.

Studio now supports setting any launch configuration to run in the background. This places the Starting StreamBase Server dialog sequence in the background so that control of Studio returns immediately after the launch. Large multimodule applications can take a moment to load and initialize, so this setting frees Studio for productive use while waiting for a large application to start. To specify this condition, edit the application's run configuration; in the Common tab, check the Launch in background checkbox and click Apply.

All the application monitoring and management functions of StreamBase Manager are now available automatically when you run applications in StreamBase Studio. The views that comprise the standalone StreamBase Manager utility are now available in the new SB Manager perspective in Studio. To view StreamBase Manager statistics for the running application, switch to the SB Manager perspective, which is automatically connected to the running server instance. You can go back and forth at will between the SB Manager and SB Test/Debug perspectives as you analyze your running application.

StreamBase Manager can still be run as a separate, standalone utility using its Start menu entry in Windows, or using the sbmanager command from the command prompt in UNIX.

The standalone StreamBase Manager utility no longer opens by default with a Welcome screen. If no connections have been made, Manager now provides reminder messages in each view to help you get started. If you have previously connected to a running server, Manager remembers and shows the URLs of its last connections. Right-click the URL of interest and select Connect from the context menu to reconnect to the same server and port.

The Help system booklet for StreamBase Manager and the SB Manager perspective is now available at the same top level as the primary StreamBase documentation in the Eclipse Help viewer.

In release 6.5.0, the SB Trace Debugger perspective replaces the SB Trace Browser perspective. As before, you can use this perspective to review and analyze runtime trace files generated for a running application, as described in Runtime Tracing. New in 6.5.0 is the ability to debug through a trace file, line by line, with automatic highlighting of the current place in the associated EventFlow module.

Release 6.5.0 offers a third launch mode for running applications in Studio. In addition to Run and Debug modes, you can now start an application in Trace mode, and you can edit and store Trace mode launch configurations in the same way as Run and Debug mode configurations. When you run an application in Trace mode, the following sequence occurs:

Trace files generated from a running application are now saved with UTF-8 encoding. This preserves any Unicode characters in tuple fields in the trace file.

Messages reporting an error in the configuration or use of a component are shown in the Properties view and in other Studio views. These error messages are now more detailed and provide better reporting of the location of the error. Error messages now report the exact field or table cell with the problem, and provide a hyperlink to take you to that location. Errors in a component in a referenced module now report a path that leads you to the exact inner module that contains the failing operator.

In previous releases, when you dragged an adapter or global Java operator icon from the Palette to the canvas, the newly dropped icon's initial name was a generic one, such as Java1 or InputAdapter1. As of release 6.5.0, newly dropped icons receive a name based on the name of the dragged adapter or global operator: CSVFileReader1, ExternalProcess3, and so on. If you program custom operators or adapters, the new default name for dropped targets is based on the name defined with setShortDisplayName().

Select any schema-bearing component in the EventFlow Editor canvas, right-click, and select Schema → Refactor to Named Schema from the context menu. This opens the Promote to Named Schema dialog, which allows you to save the schema of the selected component as a named schema, accessible in the Definitions tab for the current module. At the same time, you can ask Studio to locate components in the current module that have a compatible private schema, and to apply the newly named schema to some or all of those components. See Promoting a Private Schema to a Named Schema.

On Windows platforms only, the context menu for projects in the Package Explorer view now contains the Open StreamBase Command Prompt Here action. Invoke this action to open a StreamBase Command Prompt whose current directory is the selected project's directory in the Studio workspace.

The keyboard shortcut X X is used to quickly draw connection arcs between two selected components in the EventFlow canvas. As of 6.5.0, the X X shortcut is extended to work with more than two component selections. You can drop several stream and operator icons on the canvas, select them all, then use X X to draw all the arcs between components in left to right order. If the selection includes a data construct and there is an unequivocal connection to Query operators available, X X also automatically draws the association arcs. See Keyboard Shortcuts for further detail.

The autocompletion feature is invoked with Ctrl+Space when editing an expression in a Properties view table cell. Autocompletion now takes into account any currently selected text in the cell when presenting its completion proposals.

Studio keeps a history of the selections you make among individual components in the EventFlow canvas. You can use Alt+Left to move backwards in that selection history, and Alt+Right to move forward. These keys go back or forward to the previous or next selected component in the history, even if that selection is in another EventFlow Editor canvas.

You can also navigate your selection history using the yellow left and right arrows in the main Studio toolbar . Use the drop-down arrows next to these arrow icons to see your navigation history in list form. Select a location in the list to navigate directly to that location.

In previous releases, the Create Group action did not appear in the EventFlow Editor's context menu unless two or more components were selected. You can now create a group starting with only one icon selected, adding components to the group later.

When running or debugging a top-level application that references one or more modules, the Output Stream Selector dialog (invoked from the Application Output view) now organizes the available output streams hierarchically, to help you locate the streams of interest. See Select Multiple Streams.

When using StreamBase Studio's Visual Debugger for EventFlow applications, you can now inspect the contents of in-memory Query Tables in the Variables view.

If your EventFlow application includes custom Java code, you can now switch back and forth between debugging your EventFlow application and debugging your Java code. Use the Toggle debugging mode button on the right side of the Debug view's toolbar to switch modes.

The efficiency of the visual debugger was improved to allow debugging of larger applications.

Internal changes were made to significantly improve the performance of StreamBase Server when processing an application with 50 to 100 fields per tuple.

Internal changes were made to significantly improve the performance of StreamBase Server when processing an application with a large number of connected and active dequeue clients. In one test scenario with 80 dequeue clients, the tuples per second processing rate was two to three times faster than with previous releases.

To help administer multiple client versions connecting to StreamBase Server 6.5, the sbadmin listConnections command now reports the protocol family for each connected client. The protocol family is effectively a superset of the StreamBase release number that categorizes StreamBase releases that use the same server connection protocol. For example, the connection protocol did not change between StreamBase releases 6.4 and 6.5, so clients from both versions report 6.5 in the protocol family field in the output of listConnections. The protocol family version generally changes for StreamBase releases that add a new data type.

The sbadmin listConnections command now reports the name of the input stream each client is connected to.

StreamBase 6.5.0 includes new support for design patterns where one or more connected clients consume data at a slower rate than the server produces it. In previous releases, the server automatically disconnected unresponsive clients on the presumption that they were hung or had lost communication. The new support for slow-dequeuing clients is implemented as a new parameter setting, slow-dequeue-client-wait, for the page-pool element of the server configuration file; and as changed behavior for the existing max-client-pages parameter. These settings affect all connected clients. See the <page-pool> section of the StreamBase Server Configuration File XML Reference page for details on these settings.

You can now specify param elements as an alias for parameter elements, which are both child elements of the module-parameter element.

Automatic HA is a set of time-saving StreamBase configuration settings that let you quickly and automatically implement commonly used aspects of high-availability design patterns. The currently supported automatic HA features are automatic leadership control and automatic table replication. See Automatic HA.

The HA and table-repl samples were reworked to illustrate both automatic HA and manual customization. Both samples now provide a basic version of the sample that uses automatic HA features, and a custom version of the sample that illustrates the same design pattern accomplished with manual configuration settings, which provides more control over options. See High Availability Sample and Query Table Replication Sample.

The JDBC Query sample, formerly part of the operators group of samples, is now provided in its own sample directory. This allows the operators sample group to load in Studio without a warning. As before, the JDBC Query sample must be configured with a data-source entry in the sample's server configuration file before it can be used.

A new sample is provided in STREAMBASE_HOME/sample/logging-log4j that illustrates how to use the logging back end provided by StreamBase to load and use log4j as the logging front end. The sample also illustrates how to write a simple Java operator that writes log messages to the console, and how to set log4j logging levels in that operator.

The following adapters were removed from the StreamBase base kit:

When using a JDBC database as the source of input tuples for a feed simulation, you must make the database vendor's JDBC JAR file available to Studio. Previous releases recommended copying the JAR file to a certain location in the StreamBase installation. Starting with this release, you can also use the new STUDIO_BOOT_CLASSPATH environment variable as an alternative.

Independent of either method above, in order to use the command-line sbfeedsim with a JDBC data source, you must place the JDBC JAR file in the standard CLASSPATH. These subjects are discussed in Feed Simulation with a JDBC Data Source.

The default setting of the jdbc-batch-timeout-ms parameter of the data-source element in the server configuration file was changed to 60000 ms (60 seconds). In previous releases, the default was –1, which specified not flushing a JDBC batch buffer based on a time interval.

StreamBase 6.5.0 includes the following changes in the StreamBase Client library:

The StreamBase expression language was extended with the following new functions:

StreamBase release 6.5.0 includes the following changes in third-party libraries:

StreamBase release 6.5.0 includes the following documentation updates, corrections, and new pages that were incorporated independent of the new features discussed above:

In previous releases, when you selected a StreamBase operator, data construct, or stream in the canvas to show its Properties view, clicking the Properties view's circled-? Help button opened the Studio Help system directly onto the documentation page for the selected component. Previous releases offered this Help button feature for any component taken from the Operators, Data Constructs, or Streams drawers of the Palette view.

As of release 6.5.0, this Help button feature is extended to work with StreamBase-supplied adapters and global Java operators found in the Global Operators & Adapters drawer. As before, the selection is tab-specific. That is, for many adapters, the Help page opens directly onto the section of the page that discusses the currently selected tab in the Properties view.

For module references, custom Java operators, or custom Java adapters, clicking the Help button opens a generic Help page appropriate for the component category.