public void RunAssertionCreateSchemaModelAfter(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema EventTypeOne (hsi int)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema EventTypeTwo (event EventTypeOne)");
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window NamedWindow.std:unique(event.hsi) as EventTypeTwo");
_epService.EPAdministrator.CreateEPL("on EventTypeOne as ev insert into NamedWindow select ev as event");
IDictionary <String, object> theEvent = new LinkedHashMap <string, object>();
theEvent.Put("hsi", 10);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "EventTypeOne");
}
else
{
_epService.EPRuntime.SendEvent(theEvent, "EventTypeOne");
}
var result = stmt.First();
var getter = result.EventType.GetGetter("event.hsi");
Assert.AreEqual(10, getter.Get(result));
_epService.Initialize();
}
public void RunAssertionEventTypeColumnDef(EventRepresentationEnum eventRepresentationEnum)
{
var stmtSchema = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SchemaOne(col1 int, col2 int)");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtSchema.EventType.UnderlyingType);
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window SchemaWindow.std:lastevent() as (s1 SchemaOne)");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
stmt.AddListener(_listenerWindow);
_epService.EPAdministrator.CreateEPL("insert into SchemaWindow (s1) select sone from SchemaOne as sone");
IDictionary <String, object> theEvent = new LinkedHashMap <string, object>();
theEvent.Put("col1", 10);
theEvent.Put("col2", 11);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "SchemaOne");
}
else
{
_epService.EPRuntime.SendEvent(theEvent, "SchemaOne");
}
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), "s1.col1,s1.col2".Split(','), new object[] { 10, 11 });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("SchemaOne", true);
_epService.EPAdministrator.Configuration.RemoveEventType("SchemaWindow", true);
}
private void RunTransposeMapAndObjectArray(EventRepresentationEnum representation)
{
String[] fields = "p0,p1".Split(',');
_epService.EPAdministrator.CreateEPL("create " + representation.GetOutputTypeCreateSchemaName() + " schema MySchema(p0 string, p1 int)");
String generateFunction = representation == EventRepresentationEnum.MAP ? "generateMap" : "generateOA";
String epl = "@Name('first') insert into MySchema select transpose(" + generateFunction + "(TheString, IntPrimitive)) from SupportBean";
_epService.EPAdministrator.CreateEPL(epl).Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E1", 1 });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E2", 2 });
// MySchema already exists, start second statement
_epService.EPAdministrator.CreateEPL(epl).AddListener(_listener);
_epService.EPAdministrator.GetStatement("first").Dispose();
_epService.EPRuntime.SendEvent(new SupportBean("E3", 3));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E3", 3 });
_epService.EPAdministrator.Configuration.RemoveEventType("MySchema", true);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionObjectArrayDelivery(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowObjectArr();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select TheString, IntPrimitive from SupportBean.std:unique(TheString)");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertEqualsAnyOrder(
subscriber.GetAndResetIndicate()[0], new Object[]
{
"E1", 1
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 10));
EPAssertionUtil.AssertEqualsAnyOrder(
subscriber.GetAndResetIndicate()[0], new Object[]
{
"E2", 10
}
);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionWidening(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowSpecific();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select BytePrimitive, IntPrimitive, LongPrimitive, FloatPrimitive from SupportBean(TheString='E1')");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
var bean = new SupportBean();
bean.TheString = "E1";
bean.BytePrimitive = 1;
bean.IntPrimitive = 2;
bean.LongPrimitive = 3;
bean.FloatPrimitive = 4;
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
1, 2L, 3d, 4d
}
, subscriber.GetAndResetIndicate()[0]);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertPopulateFromNamedWindow(EventRepresentationEnum type)
{
_epService.EPAdministrator.CreateEPL("create " + type.GetOutputTypeCreateSchemaName() + " schema Node(nid string)");
_epService.EPAdministrator.CreateEPL("create window NodeWindow.std:unique(nid) as Node");
_epService.EPAdministrator.CreateEPL("insert into NodeWindow select * from Node");
_epService.EPAdministrator.CreateEPL("create " + type.GetOutputTypeCreateSchemaName() + " schema NodePlus(npid string, node Node)");
var stmt = _epService.EPAdministrator.CreateEPL("insert into NodePlus select 'E1' as npid, n1 as node from NodeWindow n1");
stmt.Events += _listener.Update;
if (type.GetOutputClass() == typeof(object[]))
{
_epService.EPRuntime.SendEvent(new Object[] { "n1" }, "Node");
}
else
{
_epService.EPRuntime.SendEvent(Collections.SingletonDataMap("nid", "n1"), "Node");
}
var @event = _listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", @event.Get("npid"));
Assert.AreEqual("n1", @event.Get("node.nid"));
var fragment = (EventBean)@event.GetFragment("node");
Assert.AreEqual("Node", fragment.EventType.Name);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("Node", true);
_epService.EPAdministrator.Configuration.RemoveEventType("NodePlus", true);
_epService.EPAdministrator.Configuration.RemoveEventType("NodeWindow", true);
}
public void RunAssertionSplitPremptiveNamedWindow(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TypeTwo(col2 int)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TypeTrigger(trigger int)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window WinTwo.win:keepall() as TypeTwo");
var stmtOrigText = "on TypeTrigger " +
"insert into OtherStream select 1 " +
"insert into WinTwo(col2) select 2 " +
"output all";
_epService.EPAdministrator.CreateEPL(stmtOrigText);
var stmt = _epService.EPAdministrator.CreateEPL("on OtherStream select col2 from WinTwo");
stmt.Events += _listener.Update;
// populate WinOne
_epService.EPRuntime.SendEvent(new SupportBean("E1", 2));
// fire trigger
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.GetEventSender("TypeTrigger").SendEvent(new Object[] { null });
}
else
{
_epService.EPRuntime.GetEventSender("TypeTrigger").SendEvent(new DataMapImpl());
}
Assert.AreEqual(2, _listener.AssertOneGetNewAndReset().Get("col2"));
_epService.Initialize();
}
private void RunAssertionOutputLimitNoJoin(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowSpecific();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select TheString, IntPrimitive from SupportBean output every 2 events");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(0, subscriber.GetAndResetIndicate().Count);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertEqualsExactOrder(new Object[][]
{
new Object[]
{
"E1", 1
}
,
new Object[]
{
"E2", 2
}
}
, subscriber.GetAndResetIndicate());
_epService.EPAdministrator.DestroyAllStatements();
}
public void RunAssertionDocExample(EventRepresentationEnum eventRepresentationEnum)
{
string baseModule = eventRepresentationEnum.GetAnnotationText() + " create schema OrderEvent as (orderId string, productId string, price double, quantity int, deletedFlag boolean)";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(baseModule, null, null, null);
string appModuleOne = eventRepresentationEnum.GetAnnotationText() + " create schema ProductTotalRec as (productId string, totalPrice double);" +
"" +
eventRepresentationEnum.GetAnnotationText() + " @Name('nwProd') create window ProductWindow.std:unique(productId) as ProductTotalRec;" +
"" +
"on OrderEvent oe\n" +
"merge ProductWindow pw\n" +
"where pw.productId = oe.productId\n" +
"when matched\n" +
"then update set totalPrice = totalPrice + oe.price\n" +
"when not matched\n" +
"then insert select productId, price as totalPrice;";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(appModuleOne, null, null, null);
string appModuleTwo = eventRepresentationEnum.GetAnnotationText() + " @Name('nwOrd') create window OrderWindow.win:keepall() as OrderEvent;" +
"" +
"on OrderEvent oe\n" +
" merge OrderWindow pw\n" +
" where pw.orderId = oe.orderId\n" +
" when not matched \n" +
" then insert select *\n" +
" when matched and oe.deletedFlag=true\n" +
" then delete\n" +
" when matched\n" +
" then update set pw.quantity = oe.quantity, pw.price = oe.price";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(appModuleTwo, null, null, null);
SendOrderEvent(eventRepresentationEnum, "O1", "P1", 10, 100, false);
SendOrderEvent(eventRepresentationEnum, "O1", "P1", 11, 200, false);
SendOrderEvent(eventRepresentationEnum, "O2", "P2", 3, 300, false);
EPAssertionUtil.AssertPropsPerRowAnyOrder(_epService.EPAdministrator.GetStatement("nwProd").GetEnumerator(), "productId,totalPrice".Split(','), new object[][] { new object[] { "P1", 21d }, new object[] { "P2", 3d } });
EPAssertionUtil.AssertPropsPerRowAnyOrder(_epService.EPAdministrator.GetStatement("nwOrd").GetEnumerator(), "orderId,quantity".Split(','), new object[][] { new object[] { "O1", 200 }, new object[] { "O2", 300 } });
string module = "create schema StreetCarCountSchema (streetid string, carcount int);" +
" create schema StreetChangeEvent (streetid string, action string);" +
" create window StreetCarCountWindow.std:unique(streetid) as StreetCarCountSchema;" +
" on StreetChangeEvent ce merge StreetCarCountWindow w where ce.streetid = w.streetid\n" +
" when not matched and ce.action = 'ENTER' then insert select streetid, 1 as carcount\n" +
" when matched and ce.action = 'ENTER' then update set StreetCarCountWindow.carcount = carcount + 1\n" +
" when matched and ce.action = 'LEAVE' then update set StreetCarCountWindow.carcount = carcount - 1;" +
" select * from StreetCarCountWindow;";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(module, null, null, null);
_epService.EPAdministrator.DestroyAllStatements();
foreach (string name in "OrderEvent,OrderWindow,StreetCarCountSchema,StreetCarCountWindow,StreetChangeEvent,ProductWindow,ProductTotalRec".Split(','))
{
_epService.EPAdministrator.Configuration.RemoveEventType(name, true);
}
}
public void RunAssertionFragment(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema InnerSchema as (key string)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema MySchema as (inside InnerSchema, insidearr InnerSchema[])");
var fields = new String[] { "t0", "t1" };
String stmtText = eventRepresentationEnum.GetAnnotationText()
+ " select Typeof(s0.inside) as t0, Typeof(s0.insidearr) as t1 from MySchema as s0";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[2], "MySchema");
}
else
{
_epService.EPRuntime.SendEvent(new Dictionary <String, Object>(),
"MySchema");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null });
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[] { new Object[2], null }, "MySchema");
}
else
{
var theEvent = new Dictionary <String, Object>();
theEvent["inside"] = new Dictionary <String, Object>();
_epService.EPRuntime.SendEvent(theEvent, "MySchema");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "InnerSchema", null });
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[] { null, new Object[2][] }, "MySchema");
}
else
{
var theEvent = new Dictionary <String, Object>();
theEvent["insidearr"] = new IDictionary <string, object> [0];
_epService.EPRuntime.SendEvent(theEvent, "MySchema");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, "InnerSchema[]" });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("InnerSchema", true);
_epService.EPAdministrator.Configuration.RemoveEventType("MySchema", true);
}
private void RunAssertionPerformance(bool namedWindow, EventRepresentationEnum outputType)
{
string eplCreate = namedWindow ?
outputType.GetAnnotationText() + " create window MyWindow.win:keepall() as (c1 string, c2 int)" :
"create table MyWindow(c1 string primary key, c2 int)";
EPStatement stmtNamedWindow = _epService.EPAdministrator.CreateEPL(eplCreate);
Assert.AreEqual(outputType.GetOutputClass(), stmtNamedWindow.EventType.UnderlyingType);
// preload events
EPStatement stmt = _epService.EPAdministrator.CreateEPL("insert into MyWindow select TheString as c1, IntPrimitive as c2 from SupportBean");
int totalUpdated = 5000;
for (int i = 0; i < totalUpdated; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 0));
}
stmt.Dispose();
string epl = "on SupportBean sb merge MyWindow nw where nw.c1 = sb.TheString " +
"when matched then update set nw.c2=sb.IntPrimitive";
stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_mergeListener);
// prime
for (int i = 0; i < 100; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 1));
}
var delta = PerformanceObserver.TimeMillis(
() =>
{
for (int i = 0; i < totalUpdated; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 1));
}
});
// verify
IEnumerator <EventBean> events = stmtNamedWindow.GetEnumerator();
int count = 0;
while (events.MoveNext())
{
EventBean next = events.Current;
Assert.AreEqual(1, next.Get("c2"));
count++;
}
Assert.AreEqual(totalUpdated, count);
Assert.IsTrue(delta < 500, "Delta=" + delta);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
}
private void SendMyEvent(EventRepresentationEnum eventRepresentationEnum, string in1, int in2) {
IDictionary<String, object> theEvent = new LinkedHashMap<string, object>();
theEvent.Put("in1", in1);
theEvent.Put("in2", in2);
if (eventRepresentationEnum.IsObjectArrayEvent()) {
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "MyEvent");
}
else {
_epService.EPRuntime.SendEvent(theEvent, "MyEvent");
}
}
public static void AddAnnotation(this EventRepresentationEnum value, EPStatementObjectModel model)
{
if (value == EventRepresentationEnum.DEFAULT)
{
return;
}
AnnotationPart part = new AnnotationPart(typeof(EventRepresentation).Name);
part.AddValue("Array", value == EventRepresentationEnum.OBJECTARRAY);
model.Annotations = Collections.SingletonList(part);
}
private void RunAssertionFields(EventRepresentationEnum representationEnum, bool eventbean)
{
EPDataFlowInstantiationOptions options;
_epService.EPAdministrator.CreateEPL("create " + representationEnum.GetOutputTypeCreateSchemaName() + " schema MyEvent(p0 string, p1 long, p2 double)");
var stmtGraph = _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " +
"" +
"BeaconSource -> BeaconStream<" + (eventbean ? "EventBean<MyEvent>" : "MyEvent") + "> {" +
" iterations : 3," +
" p0 : 'abc'," +
" p1 : MyMath.Round(MyMath.Random() * 10) + 1," +
" p2 : 1d," +
"}" +
"DefaultSupportCaptureOp(BeaconStream) {}");
var future = new DefaultSupportCaptureOp(3);
options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future));
var df = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
df.Start();
Object[] output = future.GetValue(TimeSpan.FromSeconds(2));
Assert.AreEqual(3, output.Length);
for (var i = 0; i < 3; i++)
{
if (!eventbean)
{
if (representationEnum.IsObjectArrayEvent())
{
var row = (Object[])output[i];
Assert.AreEqual("abc", row[0]);
long val = row[1].AsLong();
Assert.IsTrue(val >= 0 && val <= 11, "val=" + val);
Assert.AreEqual(1d, row[2]);
}
else
{
var row = (DataMap)output[i];
Assert.AreEqual("abc", row.Get("p0"));
long val = row.Get("p1").AsLong();
Assert.IsTrue(val >= 0 && val <= 11, "val=" + val);
Assert.AreEqual(1d, row.Get("p2"));
}
}
else
{
var row = (EventBean)output[i];
Assert.AreEqual("abc", row.Get("p0"));
}
}
stmtGraph.Dispose();
_epService.EPAdministrator.Configuration.RemoveEventType("MyEvent", true);
}
private void SendSentenceEvent(EventRepresentationEnum eventRepresentationEnum, string sentence)
{
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new object[] { sentence }, "SentenceEvent");
}
else
{
_epService.EPRuntime.SendEvent(
Collections.SingletonDataMap("sentence", sentence), "SentenceEvent");
}
}
private void RunAssertionCreateStreamTwo(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema MyEvent(myId int)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema AllMyEvent as (myEvent MyEvent, class String, reverse boolean)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema SuspectMyEvent as (myEvent MyEvent, class String)");
var stmtOne = _epService.EPAdministrator.CreateEPL(
"insert into AllMyEvent "
+ "select c as myEvent, 'test' as class, false as reverse "
+ "from MyEvent(myId=1) c");
stmtOne.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmtOne.EventType.UnderlyingType);
var stmtTwo = _epService.EPAdministrator.CreateEPL(
"insert into SuspectMyEvent "
+ "select c.myEvent as myEvent, class "
+ "from AllMyEvent(not reverse) c");
var listenerTwo = new SupportUpdateListener();
stmtTwo.Events += listenerTwo.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(MakeEvent(1).Values.ToArray(), "MyEvent");
}
else
{
_epService.EPRuntime.SendEvent(MakeEvent(1), "MyEvent");
}
var resultOne = _listener.AssertOneGetNewAndReset();
Assert.IsTrue(resultOne.Get("myEvent") is EventBean);
Assert.AreEqual(1, ((EventBean)resultOne.Get("myEvent")).Get("myId"));
Assert.NotNull(stmtOne.EventType.GetFragmentType("myEvent"));
var resultTwo = listenerTwo.AssertOneGetNewAndReset();
Assert.IsTrue(resultTwo.Get("myEvent") is EventBean);
Assert.AreEqual(1, ((EventBean)resultTwo.Get("myEvent")).Get("myId"));
Assert.NotNull(stmtTwo.EventType.GetFragmentType("myEvent"));
_epService.Initialize();
}
private void RunAssertionInsertWhereOMStaggered(EventRepresentationEnum eventRepresentationEnum)
{
IDictionary <String, object> dataType = MakeMap(new object[][] { new object[] { "a", typeof(string) }, new object[] { "b", typeof(int) } });
epService.EPAdministrator.Configuration.AddEventType("MyMap", dataType);
string stmtTextCreateOne = eventRepresentationEnum.GetAnnotationText() + " create window MyWindow.win:keepall() as select a, b from MyMap";
EPStatement stmtCreateOne = epService.EPAdministrator.CreateEPL(stmtTextCreateOne);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateOne.EventType.UnderlyingType);
stmtCreateOne.AddListener(listeners[0]);
// create insert into
string stmtTextInsertOne = "insert into MyWindow select a, b from MyMap";
epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
// populate some data
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E1" }, new object[] { "b", 2 } }), "MyMap");
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E2" }, new object[] { "b", 10 } }), "MyMap");
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E3" }, new object[] { "b", 10 } }), "MyMap");
// create window with keep-all using OM
EPStatementObjectModel model = new EPStatementObjectModel();
eventRepresentationEnum.AddAnnotation(model);
Expression where = Expressions.Eq("b", 10);
model.CreateWindow = CreateWindowClause.Create("MyWindowTwo", View.Create("win", "keepall")).SetInsert(true).SetInsertWhereClause(where);
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create("MyWindow"));
string text = eventRepresentationEnum.GetAnnotationText() + " create window MyWindowTwo.win:keepall() as select * from MyWindow insert where b=10";
Assert.AreEqual(text.Trim(), model.ToEPL());
EPStatementObjectModel modelTwo = epService.EPAdministrator.CompileEPL(text);
Assert.AreEqual(text.Trim(), modelTwo.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(modelTwo);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "a,b".Split(','), new object[][] { new object[] { "E2", 10 }, new object[] { "E3", 10 } });
// test select individual fields and from an insert-from named window
stmt = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window MyWindowThree.win:keepall() as select a from MyWindowTwo insert where a = 'E2'");
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "a".Split(','), new object[][] { new object[] { "E2" } });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
epService.EPAdministrator.Configuration.RemoveEventType("MyWindowTwo", true);
epService.EPAdministrator.Configuration.RemoveEventType("MyWindowThree", true);
}
private void RunAssertionMapTranspose(EventRepresentationEnum eventRepresentationEnum)
{
IDictionary <String, object> innerTypeOne = new Dictionary <string, object>();
innerTypeOne.Put("i1", typeof(int));
IDictionary <String, object> innerTypeTwo = new Dictionary <string, object>();
innerTypeTwo.Put("i2", typeof(int));
IDictionary <String, object> outerType = new Dictionary <string, object>();
outerType.Put("one", "T1");
outerType.Put("two", "T2");
_epService.EPAdministrator.Configuration.AddEventType("T1", innerTypeOne);
_epService.EPAdministrator.Configuration.AddEventType("T2", innerTypeTwo);
_epService.EPAdministrator.Configuration.AddEventType("OuterType", outerType);
// create window
var stmtTextCreate = eventRepresentationEnum.GetAnnotationText() + " create window MyWindow.win:keepall() as select one, two from OuterType";
var stmtCreate = _epService.EPAdministrator.CreateEPL(stmtTextCreate);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreate.EventType.UnderlyingType);
stmtCreate.AddListener(_listenerWindow);
EPAssertionUtil.AssertEqualsAnyOrder(stmtCreate.EventType.PropertyNames, new string[] { "one", "two" });
var eventType = stmtCreate.EventType;
Assert.AreEqual("T1", eventType.GetFragmentType("one").FragmentType.Name);
Assert.AreEqual("T2", eventType.GetFragmentType("two").FragmentType.Name);
// create insert into
var stmtTextInsertOne = "insert into MyWindow select one, two from OuterType";
_epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
IDictionary <String, object> innerDataOne = new Dictionary <string, object>();
innerDataOne.Put("i1", 1);
IDictionary <String, object> innerDataTwo = new Dictionary <string, object>();
innerDataTwo.Put("i2", 2);
IDictionary <String, object> outerData = new Dictionary <string, object>();
outerData.Put("one", innerDataOne);
outerData.Put("two", innerDataTwo);
_epService.EPRuntime.SendEvent(outerData, "OuterType");
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), "one.i1,two.i2".Split(','), new object[] { 1, 2 });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
}
private void SendOrderEvent(EventRepresentationEnum eventRepresentationEnum, string orderId, string productId, double price, int quantity, bool deletedFlag) {
IDictionary<String, object> theEvent = new LinkedHashMap<string, object>();
theEvent.Put("orderId", orderId);
theEvent.Put("productId", productId);
theEvent.Put("price", price);
theEvent.Put("quantity", quantity);
theEvent.Put("deletedFlag", deletedFlag);
if (eventRepresentationEnum.IsObjectArrayEvent()) {
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "OrderEvent");
}
else {
_epService.EPRuntime.SendEvent(theEvent, "OrderEvent");
}
}
private void SendEventOne(EPServiceProvider epService, EventRepresentationEnum eventRepresentationEnum, String id)
{
IDictionary <String, Object> theEvent = new LinkedHashMap <String, Object>();
theEvent.Put("id", id);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "EventOne");
}
else
{
epService.EPRuntime.SendEvent(theEvent, "EventOne");
}
}
public static bool IsObjectArrayEvent(this EventRepresentationEnum value)
{
switch (value)
{
case EventRepresentationEnum.OBJECTARRAY:
return(true);
case EventRepresentationEnum.MAP:
return(false);
default:
return(false);
}
}
public static string GetOutputTypeCreateSchemaName(this EventRepresentationEnum value)
{
switch (value)
{
case EventRepresentationEnum.OBJECTARRAY:
return(" objectarray");
case EventRepresentationEnum.MAP:
return(" map");
default:
return(null);
}
}
public static string GetAnnotationText(this EventRepresentationEnum value)
{
switch (value)
{
case EventRepresentationEnum.OBJECTARRAY:
return("@EventRepresentation(Array=True)");
case EventRepresentationEnum.MAP:
return("@EventRepresentation(Array=False)");
default:
return(string.Empty);
}
}
public void RunAssertionNestableMapArray(EventRepresentationEnum eventRepresentationEnum)
{
EPStatement stmtInner = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyInnerType as (col1 string[], col2 int[])");
EventType inner = stmtInner.EventType;
Assert.AreEqual(typeof(string[]), inner.GetPropertyType("col1"));
Assert.IsTrue(inner.GetPropertyDescriptor("col1").IsIndexed);
Assert.AreEqual(typeof(int[]), inner.GetPropertyType("col2"));
Assert.IsTrue(inner.GetPropertyDescriptor("col2").IsIndexed);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), inner.UnderlyingType);
EPStatement stmtOuter = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyOuterType as (col1 MyInnerType, col2 MyInnerType[])");
FragmentEventType type = stmtOuter.EventType.GetFragmentType("col1");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsFalse(type.IsIndexed);
Assert.IsFalse(type.IsNative);
type = stmtOuter.EventType.GetFragmentType("col2");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsTrue(type.IsIndexed);
Assert.IsFalse(type.IsNative);
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL("select * from MyOuterType");
stmtSelect.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtSelect.EventType.UnderlyingType);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Object[] innerData = { "abc,def".Split(','), new int[] { 1, 2 } };
Object[] outerData = { innerData, new Object[] { innerData, innerData } };
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
else
{
IDictionary <String, Object> innerData = new Dictionary <String, Object>();
innerData.Put("col1", "abc,def".Split(','));
innerData.Put("col2", new int[] { 1, 2 });
IDictionary <String, Object> outerData = new Dictionary <String, Object>();
outerData.Put("col1", innerData);
outerData.Put("col2", new DataMap[] { innerData, innerData });
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "col1.col1[1],col2[1].col2[1]".Split(','), new Object[] { "def", 2 });
_epService.EPAdministrator.Configuration.RemoveEventType("MyInnerType", true);
_epService.EPAdministrator.Configuration.RemoveEventType("MyOuterType", true);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionObjectArrayDelivery(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberRowByRowObjectArrayBase subscriber)
{
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select TheString, IntPrimitive from SupportBean.std:unique(TheString)");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
subscriber.AssertOneAndReset(stmt, new object[] { "E1", 1 });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 10));
subscriber.AssertOneAndReset(stmt, new object[] { "E2", 10 });
stmt.Dispose();
}
private void RunAssertionOutputLimitNoJoin(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberRowByRowSpecificBase subscriber)
{
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select TheString, IntPrimitive from SupportBean output every 2 events");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
subscriber.AssertNoneReceived();
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
subscriber.AssertMultipleReceivedAndReset(stmt, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
stmt.Dispose();
}
private void SendPortfolio(EventRepresentationEnum eventRepresentationEnum, string portfolio, string product)
{
IDictionary <String, object> theEvent = new LinkedHashMap <string, object>();
theEvent.Put("portfolio", portfolio);
theEvent.Put("product", product);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "Portfolio");
}
else
{
_epService.EPRuntime.SendEvent(theEvent, "Portfolio");
}
}
public static Type GetOutputClass(this EventRepresentationEnum value)
{
switch (value)
{
case EventRepresentationEnum.OBJECTARRAY:
return(typeof(object[]));
case EventRepresentationEnum.MAP:
return(typeof(IDictionary <string, object>));
default:
return(EventRepresentationExtensions.Default == EventRepresentation.OBJECTARRAY
? typeof(object[])
: typeof(IDictionary <string, object>));
}
}
private void MakeSendScoreEvent(String typeName, EventRepresentationEnum eventRepresentationEnum, String userId, String keyword, String productId, long score)
{
IDictionary <String, Object> theEvent = new LinkedHashMap <String, Object>();
theEvent.Put("userId", userId);
theEvent.Put("keyword", keyword);
theEvent.Put("productId", productId);
theEvent.Put("score", score);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), typeName);
}
else
{
_epService.EPRuntime.SendEvent(theEvent, typeName);
}
}
private void RunAssertionGetDynamicWObjectArr(EventRepresentationEnum eventRepresentationEnum)
{
String stmtText = eventRepresentationEnum.GetAnnotationText()
+ " select item.id? as myid from "
+ typeof (SupportBeanDynRoot).FullName;
using (var stmt = _epService.EPAdministrator.CreateEPL(stmtText))
{
stmt.Events += _listener.Update;
// check type
Assert.AreEqual(typeof (object), stmt.EventType.GetPropertyType("myid"));
// check value with an object that has the property as an int
var runtime = _epService.EPRuntime;
runtime.SendEvent(
new SupportBeanDynRoot(new SupportBean_S0(101)));
Assert.AreEqual(101, _listener.AssertOneGetNewAndReset().Get("myid"));
// check value with an object that doesn't have the property
runtime.SendEvent(new SupportBeanDynRoot("abc"));
Assert.AreEqual(null, _listener.AssertOneGetNewAndReset().Get("myid"));
// check value with an object that has the property as a string
runtime.SendEvent(
new SupportBeanDynRoot(new SupportBean_A("e1")));
Assert.AreEqual("e1", _listener.AssertOneGetNewAndReset().Get("myid"));
runtime.SendEvent(
new SupportBeanDynRoot(new SupportBean_B("e2")));
Assert.AreEqual("e2", _listener.AssertOneGetNewAndReset().Get("myid"));
runtime.SendEvent(
new SupportBeanDynRoot(new SupportBean_S1(102)));
Assert.AreEqual(102, _listener.AssertOneGetNewAndReset().Get("myid"));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Assert.AreEqual(typeof (object[]), stmt.EventType.UnderlyingType);
}
else
{
Assert.AreEqual(typeof (IDictionary<string, object>), stmt.EventType.UnderlyingType);
}
}
}
