public override void Run(EPServiceProvider epService)
{
var tagcfg = new ConfigurationEventTypeXMLDOM();
tagcfg.RootElementName = "//Tag";
tagcfg.SchemaResource = _schemaUri;
epService.EPAdministrator.Configuration.AddEventType("TagEvent", tagcfg);
EPStatement stmtExampleOne = epService.EPAdministrator.CreateEPL("select countTags, countTagsInt, idarray, tagArray, tagOne from SensorEvent");
EPStatement stmtExampleTwo_0 = epService.EPAdministrator.CreateEPL("insert into TagOneStream select tagOne.* from SensorEvent");
EPStatement stmtExampleTwo_1 = epService.EPAdministrator.CreateEPL("select ID from TagOneStream");
EPStatement stmtExampleTwo_2 = epService.EPAdministrator.CreateEPL("insert into TagArrayStream select tagArray as mytags from SensorEvent");
EPStatement stmtExampleTwo_3 = epService.EPAdministrator.CreateEPL("select mytags[1].ID from TagArrayStream");
XmlDocument doc = SupportXML.GetDocument(OBSERVATION_XML);
epService.EPRuntime.SendEvent(doc);
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleOne.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_1.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_2.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_3.First());
Object resultArray = stmtExampleOne.First().Get("idarray");
EPAssertionUtil.AssertEqualsExactOrder((object[])resultArray, new string[] { "urn:epc:1:2.24.400", "urn:epc:1:2.24.401" });
EPAssertionUtil.AssertProps(stmtExampleOne.First(), "countTags,countTagsInt".Split(','), new object[] { 2d, 2 });
Assert.AreEqual("urn:epc:1:2.24.400", stmtExampleTwo_1.First().Get("ID"));
Assert.AreEqual("urn:epc:1:2.24.401", stmtExampleTwo_3.First().Get("mytags[1].ID"));
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
env.CompileDeploy("@Name('insert') insert into MyNestedStream select nested1 from " + eventTypeName, path);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(string), typeof(char), false, false, true, false, false)
},
env.Statement("insert").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("insert").EventType);
env.CompileDeploy("@Name('s0') select * from " + eventTypeName, path);
CollectionAssert.AreEquivalent(new EventPropertyDescriptor[0], env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
SupportXML.SendDefaultEvent(env.EventService, "test", eventTypeName);
var stmtInsertWildcardBean = env.GetEnumerator("insert").Advance();
var stmtSelectWildcardBean = env.GetEnumerator("s0").Advance();
Assert.IsNotNull(stmtInsertWildcardBean.Get("nested1"));
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcardBean);
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("insert").Advance());
Assert.AreEqual(0, stmtSelectWildcardBean.EventType.PropertyNames.Length);
env.UndeployAll();
}
public override void Run(EPServiceProvider epService)
{
// Note that XPath Node results when transposed must be queried by XPath that is also absolute.
// For example: "nested1" => "/n0:simpleEvent/n0:nested1" results in a Node.
// That result Node's "prop1" => "/n0:simpleEvent/n0:nested1/n0:prop1" and "/n0:nested1/n0:prop1" does NOT result in a value.
// Therefore property transposal is disabled for Property-XPath expressions.
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
string schemaUri = SupportContainer.Instance.ResourceManager().ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
eventTypeMeta.SchemaResource = schemaUri;
eventTypeMeta.IsXPathPropertyExpr = true; // <== note this
eventTypeMeta.AddNamespacePrefix("ss", "samples:schemas:simpleSchema");
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
// note class not a fragment
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType#lastevent");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EventType type = ((EPServiceProviderSPI)epService).EventAdapterService.GetEventTypeByName("TestXMLSchemaType");
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.nested2"));
SupportXML.SendDefaultEvent(epService.EPRuntime, "ABC");
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
}
public void SetUp()
{
_epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
var config = new ConfigurationEventTypeXMLDOM();
var schemaUri = ResourceManager.ResolveResourceURL("regression/mediaOrderSchema.xsd").ToString();
config.SchemaResource = schemaUri;
config.RootElementName = "mediaorder";
_epService.EPAdministrator.Configuration.AddEventType("MediaOrder", config);
_epService.EPAdministrator.Configuration.AddEventType("Cancel", config);
var xmlStreamOne = ResourceManager.GetResourceAsStream("regression/mediaOrderOne.xml");
_eventDocOne = SupportXML.GetDocument(xmlStreamOne);
var xmlStreamTwo = ResourceManager.GetResourceAsStream("regression/mediaOrderTwo.xml");
_eventDocTwo = SupportXML.GetDocument(xmlStreamTwo);
}
private static void runAssertion(
RegressionEnvironment env,
string eventTypeName,
RegressionPath path)
{
var stmtText = "@Name('s0') select type?,dyn[1]?,nested.nes2?,map('a')? from " + eventTypeName;
env.CompileDeploy(stmtText, path).AddListener("s0");
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("type?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("dyn[1]?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("nested.nes2?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("map('a')?", typeof(XmlNode), null, false, false, false, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
var root = SupportXML.SendXMLEvent(env, NOSCHEMA_XML, eventTypeName);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreSame(root.DocumentElement.ChildNodes.Item(0), theEvent.Get("type?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(2), theEvent.Get("dyn[1]?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(3).ChildNodes.Item(0), theEvent.Get("nested.nes2?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(4), theEvent.Get("map('a')?"));
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
env.UndeployAll();
}
public override void Run(EPServiceProvider epService)
{
string xml = "<Event IsTriggering=\"True\">\n" +
"<Field Name=\"A\" Value=\"987654321\"/>\n" +
"<Field Name=\"B\" Value=\"2196958725202\"/>\n" +
"<Field Name=\"C\" Value=\"1232363702\"/>\n" +
"<Participants>\n" +
"<Participant>\n" +
"<Field Name=\"A\" Value=\"9876543210\"/>\n" +
"<Field Name=\"B\" Value=\"966607340\"/>\n" +
"<Field Name=\"D\" Value=\"353263010930650\"/>\n" +
"</Participant>\n" +
"</Participants>\n" +
"</Event>";
var desc = new ConfigurationEventTypeXMLDOM();
desc.RootElementName = "Event";
desc.AddXPathProperty("A", "//Field[@Name='A']/@Value", XPathResultType.NodeSet, "string[]");
epService.EPAdministrator.Configuration.AddEventType("Event", desc);
EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from Event");
var updateListener = new SupportUpdateListener();
stmt.Events += updateListener.Update;
XmlDocument doc = SupportXML.GetDocument(xml);
epService.EPRuntime.SendEvent(doc);
EventBean theEvent = updateListener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, "A".Split(','), new object[] { new object[] { "987654321", "9876543210" } });
}
public override void Run(EPServiceProvider epService)
{
var stmtText = "select type?,dyn[1]?,nested.nes2?,map('a')? from MyEvent";
var stmt = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("type?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("dyn[1]?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("nested.nes2?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("map('a')?", typeof(XmlNode), null, false, false, false, false, false),
}, stmt.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmt.EventType);
var root = SupportXML.SendEvent(epService.EPRuntime, NOSCHEMA_XML);
var theEvent = listener.AssertOneGetNewAndReset();
Assert.AreSame(root.DocumentElement.ChildNodes.Item(0), theEvent.Get("type?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(1), theEvent.Get("dyn[1]?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(3).ChildNodes.Item(0), theEvent.Get("nested.nes2?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(4), theEvent.Get("map('a')?"));
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
}
public override void Run(EPServiceProvider epService)
{
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
// eventTypeMeta.IsXPathPropertyExpr = false; <== the default
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(string), typeof(char), false, false, true, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EPStatement stmtSelectWildcard = epService.EPAdministrator.CreateEPL("select * from TestXMLSchemaType");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[0], stmtSelectWildcard.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcard.EventType);
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
EventBean stmtInsertWildcardBean = stmtInsert.First();
EventBean stmtSelectWildcardBean = stmtSelectWildcard.First();
Assert.IsNotNull(stmtInsertWildcardBean.Get("nested1"));
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcardBean);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
Assert.AreEqual(0, stmtSelectWildcardBean.EventType.PropertyNames.Length);
}
public override void Run(EPServiceProvider epService)
{
// url='page4'
string text = "select a.url as sesja from pattern [ every a=PageVisitEvent(url='page1') ]";
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
var updateListener = new SupportUpdateListener();
stmt.Events += updateListener.Update;
SupportXML.SendEvent(epService.EPRuntime,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<event-page-visit xmlns=\"samples:schemas:simpleSchemaWithAll\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"samples:schemas:simpleSchemaWithAll simpleSchemaWithAll.xsd\">\n" +
"<url>page1</url>" +
"</event-page-visit>");
EventBean theEvent = updateListener.LastNewData[0];
Assert.AreEqual("page1", theEvent.Get("sesja"));
updateListener.Reset();
SupportXML.SendEvent(epService.EPRuntime,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<event-page-visit xmlns=\"samples:schemas:simpleSchemaWithAll\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"samples:schemas:simpleSchemaWithAll simpleSchemaWithAll.xsd\">\n" +
"<url>page2</url>" +
"</event-page-visit>");
Assert.IsFalse(updateListener.IsInvoked);
EventType type = epService.EPAdministrator.CreateEPL("select * from PageVisitEvent").EventType;
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("sessionId", typeof(XmlNode), null, false, false, false, false, true),
new EventPropertyDescriptor("customerId", typeof(XmlNode), null, false, false, false, false, true),
new EventPropertyDescriptor("url", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("method", typeof(XmlNode), null, false, false, false, false, true),
}, type.PropertyDescriptors);
}
public override void Run(EPServiceProvider epService)
{
var container = SupportContainer.Instance;
var config = new ConfigurationEventTypeXMLDOM();
string schemaUri = container.ResourceManager().ResolveResourceURL("regression/mediaOrderSchema.xsd").ToString();
config.SchemaResource = schemaUri;
config.RootElementName = "mediaorder";
epService.EPAdministrator.Configuration.AddEventType("MediaOrder", config);
epService.EPAdministrator.Configuration.AddEventType("Cancel", config);
var xmlStreamOne = container.ResourceManager().GetResourceAsStream("regression/mediaOrderOne.xml");
var eventDocOne = SupportXML.GetDocument(xmlStreamOne);
var xmlStreamTwo = container.ResourceManager().GetResourceAsStream("regression/mediaOrderTwo.xml");
var eventDocTwo = SupportXML.GetDocument(xmlStreamTwo);
RunAssertionExample(epService, eventDocOne);
RunAssertionJoinSelfJoin(epService, eventDocOne, eventDocTwo);
RunAssertionJoinSelfLeftOuterJoin(epService, eventDocOne, eventDocTwo);
RunAssertionJoinSelfFullOuterJoin(epService, eventDocOne, eventDocTwo);
RunAssertionSolutionPattern(epService);
}
public override void Configure(Configuration configuration)
{
var avroSchema = SchemaBuilder.Record(AVRO_TYPENAME,
TypeBuilder.Field("IntPrimitive", TypeBuilder.IntType()));
string avroSchemaText = avroSchema.ToString().Replace("\"", """);
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<esper-configuration>\t\n" +
"\t<event-type name=\"MyStaticBean\" class=\"" + typeof(SupportBean).FullName + "\"/>\n" +
"\t<event-type name=\"" + MAP_TYPENAME + "\">\n" +
"\t\t<map>\n" +
"\t \t\t<map-property name=\"IntPrimitive\" class=\"int\"/>\n" +
"\t \t</map>\n" +
"\t</event-type>\n" +
"\t\n" +
"\t<event-type name=\"" + OA_TYPENAME + "\">\n" +
"\t\t<objectarray>\n" +
"\t \t\t<objectarray-property name=\"IntPrimitive\" class=\"int\"/>\n" +
"\t \t</objectarray>\n" +
"\t</event-type>\n" +
"\t<event-type name=\"" + XML_TYPENAME + "\">\n" +
"\t\t<xml-dom root-element-name=\"myevent\">\n" +
"\t\t\t<xpath-property property-name=\"IntPrimitive\" xpath=\"@IntPrimitive\" type=\"number\"/>\n" +
"\t\t</xml-dom>\n" +
"\t</event-type>\n" +
"\t<event-type name=\"" + AVRO_TYPENAME + "\">\n" +
"\t\t<avro schema-text=\"" + avroSchemaText + "\"/>\n" +
"\t</event-type>\n" +
"</esper-configuration>\n";
configuration.Configure(SupportXML.GetDocument(xml));
}
public override void Run(EPServiceProvider epService)
{
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
string schemaUri = SupportContainer.Instance
.ResourceManager()
.ResolveResourceURL(CLASSLOADER_SCHEMA_URI)
.ToString();
eventTypeMeta.SchemaResource = schemaUri;
eventTypeMeta.IsXPathPropertyExpr = true; // <== note this
eventTypeMeta.AddNamespacePrefix("ss", "samples:schemas:simpleSchema");
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
// note class not a fragment
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EventType type = ((EPServiceProviderSPI)epService).EventAdapterService.GetEventTypeByName("TestXMLSchemaType");
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.nested2"));
SupportXML.SendDefaultEvent(epService.EPRuntime, "ABC");
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
// Note that XPath Node results when transposed must be queried by XPath that is also absolute.
// For example: "nested1" -> "/n0:simpleEvent/n0:nested1" results in a Node.
// That result Node's "prop1" -> "/n0:simpleEvent/n0:nested1/n0:prop1" and "/n0:nested1/n0:prop1" does NOT result in a value.
// Therefore property transposal is disabled for Property-XPath expressions.
// note class not a fragment
env.CompileDeploy("@Name('s0') insert into MyNestedStream select nested1 from " + eventTypeName + "#lastevent", path);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
var type = env.Runtime.EventTypeService.GetEventTypePreconfigured(eventTypeName);
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.Nested2"));
SupportXML.SendDefaultEvent(env.EventService, "ABC", eventTypeName);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").First());
env.UndeployAll();
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
// try array property insert
env.CompileDeploy("@Name('s0') select nested3.nested4 as narr from " + eventTypeName + "#lastevent", path);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor(
"narr",
typeof(XmlNode[]),
typeof(XmlNode),
false,
false,
true,
false,
true)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
SupportXML.SendDefaultEvent(env.EventService, "test", eventTypeName);
var result = env.Statement("s0").First();
SupportEventTypeAssertionUtil.AssertConsistency(result);
var fragments = (EventBean[]) result.GetFragment("narr");
Assert.AreEqual(3, fragments.Length);
Assert.AreEqual("SAMPLE_V8", fragments[0].Get("prop5[1]"));
Assert.AreEqual("SAMPLE_V11", fragments[2].Get("prop5[1]"));
var fragmentItem = (EventBean) result.GetFragment("narr[2]");
Assert.AreEqual($"{eventTypeName}.nested3.nested4", fragmentItem.EventType.Name);
Assert.AreEqual("SAMPLE_V10", fragmentItem.Get("prop5[0]"));
// try array index property insert
env.CompileDeploy($"@Name('ii') select nested3.nested4[1] as narr from {eventTypeName}#lastevent", path);
CollectionAssert.AreEquivalent(
new[] {
new EventPropertyDescriptor("narr", typeof(XmlNode), null, false, false, false, false, true)
},
env.Statement("ii").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("ii").EventType);
SupportXML.SendDefaultEvent(env.EventService, "test", eventTypeName);
var resultItem = env.GetEnumerator("ii").Advance();
Assert.That(resultItem.Get("narr.id"), Is.EqualTo("b"));
SupportEventTypeAssertionUtil.AssertConsistency(resultItem);
var fragmentsInsertItem = (EventBean) resultItem.GetFragment("narr");
SupportEventTypeAssertionUtil.AssertConsistency(fragmentsInsertItem);
Assert.That(fragmentsInsertItem.Get("id"), Is.EqualTo("b"));
Assert.That(fragmentsInsertItem.Get("prop5[0]"), Is.EqualTo("SAMPLE_V9"));
env.UndeployAll();
}
private XmlNode GetXMLEvent(String xml)
{
try {
return(SupportXML.GetDocument(xml));
}
catch (Exception ex) {
throw new EPRuntimeException(ex);
}
}
public override void Run(EPServiceProvider epService)
{
var schemaURI = SupportContainer.Instance.ResourceManager().ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
eventTypeMeta.SchemaResource = schemaURI;
epService.EPAdministrator.Configuration.AddEventType("ABCType", eventTypeMeta);
eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "//nested2";
eventTypeMeta.SchemaResource = schemaURI;
eventTypeMeta.IsEventSenderValidatesRoot = false;
epService.EPAdministrator.Configuration.AddEventType("TestNested2", eventTypeMeta);
// try array property in select
var stmtInsert = epService.EPAdministrator.CreateEPL("select * from TestNested2#lastevent");
var listener = new SupportUpdateListener();
stmtInsert.Events += listener.Update;
EPAssertionUtil.AssertEqualsAnyOrder(new [] {
new EventPropertyDescriptor("prop3", typeof(int?[]), typeof(int?), false, false, true, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
Assert.IsFalse(listener.IsInvoked);
var sender = epService.EPRuntime.GetEventSender("TestNested2");
sender.SendEvent(SupportXML.GetDocument("<nested2><prop3>2</prop3><prop3></prop3><prop3>4</prop3></nested2>"));
var theEvent = stmtInsert.First();
EPAssertionUtil.AssertEqualsExactOrder((int?[])theEvent.Get("prop3"), new int?[] { 2, null, 4 });
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
// try array property nested
var stmtSelect = epService.EPAdministrator.CreateEPL("select nested3.* from ABCType#lastevent");
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
var stmtSelectResult = stmtSelect.First();
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectResult);
Assert.AreEqual(typeof(string[]), stmtSelectResult.EventType.GetPropertyType("nested4[2].prop5"));
Assert.AreEqual("SAMPLE_V8", stmtSelectResult.Get("nested4[0].prop5[1]"));
EPAssertionUtil.AssertEqualsExactOrder((string[])stmtSelectResult.Get("nested4[2].prop5"), new object[] { "SAMPLE_V10", "SAMPLE_V11" });
var fragmentNested4 = (EventBean)stmtSelectResult.GetFragment("nested4[2]");
EPAssertionUtil.AssertEqualsExactOrder((string[])fragmentNested4.Get("prop5"), new object[] { "SAMPLE_V10", "SAMPLE_V11" });
Assert.AreEqual("SAMPLE_V11", fragmentNested4.Get("prop5[1]"));
SupportEventTypeAssertionUtil.AssertConsistency(fragmentNested4);
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionEventsProcessed(RegressionEnvironment env)
{
var listenerMap = new SupportListenerTimerHRes();
var listenerBean = new SupportListenerTimerHRes();
var listenerXML = new SupportListenerTimerHRes();
var listenerOA = new SupportListenerTimerHRes();
var listenerJson = new SupportListenerTimerHRes();
env.CompileDeploy("@Name('s0') select SupportStaticMethodLib.Sleep(100) from MyMap").Statement("s0").AddListener(listenerMap);
env.CompileDeploy("@Name('s1') select SupportStaticMethodLib.Sleep(100) from SupportBean").Statement("s1").AddListener(listenerBean);
env.CompileDeploy("@Name('s2') select SupportStaticMethodLib.Sleep(100) from XMLType").Statement("s2").AddListener(listenerXML);
env.CompileDeploy("@Name('s3') select SupportStaticMethodLib.Sleep(100) from MyOA").Statement("s3").AddListener(listenerOA);
env.CompileDeploy(
"@public @buseventtype create json schema JsonEvent();\n" +
"@Name('s4') select SupportStaticMethodLib.Sleep(100) from JsonEvent")
.Statement("s4")
.AddListener(listenerJson);
var senderMap = env.EventService.GetEventSender("MyMap");
var senderBean = env.EventService.GetEventSender("SupportBean");
var senderXML = env.EventService.GetEventSender("XMLType");
var senderOA = env.EventService.GetEventSender("MyOA");
var senderJson = env.EventService.GetEventSender("JsonEvent");
long start = PerformanceObserver.MicroTime;
for (var i = 0; i < 2; i++) {
env.SendEventMap(new Dictionary<string, object>(), "MyMap");
senderMap.SendEvent(new Dictionary<string, object>());
env.SendEventBean(new SupportBean());
senderBean.SendEvent(new SupportBean());
env.SendEventXMLDOM(SupportXML.GetDocument("<myevent/>"), "XMLType");
senderXML.SendEvent(SupportXML.GetDocument("<myevent/>"));
env.SendEventObjectArray(new object[0], "MyOA");
senderOA.SendEvent(new object[0]);
env.SendEventJson("{}", "JsonEvent");
senderJson.SendEvent("{}");
}
long end = PerformanceObserver.MicroTime;
var delta = (end - start) / 1000;
Assert.IsTrue(delta < 500);
Thread.Sleep(1000);
foreach (var listener in Arrays.AsList(listenerMap, listenerBean, listenerXML, listenerOA, listenerJson)) {
Assert.AreEqual(4, listener.NewEvents.Count);
}
var spi = (EPRuntimeSPI) env.Runtime;
Assert.AreEqual(0, spi.ServicesContext.ThreadingService.InboundQueue.Count);
Assert.IsNotNull(spi.ServicesContext.ThreadingService.InboundThreadPool);
env.UndeployAll();
}
public override void Run(EPServiceProvider epService)
{
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
string schemaUri = SupportContainer.Instance.ResourceManager().ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
eventTypeMeta.SchemaResource = schemaUri;
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
// try array property insert
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("select nested3.nested4 as narr from TestXMLSchemaType#lastevent");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("narr", typeof(XmlNode[]), typeof(XmlNode), false, false, true, false, true),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
EventBean result = stmtInsert.First();
SupportEventTypeAssertionUtil.AssertConsistency(result);
EventBean[] fragments = (EventBean[])result.GetFragment("narr");
Assert.AreEqual(3, fragments.Length);
Assert.AreEqual("SAMPLE_V8", fragments[0].Get("prop5[1]"));
Assert.AreEqual("SAMPLE_V11", fragments[2].Get("prop5[1]"));
EventBean fragmentItem = (EventBean)result.GetFragment("narr[2]");
Assert.AreEqual("TestXMLSchemaType.nested3.nested4", fragmentItem.EventType.Name);
Assert.AreEqual("SAMPLE_V10", fragmentItem.Get("prop5[0]"));
// try array index property insert
EPStatement stmtInsertItem = epService.EPAdministrator.CreateEPL("select nested3.nested4[1] as narr from TestXMLSchemaType#lastevent");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("narr", typeof(XmlNode), null, false, false, false, false, true),
}, stmtInsertItem.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsertItem.EventType);
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
EventBean resultItem = stmtInsertItem.First();
Assert.AreEqual("b", resultItem.Get("narr.id"));
SupportEventTypeAssertionUtil.AssertConsistency(resultItem);
EventBean fragmentsInsertItem = (EventBean)resultItem.GetFragment("narr");
SupportEventTypeAssertionUtil.AssertConsistency(fragmentsInsertItem);
Assert.AreEqual("b", fragmentsInsertItem.Get("id"));
Assert.AreEqual("SAMPLE_V9", fragmentsInsertItem.Get("prop5[0]"));
}
public override void Run(EPServiceProvider epService)
{
AddMapEventType(epService);
AddOAEventType(epService);
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.Configuration.AddEventType("Marker", typeof(SupportMarkerInterface));
AddAvroEventType(epService);
// Bean
RunAssertionSuccess(epService, typeof(SupportBean).FullName, new SupportBean());
RunAssertionInvalid(epService, typeof(SupportBean).FullName, new SupportBean_G("G1"),
"Event object of type " + typeof(SupportBean_G).FullName + " does not equal, extend or implement the type " + typeof(SupportBean).FullName + " of event type 'SupportBean'");
RunAssertionSuccess(epService, "Marker", new SupportMarkerImplA("Q2"), new SupportBean_G("Q3"));
// Map
RunAssertionSuccess(epService, MAP_TYPENAME, new Dictionary <string, object>());
RunAssertionInvalid(epService, MAP_TYPENAME, new SupportBean(),
"Unexpected event object of type " + Name.Clean <SupportBean>() + ", expected " + Name.Clean <Map>());
// Object-Array
RunAssertionSuccess(epService, OA_TYPENAME, new object[] {});
RunAssertionInvalid(epService, OA_TYPENAME, new SupportBean(),
"Unexpected event object of type " + Name.Clean <SupportBean>() + ", expected " + Name.Clean <object[]>());
// XML
RunAssertionSuccess(epService, XML_TYPENAME, SupportXML.GetDocument("<myevent/>").DocumentElement);
RunAssertionInvalid(epService, XML_TYPENAME, new SupportBean(),
"Unexpected event object type '" + typeof(SupportBean).FullName + "' encountered, please supply a XmlDocument or XmlElement node");
RunAssertionInvalid(epService, XML_TYPENAME, SupportXML.GetDocument("<xxxx/>"),
"Unexpected root element name 'xxxx' encountered, expected a root element name of 'myevent'");
// Avro
RunAssertionSuccess(epService, AVRO_TYPENAME, new GenericRecord(GetAvroSchema()));
RunAssertionInvalid(epService, AVRO_TYPENAME, new SupportBean(),
"Unexpected event object type '" + typeof(SupportBean).FullName + "' encountered, please supply a GenericRecord");
// No such type
try {
epService.EPRuntime.GetEventSender("ABC");
Assert.Fail();
} catch (EventTypeException ex) {
Assert.AreEqual("Event type named 'ABC' could not be found", ex.Message);
}
// Internal implicit wrapper type
epService.EPAdministrator.CreateEPL("insert into ABC select *, TheString as value from SupportBean");
try {
epService.EPRuntime.GetEventSender("ABC");
Assert.Fail("Event type named 'ABC' could not be found");
} catch (EventTypeException ex) {
Assert.AreEqual("An event sender for event type named 'ABC' could not be created as the type is internal", ex.Message);
}
}
private void RunAssertionEventsProcessed(EPServiceProvider epService)
{
var listenerOne = new SupportListenerTimerHRes();
var listenerTwo = new SupportListenerTimerHRes();
var listenerThree = new SupportListenerTimerHRes();
EPStatement stmtOne = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from MyMap");
stmtOne.Events += listenerOne.Update;
EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from SupportBean");
stmtTwo.Events += listenerTwo.Update;
EPStatement stmtThree = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from XMLType");
stmtThree.Events += listenerThree.Update;
EventSender senderOne = epService.EPRuntime.GetEventSender("MyMap");
EventSender senderTwo = epService.EPRuntime.GetEventSender("SupportBean");
EventSender senderThree = epService.EPRuntime.GetEventSender("XMLType");
long start = PerformanceObserver.NanoTime;
for (int i = 0; i < 2; i++)
{
epService.EPRuntime.SendEvent(new Dictionary <string, Object>(), "MyMap");
senderOne.SendEvent(new Dictionary <string, Object>());
epService.EPRuntime.SendEvent(new SupportBean());
senderTwo.SendEvent(new SupportBean());
epService.EPRuntime.SendEvent(SupportXML.GetDocument("<myevent/>"));
senderThree.SendEvent(SupportXML.GetDocument("<myevent/>"));
}
long end = PerformanceObserver.NanoTime;
long delta = (end - start) / 1000000;
Assert.IsTrue(delta < 500);
Thread.Sleep(1000);
Assert.AreEqual(4, listenerOne.NewEvents.Count);
Assert.AreEqual(4, listenerTwo.NewEvents.Count);
Assert.AreEqual(4, listenerThree.NewEvents.Count);
EPServiceProviderSPI spi = (EPServiceProviderSPI)epService;
Assert.AreEqual(0, spi.ThreadingService.InboundQueue.Count);
Assert.IsNotNull(spi.ThreadingService.InboundThreadPool);
stmtOne.Dispose();
stmtTwo.Dispose();
stmtThree.Dispose();
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeNameNested,
String eventTypeNameABC,
RegressionPath path)
{
// try array property in select
env.CompileDeploy("@Name('s0') select * from " + eventTypeNameNested + "#lastevent", path).AddListener("s0");
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("prop3", typeof(int?[]), typeof(int?), false, false, true, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
EventSender sender = env.EventService.GetEventSender(eventTypeNameNested);
sender.SendEvent(
SupportXML.GetDocument(
"<nested2><prop3>2</prop3><prop3></prop3><prop3>4</prop3></nested2>"));
var theEvent = env.GetEnumerator("s0").Advance();
var theValues = theEvent.Get("prop3").Unwrap<object>(true);
EPAssertionUtil.AssertEqualsExactOrder(
theValues,
new object[] {2, null, 4});
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
env.UndeployModuleContaining("s0");
// try array property nested
env.CompileDeploy("@Name('s0') select nested3.* from " + eventTypeNameABC + "#lastevent", path);
SupportXML.SendDefaultEvent(env.EventService, "test", eventTypeNameABC);
var stmtSelectResult = env.GetEnumerator("s0").Advance();
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectResult);
Assert.AreEqual(typeof(string[]), stmtSelectResult.EventType.GetPropertyType("nested4[2].prop5"));
Assert.AreEqual("SAMPLE_V8", stmtSelectResult.Get("nested4[0].prop5[1]"));
EPAssertionUtil.AssertEqualsExactOrder(
(string[]) stmtSelectResult.Get("nested4[2].prop5"),
new object[] {"SAMPLE_V10", "SAMPLE_V11"});
var fragmentNested4 = (EventBean) stmtSelectResult.GetFragment("nested4[2]");
EPAssertionUtil.AssertEqualsExactOrder(
(string[]) fragmentNested4.Get("prop5"),
new object[] {"SAMPLE_V10", "SAMPLE_V11"});
Assert.AreEqual("SAMPLE_V11", fragmentNested4.Get("prop5[1]"));
SupportEventTypeAssertionUtil.AssertConsistency(fragmentNested4);
env.UndeployAll();
}
public static IList<RegressionExecution> Executions(IResourceManager resourceManager)
{
using (var xmlStreamOne = resourceManager.GetResourceAsStream("regression/mediaOrderOne.xml")) {
var eventDocOne = SupportXML.GetDocument(xmlStreamOne);
using (var xmlStreamTwo = resourceManager.GetResourceAsStream("regression/mediaOrderTwo.xml")) {
var eventDocTwo = SupportXML.GetDocument(xmlStreamTwo);
var execs = new List<RegressionExecution>();
execs.Add(new EPLContainedExample(eventDocOne));
execs.Add(new EPLContainedSolutionPattern());
execs.Add(new EPLContainedJoinSelfJoin(eventDocOne, eventDocTwo));
execs.Add(new EPLContainedJoinSelfLeftOuterJoin(eventDocOne, eventDocTwo));
execs.Add(new EPLContainedJoinSelfFullOuterJoin(eventDocOne, eventDocTwo));
execs.Add(new EPLContainedSolutionPatternFinancial());
return execs;
}
}
}
public void TestEPLVariableEngineConfigXML()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<esper-configuration xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"../esper-configuration-6-0.xsd\">" +
"<common><variable name=\"p_1\" type=\"string\" />" +
"<variable name=\"p_2\" type=\"bool\" initialization-value=\"true\"/>" +
"<variable name=\"p_3\" type=\"long\" initialization-value=\"10\"/>" +
"<variable name=\"p_4\" type=\"double\" initialization-value=\"11.1d\"/>" +
"</common></esper-configuration>";
var doc = SupportXML.GetDocument(xml);
RegressionSession session = RegressionRunner.Session();
Configuration configuration = session.Configuration;
configuration.Common.AddEventType(typeof(SupportBean));
configuration.Configure(doc);
RegressionRunner.Run(session, new EPLVariableEngineConfigXML());
session.Dispose();
}
public override void Run(EPServiceProvider epService)
{
var updateListener = new SupportUpdateListener();
string text = "select order_amount from OrderEvent";
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
stmt.Events += updateListener.Update;
SupportXML.SendEvent(epService.EPRuntime,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<order>\n" +
"<order_amount>202.1</order_amount>" +
"</order>");
EventBean theEvent = updateListener.LastNewData[0];
Assert.AreEqual(typeof(double), theEvent.Get("order_amount").GetType());
Assert.AreEqual(202.1d, theEvent.Get("order_amount"));
updateListener.Reset();
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
// url='page4'
var text = "@Name('s0') select a.url as sesja from pattern [ every a=" + eventTypeName + "(url='page1') ]";
env.CompileDeploy(text, path).AddListener("s0");
SupportXML.SendXMLEvent(
env,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<event-page-visit xmlns=\"samples:schemas:simpleSchemaWithAll\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"samples:schemas:simpleSchemaWithAll simpleSchemaWithAll.xsd\">\n" +
"<url>page1</url>" +
"</event-page-visit>",
eventTypeName);
var theEvent = env.Listener("s0").LastNewData[0];
Assert.AreEqual("page1", theEvent.Get("sesja"));
env.Listener("s0").Reset();
SupportXML.SendXMLEvent(
env,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<event-page-visit xmlns=\"samples:schemas:simpleSchemaWithAll\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"samples:schemas:simpleSchemaWithAll simpleSchemaWithAll.xsd\">\n" +
"<url>page2</url>" +
"</event-page-visit>",
eventTypeName);
Assert.IsFalse(env.Listener("s0").IsInvoked);
var type = env.CompileDeploy("@Name('s1') select * from " + eventTypeName, path).Statement("s1").EventType;
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("sessionId", typeof(XmlNode), null, false, false, false, false, true),
new EventPropertyDescriptor("customerId", typeof(XmlNode), null, false, false, false, false, true),
new EventPropertyDescriptor("url", typeof(string), null, false, false, false, false, false),
new EventPropertyDescriptor("method", typeof(XmlNode), null, false, false, false, false, true)
},
type.PropertyDescriptors);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// note class not a fragment
env.CompileDeploy("@Name('s0') insert into MyNestedStream select nested1 from TestXMLSchemaTypeTXG");
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
var type = env.Runtime.EventTypeService.GetEventTypePreconfigured("TestXMLSchemaTypeTXG");
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.Nested2"));
SupportXML.SendDefaultEvent(env.EventService, "ABC", "TestXMLSchemaTypeTXG");
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("s0").Advance());
env.UndeployAll();
}
private void RunAssertionXPathExpression()
{
var ctx = new XPathNamespaceContext();
ctx.AddNamespace("n0", "samples:schemas:simpleSchema");
var node = SupportXML.GetDocument().DocumentElement;
var nav = node.CreateNavigator();
var pathExprOne = XPathExpression.Compile("/n0:simpleEvent/n0:nested1", ctx);
var iterator = (XPathNodeIterator)nav.Evaluate(pathExprOne);
Assert.AreEqual(iterator.Count, 1);
Assert.IsTrue(iterator.MoveNext());
var result = ((IHasXmlNode)iterator.Current).GetNode();
//Log.Info("Result:\n" + SchemaUtil.Serialize(result));
var pathExprTwo = XPathExpression.Compile("/n0:simpleEvent/n0:nested1/n0:prop1", ctx);
iterator = (XPathNodeIterator)nav.Evaluate(pathExprTwo);
Assert.AreEqual(iterator.Count, 1);
Assert.IsTrue(iterator.MoveNext());
string resultTwo = (string)iterator.Current.TypedValue;
//Log.Info("Result 2: <" + resultTwo + ">");
var pathExprThree = XPathExpression.Compile("/n0:simpleEvent/n0:nested3", ctx);
iterator = (XPathNodeIterator)nav.Evaluate(pathExprThree);
Assert.AreEqual(iterator.Count, 1);
Assert.IsTrue(iterator.MoveNext());
string resultThress = (string)iterator.Current.TypedValue;
//Log.Info("Result 3: <" + resultThress + ">");
}
private static void RunAssertion(
RegressionEnvironment env,
string eventTypeName,
RegressionPath path)
{
var text = "@Name('s0') select order_amount from " + eventTypeName;
env.CompileDeploy(text, path).AddListener("s0");
SupportXML.SendXMLEvent(
env,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<order>\n" +
"<order_amount>202.1</order_amount>" +
"</order>",
"OrderEvent");
var theEvent = env.Listener("s0").LastNewData[0];
Assert.AreEqual(typeof(double), theEvent.Get("order_amount").GetType());
Assert.AreEqual(202.1d, theEvent.Get("order_amount"));
env.Listener("s0").Reset();
env.UndeployAll();
}
private static void RunAssertion(
RegressionEnvironment env,
string eventTypeName,
RegressionPath path)
{
env.CompileDeploy("@Name('s0') select countTags, countTagsInt, idarray, tagArray, tagOne from " + eventTypeName, path);
env.CompileDeploy("@Name('e0') insert into TagOneStream select tagOne.* from " + eventTypeName, path);
env.CompileDeploy("@Name('e1') select ID from TagOneStream", path);
env.CompileDeploy("@Name('e2') insert into TagArrayStream select tagArray as mytags from " + eventTypeName, path);
env.CompileDeploy("@Name('e3') select mytags[1].ID from TagArrayStream", path);
var doc = SupportXML.GetDocument(OBSERVATION_XML);
env.SendEventXMLDOM(doc, eventTypeName);
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("s0").Advance());
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("e0").Advance());
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("e1").Advance());
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("e2").Advance());
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("e3").Advance());
var resultEnumerator = env.GetEnumerator("s0");
Assert.That(resultEnumerator, Is.Not.Null);
Assert.That(resultEnumerator.MoveNext(), Is.True);
Assert.That(resultEnumerator.Current, Is.Not.Null);
var resultArray = resultEnumerator.Current.Get("idarray");
EPAssertionUtil.AssertEqualsExactOrder(
(object[]) resultArray,
new[] {"urn:epc:1:2.24.400", "urn:epc:1:2.24.401"});
EPAssertionUtil.AssertProps(
env.GetEnumerator("s0").Advance(),
new[] {"countTags", "countTagsInt"},
new object[] {2d, 2});
Assert.AreEqual("urn:epc:1:2.24.400", env.GetEnumerator("e1").Advance().Get("ID"));
Assert.AreEqual("urn:epc:1:2.24.401", env.GetEnumerator("e3").Advance().Get("mytags[1].ID"));
env.UndeployAll();
}
public override void Run(EPServiceProvider epService)
{
string stmtExampleOneText = "select ID, Observation.Command, Observation.ID,\n" +
"Observation.Tag[0].ID, Observation.Tag[1].ID\n" +
"from SensorEvent";
EPStatement stmtExampleOne = epService.EPAdministrator.CreateEPL(stmtExampleOneText);
EPStatement stmtExampleTwo_0 = epService.EPAdministrator.CreateEPL("insert into ObservationStream\n" +
"select ID, Observation from SensorEvent");
EPStatement stmtExampleTwo_1 = epService.EPAdministrator.CreateEPL("select Observation.Command, Observation.Tag[0].ID from ObservationStream");
EPStatement stmtExampleThree_0 = epService.EPAdministrator.CreateEPL("insert into TagListStream\n" +
"select ID as sensorId, Observation.* from SensorEvent");
EPStatement stmtExampleThree_1 = epService.EPAdministrator.CreateEPL("select sensorId, Command, Tag[0].ID from TagListStream");
XmlDocument doc = SupportXML.GetDocument(OBSERVATION_XML);
EventSender sender = epService.EPRuntime.GetEventSender("SensorEvent");
sender.SendEvent(doc);
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleOne.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_1.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleThree_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleThree_1.First());
EPAssertionUtil.AssertProps(stmtExampleTwo_1.First(), "Observation.Command,Observation.Tag[0].ID".Split(','), new object[] { "READ_PALLET_TAGS_ONLY", "urn:epc:1:2.24.400" });
EPAssertionUtil.AssertProps(stmtExampleThree_1.First(), "sensorId,Command,Tag[0].ID".Split(','), new object[] { "urn:epc:1:4.16.36", "READ_PALLET_TAGS_ONLY", "urn:epc:1:2.24.400" });
try {
epService.EPAdministrator.CreateEPL("select Observation.Tag.ID from SensorEvent");
Assert.Fail();
} catch (EPStatementException ex) {
Assert.AreEqual("Error starting statement: Failed to validate select-clause expression 'Observation.Tag.ID': Failed to resolve property 'Observation.Tag.ID' to a stream or nested property in a stream [select Observation.Tag.ID from SensorEvent]", ex.Message);
}
}
