public static string GetOutputTypeCreateSchemaName(this EventRepresentationChoice enumValue) { switch (enumValue) { case EventRepresentationChoice.ARRAY: return(" objectarray"); case EventRepresentationChoice.MAP: return(" map"); case EventRepresentationChoice.AVRO: return(" avro"); case EventRepresentationChoice.DEFAULT: return(""); } throw new ArgumentException("invalid value for enumValue", "enumValue"); }
public static string GetOutputTypeClassName(this EventRepresentationChoice enumValue) { switch (enumValue) { case EventRepresentationChoice.ARRAY: return(EventUnderlyingType.OBJECTARRAY.GetUnderlyingClassName()); case EventRepresentationChoice.MAP: return(EventUnderlyingType.MAP.GetUnderlyingClassName()); case EventRepresentationChoice.AVRO: return(EventUnderlyingType.AVRO.GetUnderlyingClassName()); case EventRepresentationChoice.DEFAULT: return(EventUnderlyingTypeExtensions.GetDefault().GetUnderlyingClassName()); } throw new ArgumentException("invalid value for enumValue", "enumValue"); }
public static string GetAnnotationText(this EventRepresentationChoice enumValue) { switch (enumValue) { case EventRepresentationChoice.ARRAY: return("@EventRepresentation('objectarray')"); case EventRepresentationChoice.MAP: return("@EventRepresentation('map')"); case EventRepresentationChoice.AVRO: return("@EventRepresentation('avro')"); case EventRepresentationChoice.DEFAULT: return(""); } throw new ArgumentException("invalid value for enumValue", "enumValue"); }
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(); }
private static void MakeSendScoreEvent( RegressionEnvironment env, string typeName, EventRepresentationChoice eventRepresentationEnum, string userId, string keyword, string productId, long score) { if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new LinkedHashMap<string, object>(); theEvent.Put("UserId", userId); theEvent.Put("Keyword", keyword); theEvent.Put("ProductId", productId); theEvent.Put("Score", score); env.SendEventMap(theEvent, typeName); } else if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {userId, keyword, productId, score}, typeName); } else if (eventRepresentationEnum.IsAvroEvent()) { var record = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName)) .AsRecordSchema()); record.Put("UserId", userId); record.Put("Keyword", keyword); record.Put("ProductId", productId); record.Put("Score", score); env.SendEventAvro(record, typeName); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var jobject = new JObject(); jobject.Add("UserId", userId); jobject.Add("Keyword", keyword); jobject.Add("ProductId", productId); jobject.Add("Score", score); env.SendEventJson(jobject.ToString(), typeName); } else { Assert.Fail(); } }
private static void RunAssertionCreateStream( RegressionEnvironment env, EventRepresentationChoice representation) { var epl = representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + " create schema MyEvent(myId int);\n" + representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedCompositeEvent>() + " create schema CompositeEvent(c1 MyEvent, c2 MyEvent, rule string);\n" + "insert into MyStream select c, 'additionalValue' as value from MyEvent c;\n" + "insert into CompositeEvent select e1.c as c1, e2.c as c2, '4' as rule " + " from pattern [e1=MyStream -> e2=MyStream];\n" + representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedCompositeEvent>() + " @Name('Target') select * from CompositeEvent;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("Target"); if (representation.IsObjectArrayEvent()) { env.SendEventObjectArray(MakeEvent(10).Values.ToArray(), "MyEvent"); env.SendEventObjectArray(MakeEvent(11).Values.ToArray(), "MyEvent"); } else if (representation.IsMapEvent()) { env.SendEventMap(MakeEvent(10), "MyEvent"); env.SendEventMap(MakeEvent(11), "MyEvent"); } else if (representation.IsAvroEvent()) { env.SendEventAvro(MakeEventAvro(10), "MyEvent"); env.SendEventAvro(MakeEventAvro(11), "MyEvent"); } else if (representation.IsJsonEvent() || representation.IsJsonProvidedClassEvent()) { env.SendEventJson("{\"myId\": 10}", "MyEvent"); env.SendEventJson("{\"myId\": 11}", "MyEvent"); } else { Assert.Fail(); } var theEvent = env.Listener("Target").AssertOneGetNewAndReset(); Assert.AreEqual(10, theEvent.Get("c1.myId")); Assert.AreEqual(11, theEvent.Get("c2.myId")); Assert.AreEqual("4", theEvent.Get("rule")); env.UndeployAll(); }
private void RunAssertionEventTypeColumnDef(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum) { EPStatement stmtSchema = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SchemaOne(col1 int, col2 int)"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtSchema.EventType.UnderlyingType)); EPStatement stmt = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window SchemaWindow#lastevent as (s1 SchemaOne)"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmt.EventType.UnderlyingType)); var listenerWindow = new SupportUpdateListener(); stmt.Events += listenerWindow.Update; epService.EPAdministrator.CreateEPL("insert into SchemaWindow (s1) select sone from SchemaOne as sone"); if (eventRepresentationEnum.IsObjectArrayEvent()) { epService.EPRuntime.SendEvent(new object[] { 10, 11 }, "SchemaOne"); } else if (eventRepresentationEnum.IsMapEvent()) { var theEvent = new LinkedHashMap <string, object>(); theEvent.Put("col1", 10); theEvent.Put("col2", 11); epService.EPRuntime.SendEvent(theEvent, "SchemaOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord(SupportAvroUtil.GetAvroSchema(epService, "SchemaOne").AsRecordSchema()); theEvent.Put("col1", 10); theEvent.Put("col2", 11); epService.EPRuntime.SendEventAvro(theEvent, "SchemaOne"); } else { Assert.Fail(); } 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 RunAssertionCreateStreamTwo(EventRepresentationChoice 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 bool)"); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SuspectMyEvent as (myEvent MyEvent, class string)"); EPStatement stmtOne = epService.EPAdministrator.CreateEPL("insert into AllMyEvent " + "select c as myEvent, 'test' as class, false as reverse " + "from MyEvent(myId=1) c"); stmtOne.AddListener(listener); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtOne.EventType.UnderlyingType)); EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("insert into SuspectMyEvent " + "select c.myEvent as myEvent, class " + "from AllMyEvent(not reverse) c"); var listenerTwo = new SupportUpdateListener(); stmtTwo.AddListener(listenerTwo); if (eventRepresentationEnum.IsObjectArrayEvent()) { epService.EPRuntime.SendEvent(MakeEvent(1).Values.ToArray(), "MyEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { epService.EPRuntime.SendEvent(MakeEvent(1), "MyEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { epService.EPRuntime.SendEventAvro(MakeEventAvro(1), "MyEvent"); } else { Assert.Fail(); } AssertCreateStreamTwo(eventRepresentationEnum, listener.AssertOneGetNewAndReset(), stmtOne); AssertCreateStreamTwo(eventRepresentationEnum, listenerTwo.AssertOneGetNewAndReset(), stmtTwo); epService.Initialize(); }
private static void TryAssertionInheritance( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { string epl = eventRepresentationEnum.GetAnnotationText() + " create schema BaseEvent as (b1 string);\n"; epl += eventRepresentationEnum.GetAnnotationText() + " create schema SubEvent as (s1 string) inherits BaseEvent;\n"; epl += eventRepresentationEnum.GetAnnotationText() + " create schema OuterEvent as (bases BaseEvent[], subs SubEvent[]);\n"; epl += eventRepresentationEnum.GetAnnotationText() + " @name('s0') select bases.union(subs) as val from OuterEvent;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray( new object[] { new object[][] { new object[] { "b10" } }, new object[][] { new object[] { "b10", "s10" } } }, "OuterEvent"); } else { IDictionary <string, object> baseEvent = MakeMap("b1", "b10"); IDictionary <string, object> subEvent = MakeMap("s1", "s10"); IDictionary <string, object> outerEvent = MakeMap( "bases", new IDictionary <string, object>[] { baseEvent }, "subs", new IDictionary <string, object>[] { subEvent }); env.SendEventMap(outerEvent, "OuterEvent"); } var result = env.Listener("s0").AssertOneGetNewAndReset().Get("val").Unwrap <object>(); Assert.AreEqual(2, result.Count); env.UndeployAll(); }
public void RunAssertionSplitPremptiveNamedWindow(EventRepresentationChoice 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#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 if (eventRepresentationEnum.IsMapEvent()) { _epService.EPRuntime.GetEventSender("TypeTrigger").SendEvent(new Dictionary <string, object>()); } else if (eventRepresentationEnum.IsAvroEvent()) { var @event = new GenericRecord(SchemaBuilder.Record("name", TypeBuilder.OptionalInt("trigger"))); _epService.EPRuntime.GetEventSender("TypeTrigger").SendEvent(@event); } else { Assert.Fail(); } Assert.AreEqual(2, _listener.AssertOneGetNewAndReset().Get("col2")); _epService.Initialize(); }
private void TryAssertionNamedWindow(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum) { var fields = "key,value".Split(','); var subscriberNamedWindow = new SubscriberMap(); var stmtTextCreate = eventRepresentationEnum.GetAnnotationText() + " create window MyWindow#keepall as select TheString as key, IntPrimitive as value from SupportBean"; var stmt = epService.EPAdministrator.CreateEPL(stmtTextCreate); stmt.Subscriber = subscriberNamedWindow; var subscriberInsertInto = new SubscriberFields(); var stmtTextInsertInto = "insert into MyWindow select TheString as key, IntPrimitive as value from SupportBean"; stmt = epService.EPAdministrator.CreateEPL(stmtTextInsertInto); stmt.Subscriber = subscriberInsertInto; epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); EPAssertionUtil.AssertPropsMap(subscriberNamedWindow.GetAndResetIndicate()[0], fields, new object[] { "E1", 1 }); EPAssertionUtil.AssertEqualsExactOrder(new object[][] { new object[] { "E1", 1 } }, subscriberInsertInto.GetAndResetIndicate()); // test on-delete var subscriberDelete = new SubscriberMap(); var stmtTextDelete = "on SupportMarketDataBean s0 delete from MyWindow s1 where s0.symbol = s1.key"; stmt = epService.EPAdministrator.CreateEPL(stmtTextDelete); stmt.Subscriber = subscriberDelete; epService.EPRuntime.SendEvent(new SupportMarketDataBean("E1", 0, 1L, "")); EPAssertionUtil.AssertPropsMap(subscriberDelete.GetAndResetIndicate()[0], fields, new object[] { "E1", 1 }); // test on-select var subscriberSelect = new SubscriberMap(); var stmtTextSelect = "on SupportMarketDataBean s0 select key, value from MyWindow s1"; stmt = epService.EPAdministrator.CreateEPL(stmtTextSelect); stmt.Subscriber = subscriberSelect; epService.EPRuntime.SendEvent(new SupportBean("E2", 2)); epService.EPRuntime.SendEvent(new SupportMarketDataBean("M1", 0, 1L, "")); EPAssertionUtil.AssertPropsMap(subscriberSelect.GetAndResetIndicate()[0], fields, new object[] { "E2", 2 }); epService.EPAdministrator.DestroyAllStatements(); }
public void RunAssertionInheritance(EventRepresentationChoice eventRepresentationEnum) { _epService.EPAdministrator.CreateEPL( eventRepresentationEnum.GetAnnotationText() + " create schema BaseEvent as (b1 string)"); _epService.EPAdministrator.CreateEPL( eventRepresentationEnum.GetAnnotationText() + " create schema SubEvent as (s1 string) inherits BaseEvent"); _epService.EPAdministrator.CreateEPL( eventRepresentationEnum.GetAnnotationText() + " create schema OuterEvent as (bases BaseEvent[], subs SubEvent[])"); EPStatement stmt = _epService.EPAdministrator.CreateEPL( eventRepresentationEnum.GetAnnotationText() + " select bases.union(subs) as val from OuterEvent"); stmt.Events += _listener.Update; if (eventRepresentationEnum.IsObjectArrayEvent()) { _epService.EPRuntime.SendEvent( new Object[] { new Object[][] { new Object[] { "b10" } }, new Object[][] { new Object[] { "b10", "s10" } } }, "OuterEvent"); } else { IDictionary <String, Object> baseEvent = MakeMap("b1", "b10"); IDictionary <String, Object> subEvent = MakeMap("s1", "s10"); IDictionary <String, Object> outerEvent = MakeMap( "bases", new Map[] { baseEvent }, "subs", new Map[] { subEvent }); _epService.EPRuntime.SendEvent(outerEvent, "OuterEvent"); } var result = (ICollection <object>)_listener.AssertOneGetNewAndReset().Get("val"); Assert.AreEqual(2, result.Count); _epService.Initialize(); }
private void RunAssertionCreateSchemaWTypes<T>( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string typeOfDatetimeProp, object startA, object endA, object startB, object endB) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<T>() + " create schema TypeA as (startts " + typeOfDatetimeProp + ", endts " + typeOfDatetimeProp + ") starttimestamp startts endtimestamp endts;\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<T>() + " create schema TypeB as (startts " + typeOfDatetimeProp + ", endts " + typeOfDatetimeProp + ") starttimestamp startts endtimestamp endts;\n"; epl += "@Name('s0') select a.includes(b) as val0 from TypeA#lastevent as a, TypeB#lastevent as b;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); MakeSendEvent(env, "TypeA", eventRepresentationEnum, startA, endA); MakeSendEvent(env, "TypeB", eventRepresentationEnum, startB, endB); Assert.AreEqual(true, env.Listener("s0").AssertOneGetNewAndReset().Get("val0")); env.UndeployAll(); }
private void TryAssertionInnerJoinLateStart(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum) { EPStatement stmtOne = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema Product (product string, size int)"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtOne.EventType.UnderlyingType)); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema Portfolio (portfolio string, product string)"); EPStatement stmtTwo = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window ProductWin#keepall as Product"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtTwo.EventType.UnderlyingType)); epService.EPAdministrator.CreateEPL("insert into ProductWin select * from Product"); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window PortfolioWin#keepall as Portfolio"); epService.EPAdministrator.CreateEPL("insert into PortfolioWin select * from Portfolio"); SendProduct(epService, eventRepresentationEnum, "productA", 1); SendProduct(epService, eventRepresentationEnum, "productB", 2); SendPortfolio(epService, eventRepresentationEnum, "Portfolio", "productA"); string stmtText = "@Name(\"Query2\") select portfolio, ProductWin.product, size " + "from PortfolioWin unidirectional inner join ProductWin on PortfolioWin.product=ProductWin.product"; EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtText); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; SendPortfolio(epService, eventRepresentationEnum, "Portfolio", "productB"); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), new string[] { "portfolio", "ProductWin.product", "size" }, new object[] { "Portfolio", "productB", 2 }); SendPortfolio(epService, eventRepresentationEnum, "Portfolio", "productC"); listener.Reset(); SendProduct(epService, eventRepresentationEnum, "productC", 3); SendPortfolio(epService, eventRepresentationEnum, "Portfolio", "productC"); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), new string[] { "portfolio", "ProductWin.product", "size" }, new object[] { "Portfolio", "productC", 3 }); epService.EPAdministrator.DestroyAllStatements(); foreach (string name in "Product,Portfolio,ProductWin,PortfolioWin".Split(',')) { epService.EPAdministrator.Configuration.RemoveEventType(name, true); } }
private void RunAssertionScoringUseCase(EventRepresentationChoice eventRepresentationEnum) { var fields = "userId,keyword,sumScore".Split(','); var epl = eventRepresentationEnum.GetAnnotationText() + " create schema ScoreCycle (userId string, keyword string, productId string, score long);\n" + eventRepresentationEnum.GetAnnotationText() + " create schema UserKeywordTotalStream (userId string, keyword string, sumScore long);\n" + "\n" + eventRepresentationEnum.GetAnnotationText() + " create context HashByUserCtx as " + "coalesce by Consistent_hash_crc32(userId) from ScoreCycle, " + "consistent_hash_crc32(userId) from UserKeywordTotalStream " + "granularity 1000000;\n" + "\n" + "context HashByUserCtx create window ScoreCycleWindow#unique(productId, keyword) as ScoreCycle;\n" + "\n" + "context HashByUserCtx insert into ScoreCycleWindow select * from ScoreCycle;\n" + "\n" + "@Name('outOne') context HashByUserCtx insert into UserKeywordTotalStream \n" + "select userId, keyword, Sum(score) as sumScore from ScoreCycleWindow group by keyword;\n" + "\n" + "@Name('outTwo') context HashByUserCtx on UserKeywordTotalStream(sumScore > 10000) delete from ScoreCycleWindow;\n"; _epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl); _epService.EPAdministrator.GetStatement("outOne").Events += _listener.Update; MakeSendScoreEvent("ScoreCycle", eventRepresentationEnum, "Pete", "K1", "P1", 100); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "Pete", "K1", 100L }); MakeSendScoreEvent("ScoreCycle", eventRepresentationEnum, "Pete", "K1", "P2", 15); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "Pete", "K1", 115L }); MakeSendScoreEvent("ScoreCycle", eventRepresentationEnum, "Joe", "K1", "P2", 30); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "Joe", "K1", 30L }); MakeSendScoreEvent("ScoreCycle", eventRepresentationEnum, "Joe", "K2", "P1", 40); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "Joe", "K2", 40L }); MakeSendScoreEvent("ScoreCycle", eventRepresentationEnum, "Joe", "K1", "P1", 20); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "Joe", "K1", 50L }); _epService.Initialize(); }
private void TryAssertionCreateSchemaModelAfter( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedEventTypeOne>() + " create schema EventTypeOne (hsi int);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedEventTypeTwo>() + " create schema EventTypeTwo (event EventTypeOne);\n" + "@Name('create') create window NamedWindow#unique(event.hsi) as EventTypeTwo;\n" + "on EventTypeOne as ev insert into NamedWindow select ev as event;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {10}, "EventTypeOne"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("hsi", 10), "EventTypeOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil .GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("EventTypeOne")) .AsRecordSchema()); theEvent.Put("hsi", 10); env.EventService.SendEventAvro(theEvent, "EventTypeOne"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{\"hsi\": 10}", "EventTypeOne"); } else { Assert.Fail(); } var result = env.Statement("create").First(); var getter = result.EventType.GetGetter("event.hsi"); Assert.AreEqual(10, getter.Get(result)); env.UndeployAll(); }
private void SendSentenceEvent(EventRepresentationChoice eventRepresentationEnum, string sentence) { if (eventRepresentationEnum.IsObjectArrayEvent()) { _epService.EPRuntime.SendEvent(new Object[] { sentence }, "SentenceEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { _epService.EPRuntime.SendEvent(Collections.SingletonDataMap("sentence", sentence), "SentenceEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { var schema = SchemaBuilder.Record("sentence", TypeBuilder.RequiredString("sentence")); var record = new GenericRecord(schema); record.Put("sentence", sentence); _epService.EPRuntime.SendEventAvro(record, "SentenceEvent"); } else { throw new IllegalStateException("Unrecognized enum " + eventRepresentationEnum); } }
private void RunAssertionCSVGraphSchema(EventRepresentationChoice representationEnum) { var fields = "MyString,MyInt,timestamp, MyDouble".SplitCsv(); CompileDeploy( runtime, representationEnum.GetAnnotationText() + " @public @buseventtype create schema MyEvent(MyString string, MyInt int, timestamp long, MyDouble double)"); var graph = "create dataflow ReadCSV " + "FileSource -> mystream<MyEvent> {" + " file: '../../../etc/regression/titleRow.csv'," + " hasHeaderLine: true " + "}" + "DefaultSupportCaptureOp(mystream) {}"; var deployment = CompileDeploy(runtime, graph); var outputOp = new DefaultSupportCaptureOp(); var instance = runtime.DataFlowService.Instantiate( deployment.DeploymentId, "ReadCSV", new EPDataFlowInstantiationOptions().WithOperatorProvider(new DefaultSupportGraphOpProvider(outputOp))); instance.Run(); var received = outputOp.GetAndReset(); Assert.AreEqual(1, received.Count); EPAssertionUtil.AssertPropsPerRow( container, received[0].ToArray(), fields, new object[][] { new object[] { "one", 1, 100L, 1.1 }, new object[] { "three", 3, 300L, 3.3 }, new object[] { "five", 5, 500L, 5.5 } }); Assert.IsTrue(representationEnum.MatchesClass(received[0].ToArray()[0].GetType())); UndeployAll(runtime); }
private void RunAssertionStreamInsertWWidenMap(EventRepresentationChoice rep) { EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(); epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema Src as (myint int, mystr string)"); epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema D1 as (myint int, mystr string, addprop long)"); var eplOne = "insert into D1 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(rep, eplOne, "myint,mystr,addprop", new Object[] { 123, "abc", 1L }); epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema D2 as (mystr string, myint int, addprop double)"); var eplTwo = "insert into D2 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(rep, eplTwo, "myint,mystr,addprop", new Object[] { 123, "abc", 1d }); epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema D3 as (mystr string, addprop int)"); var eplThree = "insert into D3 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(rep, eplThree, "mystr,addprop", new Object[] { "abc", 1 }); epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema D4 as (myint int, mystr string)"); var eplFour = "insert into D4 select mysrc.* from Src as mysrc"; RunStreamInsertAssertion(rep, eplFour, "myint,mystr", new Object[] { 123, "abc" }); var eplFive = "insert into D4 select mysrc.*, 999 as myint, 'xxx' as mystr from Src as mysrc"; RunStreamInsertAssertion(rep, eplFive, "myint,mystr", new Object[] { 999, "xxx" }); var eplSix = "insert into D4 select 999 as myint, 'xxx' as mystr, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(rep, eplSix, "myint,mystr", new Object[] { 999, "xxx" }); epService.EPAdministrator.DestroyAllStatements(); foreach (string name in new[] { "Src", "D1", "D2", "D3", "D4" }) { epService.EPAdministrator.Configuration.RemoveEventType(name, false); } }
private void RunAssertionBindMap(EventRepresentationChoice eventRepresentationEnum, SupportSubscriberMultirowMapBase subscriber) { var stmtText = eventRepresentationEnum.GetAnnotationText() + " select irstream TheString, IntPrimitive from " + typeof(SupportBean).FullName + "#length_batch(2)"; var stmt = _epService.EPAdministrator.CreateEPL(stmtText); stmt.Subscriber = subscriber; Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmt.EventType.UnderlyingType)); _epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); subscriber.AssertNoneReceived(); _epService.EPRuntime.SendEvent(new SupportBean("E2", 2)); subscriber.AssertOneReceivedAndReset(stmt, _fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } }, null); _epService.EPRuntime.SendEvent(new SupportBean("E3", 3)); subscriber.AssertNoneReceived(); _epService.EPRuntime.SendEvent(new SupportBean("E4", 4)); subscriber.AssertOneReceivedAndReset(stmt, _fields, new object[][] { new object[] { "E3", 3 }, new object[] { "E4", 4 } }, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } }); stmt.Dispose(); }
private void RunStreamInsertAssertion(EventRepresentationChoice rep, string epl, string fields, Object[] expected) { var stmt = _epService.EPAdministrator.CreateEPL(epl); stmt.AddListener(_listener); if (rep.IsMapEvent()) { _epService.EPRuntime.SendEvent(MakeMap(123, "abc"), "Src"); } else if (rep.IsObjectArrayEvent()) { _epService.EPRuntime.SendEvent(new Object[] { 123, "abc" }, "Src"); } else if (rep.IsAvroEvent()) { GenericRecord @event = new GenericRecord(SupportAvroUtil.GetAvroSchema(_epService, "Src").AsRecordSchema()); @event.Put("myint", 123); @event.Put("mystr", "abc"); _epService.EPRuntime.SendEventAvro(@event, "Src"); } EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields.SplitCsv(), expected); stmt.Dispose(); }
private void RunAssertionInvalid(EventRepresentationChoice rep) { _epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema Src as (myint int, mystr string)"); // mismatch in type _epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema E1 as (myint long)"); var message = !rep.IsAvroEvent() ? "Error starting statement: Type by name 'E1' in property 'myint' expected " + Name.Of <int>() + " but receives " + Name.Of <long>() : "Error starting statement: Type by name 'E1' in property 'myint' expected schema '{\"type\":\"long\"}' but received schema '{\"type\":\"int\"}'"; SupportMessageAssertUtil.TryInvalid(_epService, "insert into E1 select mysrc.* from Src as mysrc", message); // mismatch in column name _epService.EPAdministrator.CreateEPL("create " + rep.GetOutputTypeCreateSchemaName() + " schema E2 as (someprop long)"); SupportMessageAssertUtil.TryInvalid(_epService, "insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc", "Error starting statement: Failed to find column 'otherprop' in target type 'E2' [insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc]"); _epService.EPAdministrator.DestroyAllStatements(); foreach (string name in new[] { "Src", "E1", "E2" }) { _epService.EPAdministrator.Configuration.RemoveEventType(name, false); } }
private void TryAssertionCreateSchemaModelAfter(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum) { epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema EventTypeOne (hsi int)"); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema EventTypeTwo (event EventTypeOne)"); EPStatement stmt = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window NamedWindow#unique(event.hsi) as EventTypeTwo"); epService.EPAdministrator.CreateEPL("on EventTypeOne as ev insert into NamedWindow select ev as event"); if (eventRepresentationEnum.IsObjectArrayEvent()) { epService.EPRuntime.SendEvent(new object[] { 10 }, "EventTypeOne"); } else if (eventRepresentationEnum.IsMapEvent()) { epService.EPRuntime.SendEvent(Collections.SingletonDataMap("hsi", 10), "EventTypeOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord(SupportAvroUtil.GetAvroSchema(epService, "EventTypeOne").AsRecordSchema()); theEvent.Put("hsi", 10); epService.EPRuntime.SendEventAvro(theEvent, "EventTypeOne"); } else { Assert.Fail(); } EventBean result = stmt.First(); EventPropertyGetter getter = result.EventType.GetGetter("event.hsi"); Assert.AreEqual(10, getter.Get(result)); epService.EPAdministrator.DestroyAllStatements(); foreach (string name in "EventTypeOne,EventTypeTwo,NamedWindow".Split(',')) { epService.EPAdministrator.Configuration.RemoveEventType(name, true); } }
private void RunAssertionCreateStream(EventRepresentationChoice eventRepresentationEnum) { epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEvent(myId int)"); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema CompositeEvent(c1 MyEvent, c2 MyEvent, rule string)"); epService.EPAdministrator.CreateEPL("insert into MyStream select c, 'additionalValue' as value from MyEvent c"); epService.EPAdministrator.CreateEPL("insert into CompositeEvent select e1.c as c1, e2.c as c2, '4' as rule " + "from pattern [e1=MyStream -> e2=MyStream]"); epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " @Name('Target') select * from CompositeEvent"); epService.EPAdministrator.GetStatement("Target").AddListener(listener); if (eventRepresentationEnum.IsObjectArrayEvent()) { epService.EPRuntime.SendEvent(MakeEvent(10).Values.ToArray(), "MyEvent"); epService.EPRuntime.SendEvent(MakeEvent(11).Values.ToArray(), "MyEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { epService.EPRuntime.SendEvent(MakeEvent(10), "MyEvent"); epService.EPRuntime.SendEvent(MakeEvent(11), "MyEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { epService.EPRuntime.SendEventAvro(MakeEventAvro(10), "MyEvent"); epService.EPRuntime.SendEventAvro(MakeEventAvro(11), "MyEvent"); } else { Assert.Fail(); } EventBean theEvent = listener.AssertOneGetNewAndReset(); Assert.AreEqual(10, theEvent.Get("c1.myId")); Assert.AreEqual(11, theEvent.Get("c2.myId")); Assert.AreEqual("4", theEvent.Get("rule")); epService.Initialize(); }
private static void TryAssertionStreamInsertWWidenMap( RegressionEnvironment env, EventRepresentationChoice rep) { RegressionPath path = new RegressionPath(); string schemaSrc = rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSrc>() + "@Name('schema') create schema Src as (myint int, mystr string)"; env.CompileDeployWBusPublicType(schemaSrc, path); env.CompileDeploy( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD1>() + "create schema D1 as (myint int, mystr string, addprop long)", path); string eplOne = "insert into D1 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplOne, "myint,mystr,addprop", new object[] {123, "abc", 1L}); env.CompileDeploy( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD2>() + "create schema D2 as (mystr string, myint int, addprop double)", path); string eplTwo = "insert into D2 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplTwo, "myint,mystr,addprop", new object[] {123, "abc", 1d}); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD3>() + "create schema D3 as (mystr string, addprop int)", path); string eplThree = "insert into D3 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplThree, "mystr,addprop", new object[] {"abc", 1}); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD4>() + "create schema D4 as (myint int, mystr string)", path); string eplFour = "insert into D4 select mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplFour, "myint,mystr", new object[] {123, "abc"}); string eplFive = "insert into D4 select mysrc.*, 999 as myint, 'xxx' as mystr from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplFive, "myint,mystr", new object[] {999, "xxx"}); string eplSix = "insert into D4 select 999 as myint, 'xxx' as mystr, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplSix, "myint,mystr", new object[] {999, "xxx"}); env.UndeployAll(); }
private static void TryAssertionInvalid( RegressionEnvironment env, EventRepresentationChoice rep) { RegressionPath path = new RegressionPath(); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSrc>() + "create schema Src as (myint int, mystr string)", path); // mismatch in type env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedE1>() + "create schema E1 as (myint long)", path); string message = !rep.IsAvroEvent() ? "Type by name 'E1' in property 'myint' expected System.Nullable<System.Int32> but receives System.Nullable<System.Int64>" : "Type by name 'E1' in property 'myint' expected schema '{\"type\":\"long\"}' but received schema '{\"type\":\"int\"}'"; SupportMessageAssertUtil.TryInvalidCompile(env, path, "insert into E1 select mysrc.* from Src as mysrc", message); // mismatch in column name env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedE2>() + "create schema E2 as (someprop long)", path); SupportMessageAssertUtil.TryInvalidCompile( env, path, "insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc", "Failed to find column 'otherprop' in target type 'E2' [insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc]"); env.UndeployAll(); }
private static void RunStreamInsertAssertion( RegressionEnvironment env, RegressionPath path, EventRepresentationChoice rep, string epl, string fields, object[] expected) { env.CompileDeploy("@Name('s0') " + epl, path).AddListener("s0"); if (rep.IsMapEvent()) { env.SendEventMap(MakeMap(123, "abc"), "Src"); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {123, "abc"}, "Src"); } else if (rep.IsAvroEvent()) { var eventType = env.Runtime.EventTypeService.GetEventType(env.DeploymentId("schema"), "Src"); var @event = new GenericRecord(SupportAvroUtil.GetAvroSchema(eventType).AsRecordSchema()); @event.Put("myint", 123); @event.Put("mystr", "abc"); env.SendEventAvro(@event, "Src"); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { JObject @object = new JObject(); @object.Add("myint", 123); @object.Add("mystr", "abc"); env.SendEventJson(@object.ToString(), "Src"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields.SplitCsv(), expected); env.UndeployModuleContaining("s0"); }
private void TryAssertionWidening( EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum, SupportSubscriberRowByRowSpecificBase subscriber) { EPStatement stmt = epService.EPAdministrator.CreateEPL( eventRepresentationEnum.GetAnnotationText() + " select bytePrimitive, IntPrimitive, LongPrimitive, FloatPrimitive from SupportBean(TheString='E1')"); stmt.Subscriber = subscriber; Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmt.EventType.UnderlyingType)); var bean = new SupportBean(); bean.TheString = "E1"; bean.BytePrimitive = (byte)1; bean.IntPrimitive = 2; bean.LongPrimitive = 3; bean.FloatPrimitive = 4; epService.EPRuntime.SendEvent(bean); subscriber.AssertOneReceivedAndReset(stmt, new object[] { 1, 2L, 3d, 4d }); stmt.Dispose(); }
private void RunAssertionInnerJoinLateStart(EventRepresentationChoice eventRepresentationEnum) { var stmtOne = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema Product (product string, size int)"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtOne.EventType.UnderlyingType)); _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema Portfolio (portfolio string, product string)"); var stmtTwo = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window ProductWin#keepall as Product"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtTwo.EventType.UnderlyingType)); _epService.EPAdministrator.CreateEPL("insert into ProductWin select * from Product"); _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window PortfolioWin#keepall as Portfolio"); _epService.EPAdministrator.CreateEPL("insert into PortfolioWin select * from Portfolio"); SendProduct(eventRepresentationEnum, "productA", 1); SendProduct(eventRepresentationEnum, "productB", 2); SendPortfolio(eventRepresentationEnum, "Portfolio", "productA"); var stmtText = "@Name(\"Query2\") select portfolio, ProductWin.product, size " + "from PortfolioWin unidirectional inner join ProductWin on PortfolioWin.product=ProductWin.product"; var stmt = _epService.EPAdministrator.CreateEPL(stmtText); stmt.AddListener(_listenerStmtOne); SendPortfolio(eventRepresentationEnum, "Portfolio", "productB"); EPAssertionUtil.AssertProps(_listenerStmtOne.AssertOneGetNewAndReset(), new string[] { "portfolio", "ProductWin.product", "size" }, new object[] { "Portfolio", "productB", 2 }); SendPortfolio(eventRepresentationEnum, "Portfolio", "productC"); _listenerStmtOne.Reset(); SendProduct(eventRepresentationEnum, "productC", 3); SendPortfolio(eventRepresentationEnum, "Portfolio", "productC"); EPAssertionUtil.AssertProps(_listenerStmtOne.AssertOneGetNewAndReset(), new string[] { "portfolio", "ProductWin.product", "size" }, new object[] { "Portfolio", "productC", 3 }); _epService.Initialize(); }
public EPLInsertIntoTypableAndCaseNew(EventRepresentationChoice representation) { this.representation = representation; }