action action_name([arglist]) returns retType {
  do_something>;
}
 
action notifyUser(){
log "Event sequence detected.";
}

aggregate [bounded|unbounded] aggregateName (
[arglist]) returns retType {
aggregateBody }
 
aggregate bounded wstddev( decimal x, decimal w )
returns decimal {
    do something}

all event_template
 
on all StockTick(*,*):newTick processTick();

all event_template_with_no_other_operators
 
stream<Tick> ticks := all Tick(symbol="APMA");

on event_template and event_template action;
 
on A() and B() executeAction();

if ordinary_exp and ordinary_exp block;
 
if x and y {myBlock;}

import "plug-in-library" as identifier;
 
import "MyPlugin" as foo;

event1() key field1 duration;
event2() key field2 as field1 duration;
 
CarNum() key road within 1 hour;
Accident() key roadName as road within 1 hour;

on all event_expression as variable action;
 
on all StockTick(*,*) as newTick processTick();

at(minutes, hours, days_of_month, months,
days_of_week [,seconds])
 
on all at(5, 9, *, *, *) success;

log string [at log_level];
 
log "Your message here" at INFO;

between (identifier1 identifier2 ...)
 
between (a b)

boolean identifier;
 
boolean marketOpen;

break;

chunk identifier;
 
chunk complexProductInfo;

on all completed event_expression action;
 
on all completed A(f < 10.0) {}

constant type name := literal;
 
constant float GOLDEN := 1.61803398874;

context(string name)
context(string name, boolean receivesInput)
 
context c:=context("test");

continue;

log currentTime.toString();
send TestEvent(currentTime) to "output";

decimal identifier;
 
decimal exactValue;
exactValue := 1.2345d;

within integer day | days
 
within 3 days

dictionary <key_type, data_type> identifier;
 
dictionary <integer, string> myOrders;

die;
 
on NewStock (chosenStock.name,
chosenStock.owner) die;

emit event;
 
emit newEvent;

emit event to channel;
 
emit newEvent to "com.apamax.pricechanges";

enqueue event;
 
enqueue newEvent;

enqueue event_expr to context_expr;
enqueue event_expr to sequence<context_expr>;
 
enqueue tick to c;

event event_type {
   [ [wildcard] field_type field_name; |
   constant field_type field_name := literal; |
   action_definition ... ]
}
 
event StockTick {
   string name;
   float price;
}

every batchPeriodExpr
 
from v in values
within 3.0 every 3.0
select v

every batchSizeExpr
 
from v in values
retain 3 every 3
select v

find every event as coassignment
select_or_having_clause
 
find every A as a
select avg(a.x) as aax { }

find
   [every]
   query_event_pattern
   [where_clause]
   [within_clause]
   [without_clause]
   [select_clause]
   [having_clause] {
   block
   }
 
find
   Withdrawal as w1 -> Withdrawal as w2
   where w2.country != w1.country {
      log "Suspicious withdrawal: "
   }

float identifier;
 
float squareRoot;

for identifier in sequenceExpression {
...
}
 
for i in s { 
print i.toString();
}

from itemIdentifier in streamExpr
[windowDefinition]
 
from t in ticks retain 3

from itemIdentifier in streamExpr
[windowDefinition]
from itemIdentifier in streamExpr
[windowDefinition]
 
from x in letters retain 2
from y in numbers retain 2
select P(x,y)

[listener :=] from streamExpr :
identifier statement
 
float p;
from t in all Tick(symbol="APMA")
   select t.price : p {
   print "'APMA' price is: " +
p.toString();
}

group by groupByExpr [, groupByExpr]...
 
from t in ticks
within 60.0 group by t.symbol
select mean(t.price)

from t in all Temperature()
within 60.0
having count() > 10
select mean(t.value)

having boolean_projection_expr
 
find every ATMWithdrawal as w
   having last(w.amount) > THRESHOLD
      * avg(w.amount)
   select last(w.transactionId) as tid {
   send SuspiciousTransaction(tid) to
      SuspiciousTxHandler;
   }

within integer hour | hours
 
within 5 hour

if booleanExpression [then] {
...
} [ else {
...
} ]
 
if floatVariable > 5.0 {
integerVariable := 1;
} else if floatVariable < -5.0 {
integerVariable := -1;
} else {
integerVariable := 0;
}

if floatVariable > 5.0 then {
integerVariable := 1;
}

import "plug-in_name" as identifier;
 
import "complex_plugin" as complex;

on event_name(event_field in [range])
 
on all A(m in [0:10])

inputs {
event_type(event_filter)
key query_key
[within_clause]
[retain_clause]
[with_unique_clause]
[time_from_clause wait_clause
[or_clause]] ;
 
[ event_type(event_filter)
key query_key
[within_clause]
[retain_clause]
[with_unique_clause]
[time_from_clause wait_clause
[or_clause]] ; ]...
}

 

inputs {
Transaction() key
source as txSource,
dest as txDest
within PERIOD;
Acknowledgement() key
dest as txSource,
source as txDest
within PERIOD
}

integer identifier;
 
integer count;

join itemIdentifier in streamExpr
[windowDefinition]
on joinKeyExpr1 equals joinKeyExpr2
 
from r in priceRequest
join p in prices
partition by p.symbol retain 1
on r.symbol equals p.symbol
select p.price

join(sequence<string> s)
 
sequence<string> s :=
["Something", "Completely", "Different"];   
print ", ".join(s);

key field_name [as field_name2] duration

inputs {
Withdrawal() key cardNumber within (period);
}

location(15.23, 24.234, 19.1232, 28.873)

log string [at log_level];
 
log "Your message here" at INFO;

within integer millisecond | milliseconds | msec
 
within 100 msec

within integer minute | minutes | min
 
within 3 min

monitor monitor_name {
...
}
 
monitor SimpleShareSearch {
...
}

monitor.subscribe("channel_name");
monitor.unsubscribe("channel_name");
 
action start_trade()
{
// Subscribe to two channels:
monitor.subscribe("SOW_Ticks");
monitor.subscribe("IBM_Ticks");
}

new typeName;
 
b := new Foo();

not event_template
 
on A() and not B() executeAction();

if not ordinary_exp block;
 
if not x myBlock;

on [all] event_expression action;
 
on NewsItem("ACME",*) findStockChange();

action onBeginRecovery() { }
 
action onBeginRecovery() {  
if (timeFormatPlugin.getTime() -
currentTime > (60.0 * 60.0 * 2)
{ longDowntime:=true;
... // do something if
// downTime was long
}
}

action onConcludeRecovery() { }
 
action onConcludeRecovery() {    
initiateListener(); // go back
//to normal
}

action ondie() { }
 
action ondie() {    
log "sub-monitor terminating for "
+ myId;
route InternalError("Foo");
}

action onload(){ ... }
 
action onload() {   
on all StockTick(*,*):newTick {
processTick();   
}
}

action onunload() { };
 
action onunload() {   
route LastMonitorTerminating();
}

optional<data_type> identifier;
 
optional<float> myOptFloat;

on event_template or event_template action;
 
on A() or B() executeAction();

if ordinary_exp or ordinary_exp block;
 
if x or y myBlock;

package identifier;
 
package com.apamax.orders;

parameters {
data_type parameter_name;
[ data_type parameter_name; ]...
}
 
parameters {
integer threshold;
float period;
}

partition by partitionByExpr
[, partitionByExpr]...
 
from t in all Tick()
partition by t.symbol
retain 10 with unique t.price
select t.price

persistent monitor string
 
persistent monitor ManageOrders

print string;
 
print "Your message here.";

query name {
[ parameters { parameters_block } ]
inputs { inputs_block }
find pattern block
[ action_definition ... ]
}
 
query FraudulentWithdrawalDetection2 {
inputs {
Withdrawal() key userId retain 3;
}
find Withdrawal as w1 -> Withdrawal as w2
where w1.city != w2.city {
log "Suspicious withdrawal: "
+ w2.toString() at INFO;
}
}

retain windowSizeExpr
 
inputs {
Withdrawal() key userId retain 3;
}
 
from v in values
retain 10
select mean(v)

retain all
 
from v in values
retain all
select mean(v)

returns typeToReturn
return retValue
 
action complexAction(
integer i, float f) returns string {   
// do something  
return "Hello";
}

route event();
 
route StockTick();

select [rstream] selectExpr
 
from i in inputs
retain 2
select rstream i;

within integer second | seconds | sec
 
within 3 sec

select [rstream] selectExpr
 
from v in values
retain 10
select mean(v);

select projection_expr as identifier
 
find every ATMWithdrawal as w
having last(w.amount) > THRESHOLD * avg(w.amount)
select last(w.transactionId) as tid {
send SuspiciousTransaction(tid) to
SuspiciousTxHandler;
}

send event_expr to channel;
send event_expr to context;
send event_expr to sequence<channel>;
 
send tick to "ticks-SOW";

sequence<data_type> identifier;
 
sequence<float> myPrices;

spawn action([parameter_list]);
 
action onload() {   
spawn forward("a", "channelA");   
spawn forward("b", "channelB");
}

spawn action([arg_list]) to context_expr;
 
spawn doCalc(cal) to context("Calculation");

static action static_action_name([arglist])
returns retType {
  do_something>;
}
 
event E {
static action someStaticAction(){
print "I am a static action on event type E";
}
}

stream<type> name;
 
stream<decimal> prices;

string identifier;
 
string message;

try block1
catch(Exception variable) block2
 
try {
return float.parse(prices[fxPair]);
} catch(Exception e) {
return 1.0;
}

on all unmatched event_expression[:coassignment]
action;
 
on all unmatched Tick():tick processTick();

using packageName.{aggregateName|eventName};
 
using com.apamax.custom.myAggregateFunction;

wait(float)
 
on A() -> wait(10.0) -> C() success;

wait(value) as identifier
 
find wait(1 minute) as previous
-> DoorOpened as d without Unlock as u

where booleanExpr
 
from t in ticks
retain 100 where t.price*t.volume>threshold
select mean(t.price)

where booleanExpr
 
find LoggedIn as lc -> OneTimePass as otp
where lc.user = otp.user
within 30.0 {
emit AccessGranted(lc.user);
}

while booleanExpression {
...
}
 
while integerVariable > 10 {   
integerVariable := integerVariable – 1;   
on StockTick(
"ACME", integerVariable) doAction(); }

wildcard param_type param_name;
 
event StockTick {   
string name;   
float price;   
wildcard string exchange;
}

with unique keyExpr
 
from p in pairs
retain 3 with unique p.letter
select sum(p.number)

within(float)
 
on A() -> B() within(30.0) notifyUser();

within windowDurationExpr
 
from v in values
within 20.0
select mean(v);

within durationExpression
[ between ( identifer1 identifier2 ... ) ]
 
find Withdrawal as w1 -> Withdrawal as w2
where w2.country != w1.country
within 1 hour {
log "Suspicious withdrawal: "
+ w2.toString() at INFO;
}

without typeId as coassignmentId
[ where boolean_expression ]
[ between ( identifier1 identifier2... )]
 
find OuterDoorOpened as od -> InnerDoorOpened as id
where od.user = id.user
without SecurityCodeEntered as sce
where od.user = sce.user {
emit Alert("Intruder "+id.user);
}

xor event_template
 
on A() xor B() notifyUser();

if ordinary_exp xor ordinary_exp block;
 
if x xor y myBlock;

#identifier
 
print f.#integer.toString();