public void TestInvalidJoinRun()
{
_epService.EPAdministrator.CreateEPL(
"create dataflow MyDataFlowOne " +
"BeaconSource -> BeaconStream {iterations : 1}");
var source = new DefaultSupportSourceOp(
new Object[]
{
5000
});
EPDataFlowInstantiationOptions options =
new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(source));
EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
// invalid join
try
{
dfOne.Join();
Assert.Fail();
}
catch (IllegalStateException ex)
{
Assert.AreEqual(
"Data flow 'MyDataFlowOne' instance has not been executed, please use join after start or run",
ex.Message);
}
// cancel
dfOne.Cancel();
// invalid run and start
try
{
dfOne.Run();
Assert.Fail();
}
catch (IllegalStateException ex)
{
Assert.AreEqual(
"Data flow 'MyDataFlowOne' instance has been cancelled and cannot be run or started", ex.Message);
}
try
{
dfOne.Start();
Assert.Fail();
}
catch (IllegalStateException ex)
{
Assert.AreEqual(
"Data flow 'MyDataFlowOne' instance has been cancelled and cannot be run or started", ex.Message);
}
// cancel again
dfOne.Cancel();
}
private void RunAssertionOuterJoinMultirow(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean_S0>();
epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S1));
string graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean_S0>{name: 'emitterS0'}\n" +
"Emitter -> instream_s1<SupportBean_S1>{name: 'emitterS1'}\n" +
"Select(instream_s0 as S0, instream_s1 as S1) -> outstream {\n" +
" select: (select p00, p10 from S0#keepall full outer join S1#keepall)\n" +
"}\n" +
"CaptureOp(outstream) {}\n";
epService.EPAdministrator.CreateEPL(graph);
var capture = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
IDictionary <string, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
captive.Emitters.Get("emitterS0").Submit(new SupportBean_S0(1, "S0_1"));
EPAssertionUtil.AssertProps(
epService.Container, capture.GetCurrentAndReset()[0], "p00,p11".Split(','), new object[] { "S0_1", null });
instance.Cancel();
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionAllTypes(EPServiceProvider epService, string typeName, object[] events)
{
string graph = "create dataflow MySelect\n" +
"DefaultSupportSourceOp -> instream<" + typeName + ">{}\n" +
"Select(instream as ME) -> outstream {select: (select myString, sum(myInt) as total from ME)}\n" +
"DefaultSupportCaptureOp(outstream) {}";
EPStatement stmtGraph = epService.EPAdministrator.CreateEPL(graph);
var source = new DefaultSupportSourceOp(events);
var capture = new DefaultSupportCaptureOp(2, SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions();
options.OperatorProvider(new DefaultSupportGraphOpProvider(source, capture));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
instance.Run();
object[] result = capture.GetAndReset()[0].ToArray();
EPAssertionUtil.AssertPropsPerRow(
epService.Container, result, "myString,total".Split(','), new object[][] { new object[] { "one", 1 }, new object[] { "two", 3 } });
instance.Cancel();
stmtGraph.Dispose();
}
private static void RunAssertionAfterExec(EPDataFlowInstance df)
{
// cancel and join ignored
df.Join();
// can't start or run again
try
{
df.Run();
Assert.Fail();
}
catch (IllegalStateException ex)
{
Assert.AreEqual(
"Data flow 'MyDataFlowOne' instance has already completed, please use instantiate to run the data flow again",
ex.Message);
}
try
{
df.Start();
Assert.Fail();
}
catch (IllegalStateException ex)
{
Assert.AreEqual(
"Data flow 'MyDataFlowOne' instance has already completed, please use instantiate to run the data flow again",
ex.Message);
}
df.Cancel();
df.Join();
}
public void RunAssertionJoinOrder(String fromClause)
{
String graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean_S0>{name: 'emitterS0'}\n" +
"Emitter -> instream_s1<SupportBean_S1>{name: 'emitterS1'}\n" +
"Emitter -> instream_s2<SupportBean_S2>{name: 'emitterS2'}\n" +
"Select(instream_s0 as S0, instream_s1 as S1, instream_s2 as S2) -> outstream {\n" +
" select: (select s0.id as s0id, s1.id as s1id, s2.id as s2id " + fromClause + ")\n" +
"}\n" +
"CaptureOp(outstream) {}\n";
EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL(graph);
DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp();
IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
captive.Emitters.Get("emitterS0").Submit(new SupportBean_S0(1));
captive.Emitters.Get("emitterS1").Submit(new SupportBean_S1(10));
Assert.AreEqual(0, capture.GetCurrent().Length);
captive.Emitters.Get("emitterS2").Submit(new SupportBean_S2(100));
Assert.AreEqual(1, capture.GetCurrent().Length);
EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "s0id,s1id,s2id".Split(','), new Object[] { 1, 10, 100 });
instance.Cancel();
captive.Emitters.Get("emitterS2").Submit(new SupportBean_S2(101));
Assert.AreEqual(0, capture.GetCurrent().Length);
stmtGraph.Dispose();
}
private void RunAssertionOA(bool underlying)
{
EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"EventBusSource -> ReceivedStream<" + (underlying ? "MyEvent" : "EventBean<MyEvent>") + "> {} " +
"DefaultSupportCaptureOp(ReceivedStream) {}");
DefaultSupportCaptureOp future = new DefaultSupportCaptureOp(1);
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions()
.OperatorProvider(new DefaultSupportGraphOpProvider(future));
EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
instance.Start();
_epService.EPRuntime.SendEvent(new Object[] { "abc", 100L }, "MyEvent");
Object[] rows = future.GetValue(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, rows.Length);
if (underlying)
{
EPAssertionUtil.AssertEqualsExactOrder((Object[])rows[0], new Object[] { "abc", 100L });
}
else
{
EPAssertionUtil.AssertProps((EventBean)rows[0], "p0,p1".Split(','), new Object[] { "abc", 100L });
}
instance.Cancel();
stmtGraph.Dispose();
}
private void RunAssertionStatementNameExists(EPServiceProvider epService, string typeName, object[] events)
{
epService.EPAdministrator.CreateEPL("@Name('MyStatement') select * from " + typeName);
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"create schema AllObject System.Object," +
"EPStatementSource -> thedata<AllObject> {" +
" statementName : 'MyStatement'," +
"} " +
"DefaultSupportCaptureOp(thedata) {}");
var captureOp = new DefaultSupportCaptureOp(2, SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions()
.OperatorProvider(new DefaultSupportGraphOpProvider(captureOp));
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
df.Start();
EventSender sender = epService.EPRuntime.GetEventSender(typeName);
foreach (Object @event in events)
{
sender.SendEvent(@event);
}
captureOp.GetValue(1, TimeUnit.SECONDS);
EPAssertionUtil.AssertEqualsExactOrder(events, captureOp.Current);
df.Cancel();
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionOA(EPServiceProvider epService, bool underlying)
{
EPStatement stmtGraph = epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"EventBusSource -> ReceivedStream<" + (underlying ? "MyEventOA" : "EventBean<MyEventOA>") + "> {} " +
"DefaultSupportCaptureOp(ReceivedStream) {}");
var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions()
.OperatorProvider(new DefaultSupportGraphOpProvider(future));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
instance.Start();
epService.EPRuntime.SendEvent(new object[] { "abc", 100L }, "MyEventOA");
object[] rows = future.GetValue(1, TimeUnit.SECONDS);
Assert.AreEqual(1, rows.Length);
if (underlying)
{
EPAssertionUtil.AssertEqualsExactOrder((object[])rows[0], new object[] { "abc", 100L });
}
else
{
EPAssertionUtil.AssertProps((EventBean)rows[0], "p0,p1".Split(','), new object[] { "abc", 100L });
}
instance.Cancel();
stmtGraph.Dispose();
}
private void RunAssertionAllTypes(String typeName, Object[] events)
{
String graph = "create dataflow MySelect\n" +
"DefaultSupportSourceOp -> instream.with.dot<" + typeName + ">{}\n" +
"Filter(instream.with.dot) -> outstream.dot {filter: myString = 'two'}\n" +
"DefaultSupportCaptureOp(outstream.dot) {}";
EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL(graph);
DefaultSupportSourceOp source = new DefaultSupportSourceOp(events);
DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp(2);
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions();
options.SetDataFlowInstanceUserObject("myuserobject");
options.SetDataFlowInstanceId("myinstanceid");
options.OperatorProvider(new DefaultSupportGraphOpProvider(source, capture));
EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
Assert.AreEqual("myuserobject", instance.UserObject);
Assert.AreEqual("myinstanceid", instance.InstanceId);
instance.Run();
Object[] result = capture.GetAndReset()[0].ToArray();
Assert.AreEqual(1, result.Length);
Assert.AreSame(events[1], result[0]);
instance.Cancel();
stmtGraph.Dispose();
}
public void TestTimeWindowTriggered()
{
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
String graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean>{name: 'emitterS0'}\n" +
"Select(instream_s0) -> outstream {\n" +
" select: (select sum(IntPrimitive) as sumInt from instream_s0.win:time(1 minute))\n" +
"}\n" +
"CaptureOp(outstream) {}\n";
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
_epService.EPAdministrator.CreateEPL(graph);
DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp();
IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(5000));
captive.Emitters.Get("emitterS0").Submit(new SupportBean("E1", 2));
EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 2 });
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(10000));
captive.Emitters.Get("emitterS0").Submit(new SupportBean("E2", 5));
EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 7 });
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(65000));
EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 5 });
instance.Cancel();
}
public void TestOuterJoinMultirow()
{
_epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S0));
_epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S1));
String graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean_S0>{name: 'emitterS0'}\n" +
"Emitter -> instream_s1<SupportBean_S1>{name: 'emitterS1'}\n" +
"Select(instream_s0 as S0, instream_s1 as S1) -> outstream {\n" +
" select: (select p00, p10 from S0.win:keepall() full outer join S1.win:keepall())\n" +
"}\n" +
"CaptureOp(outstream) {}\n";
_epService.EPAdministrator.CreateEPL(graph);
DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp();
IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
captive.Emitters.Get("emitterS0").Submit(new SupportBean_S0(1, "S0_1"));
EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "p00,p11".Split(','), new Object[] { "S0_1", null });
instance.Cancel();
}
public override void Run(EPServiceProvider epService)
{
MyExceptionHandler.Contexts.Clear();
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
// test exception by graph source
EPStatement stmtGraph = epService.EPAdministrator.CreateEPL("create dataflow MyDataFlow DefaultSupportSourceOp -> outstream<SupportBean> {}");
var op = new DefaultSupportSourceOp(new object[] { new EPRuntimeException("My-Exception-Is-Here") });
var options = new EPDataFlowInstantiationOptions();
options.OperatorProvider(new DefaultSupportGraphOpProvider(op));
var handler = new MyExceptionHandler();
options.ExceptionHandler(handler);
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlow", options);
df.Start();
Thread.Sleep(100);
Assert.AreEqual(EPDataFlowState.COMPLETE, df.State);
Assert.AreEqual(1, MyExceptionHandler.Contexts.Count);
EPDataFlowExceptionContext context = MyExceptionHandler.Contexts[0];
Assert.AreEqual("MyDataFlow", context.DataFlowName);
Assert.AreEqual("DefaultSupportSourceOp", context.OperatorName);
Assert.AreEqual(0, context.OperatorNumber);
Assert.AreEqual("DefaultSupportSourceOp#0() -> outstream<SupportBean>", context.OperatorPrettyPrint);
Assert.AreEqual("Support-graph-source generated exception: My-Exception-Is-Here", context.Exception.Message);
df.Cancel();
stmtGraph.Dispose();
MyExceptionHandler.Contexts.Clear();
// test exception by operator
epService.EPAdministrator.Configuration.AddImport(typeof(MyExceptionOp));
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlow DefaultSupportSourceOp -> outstream<SupportBean> {}" +
"MyExceptionOp(outstream) {}");
var opTwo = new DefaultSupportSourceOp(new object[] { new SupportBean("E1", 1) });
var optionsTwo = new EPDataFlowInstantiationOptions();
optionsTwo.OperatorProvider(new DefaultSupportGraphOpProvider(opTwo));
var handlerTwo = new MyExceptionHandler();
optionsTwo.ExceptionHandler(handlerTwo);
EPDataFlowInstance dfTwo = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlow", optionsTwo);
dfTwo.Start();
Thread.Sleep(100);
Assert.AreEqual(1, MyExceptionHandler.Contexts.Count);
EPDataFlowExceptionContext contextTwo = MyExceptionHandler.Contexts[0];
Assert.AreEqual("MyDataFlow", contextTwo.DataFlowName);
Assert.AreEqual("MyExceptionOp", contextTwo.OperatorName);
Assert.AreEqual(1, contextTwo.OperatorNumber);
Assert.AreEqual("MyExceptionOp#1(outstream)", contextTwo.OperatorPrettyPrint);
Assert.AreEqual("Operator-thrown-exception", contextTwo.Exception.Message);
}
private void RunAssertionStmtNameDynamic(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"create map schema SingleProp (id string), " +
"EPStatementSource -> thedata<SingleProp> {" +
" statementName : 'MyStatement'," +
"} " +
"DefaultSupportCaptureOp(thedata) {}");
var captureOp = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions()
.OperatorProvider(new DefaultSupportGraphOpProvider(captureOp));
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
Assert.IsNull(df.UserObject);
Assert.IsNull(df.InstanceId);
df.Start();
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(0, captureOp.Current.Length);
EPStatement stmt = epService.EPAdministrator.CreateEPL("@Name('MyStatement') select TheString as id from SupportBean");
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
captureOp.WaitForInvocation(100, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "E2" });
stmt.Stop();
epService.EPRuntime.SendEvent(new SupportBean("E3", 3));
Assert.AreEqual(0, captureOp.Current.Length);
stmt.Start();
epService.EPRuntime.SendEvent(new SupportBean("E4", 4));
captureOp.WaitForInvocation(100, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "E4" });
stmt.Dispose();
epService.EPRuntime.SendEvent(new SupportBean("E5", 5));
Assert.AreEqual(0, captureOp.Current.Length);
epService.EPAdministrator.CreateEPL("@Name('MyStatement') select 'X'||TheString||'X' as id from SupportBean");
epService.EPRuntime.SendEvent(new SupportBean("E6", 6));
captureOp.WaitForInvocation(100, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "XE6X" });
df.Cancel();
epService.EPAdministrator.DestroyAllStatements();
}
public void TestBlockingCancel()
{
// declare
_epService.EPAdministrator.CreateEPL(
"create dataflow MyDataFlowOne " +
"SourceOne -> outstream<SomeType> {}" +
"OutputOp(outstream) {}");
// instantiate
var latchOne = new CountDownLatch(1);
IDictionary <String, Object> ops = new Dictionary <String, Object>();
ops.Put(
"SourceOne", new DefaultSupportSourceOp(
new Object[]
{
latchOne, new Object[]
{
1
}
}));
var output = new DefaultSupportCaptureOp();
ops["OutputOp"] = output;
EPDataFlowInstantiationOptions options =
new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(ops));
EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
var cancellingThread = new Thread(
() =>
{
try
{
Thread.Sleep(300);
dfOne.Cancel();
}
catch (Exception e)
{
Console.Error.WriteLine(e.StackTrace);
}
});
cancellingThread.Start();
try
{
dfOne.Run();
Assert.Fail();
}
catch (EPDataFlowCancellationException ex)
{
Assert.AreEqual("Data flow 'MyDataFlowOne' execution was cancelled", ex.Message);
}
Assert.AreEqual(EPDataFlowState.CANCELLED, dfOne.State);
Assert.AreEqual(0, output.GetAndReset().Count);
}
public override void Run(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddImport(typeof(DefaultSupportCaptureOp).Name);
string[] fields = "p0,p1".Split(',');
epService.EPAdministrator.Configuration.AddEventType("MyOAEventType", fields, new object[] { typeof(string), typeof(int) });
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlow " +
"Emitter -> outstream<MyOAEventType> {name:'src1'}" +
"DefaultSupportCaptureOp(outstream) {}");
var container = epService.Container;
var captureOp = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions();
options.OperatorProvider(new DefaultSupportGraphOpProvider(captureOp));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlow", options);
EPDataFlowInstanceCaptive captiveStart = instance.StartCaptive();
Assert.AreEqual(0, captiveStart.Runnables.Count);
Assert.AreEqual(1, captiveStart.Emitters.Count);
Emitter emitter = captiveStart.Emitters.Get("src1");
Assert.AreEqual(EPDataFlowState.RUNNING, instance.State);
emitter.Submit(new object[] { "E1", 10 });
EPAssertionUtil.AssertPropsPerRow(container, captureOp.Current, fields, new object[][] { new object[] { "E1", 10 } });
emitter.Submit(new object[] { "E2", 20 });
EPAssertionUtil.AssertPropsPerRow(container, captureOp.Current, fields, new object[][] { new object[] { "E1", 10 }, new object[] { "E2", 20 } });
emitter.SubmitSignal(new EPDataFlowSignalFinalMarkerImpl());
EPAssertionUtil.AssertPropsPerRow(container, captureOp.Current, fields, new Object[0][]);
EPAssertionUtil.AssertPropsPerRow(container, captureOp.GetAndReset()[0].ToArray(), fields, new object[][] { new object[] { "E1", 10 }, new object[] { "E2", 20 } });
emitter.Submit(new object[] { "E3", 30 });
EPAssertionUtil.AssertPropsPerRow(container, captureOp.Current, fields, new object[][] { new object[] { "E3", 30 } });
// stays running until cancelled (no transition to complete)
Assert.AreEqual(EPDataFlowState.RUNNING, instance.State);
instance.Cancel();
Assert.AreEqual(EPDataFlowState.CANCELLED, instance.State);
// test doc sample
string epl = "create dataflow HelloWorldDataFlow\n" +
" create schema SampleSchema(text string),\t// sample type\t\t\n" +
"\t\n" +
" Emitter -> helloworld.stream<SampleSchema> { name: 'myemitter' }\n" +
" LogSink(helloworld.stream) {}";
epService.EPAdministrator.CreateEPL(epl);
epService.EPRuntime.DataFlowRuntime.Instantiate("HelloWorldDataFlow");
}
private void RunAssertionOutputRateLimit(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
string graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean>{name: 'emitterS0'}\n" +
"Select(instream_s0) -> outstream {\n" +
" select: (select sum(IntPrimitive) as sumInt from instream_s0 output snapshot every 1 minute)\n" +
"}\n" +
"CaptureOp(outstream) {}\n";
epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
epService.EPAdministrator.CreateEPL(graph);
var capture = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
IDictionary <string, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
Emitter emitter = captive.Emitters.Get("emitterS0");
epService.EPRuntime.SendEvent(new CurrentTimeEvent(5000));
emitter.Submit(new SupportBean("E1", 5));
emitter.Submit(new SupportBean("E2", 3));
emitter.Submit(new SupportBean("E3", 6));
Assert.AreEqual(0, capture.GetCurrentAndReset().Length);
epService.EPRuntime.SendEvent(new CurrentTimeEvent(60000 + 5000));
EPAssertionUtil.AssertProps(
epService.Container, capture.GetCurrentAndReset()[0], "sumInt".Split(','), new object[] { 14 });
emitter.Submit(new SupportBean("E4", 3));
emitter.Submit(new SupportBean("E5", 6));
Assert.AreEqual(0, capture.GetCurrentAndReset().Length);
epService.EPRuntime.SendEvent(new CurrentTimeEvent(120000 + 5000));
EPAssertionUtil.AssertProps(
epService.Container, capture.GetCurrentAndReset()[0], "sumInt".Split(','), new object[] { 14 + 9 });
instance.Cancel();
emitter.Submit(new SupportBean("E5", 6));
epService.EPRuntime.SendEvent(new CurrentTimeEvent(240000 + 5000));
Assert.AreEqual(0, capture.GetCurrentAndReset().Length);
epService.EPAdministrator.DestroyAllStatements();
}
public void TestGraph()
{
String epl = "create dataflow RollingTopWords\n" +
"create objectarray schema WordEvent (word string),\n" +
"Emitter -> wordstream<WordEvent> {name:'a'} // Produces word stream\n" +
"Select(wordstream) -> wordcount { // Sliding time window count per word\n" +
" select: (select word, Count(*) as wordcount from wordstream.win:time(30) group by word)\n" +
"}\n" +
"Select(wordcount) -> wordranks { // Rank of words\n" +
" select: (select Window(*) as rankedWords from wordcount.ext:sort(3, wordcount desc) output snapshot every 2 seconds)\n" +
"}\n" +
"DefaultSupportCaptureOp(wordranks) {}";
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
_epService.EPAdministrator.CreateEPL(epl);
// prepare test
DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp();
EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions();
options.OperatorProvider(new DefaultSupportGraphOpProvider(capture));
EPDataFlowInstance instanceOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("RollingTopWords", options);
Emitter emitter = instanceOne.StartCaptive().Emitters.Get("a");
foreach (String word in new String[] { "this", "is", "a", "test", "that", "is", "a", "word", "test" })
{
emitter.Submit(new Object[] { word });
}
Assert.AreEqual(0, capture.GetCurrentAndReset().Length);
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(2000));
Assert.AreEqual(1, capture.GetCurrent().Length);
Map map = (Map)capture.GetCurrent()[0];
IList <Object[]> rows = (Object[][])map.Get("rankedWords");
EPAssertionUtil.AssertPropsPerRow(
rows,
"word,count".Split(','),
new Object[][]
{
new Object[] { "is", 2L },
new Object[] { "a", 2L },
new Object[] { "test", 2L }
});
instanceOne.Cancel();
}
private void RunAssertionAllTypes(EPServiceProvider epService, string typeName, SendableEvent[] events)
{
EPStatement stmtGraph = epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"EventBusSource -> ReceivedStream<" + typeName + "> {} " +
"DefaultSupportCaptureOp(ReceivedStream) {}");
var future = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions()
.OperatorProvider(new DefaultSupportGraphOpProvider(future));
events[0].Send(epService.EPRuntime);
Assert.AreEqual(0, future.Current.Length);
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
events[0].Send(epService.EPRuntime);
Assert.AreEqual(0, future.Current.Length);
df.Start();
// send events
for (int i = 0; i < events.Length; i++)
{
events[i].Send(epService.EPRuntime);
}
// assert
future.WaitForInvocation(200, events.Length);
object[] rows = future.GetCurrentAndReset();
Assert.AreEqual(events.Length, rows.Length);
for (int i = 0; i < events.Length; i++)
{
Assert.AreSame(events[i].Underlying, rows[i]);
}
df.Cancel();
events[0].Send(epService.EPRuntime);
Thread.Sleep(50);
Assert.AreEqual(0, future.Current.Length);
stmtGraph.Dispose();
}
public void TestNonBlockingJoinCancel()
{
_epService.EPAdministrator.CreateEPL(
"create dataflow MyDataFlowOne " +
"DefaultSupportSourceOp -> outstream<SomeType> {}" +
"DefaultSupportCaptureOp(outstream) {}");
var latchOne = new CountDownLatch(1);
var src = new DefaultSupportSourceOp(
new Object[]
{
latchOne
});
var output = new DefaultSupportCaptureOp();
EPDataFlowInstantiationOptions options =
new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(src, output));
EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
dfOne.Start();
var cancellingThread = new Thread(
() =>
{
try
{
Thread.Sleep(300);
dfOne.Cancel();
}
catch (Exception e)
{
Console.Error.WriteLine(e.StackTrace);
}
});
cancellingThread.Start();
dfOne.Join();
Assert.AreEqual(EPDataFlowState.CANCELLED, dfOne.State);
Assert.AreEqual(0, output.GetAndReset().Count);
}
private void RunAssertionIterateFinalMarker(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
string graph = "create dataflow MySelect\n" +
"Emitter -> instream_s0<SupportBean>{name: 'emitterS0'}\n" +
"@Audit Select(instream_s0 as ALIAS) -> outstream {\n" +
" select: (select TheString, sum(IntPrimitive) as sumInt from ALIAS group by TheString order by TheString asc),\n" +
" iterate: true" +
"}\n" +
"CaptureOp(outstream) {}\n";
epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
epService.EPAdministrator.CreateEPL(graph);
var capture = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
IDictionary <string, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture);
var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators));
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options);
EPDataFlowInstanceCaptive captive = instance.StartCaptive();
Emitter emitter = captive.Emitters.Get("emitterS0");
emitter.Submit(new SupportBean("E3", 4));
emitter.Submit(new SupportBean("E2", 3));
emitter.Submit(new SupportBean("E1", 1));
emitter.Submit(new SupportBean("E2", 2));
emitter.Submit(new SupportBean("E1", 5));
Assert.AreEqual(0, capture.Current.Length);
emitter.SubmitSignal(new EPDataFlowSignalFinalMarkerImpl());
EPAssertionUtil.AssertPropsPerRow(
epService.Container, capture.Current,
"TheString,sumInt".Split(','),
new[] { new object[] { "E1", 6 }, new object[] { "E2", 5 }, new object[] { "E3", 4 } });
instance.Cancel();
epService.EPAdministrator.DestroyAllStatements();
}
public void TestNonBlockingCancel()
{
// declare
_epService.EPAdministrator.CreateEPL(
"create dataflow MyDataFlowOne " +
"SourceOne -> outstream<SomeType> {}" +
"OutputOp(outstream) {}");
// instantiate
var latchOne = new CountDownLatch(1);
IDictionary <String, Object> ops = new Dictionary <String, Object>();
ops.Put(
"SourceOne", new DefaultSupportSourceOp(
new Object[]
{
latchOne, new Object[]
{
1
}
}));
var output = new DefaultSupportCaptureOp();
ops["OutputOp"] = output;
EPDataFlowInstantiationOptions options =
new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(ops));
EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
dfOne.Start();
Assert.AreEqual(EPDataFlowState.RUNNING, dfOne.State);
dfOne.Cancel();
latchOne.CountDown();
Thread.Sleep(100);
Assert.AreEqual(EPDataFlowState.CANCELLED, dfOne.State);
Assert.AreEqual(0, output.GetAndReset().Count);
}
public void TestNonBlockingJoinSingleRunnable()
{
// declare
_epService.EPAdministrator.CreateEPL(
"create dataflow MyDataFlowOne " +
"DefaultSupportSourceOp -> outstream<SomeType> {}" +
"DefaultSupportCaptureOp(outstream) {}");
// instantiate
var latch = new CountDownLatch(1);
var source = new DefaultSupportSourceOp(
new Object[]
{
latch, new Object[]
{
1
}
});
var future = new DefaultSupportCaptureOp(1);
EPDataFlowInstantiationOptions options =
new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(source, future));
EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName);
Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State);
dfOne.Start();
Thread.Sleep(100);
Assert.AreEqual(EPDataFlowState.RUNNING, dfOne.State);
latch.CountDown();
dfOne.Join();
Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State);
Assert.AreEqual(1, future.GetAndReset()[0].Count);
Assert.AreEqual(2, source.GetCurrentCount());
dfOne.Cancel();
Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State);
}
private void RunAssertion(EPServiceProvider epService, string format, bool?log, string layout, string title, bool?linefeed)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
string graph = "create dataflow MyConsoleOut\n" +
"Emitter -> instream<SupportBean>{name : 'e1'}\n" +
"LogSink(instream) {\n" +
(format == null ? "" : " format: '" + format + "',\n") +
(log == null ? "" : " log: " + log + ",\n") +
(layout == null ? "" : " layout: '" + layout + "',\n") +
(title == null ? "" : " title: '" + title + "',\n") +
(linefeed == null ? "" : " linefeed: " + linefeed + ",\n") +
"}";
EPStatement stmtGraph = epService.EPAdministrator.CreateEPL(graph);
EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MyConsoleOut");
Emitter emitter = instance.StartCaptive().Emitters.Get("e1");
emitter.Submit(new SupportBean("E1", 1));
instance.Cancel();
stmtGraph.Dispose();
}
private void RunAssertionStatementFilter(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_A));
epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_B));
// one statement Exists before the data flow
EPStatement stmt = epService.EPAdministrator.CreateEPL("select id from SupportBean_B");
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"create schema AllObjects Object," +
"EPStatementSource -> thedata<AllObjects> {} " +
"DefaultSupportCaptureOp(thedata) {}");
var captureOp = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager());
var options = new EPDataFlowInstantiationOptions();
var myFilter = new MyFilter();
options.ParameterProvider(new DefaultSupportGraphParamProvider(Collections.SingletonDataMap("statementFilter", myFilter)));
options.OperatorProvider(new DefaultSupportGraphOpProvider(captureOp));
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
df.Start();
epService.EPRuntime.SendEvent(new SupportBean_B("B1"));
captureOp.WaitForInvocation(200, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "B1" });
epService.EPAdministrator.CreateEPL("select TheString, IntPrimitive from SupportBean");
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
captureOp.WaitForInvocation(200, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "TheString,IntPrimitive".Split(','), new object[] { "E1", 1 });
EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("select id from SupportBean_A");
epService.EPRuntime.SendEvent(new SupportBean_A("A1"));
captureOp.WaitForInvocation(200, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "A1" });
stmtTwo.Stop();
epService.EPRuntime.SendEvent(new SupportBean_A("A2"));
Thread.Sleep(50);
Assert.AreEqual(0, captureOp.Current.Length);
stmtTwo.Start();
epService.EPRuntime.SendEvent(new SupportBean_A("A3"));
captureOp.WaitForInvocation(200, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "A3" });
epService.EPRuntime.SendEvent(new SupportBean_B("B2"));
captureOp.WaitForInvocation(200, 1);
EPAssertionUtil.AssertProps(
epService.Container, captureOp.GetCurrentAndReset()[0], "id".Split(','), new object[] { "B2" });
df.Cancel();
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
epService.EPRuntime.SendEvent(new SupportBean_A("A1"));
epService.EPRuntime.SendEvent(new SupportBean_B("B3"));
Assert.AreEqual(0, captureOp.Current.Length);
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionAudit(EPServiceProvider epService)
{
// stream, and test audit callback
var callback = new SupportAuditCallback();
AuditPath.AuditCallback = callback.Audit;
AUDITLOG.Info("*** Stream: ");
EPStatement stmtInput = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('stream') select * from SupportBean(TheString = 'E1')");
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(1, callback.Audits.Count);
AuditContext cb = callback.Audits[0];
Assert.AreEqual("SupportBean(TheString=...) inserted SupportBean[SupportBean(E1, 1)]", cb.Message);
Assert.AreEqual("ABC", cb.StatementName);
Assert.AreEqual(EPServiceProviderConstants.DEFAULT_ENGINE_URI, cb.EngineURI);
Assert.AreEqual(AuditEnum.STREAM, cb.Category);
AuditPath.AuditCallback = null;
stmtInput.Dispose();
AUDITLOG.Info("*** Named Window And Insert-Into: ");
EPStatement stmtNW = epService.EPAdministrator.CreateEPL("@Name('create') @Audit create window WinOne#keepall as SupportBean");
EPStatement stmtInsertNW = epService.EPAdministrator.CreateEPL("@Name('insert') @Audit insert into WinOne select * from SupportBean");
EPStatement stmtConsumeNW = epService.EPAdministrator.CreateEPL("@Name('select') @Audit select * from WinOne");
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
stmtNW.Dispose();
stmtInsertNW.Dispose();
stmtConsumeNW.Dispose();
AUDITLOG.Info("*** Insert-Into: ");
EPStatement stmtInsertInto = epService.EPAdministrator.CreateEPL("@Name('insert') @Audit insert into ABC select * from SupportBean");
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
stmtInsertInto.Dispose();
AUDITLOG.Info("*** Schedule: ");
epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
EPStatement stmtSchedule = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('schedule') select irstream * from SupportBean#time(1 sec)");
var listener = new SupportUpdateListener();
stmtSchedule.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
listener.Reset();
Log.Info("Sending time");
epService.EPRuntime.SendEvent(new CurrentTimeEvent(2000));
Assert.IsTrue(listener.IsInvoked);
listener.Reset();
stmtSchedule.Dispose();
// exprdef-instances
AUDITLOG.Info("*** Expression-Def: ");
EPStatement stmtExprDef = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('exprdef') " +
"expression DEF { 1 } " +
"expression INN { x => x.TheString }" +
"expression OUT { x => INN(x) } " +
"select DEF(), OUT(sb) from SupportBean sb");
stmtExprDef.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(1, listener.AssertOneGetNewAndReset().Get("DEF()"));
stmtExprDef.Dispose();
// pattern-instances
AUDITLOG.Info("*** Pattern-Lifecycle: ");
EPStatement stmtPatternLife = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('pattern-instances') select a.IntPrimitive as val0 from pattern [every a=SupportBean -> (b=SupportBean_ST0 and not SupportBean_ST1)]");
stmtPatternLife.Events += listener.Update;
Log.Info("Sending E1");
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Log.Info("Sending E2");
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
Log.Info("Sending E3");
epService.EPRuntime.SendEvent(new SupportBean_ST1("E3", 3));
stmtPatternLife.Dispose();
// pattern
AUDITLOG.Info("*** Pattern: ");
EPStatement stmtPattern = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('pattern') select a.IntPrimitive as val0 from pattern [a=SupportBean -> b=SupportBean_ST0]");
stmtPattern.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
epService.EPRuntime.SendEvent(new SupportBean_ST0("E2", 2));
Assert.AreEqual(1, listener.AssertOneGetNewAndReset().Get("val0"));
stmtPattern.Dispose();
// view
AUDITLOG.Info("*** View: ");
EPStatement stmtView = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('view') select IntPrimitive from SupportBean#lastevent");
stmtView.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
Assert.AreEqual(50, listener.AssertOneGetNewAndReset().Get("IntPrimitive"));
stmtView.Dispose();
EPStatement stmtGroupedView = epService.EPAdministrator.CreateEPL("@Audit Select * From SupportBean#groupwin(TheString)#length(2)");
stmtGroupedView.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
listener.Reset();
stmtGroupedView.Dispose();
EPStatement stmtGroupedWIntersectionView = epService.EPAdministrator.CreateEPL("@Audit Select * From SupportBean#groupwin(TheString)#length(2)#unique(IntPrimitive)");
stmtGroupedWIntersectionView.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
listener.Reset();
stmtGroupedWIntersectionView.Dispose();
// expression
AUDITLOG.Info("*** Expression: ");
EPStatement stmtExpr = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('expression') select IntPrimitive*100 as val0, sum(IntPrimitive) as val1 from SupportBean");
stmtExpr.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
Assert.AreEqual(5000, listener.AssertOneGetNew().Get("val0"));
Assert.AreEqual(50, listener.AssertOneGetNewAndReset().Get("val1"));
stmtExpr.Dispose();
// expression-detail
AUDITLOG.Info("*** Expression-Nested: ");
EPStatement stmtExprNested = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('expression-nested') select ('A'||TheString)||'X' as val0 from SupportBean");
stmtExprNested.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
Assert.AreEqual("AE1X", listener.AssertOneGetNewAndReset().Get("val0"));
stmtExprNested.Dispose();
// property
AUDITLOG.Info("*** Property: ");
EPStatement stmtProp = epService.EPAdministrator.CreateEPL("@Name('ABC') @Audit('property') select IntPrimitive from SupportBean");
stmtProp.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
Assert.AreEqual(50, listener.AssertOneGetNewAndReset().Get("IntPrimitive"));
stmtProp.Dispose();
// with aggregation
epService.EPAdministrator.CreateEPL("@Audit @Name ('create') create window MyWindow#keepall as SupportBean");
string eplWithAgg = "@Audit @Name('S0') on SupportBean as sel select count(*) from MyWindow as win having count(*)=3 order by win.IntPrimitive";
EPStatement stmtWithAgg = epService.EPAdministrator.CreateEPL(eplWithAgg);
stmtWithAgg.Dispose();
// data flow
EPStatement stmtDataflow = epService.EPAdministrator.CreateEPL("@Audit @Name('df') create dataflow MyFlow " +
"EventBusSource -> a<SupportBean> {filter:TheString like 'I%'} " +
"Filter(a) -> b {filter: true}" +
"LogSink(b) {log:false}");
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyFlow");
df.Start();
epService.EPRuntime.SendEvent(new SupportBean("I1", 1));
df.Cancel();
// context partitions
epService.EPAdministrator.CreateEPL("create context WhenEventArrives " +
"initiated by SupportBean_ST0 as st0 " +
"terminated by SupportBean_ST1(id=st0.id)");
epService.EPAdministrator.CreateEPL("@Audit('ContextPartition') context WhenEventArrives select * from SupportBean");
epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 0));
epService.EPRuntime.SendEvent(new SupportBean_ST1("E1", 0));
stmtDataflow.Dispose();
// table
AUDITLOG.Info("*** Table And Insert-Into and Into-table: ");
EPStatement stmtTable = epService.EPAdministrator.CreateEPL("@Name('create-table') @Audit create table TableOne(c0 string primary key, cnt count(*))");
EPStatement stmtIntoTable = epService.EPAdministrator.CreateEPL("@Name('into-table') @Audit into table TableOne select count(*) as cnt from SupportBean group by TheString");
EPStatement stmtAccessTable = epService.EPAdministrator.CreateEPL("@Name('access-table') @Audit select TableOne[id].cnt from SupportBean_ST0");
stmtAccessTable.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 0));
stmtTable.Dispose();
stmtIntoTable.Dispose();
stmtAccessTable.Dispose();
}