Control Flow

This page shows how to control the order in which activities are processed by a service.

Request Components

A request component is either an activity, a flow or a sequence.

Flow components contain one or more subcomponents that are processed in parallel. A subcomponent is usually an activity (or more precisely, a string of connected activities) but it can also be another flow or sequence component, i.e. flows can be nested.

Sequence components contain one or more subcomponents that are processed in sequence. A subcomponent can either be a string of connected activities or another flow or sequence component.

Flow control

A flow contains a number of request components which are processed in parallel by the server.

Say you'd like to process the following activities in parallel:

SQLUpdate update1 = new SQLUpdate("insert into littleblackbook (id, name) values ('99998', 'Alice')");
SQLUpdate update2 = new SQLUpdate("insert into littleblackbook (id, name) values ('99999', 'Bob')");

First, we create a new, empty Flow object.
```
Flow flow = new Flow();
```
Then we add all activities to the flow.
```
flow.addChild(update1);
flow.addChild(update2);
```
Since the activities will be processed at the same time it doesn't matter in which order they are added to the flow.
Now perform the flow.
```
service.perform(flow);
```

Sequence control

A sequence contains a number of request components which are processed sequentially by the server.

Say you'd like to do the following: Create a new table in a data resource, bulk load some data into the table and then query the data. Obviously, the bulk load cannot start before the table has been created. Likewise, the query should not commence before the data has been loaded into the new table.

You could solve the problem by sending three requests to a service:

Create the new table.
Perform the bulk load.
Query the bulk loaded data in the new table.

This however means that you are sending three requests to the service - three requests go over the network which the associated communications overheads this incurs. It would be nicer if we could specify these activities in a single request:

Create the new table THEN
Perform the bulk load THEN
Query the bulk loaded data in the new table.

while being reassured that the query will not run until the bulk load has finished and that the bulk load won't start until the table has been created. This is where the sequence component comes in - we make our three activities components of a single request and have a guarantee that they will be executed strictly in sequence.

Sequence components are used as follows.

Create an empty sequence object.
```
Sequence sequence = new Sequence();
```

Create the update, bulk load and query objects with the appropriate SQL strings.

SQLUpdate create = new SQLUpdate("create table mytable (id integer, number integer));
SQLQuery query1  = 
   new SQLQuery("select id, phone from littleblackbook where name like '%Krause'");
WebRowSet rowset1 = new WebRowSet(query1.getOutput());
SQLBulkLoad bulkload = new SQLBulkLoad( rowset1.getOutput(), "mytable" );
SQLQuery query2 = new SQLQuery(select count(*) from mytable);
WebRowSet rowset2 = new WebRowSet(query2.getOutput());

Add the above activities to the sequence.

sequence.addChild(create);
sequence.addChild(query1);
sequence.addChild(rowset1);
sequence.addChild(bulkload);
sequence.addChild(query2);
sequence.addChild(rowset2);

It is also possible to insert a child component into the sequence at a certain position.

SQLQuery query3 = new SQLQuery("select * from mytable");
sequence.insertChild(2, query3);

Or remove a component that is not required by specifying
- Either the object itself:
```
sequence.removeChild(query3);
```
- Or the index in the sequence:
```
sequence.removeChild(2);
```