- Index

< Previous |  | Next >

# StreamBase Path Notation

StreamBase's formal path notation is designed to avoid naming conflicts when you run multiple modules in the same fragment in different EventFlow containers, and to avoid conflicts when operators are run in separate parallel regions.

You use StreamBase path notation to address individual streams or operators when using the sbadmin and sbc commands, or when configuring container connections in a StreamBase configuration file. For example, the following command requests the XML representation of one particular stream:

    sbc describe default.OutputStream1

In addition, StreamBase path notation is used in the output of the StreamBase profiling tools, especially in the Operators View and Queues View of those tools.

StreamBase path notation has the following syntax, with a period separator between each element:

    [containerName.][moduleRefName[[.moduleRef2Name].[..]]entityName

containerName

  The name of the EventFlow container hosting the application. Container names are either `system`, `default`, or a name you assign when creating a container. The following example addresses two operators with the same name in separate containers:

      container1.ReadOrders
      default.ReadOrders

  When `containerName` is omitted, the EventFlow container named `default` is assumed. Every EventFlow fragment has a default container named `default`, which contains the application's top-level module unless you explicitly create a non-default container. This means you can often omit the `containerName` portion of the address. For example, the following commands are equivalent if the server is running a single container fragment:

      sbc enqueue default.InputStream1
      sbc enqueue InputStream1

  Use the `containerName` portion of the address when you are addressing a non-default container, or when a name conflict would otherwise occur.

moduleRefName

  The name of a module that is either referenced explicitly in the fragment, or referenced implicitly by StreamBase. Implicit references occur when a component runs in separate or multiple parallel regions; in this case, StreamBase automatically creates a module for each running instance. There can be multiple `moduleRefName` levels in the address syntax.

  The following line addresses an operator named `SumOrders` within a module reference named `MWindowModuleRef1`:

      MWindowModuleRef1.SumOrders

  The next example addresses a group of entities associated with an operator that you have configured, using the Concurrency tab of the operator's Properties view, to run in a parallel region. In each entity, the prefix references the module that StreamBase creates for the operator's parallel region.

      MyOperator.InputStream1              (input stream)
      MyOperator.out:MyOperator_1          (output stream)
      MyOperator.schema:RetrieveLastOrders (schema)
      MyOperator.MyOperator                (operator)

  Finally, If you set a component to run in multiple parallel regions, you can address each region separately. The following example addresses two instances for the same operator, each running in its own parallel region.

      default.Filter:0.Filter
      default.Filter:1.Filter

entityName

  The name of an individual stream, operator, schema, or queue.

  When used in the output of profiling tools, you might also see a parallel region instance number appended to the `entityName` in the form `entityName[:`instanceNumber`]`, using zero-based instance numbers. For example: `Update_Bids_and_Asks:0`, `Update_Bids_and_Asks:1`, and so on.