public void Run(RegressionEnvironment env) { // Test substitution parameter and inheritance in key matching var path = new RegressionPath(); var types = "create schema MyEventOne as " + typeof(MyEventOne).MaskTypeName() + ";\n" + "create schema MyEventTwo as " + typeof(MyEventTwo).MaskTypeName() + ";\n"; env.CompileDeployWBusPublicType(types, path); var epl = "select * from MyEventOne(Key = ?::IKey)"; var compiled = env.Compile(epl, path); var lKey = new MyObjectKeyInterface(); DeployWithResolver(env, compiled, "s0", prepared => prepared.SetObject(1, lKey)); env.AddListener("s0"); env.SendEventBean(new MyEventOne(lKey)); Assert.IsTrue(env.Listener("s0").GetAndClearIsInvoked()); // Test substitution parameter and concrete subclass in key matching epl = "select * from MyEventTwo where Key = ?::MyObjectKeyConcrete"; compiled = env.Compile(epl, path); var cKey = new MyObjectKeyConcrete(); DeployWithResolver(env, compiled, "s1", prepared => prepared.SetObject(1, cKey)); env.AddListener("s1"); env.SendEventBean(new MyEventTwo(cKey)); Assert.IsTrue(env.Listener("s1").GetAndClearIsInvoked()); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { string epl = "create objectarray schema Event();\n" + "create objectarray schema ChildEvent(id string, action string) inherits Event;\n" + "create objectarray schema Incident(name string, event Event);\n" + "@Name('window') create window IncidentWindow#keepall as Incident;\n" + "\n" + "on ChildEvent e\n" + " merge IncidentWindow w\n" + " where e.id = cast(w.event.id? as string)\n" + " when not matched\n" + " then insert (name, event) select 'ChildIncident', e \n" + " where e.action = 'INSERT'\n" + " when matched\n" + " then update set w.event = e \n" + " where e.action = 'INSERT'\n" + " then delete\n" + " where e.action = 'CLEAR';"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); env.SendEventObjectArray(new object[] {"ID1", "INSERT"}, "ChildEvent"); EventBean @event = env.Statement("window").First(); object[] underlying = (object[]) @event.Underlying; Assert.AreEqual("ChildIncident", underlying[0]); object[] underlyingInner = (object[]) ((EventBean) underlying[1]).Underlying; EPAssertionUtil.AssertEqualsExactOrder(new object[] {"ID1", "INSERT"}, underlyingInner); env.UndeployAll(); }
private void RunAssertionDynamicProp(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeployWBusPublicType("create avro schema MyEvent()", path); env.CompileDeploy("@Name('s0') select * from MyEvent", path).AddListener("s0"); var schema = ((AvroEventType) env.Statement("s0").EventType).SchemaAvro; env.SendEventAvro(new GenericRecord(schema.AsRecordSchema()), "MyEvent"); var @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(null, @event.Get("a?.b")); var innerSchema = SchemaBuilder.Record( "InnerSchema", Field("b", StringType(Property(PROP_STRING_KEY, PROP_STRING_VALUE)))); var inner = new GenericRecord(innerSchema); inner.Put("b", "X"); var recordSchema = SchemaBuilder.Record( "RecordSchema", Field("a", innerSchema)); var record = new GenericRecord(recordSchema); record.Put("a", inner); env.SendEventAvro(record, "MyEvent"); @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual("X", @event.Get("a?.b")); env.UndeployAll(); }
private static void TryAssertion2StreamInnerWGroupBy(RegressionEnvironment env) { var epl = "create objectarray schema E1 (id string, grp string, value int);\n" + "create objectarray schema E2 (id string, value2 int);\n" + "@Name('s0') select count(*) as c0, sum(E1.value) as c1, E1.id as c2 " + "from E1 unidirectional inner join E2#keepall on E1.id = E2.id group by E1.grp"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); env.AddListener("s0"); var fields = new[] {"c0", "c1", "c2"}; env.SendEventObjectArray(new object[] {"A", 100}, "E2"); Assert.IsFalse(env.Listener("s0").IsInvoked); env.SendEventObjectArray(new object[] {"A", "X", 10}, "E1"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {1L, 10, "A"}); env.SendEventObjectArray(new object[] {"A", "Y", 20}, "E1"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {1L, 20, "A"}); env.UndeployAll(); }
private static void TryAssertionTypableNewOperatorDocSample( RegressionEnvironment env, string typeType) { var path = new RegressionPath(); env.CompileDeploy("create " + typeType + " schema Item(name string, Price double)", path); env.CompileDeploy("create " + typeType + " schema PurchaseOrder(OrderId string, items Item[])", path); env.CompileDeployWBusPublicType("create schema TriggerEvent()", path); env.CompileDeploy( "@Name('s0') insert into PurchaseOrder select '001' as OrderId, new {name= 'i1', Price=10} as items from TriggerEvent", path) .AddListener("s0"); env.SendEventMap(Collections.EmptyDataMap, "TriggerEvent"); var @event = env.Listener("s0").AssertOneGetNewAndReset(); EPAssertionUtil.AssertProps( @event, new[] {"OrderId", "items[0].name", "items[0].Price"}, new object[] {"001", "i1", 10d}); var underlying = (EventBean[]) @event.Get("items"); Assert.AreEqual(1, underlying.Length); Assert.AreEqual("i1", underlying[0].Get("name")); Assert.AreEqual(10d, underlying[0].Get("Price")); env.UndeployAll(); }
private static void TryAssertionFragmentSingeColNamedWindow(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeployWBusPublicType("create schema AEvent (Symbol string)", path); env.CompileDeploy("create window MyEventWindow#lastevent (e AEvent)", path); env.CompileDeploy( "insert into MyEventWindow select (select * from AEvent#lastevent) as e from SupportBean(TheString = 'A')", path); env.CompileDeploy("create schema BEvent (e AEvent)", path); env.CompileDeploy( "@Name('s0') insert into BEvent select (select e from MyEventWindow) as e from SupportBean(TheString = 'B')", path) .AddListener("s0"); env.SendEventMap(Collections.SingletonDataMap("Symbol", "GE"), "AEvent"); env.SendEventBean(new SupportBean("A", 1)); env.SendEventBean(new SupportBean("B", 2)); var result = env.Listener("s0").AssertOneGetNewAndReset(); var fragment = (EventBean) result.Get("e"); Assert.AreEqual("AEvent", fragment.EventType.Name); Assert.AreEqual("GE", fragment.Get("Symbol")); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeployWBusPublicType("create schema Geofence(x double, y double, vin string)", path); env.CompileDeploy( "create table Regions(regionId string primary key, rx double, ry double, rwidth double, rheight double)", path); env.CompileDeploy( "create index RectangleIndex on Regions((rx, ry, rwidth, rheight) mxcifquadtree(0, 0, 10, 12))", path); env.CompileDeploy( "@Name('s0') " + IndexBackingTableInfo.INDEX_CALLBACK_HOOK + "on Geofence as vin insert into VINWithRegion select regionId, vin from Regions where rectangle(rx, ry, rwidth, rheight).intersects(rectangle(vin.x, vin.y, 0, 0))", path); env.AddListener("s0"); SupportQueryPlanIndexHook.AssertOnExprTableAndReset( "RectangleIndex", "non-unique hash={} btree={} advanced={mxcifquadtree(rx,ry,rwidth,rheight)}"); env.CompileExecuteFAF("insert into Regions values ('R1', 2, 2, 5, 5)", path); env.SendEventMap(CollectionUtil.PopulateNameValueMap("x", 3d, "y", 3d, "vin", "V1"), "Geofence"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"vin", "regionId"}, new object[] {"V1", "R1"}); env.UndeployAll(); }
private static void TryAssertionFromClauseDocSample(RegressionEnvironment env) { var epl = "create schema MyOrderItem(itemId string);\n" + "create schema MyOrderEvent(OrderId string, items MyOrderItem[]);\n" + "on MyOrderEvent\n" + " insert into MyOrderBeginEvent select OrderId\n" + " insert into MyOrderItemEvent select * from [select OrderId, * from items]\n" + " insert into MyOrderEndEvent select OrderId\n" + " output all;\n" + "create context MyOrderContext \n" + " initiated by MyOrderBeginEvent as obe\n" + " terminated by MyOrderEndEvent(OrderId = obe.OrderId);\n" + "@Name('count') context MyOrderContext select count(*) as orderItemCount from MyOrderItemEvent output when terminated;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("count"); var @event = new Dictionary<string, object>(); @event.Put("OrderId", "1010"); @event.Put( "items", new[] { Collections.SingletonDataMap("itemId", "A0001") }); env.SendEventMap(@event, "MyOrderEvent"); Assert.AreEqual(1L, env.Listener("count").AssertOneGetNewAndReset().Get("orderItemCount")); env.UndeployAll(); }
private static void TryAssertion( RegressionEnvironment env, bool enableIndexShareCreate, bool disableIndexShareConsumer, bool createExplicitIndex) { var path = new RegressionPath(); env.CompileDeployWBusPublicType("create schema EventSchema(e0 string, e1 int, e2 string)", path); var createEpl = "create window MyWindow#keepall as select * from SupportBean"; if (enableIndexShareCreate) { createEpl = "@Hint('enable_window_subquery_indexshare') " + createEpl; } env.CompileDeploy(createEpl, path); env.CompileDeploy("insert into MyWindow select * from SupportBean", path); if (createExplicitIndex) { env.CompileDeploy("create index MyIndex on MyWindow (TheString)", path); } var consumeEpl = "@Name('s0') select e0, (select TheString from MyWindow where IntPrimitive = es.e1 and TheString = es.e2) as val from EventSchema as es"; if (disableIndexShareConsumer) { consumeEpl = "@Hint('disable_window_subquery_indexshare') " + consumeEpl; } env.CompileDeploy(consumeEpl, path).AddListener("s0"); var fields = new[] {"e0", "val"}; // test once env.SendEventBean(new SupportBean("WX", 10)); SendEvent(env, "E1", 10, "WX"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E1", "WX"}); // preload for (var i = 0; i < 10000; i++) { env.SendEventBean(new SupportBean("W" + i, i)); } var startTime = PerformanceObserver.MilliTime; for (var i = 0; i < 5000; i++) { SendEvent(env, "E" + i, i, "W" + i); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E" + i, "W" + i}); } var endTime = PerformanceObserver.MilliTime; var delta = endTime - startTime; Assert.That(delta, Is.LessThan(500), "delta=" + delta); env.UndeployAll(); }
private static void TrySend( RegressionEnvironment env, int numThreads, int numEventsPerThread, bool indexShare) { // setup statements var path = new RegressionPath(); var schemas = "create schema UpdateEvent as (uekey string, ueint int);\n" + "create schema WindowSchema as (wskey string, wsint int);\n"; env.CompileDeployWBusPublicType(schemas, path); var createEpl = "@Name('namedWindow') create window MyWindow#keepall as WindowSchema"; if (indexShare) { createEpl = "@Hint('enable_window_subquery_indexshare') " + createEpl; } env.CompileDeploy(createEpl, path); env.CompileDeploy("create index ABC on MyWindow(wskey)", path); env.CompileDeploy( "on UpdateEvent mue merge MyWindow mw " + "where uekey = wskey and ueint = wsint " + "when not matched then insert select uekey as wskey, ueint as wsint " + "when matched then delete", path); // note: here all threads use the same string key to insert/delete and different values for the int env.CompileDeploy( "@Name('target') select (select intListAgg(wsint) from MyWindow mw where wskey = sb.TheString) as val from SupportBean sb", path); // execute var executor = Executors.NewMultiThreadedExecutor(numThreads); // new SupportThreadFactory(typeof(MultithreadStmtNamedWindowSubqueryAgg)).ThreadFactory) var futures = new List<IFuture<bool?>>(); for (var i = 0; i < numThreads; i++) { futures.Add(executor.Submit( new StmtNamedWindowSubqueryAggCallable( i, env.Runtime, numEventsPerThread, env.Statement("target")))); } // Give the futures 10 seconds to complete the futures... futures.AsParallel().ForAll(future => future.Wait(TimeSpan.FromSeconds(10))); executor.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(executor, TimeSpan.FromSeconds(10)); SupportCompileDeployUtil.AssertFutures(futures); var events = EPAssertionUtil.EnumeratorToArray(env.Statement("namedWindow").GetEnumerator()); Assert.AreEqual(0, events.Length); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { RegressionPath path = new RegressionPath(); AssertStmt(env, path, "select Items.firstof().AssetId as firstcenter from LocationReport"); AssertStmt(env, path, "select Items.where(p => p.Type=\"P\") from LocationReport"); AssertStmt(env, path, "select Items.where((p,ind) => p.Type=\"P\" and ind>2) from LocationReport"); AssertStmt(env, path, "select Items.aggregate(\"\",(result,item) => result||(case when result=\"\" then \"\" else \",\" end)||item.AssetId) as assets from LocationReport"); AssertStmt(env, path, "select Items.allof(i => distance(i.Location.X,i.Location.Y,0,0)<1000) as assets from LocationReport"); AssertStmt(env, path, "select Items.average(i => distance(i.Location.X,i.Location.Y,0,0)) as avgdistance from LocationReport"); AssertStmt(env, path, "select Items.countof(i => distance(i.Location.X,i.Location.Y,0,0)<20) as cntcenter from LocationReport"); AssertStmt(env, path, "select Items.firstof(i => distance(i.Location.X,i.Location.Y,0,0)<20) as firstcenter from LocationReport"); AssertStmt(env, path, "select Items.lastof().AssetId as firstcenter from LocationReport"); AssertStmt(env, path, "select Items.lastof(i => distance(i.Location.X,i.Location.Y,0,0)<20) as lastcenter from LocationReport"); AssertStmt(env, path, "select Items.where(i => i.Type=\"L\").groupby(i => AssetIdPassenger) as luggagePerPerson from LocationReport"); AssertStmt(env, path, "select Items.where((p,Ind) => p.Type=\"P\" and Ind>2) from LocationReport"); AssertStmt(env, path, "select Items.groupby(k => AssetId,v => distance(v.Location.X,v.Location.Y,0,0)) as distancePerItem from LocationReport"); AssertStmt(env, path, "select Items.min(i => distance(i.Location.X,i.Location.Y,0,0)) as mincenter from LocationReport"); AssertStmt(env, path, "select Items.max(i => distance(i.Location.X,i.Location.Y,0,0)) as maxcenter from LocationReport"); AssertStmt(env, path, "select Items.minBy(i => distance(i.Location.X,i.Location.Y,0,0)) as minItemCenter from LocationReport"); AssertStmt(env, path, "select Items.minBy(i => distance(i.Location.X,i.Location.Y,0,0)).AssetId as minItemCenter from LocationReport"); AssertStmt(env, path, "select Items.orderBy(i => distance(i.Location.X,i.Location.Y,0,0)) as itemsOrderedByDist from LocationReport"); AssertStmt(env, path, "select Items.selectFrom(i => AssetId) as itemAssetIds from LocationReport"); AssertStmt(env, path, "select Items.take(5) as first5Items, Items.takeLast(5) as last5Items from LocationReport"); AssertStmt(env, path, "select Items.toMap(k => k.AssetId,v => distance(v.Location.X,v.Location.Y,0,0)) as assetDistance from LocationReport"); AssertStmt(env, path, "select Items.where(i => i.AssetId=\"L001\").union(Items.where(i => i.Type=\"P\")) as itemsUnion from LocationReport"); AssertStmt(env, path, "select (select Name from Zone#unique(Name)).orderBy() as orderedZones from pattern [every timer:interval(30)]"); env.CompileDeployWBusPublicType("create schema MyEvent as (seqone String[], seqtwo String[])", path); AssertStmt(env, path, "select seqone.sequenceEqual(seqtwo) from MyEvent"); AssertStmt(env, path, "select window(AssetId).orderBy() as orderedAssetIds from Item#time(10) group by AssetId"); AssertStmt(env, path, "select prevwindow(AssetId).orderBy() as orderedAssetIds from Item#time(10) as items"); AssertStmt(env, path, "select getZoneNames().where(z => z!=\"Z1\") from pattern [every timer:interval(30)]"); AssertStmt( env, path, "select Items.selectFrom(i => new{AssetId,distanceCenter=distance(i.Location.X,i.Location.Y,0,0)}) as itemInfo from LocationReport"); AssertStmt(env, path, "select Items.leastFrequent(i => Type) as leastFreqType from LocationReport"); string epl = "expression myquery {itm => " + "(select * from Zone#keepall).where(z => inrect(z.Rectangle,itm.Location))" + "} " + "select AssetId, myquery(item) as subq, myquery(item).where(z => z.Name=\"Z01\") as assetItem " + "from Item as item"; AssertStmt(env, path, epl); AssertStmt( env, path, "select za.Items.except(zb.Items) as itemsCompared from LocationReport as za unidirectional, LocationReport#length(10) as zb"); env.UndeployAll(); }
private static void RunTransposeMapAndObjectArray( RegressionEnvironment env, EventRepresentationChoice representation) { var fields = new[] {"p0", "p1"}; var path = new RegressionPath(); var schema = representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMySchema>() + "create schema MySchema(p0 string, p1 int)"; env.CompileDeployWBusPublicType(schema, path); string generateFunction; if (representation.IsObjectArrayEvent()) { generateFunction = "GenerateOA"; } else if (representation.IsMapEvent()) { generateFunction = "GenerateMap"; } else if (representation.IsAvroEvent()) { generateFunction = "GenerateAvro"; } else if (representation.IsJsonEvent() || representation.IsJsonProvidedClassEvent()) { generateFunction = "GenerateJson"; } else { throw new IllegalStateException("Unrecognized code " + representation); } var epl = "insert into MySchema select transpose(" + generateFunction + "(TheString, IntPrimitive)) from SupportBean"; env.CompileDeploy("@Name('s0') " + epl, path).AddListener("s0"); env.SendEventBean(new SupportBean("E1", 1)); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E1", 1}); env.SendEventBean(new SupportBean("E2", 2)); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E2", 2}); // MySchema already exists, start second statement env.CompileDeploy("@Name('s1') " + epl, path).AddListener("s1"); env.UndeployModuleContaining("s0"); env.SendEventBean(new SupportBean("E3", 3)); EPAssertionUtil.AssertProps( env.Listener("s1").AssertOneGetNewAndReset(), fields, new object[] {"E3", 3}); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeployWBusPublicType( "create objectarray schema MyEventThree(k0 int, k1 int, k2 int, col int)", path); env.CompileDeploy( "create table MyTableGS3D(k0 int primary key, k1 int primary key, k2 int primary key, total sum(int))", path); env.CompileDeploy( "into table MyTableGS3D insert into MyStreamThree select sum(col) as total from MyEventThree#length(3) group by grouping sets(k0,k1,k2)", path); var fields = new[] {"k0", "k1", "k2", "total"}; env.SendEventObjectArray(new object[] {1, 10, 100, 1000}, "MyEventThree"); env.SendEventObjectArray(new object[] {2, 10, 200, 2000}, "MyEventThree"); env.Milestone(0); env.SendEventObjectArray(new object[] {1, 20, 300, 3000}, "MyEventThree"); AssertValuesIterate( env, path, "MyTableGS3D", fields, new[] { new object[] {1, null, null, 4000}, new object[] {2, null, null, 2000}, new object[] {null, 10, null, 3000}, new object[] {null, 20, null, 3000}, new object[] {null, null, 100, 1000}, new object[] {null, null, 200, 2000}, new object[] {null, null, 300, 3000} }); env.Milestone(1); env.SendEventObjectArray(new object[] {1, 10, 400, 4000}, "MyEventThree"); // expires {1, 10, 100, 1000} env.Milestone(2); AssertValuesIterate( env, path, "MyTableGS3D", fields, new[] { new object[] {1, null, null, 7000}, new object[] {2, null, null, 2000}, new object[] {null, 10, null, 6000}, new object[] {null, 20, null, 3000}, new object[] {null, null, 100, null}, new object[] {null, null, 400, 4000}, new object[] {null, null, 200, 2000}, new object[] {null, null, 300, 3000} }); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var epl = "create schema N1N1 (n1n1 string);\n" + "create schema N1 (n1 string, n2 N1N1);\n" + "create schema NestedMapWithSimpleProps (nested N1);\n"; env.CompileDeployWBusPublicType(epl, path); RunAssertion(env, path); }
public void Run(RegressionEnvironment env) { var epl = "create objectarray schema RootEvent(base string);\n" + "create objectarray schema Sub1Event(sub1 string) inherits RootEvent;\n" + "create objectarray schema Sub2Event(sub2 string) inherits RootEvent;\n" + "create objectarray schema SubAEvent(suba string) inherits Sub1Event;\n" + "create objectarray schema SubBEvent(subb string) inherits SubAEvent;\n"; var path = new RegressionPath(); env.CompileDeployWBusPublicType(epl, path); EventObjectArrayInheritanceConfigInit.RunObjectArrInheritanceAssertion(env, path); }
public void Run(RegressionEnvironment env) { var fields = new [] { "company","value","total" }; var eplSchema = "create schema S2 ( company string, value double, total double)"; var path = new RegressionPath(); env.CompileDeployWBusPublicType(eplSchema, path); // ESPER-568 env.CompileDeploy("@Name('create') create window S2Win#time(25 hour)#firstunique(company) as S2", path); env.CompileDeploy("insert into S2Win select * from S2#firstunique(company)", path); env.CompileDeploy("on S2 as a update S2Win as b set total = b.value + a.value", path); env.CompileDeploy("@Name('s0') select count(*) as cnt from S2Win", path).AddListener("s0"); CreateSendEvent(env, "S2", "AComp", 3.0, 0.0); Assert.AreEqual(1L, env.Listener("s0").AssertOneGetNewAndReset().Get("cnt")); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("create"), fields, new[] {new object[] {"AComp", 3.0, 0.0}}); CreateSendEvent(env, "S2", "AComp", 6.0, 0.0); Assert.AreEqual(1L, env.Listener("s0").AssertOneGetNewAndReset().Get("cnt")); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("create"), fields, new[] {new object[] {"AComp", 3.0, 9.0}}); CreateSendEvent(env, "S2", "AComp", 5.0, 0.0); Assert.AreEqual(1L, env.Listener("s0").AssertOneGetNewAndReset().Get("cnt")); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("create"), fields, new[] {new object[] {"AComp", 3.0, 8.0}}); CreateSendEvent(env, "S2", "BComp", 4.0, 0.0); // this example does not have @priority thereby it is undefined whether there are two counts delivered or one if (env.Listener("s0").LastNewData.Length == 2) { Assert.AreEqual(1L, env.Listener("s0").LastNewData[0].Get("cnt")); Assert.AreEqual(2L, env.Listener("s0").LastNewData[1].Get("cnt")); } else { Assert.AreEqual(2L, env.Listener("s0").AssertOneGetNewAndReset().Get("cnt")); } EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("create"), fields, new[] {new object[] {"AComp", 3.0, 7.0}, new object[] {"BComp", 4.0, 0.0}}); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create schema ScoreCycle (userId string, keyword string, ProductId string, score long);\n" + "\n" + "create schema UserKeywordTotalStream (userId string, keyword string, sumScore long);\n" + "\n" + "create context HashByUserCtx as\n" + "coalesce by consistent_hash_crc32(userId) from ScoreCycle,\n" + "consistent_hash_crc32(userId) from UserKeywordTotalStream \n" + "granularity 10000000;\n" + "\n" + "context HashByUserCtx create window ScoreCycleWindow#unique(userId, keyword, ProductId) as ScoreCycle;\n" + "\n" + "context HashByUserCtx insert into ScoreCycleWindow select * from ScoreCycle;\n" + "\n" + "@Name('Select') context HashByUserCtx insert into UserKeywordTotalStream\n" + "select userId, keyword, sum(score) as sumScore from ScoreCycleWindow group by userId, keyword;"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); var listener = new MyUpdateListener(); env.Statement("Select").AddListener(listener); IList<IDictionary<string, object>> sendsT1 = new List<IDictionary<string, object>>(); sendsT1.Add(MakeEvent("A", "house", "P0", 1)); sendsT1.Add(MakeEvent("B", "house", "P0", 2)); IList<IDictionary<string, object>> sendsT2 = new List<IDictionary<string, object>>(); sendsT2.Add(MakeEvent("B", "house", "P0", 3)); sendsT1.Add(MakeEvent("A", "house", "P0", 4)); var threadPool = Executors.NewFixedThreadPool( 2, new SupportThreadFactory(typeof(MultithreadContextUnique)).ThreadFactory); var runnableOne = new SendEventRunnable(env.Runtime, sendsT1, "ScoreCycle"); var runnableTwo = new SendEventRunnable(env.Runtime, sendsT2, "ScoreCycle"); threadPool.Submit(runnableOne.Run); threadPool.Submit(runnableTwo.Run); threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 1, TimeUnit.SECONDS); Assert.IsNull(runnableOne.LastException); Assert.IsNull(runnableTwo.LastException); // compare var received = listener.Received; foreach (var item in received) { Console.Out.WriteLine(item); } Assert.AreEqual(4, received.Count); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var epl = "create schema RootEvent(base string);\n" + "create schema Sub1Event(sub1 string) inherits RootEvent;\n" + "create schema Sub2Event(sub2 string) inherits RootEvent;\n" + "create schema SubAEvent(suba string) inherits Sub1Event;\n" + "create schema SubBEvent(subb string) inherits Sub1Event, Sub2Event;\n"; env.CompileDeployWBusPublicType(epl, path); EventMapInheritanceInitTime.RunAssertionMapInheritance(env, path); }
private static void RunAssertionObjectArrPropertyReorder(RegressionEnvironment env) { var epl = "create objectarray schema MyInner (p_inner string);\n" + "create objectarray schema MyOATarget (unfilled string, p0 string, p1 string, i0 MyInner);\n" + "create objectarray schema MyOASource (p0 string, p1 string, i0 MyInner);\n" + "insert into MyOATarget select p0, p1, i0, null as unfilled from MyOASource;\n" + "@Name('s0') select * from MyOATarget;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); env.SendEventObjectArray(new object[] {"p0value", "p1value", new object[] {"i"}}, "MyOASource"); EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), "p0,p1".SplitCsv(), new object[] {"p0value", "p1value"}); env.UndeployAll(); }
private static void RunAssertionCreateStreamTwo( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + " create schema MyEvent(myId int)\n;" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedAllMyEvent>() + " create schema AllMyEvent as (myEvent MyEvent, clazz String, reverse boolean);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSuspectMyEvent>() + " create schema SuspectMyEvent as (myEvent MyEvent, clazz String);\n"; env.CompileDeployWBusPublicType(epl, path); env.CompileDeploy( "@Name('s0') insert into AllMyEvent " + "select c as myEvent, 'test' as clazz, false as reverse " + "from MyEvent(myId=1) c", path) .AddListener("s0"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("s0").EventType.UnderlyingType)); env.CompileDeploy( "@Name('s1') insert into SuspectMyEvent " + "select c.myEvent as myEvent, clazz " + "from AllMyEvent(not reverse) c", path) .AddListener("s1"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(MakeEvent(1).Values.ToArray(), "MyEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(MakeEvent(1), "MyEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { env.SendEventAvro(MakeEventAvro(1), "MyEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson("{\"myId\": 1}", "MyEvent"); } else { Assert.Fail(); } AssertCreateStreamTwo(eventRepresentationEnum, env.Listener("s0").AssertOneGetNewAndReset(), env.Statement("s0")); AssertCreateStreamTwo(eventRepresentationEnum, env.Listener("s1").AssertOneGetNewAndReset(), env.Statement("s1")); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { string epl = "create objectarray schema Event(meta1 string[], meta2 string[]);\n" + "@Name('s0') select * from Event(meta1.intersect(meta2).countOf() > 0);\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); SendAndAssert(env, "a,b", "a,b", true); SendAndAssert(env, "c,d", "a,b", false); SendAndAssert(env, "c,d", "a,d", true); SendAndAssert(env, "a,d,a,a", "b,c", false); SendAndAssert(env, "a,d,a,a", "b,d", true); env.UndeployAll(); }
private static void TryAssertionSplitPremptiveNamedWindow( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); env.CompileDeployWBusPublicType( eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTrigger>() + " create schema TypeTrigger(trigger int)", path); env.CompileDeploy(eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTypeTwo>() + " create schema TypeTwo(col2 int)", path); env.CompileDeploy( eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTypeTwo>() + " create window WinTwo#keepall as TypeTwo", path); var stmtOrigText = "on TypeTrigger " + "insert into OtherStream select 1 " + "insert into WinTwo(col2) select 2 " + "output all"; env.CompileDeploy(stmtOrigText, path); env.CompileDeploy("@Name('s0') on OtherStream select col2 from WinTwo", path).AddListener("s0"); // populate WinOne env.SendEventBean(new SupportBean("E1", 2)); // fire trigger if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {null}, "TypeTrigger"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(new Dictionary<string, object>(), "TypeTrigger"); } else if (eventRepresentationEnum.IsAvroEvent()) { var @event = new GenericRecord( SchemaBuilder.Record("name", TypeBuilder.OptionalInt("trigger"))); env.SendEventAvro(@event, "TypeTrigger"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson("{}", "TypeTrigger"); } else { Assert.Fail(); } Assert.AreEqual(2, env.Listener("s0").AssertOneGetNewAndReset().Get("col2")); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create schema IncomingEvent(Id int);\n" + "create schema RetainedEvent(Id int);\n" + "insert into RetainedEvent select * from IncomingEvent#expr_batch(current_count >= 10000);\n" + "create window RetainedEventWindow#keepall as RetainedEvent;\n" + "insert into RetainedEventWindow select * from RetainedEvent;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); IDictionary<string, object> @event = new Dictionary<string, object>(); @event.Put("Id", 1); for (var i = 0; i < 10000; i++) { env.SendEventMap(@event, "IncomingEvent"); } env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create schema ValueEvent(value long);\n" + "create schema ResetEvent(startThreshold long);\n" + "create table CurrentMaxTable(currentThreshold long);\n" + "@Name('s0') insert into ThresholdTriggered select * from ValueEvent(value >= CurrentMaxTable.currentThreshold);\n" + "on ResetEvent merge CurrentMaxTable when matched then update set currentThreshold = startThreshold when not matched then insert select startThreshold as currentThreshold;\n" + "on ThresholdTriggered update CurrentMaxTable set currentThreshold = value + 100;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); env.SendEventMap(Collections.SingletonDataMap("startThreshold", 100L), "ResetEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 30L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 99L), "ValueEvent"); env.Milestone(0); env.SendEventMap(Collections.SingletonDataMap("value", 100L), "ValueEvent"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"value"}, new object[] {100L}); env.SendEventMap(Collections.SingletonDataMap("value", 101L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 103L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 130L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 199L), "ValueEvent"); env.Milestone(1); env.SendEventMap(Collections.SingletonDataMap("value", 200L), "ValueEvent"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"value"}, new object[] {200L}); env.SendEventMap(Collections.SingletonDataMap("value", 201L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 260L), "ValueEvent"); env.SendEventMap(Collections.SingletonDataMap("value", 301L), "ValueEvent"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"value"}, new object[] {301L}); env.UndeployAll(); }
private static void TryAssertionInnerJoinLateStart( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var schemaEPL = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedProduct>() + "@Name('schema') create schema Product (product string, size int);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedPortfolio>() + " create schema Portfolio (portfolio string, product string);\n"; var path = new RegressionPath(); env.CompileDeployWBusPublicType(schemaEPL, path); env.CompileDeploy("@Name('window') create window ProductWin#keepall as Product", path); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("schema").EventType.UnderlyingType)); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("window").EventType.UnderlyingType)); env.CompileDeploy("insert into ProductWin select * from Product", path); env.CompileDeploy("create window PortfolioWin#keepall as Portfolio", path); env.CompileDeploy("insert into PortfolioWin select * from Portfolio", path); SendProduct(env, eventRepresentationEnum, "productA", 1); SendProduct(env, eventRepresentationEnum, "productB", 2); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productA"); var stmtText = "@Name(\"Query2\") select portfolio, ProductWin.product, size " + "from PortfolioWin unidirectional inner join ProductWin on PortfolioWin.product=ProductWin.product"; env.CompileDeploy(stmtText, path).AddListener("Query2"); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productB"); EPAssertionUtil.AssertProps( env.Listener("Query2").AssertOneGetNewAndReset(), new[] {"portfolio", "ProductWin.product", "size"}, new object[] {"Portfolio", "productB", 2}); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productC"); env.Listener("Query2").Reset(); SendProduct(env, eventRepresentationEnum, "productC", 3); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productC"); EPAssertionUtil.AssertProps( env.Listener("Query2").AssertOneGetNewAndReset(), new[] {"portfolio", "ProductWin.product", "size"}, new object[] {"Portfolio", "productC", 3}); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var schemaEPL = "create objectarray schema MyEventOne(type string, p0 int, p1 string);\n" + "create objectarray schema MyEventTwo(type string, f0 string, f1 int);\n"; env.CompileDeployWBusPublicType(schemaEPL, path); env.CompileDeploy("@Name('s0') select * from MyEventOne", path).AddListener("s0"); env.CompileDeploy("@Name('s1') select * from MyEventTwo", path).AddListener("s1"); env.CompileDeploy( "@Name('flow') create dataflow MyDataFlow " + "MyObjectArrayGraphSource -> OutStream<?> {}" + "EventBusSink(OutStream) {" + " collector : {" + " class: '" + typeof(MyTransformToEventBus).FullName + "'" + " }" + "}"); var source = new MyObjectArrayGraphSource( Arrays.AsList( new object[] {"type1", 100, "abc"}, new object[] {"type2", "GE", -1} ) .GetEnumerator()); var options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProvider(source)); env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MyDataFlow", options).Start(); env.Listener("s0").WaitForInvocation(3000, 1); env.Listener("s1").WaitForInvocation(3000, 1); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new [] { "p0","p1" }, new object[] {100, "abc"}); EPAssertionUtil.AssertProps( env.Listener("s1").AssertOneGetNewAndReset(), new [] { "f0","f1" }, new object[] {"GE", -1}); env.UndeployAll(); }
private static void TrySend( RegressionEnvironment env, int numThreads, int numEventsPerThread) { var path = new RegressionPath(); var schemas = "create schema MyUpdateEvent as (key string, intupd int);\n" + "create schema MySchema as (TheString string, intval int);\n"; env.CompileDeployWBusPublicType(schemas, path); env.CompileDeploy("@Name('window') create window MyWindow#keepall as MySchema", path); env.CompileDeploy( "on MyUpdateEvent mue merge MyWindow mw " + "where mw.TheString = mue.key " + "when not matched then insert select key as TheString, intupd as intval " + "when matched then delete", path); env.CompileDeploy( "@Name('target') select (select intval from MyWindow mw where mw.TheString = sb.TheString) as val from SupportBean sb", path); // execute var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtNamedWindowSubqueryLookup)).ThreadFactory); var future = new IFuture<bool?>[numThreads]; for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit( new StmtNamedWindowSubqueryLookupCallable( i, env.Runtime, numEventsPerThread, env.Statement("target"))); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); var events = EPAssertionUtil.EnumeratorToArray(env.GetEnumerator("window")); Assert.AreEqual(0, events.Length); env.UndeployAll(); }
private void RunAssertionBean(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeployWBusPublicType( "create schema MyIndexMappedSamplerBean as " + typeof(MyIndexMappedSamplerBean).MaskTypeName(), path); env.CompileDeploy("@Name('s0') select * from MyIndexMappedSamplerBean", path).AddListener("s0"); env.SendEventBean(new MyIndexMappedSamplerBean()); var @event = env.Listener("s0").AssertOneGetNewAndReset(); var type = @event.EventType; Assert.AreEqual(2, type.GetGetterIndexed("ListOfInt").Get(@event, 1)); Assert.AreEqual(2, type.GetGetterIndexed("IterableOfInt").Get(@event, 1)); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSchemaOne>() + " @name('schema') create schema SchemaOne(col1 int, col2 int);\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSchemaWindow>() + " @name('create') create window SchemaWindow#lastevent as (s1 SchemaOne);\n"; epl += "insert into SchemaWindow (s1) select sone from SchemaOne as sone;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("create"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("schema").EventType.UnderlyingType)); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("create").EventType.UnderlyingType)); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {10, 11}, "SchemaOne"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new Dictionary<string, object>(); theEvent.Put("col1", 10); theEvent.Put("col2", 11); env.SendEventMap(theEvent, "SchemaOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil .GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("SchemaOne")) .AsRecordSchema()); theEvent.Put("col1", 10); theEvent.Put("col2", 11); env.EventService.SendEventAvro(theEvent, "SchemaOne"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{\"col1\": 10, \"col2\": 11}", "SchemaOne"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps( env.Listener("create").AssertOneGetNewAndReset(), new[] {"s1.col1", "s1.col2"}, new object[] {10, 11}); env.UndeployAll(); }
private static void RunAssertPopulateFromNamedWindow( RegressionEnvironment env, EventRepresentationChoice type) { var path = new RegressionPath(); var schemaEPL = type.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNode>() + "create schema Node(nid string)"; env.CompileDeployWBusPublicType(schemaEPL, path); env.CompileDeploy("create window NodeWindow#unique(nid) as Node", path); env.CompileDeploy("insert into NodeWindow select * from Node", path); env.CompileDeploy( type.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNodePlus>() + "create schema NodePlus(npid string, node Node)", path); env.CompileDeploy("@Name('s0') insert into NodePlus select 'E1' as npid, n1 as node from NodeWindow n1", path).AddListener("s0"); if (type.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {"n1"}, "Node"); } else if (type.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("nid", "n1"), "Node"); } else if (type.IsAvroEvent()) { var genericRecord = new GenericRecord(SchemaBuilder.Record("name", RequiredString("nid"))); genericRecord.Put("nid", "n1"); env.SendEventAvro(genericRecord, "Node"); } else if (type.IsJsonEvent() || type.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("nid", "n1"); env.SendEventJson(@object.ToString(), "Node"); } else { Assert.Fail(); } var @event = env.Listener("s0").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); env.UndeployAll(); }