Designing a Project

Contents

Introduction
Create a Project
Configure a Data Table
Put Data in the Data Table

Introduction

StreamBase LiveView takes data and gives you numerous way to view, query, and understand it.

Create a Project

This example simulates a very simple data feed of a single stock symbol with corresponding price and quantity fields.

  1. Create a new LiveView Project.

    1. Open StreamBase Studio.

    2. In StreamBase Studio's Authoring perspective, select File → New → StreamBase Project. The New StreamBase Project dialog opens.

    3. In the New StreamBase Project dialog, enter a name for the project. This example uses my-first-liveview-project.

    4. Clear the check box for Create empty EventFlow Application file. Keep the default selections for the check boxes Use default location, Options, and Java Build Path Options.

    5. Click Finish. A folder for the my-first-liveview-project appears in the Package Explorer view.

  2. Create a table space configuration for the project.Table spaces are a convenient way to share configuration options across multiple tables. If you do not configure a table space, LiveView uses the default table space.

    1. Select File → New → StreamBase LiveView Configuration File. The New StreamBase LiveView Configuration File dialog opens.

    2. Select my-first-liveview-project for the parent folder.

    3. Name the configuration file DefaultTableSpace.

    4. Select the radio button for Table space.

    5. Optionally, you can select the check box for Generate comments. This option generates comments in the lvconf file that provide additional assistance.

    6. Click Finish. The configuration file opens in the StreamBase editor view with the following contents: 

      <?xml version="1.0" encoding="UTF-8"?>
<liveview-configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:noNamespaceSchemaLocation="http://www.streambase.com/schemas/lvconf/">
    <!--A "table space" configures LiveView tables
         (such as memory settings and persistence options).
         Every table belongs to a default or specified table space.-->
    <table-space id="DefaultTableSpace"/>
</liveview-configuration>

You have now completed the initial project configuration. You will next configure a table for your data.

Configure a Data Table

LiveView data tables process streaming data. They can receive data from multiple sources, including EventFlow Applications, external data sources, and other LiveView tables. This example configures a data table with three fields.

  1. Create an lvconf file for the data table, Orders.lvconf.

    1. Right-click the project folder and select New → StreamBase LiveView Configuration File.

    2. Select my-first-liveview-project for the parent folder.

    3. Enter Orders for the LiveView Configuration file name.

    4. Select the radio button for Data table.

    5. Optionally, select the check box for Generate comments.

    6. Click Next. The Data Table Schema wizard opens.

    7. Click the green plus sign to add the following fields to the table.

      • Symbol (type string).

      • Price (type double).

      • Quantity (type int).

    8. Click Next. The Data Table Primary Key(s) dialog opens.

    9. Select Symbol and add it to the Index Fields column.

    10. Click Finish. StreamBase Studio opens Orders.lvconf in the editor view: 

      <?xml version="1.0" encoding="UTF-8"?>
<liveview-configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:noNamespaceSchemaLocation="http://www.streambase.com/schemas/lvconf/">
    <data-table id="Orders">
        <fields>
            <field name="Symbol" type="string"/>
            <field name="Price" type="double"/>
            <field name="Quantity" type="int"/>
        </fields>
        <primary-key>
            <field ref="Symbol"/>
        </primary-key>
    </data-table>
</liveview-configuration>

  2. Alternatively, you can create an EventFlow interface and then copy or import the schema from a named schema in the interface.

    1. Right-click the project folder and select New → StreamBase Interface.

    2. Select my-first-liveview-project for the parent folder.

    3. Enter orders_schemas for the interface name.

    4. Click Finish. The orders_schemas.sbint application opens.

    5. Click Add Named Schema. The Edit Named Schema dialog opens.

    6. Name the schema orders_schema.

    7. Click the green plus sign to add the following fields to the schema.

      • Symbol (type string).

      • Price (type double).

      • Quantity (type int).

    There are two ways to use the named schema in an lvconf:

    • Use the lvconf wizard to copy the schema. This copies the fields from the schema into the lvconf. Once the fields are copied, any changes you make to the named schema will not be carried through to the lvconf unless you re-copy them.

      1. Create the Orders.lvconf file as detailed previously. In the lvconf wizard, instead of adding the fields with the green plus sign, click the Copy Schema from Existing Component button. The Copy Schema From dialog opens.

      2. Select orders_schema from the Locally defined Named Schemas entry in the Copy schema from field.

      3. Click OK.

      Complete the indexing as previously noted by using the Data Table Primary Key(s) dialog. The resulting lvconf has the schema copied directly into its text.

    • Use the import-schema tag. This references the named schema. This means that any changes you make in the named schema are carried through to the lvconf.

      Warning

      The import-schema tag imports by reference. Any processes that use that table schema, such as the generation of EventFlow applications configured for use with LiveView, will not accept a referenced schema.

      1. Create the Orders.lvconf file as detailed previously. In the lvconf wizard, instead of adding the fields with the green plus sign, click Finish instead of Next. Orders.lvconf opens in the Editor tab with empty <fields/> and <primary-key/> tags: 

        <?xml version="1.0" encoding="UTF-8"?>
<liveview-configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:noNamespaceSchemaLocation="http://www.streambase.com/schemas/lvconf/">
    <data-table id="Orders">
        <fields/>
        <primary-key/>
    </data-table>
</liveview-configuration>

      2. Replace the <fields/> tag with the <import-schema> tag: 

        <data-table id="Orders">
     <import-schema schema="orders_schema" from="orders_schemas.sbint"/>
     <primary-key/>
</data-table>

      3. Complete the indexing by editing the lvconf directly. Your lvconf file should look like this: 

        <?xml version="1.0" encoding="UTF-8"?>
<liveview-configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://www.streambase.com/schemas/lvconf/">
 <data-table id="Orders">
   <import-schema schema="orders_schema" from="orders_schemas.sbint" />
   <primary-key>
     <field ref="Symbol" />
   </primary-key>
 </data-table>
</liveview-configuration>

Your data table is now fully configured and ready to receive data.

Put Data in the Data Table

Now you can configure the EventFlow application that will populate your data table. This example uses a feed simulation to populate a DataOut stream.

  1. Create a data source table, OrdersDataSource. This table will call the data-source. In this example, the data-source for the table will be an EventFlow application. This step is not strictly necessary; however, it is recommended that you store all of the project's EventFlow application files in a sub-folder under the project's root directory for convenience.

    This step creates an lvconf that accesses the sub-folder where the applications are stored, so that successive project tables can reference this lvconf rather than individual EventFlow applications.

    1. Select File → New → StreamBase LiveView Configuration File

    2. Select my-first-liveview-project for the parent folder.

    3. Enter OrdersDataSource for the LiveView Configuration file name.

    4. Click Finish. StreamBase Studio opens the OrdersDataSource.lvconf in the editor view.

    5. Add the following <application> tag to the OrdersDataSource.lvconf file: 

      <?xml version="1.0" encoding="UTF-8"?>
<liveview-configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://www.streambase.com/schemas/lvconf/">

<!-- This configuration file is simply declaring a StreamBase application file
     as a data source with the id 'OrdersDataSource'.  -->
     
  <application sub-folder="OrdersDataSource" filename="orders.sbapp"
    id="OrdersDataSource">
  </application>

</liveview-configuration>

      The application specified in the OrdersDataSource table (orders.sbapp) will generate tuples that will, in turn, populate the data streams that you will view from the data tables.

  2. Add the reference from OrdersDataSource to Orders.

    The Orders table will use the OrdersDataSource.lvconf file to talk to EventFlow applications.

  3. Create a sub-folder for the EventFlow application that will populate the incoming data stream.

    1. Select File → New → Folder.

    2. Select my-first-liveview-project for the parent folder.

    3. Enter OrdersDataSource for the Folder name.

    4. Click Finish.

  4. Generate a data-source application with the correct schemas as given by the table configuration. You can do this by using the EventFlow application wizard, which will create an interface file with all the correct schemas.

    Note

    The EventFlow application wizard does not accept referenced schemas. Your table must have all fields explicitly specified in its lvconf file in order to use the EventFlow application wizard.

    1. Select File → New → EventFlow Application. The New StreamBase EventFlow Application dialog opens.

    2. Select my-first-liveview-project/OrdersDataSource for the parent folder.

    3. Enter orders for the EventFlow Application file name.

    4. Select the check box for Configure for use with StreamBase LiveView.

    5. Click Next.

    6. Select Data Source from the Type of Application pull-down menu. Since this project has only on data-table, the wizard automatically selects Orders for the Table name.

    7. Click Finish. StreamBase Studio opens the OrdersDataSource/orders.sbapp file in the editor view.

    The EventFlow application wizard created an interface file to store the correct schemas. You can see the generated schemas in the file lv-interfaces/OrdersSchemas.sbint. LiveView used the interfaces to create a data stream with the correct schema for the Orders table.

  5. Click the DataOut icon in the editor, select General from the StreamBase Properties view, and make sure that the check box for Always expose Stream for Dequeue is selected.

  6. Click the DataOut icon in the editor and select Schema from the StreamBase Properties view. You can see the schema for the DataOut stream contains the following fields:

    Note the schema name is OrdersDataInSchema. The schema is required to match the required schema for sending data into the Orders table.

  7. Now, you can create the data to populate the data stream. This example uses a StreamBase Input Feed Simulation Adapter with a custom feed simulation. To add the feed simulation adapter to your application, follow these steps:

    1. Open OrdersDataSource/orders.sbapp in the StreamBase Editor view.

    2. Drag an Input Adapter from the Palette view onto the editor canvas. The Insert an Input Adapter dialog opens.

    3. Enter feed into the filter and select Feed Simulation from the Global Input Adapters category.

    4. Connect the lower output port of the Adapter to the input port on the DataOut stream.

    The adapter appears red. This is because the Feed Simulation adapter needs a feed simulation.

  8. You will now create a feed simulation and connect it to the adapter. To create the feed simulation, follow these steps:

    1. Select File → New → Feed Simulation. This opens the New StreamBase Feed Simulation wizard.

    2. Select my-first-liveview-app as the parent folder, specify the file name Orders, and click Finish. This creates a file named Orders.sbfs and opens it in the editor.

    3. Enter a description in the Simulation Description field. This example uses Simple data feed.

    4. In the Simulation Streams section, click Copy from Stream/Named Schema.

    5. Select the schema OrdersDataInSchema from the interface file in my-first-liveviewproject/lv-interfaces/OrdersSchemas.sbint.

    6. Next, select the Custom generation method and click the Customize Field button to open the Customize Fields dialog. We will use this dialog to specify the range of values for the feed simulation to generate for each field. For each field, select from the Generation Method drop-down list as shown in the following table.

      Field Generation Method Values Reason
      PublisherID Constant feedsim A string to identify the data source.
      PublisherSN Incremented 0 to 10,000 by 1 Generate an incrementing serial number.
      CQSDataUpdatePredicate Constant null Set to null; non-null would update all matching rows of a table.
      CQSReferredCount Constant null Set to null; the system might use this field internally.
      Symbol Enumerated; Generate 20 random values with equal weights. Random values; Minimum length 4 and Maximum length 4. Generates 20 four-character random strings.
      Price Uniform 1.0 to 500.0, probability of generating null 0. Generates doubles in a uniform random distribution.
      Quantity Uniform 01 to 1500, probability of generating null 0. Generates integers in a uniform random distribution.

      When done, click OK.

    7. Save the feed simulation with Ctrl+S.

  9. Run the application. Right-click in the editor canvas or on the orders.sbapp file in the Package Explorer view and select Run As StreamBase Application.

  10. Observe the application output tab. The output from the feed simulation is populating the outgoing data stream.

  11. Click on a row in the application output tab and examine the tuple contents. Each tuple shows a value to Symbol, Price, and Quantity, in addition to the required fields.

  12. Compile the project and start LiveView server.

  13. Open LiveView Desktop.

    1. Name the workspace my-first-liveview-project.

    2. Look at the Orders table in a grid view. The grid view shows just the table fields, filtering out the internal fields from the feed simulation. When LiveView Server receives a tuple from the data source, it publishes a row in the table.

  14. When done, close LiveView Desktop and stop LiveView server by clicking the red and green button in StreamBase Studio.

Now you have configured a simple LiveView project.