Specifying input streams in from clauses
In a stream query, each from clause specifies a stream that the query is operating on. The syntax of the from clause is as follows:
from itemIdentifier in streamExpr [WindowDefinition]
Syntax description
itemIdentifier | Specify an identifier that you want to use to represent the current item in the stream you are querying. You use this identifier in subsequent clauses in the query. For details about the characters you can specify, see Identifiers in the Apama EPL Reference. The type of the identifier is the same as the type of the items that are in the stream you are querying. There is no link between an item identifier in a query and a variable that you might define elsewhere in your code. In other words, it is okay for an in-scope variable to have the same name as an item identifier in a query. Inside the query, the item identifier hides that variable. See the second example below. |
streamExpr | Specify an expression that returns a stream type. This is the stream that you want to query. |
WindowDefinition | |
Examples
The query below generates a stream of
float items. The item identifier is
a. The stream variable,
ticks, refers to a stream of
Tick events. The
select clause specifies that each query result item contains only the
price value from the
Tick event. Details about the
select clause are in
Generating query results.
stream<float> prices := from a in ticks select a.price;
The all keyword followed by an event template is an expression of type stream referred to as a stream source template. Consequently, you can use this in a from clause. For example, you can modify the previous example to use the stream source template directly within the stream query:
stream<float> prices :=
from a in all Tick(symbol="APMA") select a.price;
Notes
A stream query is an expression of type
stream and so anywhere that you can specify a
stream expression you can use a stream query in its place. (There is one exception to this. See
Linking stream queries together.) This means you can nest stream queries to create a compound stream query. For example, consider the following non-nested stream queries:
stream<A> sA := all A();
stream<integer> derived :=
from a in sA retain 2 select mean(a.x);
stream<B> sB :=
from a in derived within 10.0 select B(stddev(a));
An equivalent way to write this is as follows:
stream<B> sB :=
from b in
from a in all A() retain 2 select mean(a.x)
within 10.0
select B(stddev(b));
The compiler generates the same stream network in both cases so the performance is exactly the same. However, nesting stream queries beyond one level can make the compound stream query hard to understand.
To define a query that operates on two streams, specify two consecutive
from clauses or specify a
from clause followed by a
join clause. See
Joining two streams.