public void RunAssertionEventTypeColumnDef(EventRepresentationEnum eventRepresentationEnum)
{
var stmtSchema = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SchemaOne(col1 int, col2 int)");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtSchema.EventType.UnderlyingType);
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window SchemaWindow.std:lastevent() as (s1 SchemaOne)");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
stmt.AddListener(_listenerWindow);
_epService.EPAdministrator.CreateEPL("insert into SchemaWindow (s1) select sone from SchemaOne as sone");
IDictionary <String, object> theEvent = new LinkedHashMap <string, object>();
theEvent.Put("col1", 10);
theEvent.Put("col2", 11);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(theEvent.Values.ToArray(), "SchemaOne");
}
else
{
_epService.EPRuntime.SendEvent(theEvent, "SchemaOne");
}
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), "s1.col1,s1.col2".Split(','), new object[] { 10, 11 });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("SchemaOne", true);
_epService.EPAdministrator.Configuration.RemoveEventType("SchemaWindow", true);
}
public void RunAssertionNestableMapArray(EventRepresentationEnum eventRepresentationEnum)
{
EPStatement stmtInner = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyInnerType as (col1 string[], col2 int[])");
EventType inner = stmtInner.EventType;
Assert.AreEqual(typeof(string[]), inner.GetPropertyType("col1"));
Assert.IsTrue(inner.GetPropertyDescriptor("col1").IsIndexed);
Assert.AreEqual(typeof(int[]), inner.GetPropertyType("col2"));
Assert.IsTrue(inner.GetPropertyDescriptor("col2").IsIndexed);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), inner.UnderlyingType);
EPStatement stmtOuter = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyOuterType as (col1 MyInnerType, col2 MyInnerType[])");
FragmentEventType type = stmtOuter.EventType.GetFragmentType("col1");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsFalse(type.IsIndexed);
Assert.IsFalse(type.IsNative);
type = stmtOuter.EventType.GetFragmentType("col2");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsTrue(type.IsIndexed);
Assert.IsFalse(type.IsNative);
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL("select * from MyOuterType");
stmtSelect.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtSelect.EventType.UnderlyingType);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Object[] innerData = { "abc,def".Split(','), new int[] { 1, 2 } };
Object[] outerData = { innerData, new Object[] { innerData, innerData } };
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
else
{
IDictionary <String, Object> innerData = new Dictionary <String, Object>();
innerData.Put("col1", "abc,def".Split(','));
innerData.Put("col2", new int[] { 1, 2 });
IDictionary <String, Object> outerData = new Dictionary <String, Object>();
outerData.Put("col1", innerData);
outerData.Put("col2", new DataMap[] { innerData, innerData });
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "col1.col1[1],col2[1].col2[1]".Split(','), new Object[] { "def", 2 });
_epService.EPAdministrator.Configuration.RemoveEventType("MyInnerType", true);
_epService.EPAdministrator.Configuration.RemoveEventType("MyOuterType", true);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertPopulateFromNamedWindow(EventRepresentationEnum type)
{
_epService.EPAdministrator.CreateEPL("create " + type.GetOutputTypeCreateSchemaName() + " schema Node(nid string)");
_epService.EPAdministrator.CreateEPL("create window NodeWindow.std:unique(nid) as Node");
_epService.EPAdministrator.CreateEPL("insert into NodeWindow select * from Node");
_epService.EPAdministrator.CreateEPL("create " + type.GetOutputTypeCreateSchemaName() + " schema NodePlus(npid string, node Node)");
var stmt = _epService.EPAdministrator.CreateEPL("insert into NodePlus select 'E1' as npid, n1 as node from NodeWindow n1");
stmt.Events += _listener.Update;
if (type.GetOutputClass() == typeof(object[]))
{
_epService.EPRuntime.SendEvent(new Object[] { "n1" }, "Node");
}
else
{
_epService.EPRuntime.SendEvent(Collections.SingletonDataMap("nid", "n1"), "Node");
}
var @event = _listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", @event.Get("npid"));
Assert.AreEqual("n1", @event.Get("node.nid"));
var fragment = (EventBean)@event.GetFragment("node");
Assert.AreEqual("Node", fragment.EventType.Name);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("Node", true);
_epService.EPAdministrator.Configuration.RemoveEventType("NodePlus", true);
_epService.EPAdministrator.Configuration.RemoveEventType("NodeWindow", true);
}
private void RunAssertionObjectArrayDelivery(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowObjectArr();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select TheString, IntPrimitive from SupportBean.std:unique(TheString)");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertEqualsAnyOrder(
subscriber.GetAndResetIndicate()[0], new Object[]
{
"E1", 1
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 10));
EPAssertionUtil.AssertEqualsAnyOrder(
subscriber.GetAndResetIndicate()[0], new Object[]
{
"E2", 10
}
);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionOutputLimitNoJoin(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowSpecific();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select TheString, IntPrimitive from SupportBean output every 2 events");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(0, subscriber.GetAndResetIndicate().Count);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertEqualsExactOrder(new Object[][]
{
new Object[]
{
"E1", 1
}
,
new Object[]
{
"E2", 2
}
}
, subscriber.GetAndResetIndicate());
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionWidening(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberRowByRowSpecific();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " select BytePrimitive, IntPrimitive, LongPrimitive, FloatPrimitive from SupportBean(TheString='E1')");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
var bean = new SupportBean();
bean.TheString = "E1";
bean.BytePrimitive = 1;
bean.IntPrimitive = 2;
bean.LongPrimitive = 3;
bean.FloatPrimitive = 4;
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
1, 2L, 3d, 4d
}
, subscriber.GetAndResetIndicate()[0]);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionPerformance(bool namedWindow, EventRepresentationEnum outputType)
{
string eplCreate = namedWindow ?
outputType.GetAnnotationText() + " create window MyWindow.win:keepall() as (c1 string, c2 int)" :
"create table MyWindow(c1 string primary key, c2 int)";
EPStatement stmtNamedWindow = _epService.EPAdministrator.CreateEPL(eplCreate);
Assert.AreEqual(outputType.GetOutputClass(), stmtNamedWindow.EventType.UnderlyingType);
// preload events
EPStatement stmt = _epService.EPAdministrator.CreateEPL("insert into MyWindow select TheString as c1, IntPrimitive as c2 from SupportBean");
int totalUpdated = 5000;
for (int i = 0; i < totalUpdated; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 0));
}
stmt.Dispose();
string epl = "on SupportBean sb merge MyWindow nw where nw.c1 = sb.TheString " +
"when matched then update set nw.c2=sb.IntPrimitive";
stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_mergeListener);
// prime
for (int i = 0; i < 100; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 1));
}
var delta = PerformanceObserver.TimeMillis(
() =>
{
for (int i = 0; i < totalUpdated; i++)
{
_epService.EPRuntime.SendEvent(new SupportBean("E" + i, 1));
}
});
// verify
IEnumerator <EventBean> events = stmtNamedWindow.GetEnumerator();
int count = 0;
while (events.MoveNext())
{
EventBean next = events.Current;
Assert.AreEqual(1, next.Get("c2"));
count++;
}
Assert.AreEqual(totalUpdated, count);
Assert.IsTrue(delta < 500, "Delta=" + delta);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
}
private void RunAssertionCreateStreamTwo(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema MyEvent(myId int)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema AllMyEvent as (myEvent MyEvent, class String, reverse boolean)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema SuspectMyEvent as (myEvent MyEvent, class String)");
var stmtOne = _epService.EPAdministrator.CreateEPL(
"insert into AllMyEvent "
+ "select c as myEvent, 'test' as class, false as reverse "
+ "from MyEvent(myId=1) c");
stmtOne.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmtOne.EventType.UnderlyingType);
var stmtTwo = _epService.EPAdministrator.CreateEPL(
"insert into SuspectMyEvent "
+ "select c.myEvent as myEvent, class "
+ "from AllMyEvent(not reverse) c");
var listenerTwo = new SupportUpdateListener();
stmtTwo.Events += listenerTwo.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(MakeEvent(1).Values.ToArray(), "MyEvent");
}
else
{
_epService.EPRuntime.SendEvent(MakeEvent(1), "MyEvent");
}
var resultOne = _listener.AssertOneGetNewAndReset();
Assert.IsTrue(resultOne.Get("myEvent") is EventBean);
Assert.AreEqual(1, ((EventBean)resultOne.Get("myEvent")).Get("myId"));
Assert.NotNull(stmtOne.EventType.GetFragmentType("myEvent"));
var resultTwo = listenerTwo.AssertOneGetNewAndReset();
Assert.IsTrue(resultTwo.Get("myEvent") is EventBean);
Assert.AreEqual(1, ((EventBean)resultTwo.Get("myEvent")).Get("myId"));
Assert.NotNull(stmtTwo.EventType.GetFragmentType("myEvent"));
_epService.Initialize();
}
private void RunAssertionInsertWhereOMStaggered(EventRepresentationEnum eventRepresentationEnum)
{
IDictionary <String, object> dataType = MakeMap(new object[][] { new object[] { "a", typeof(string) }, new object[] { "b", typeof(int) } });
epService.EPAdministrator.Configuration.AddEventType("MyMap", dataType);
string stmtTextCreateOne = eventRepresentationEnum.GetAnnotationText() + " create window MyWindow.win:keepall() as select a, b from MyMap";
EPStatement stmtCreateOne = epService.EPAdministrator.CreateEPL(stmtTextCreateOne);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateOne.EventType.UnderlyingType);
stmtCreateOne.AddListener(listeners[0]);
// create insert into
string stmtTextInsertOne = "insert into MyWindow select a, b from MyMap";
epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
// populate some data
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E1" }, new object[] { "b", 2 } }), "MyMap");
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E2" }, new object[] { "b", 10 } }), "MyMap");
epService.EPRuntime.SendEvent(MakeMap(new object[][] { new object[] { "a", "E3" }, new object[] { "b", 10 } }), "MyMap");
// create window with keep-all using OM
EPStatementObjectModel model = new EPStatementObjectModel();
eventRepresentationEnum.AddAnnotation(model);
Expression where = Expressions.Eq("b", 10);
model.CreateWindow = CreateWindowClause.Create("MyWindowTwo", View.Create("win", "keepall")).SetInsert(true).SetInsertWhereClause(where);
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create("MyWindow"));
string text = eventRepresentationEnum.GetAnnotationText() + " create window MyWindowTwo.win:keepall() as select * from MyWindow insert where b=10";
Assert.AreEqual(text.Trim(), model.ToEPL());
EPStatementObjectModel modelTwo = epService.EPAdministrator.CompileEPL(text);
Assert.AreEqual(text.Trim(), modelTwo.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(modelTwo);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "a,b".Split(','), new object[][] { new object[] { "E2", 10 }, new object[] { "E3", 10 } });
// test select individual fields and from an insert-from named window
stmt = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window MyWindowThree.win:keepall() as select a from MyWindowTwo insert where a = 'E2'");
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "a".Split(','), new object[][] { new object[] { "E2" } });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
epService.EPAdministrator.Configuration.RemoveEventType("MyWindowTwo", true);
epService.EPAdministrator.Configuration.RemoveEventType("MyWindowThree", true);
}
private void RunAssertionMapTranspose(EventRepresentationEnum eventRepresentationEnum)
{
IDictionary <String, object> innerTypeOne = new Dictionary <string, object>();
innerTypeOne.Put("i1", typeof(int));
IDictionary <String, object> innerTypeTwo = new Dictionary <string, object>();
innerTypeTwo.Put("i2", typeof(int));
IDictionary <String, object> outerType = new Dictionary <string, object>();
outerType.Put("one", "T1");
outerType.Put("two", "T2");
_epService.EPAdministrator.Configuration.AddEventType("T1", innerTypeOne);
_epService.EPAdministrator.Configuration.AddEventType("T2", innerTypeTwo);
_epService.EPAdministrator.Configuration.AddEventType("OuterType", outerType);
// create window
var stmtTextCreate = eventRepresentationEnum.GetAnnotationText() + " create window MyWindow.win:keepall() as select one, two from OuterType";
var stmtCreate = _epService.EPAdministrator.CreateEPL(stmtTextCreate);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreate.EventType.UnderlyingType);
stmtCreate.AddListener(_listenerWindow);
EPAssertionUtil.AssertEqualsAnyOrder(stmtCreate.EventType.PropertyNames, new string[] { "one", "two" });
var eventType = stmtCreate.EventType;
Assert.AreEqual("T1", eventType.GetFragmentType("one").FragmentType.Name);
Assert.AreEqual("T2", eventType.GetFragmentType("two").FragmentType.Name);
// create insert into
var stmtTextInsertOne = "insert into MyWindow select one, two from OuterType";
_epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
IDictionary <String, object> innerDataOne = new Dictionary <string, object>();
innerDataOne.Put("i1", 1);
IDictionary <String, object> innerDataTwo = new Dictionary <string, object>();
innerDataTwo.Put("i2", 2);
IDictionary <String, object> outerData = new Dictionary <string, object>();
outerData.Put("one", innerDataOne);
outerData.Put("two", innerDataTwo);
_epService.EPRuntime.SendEvent(outerData, "OuterType");
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), "one.i1,two.i2".Split(','), new object[] { 1, 2 });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
}
private void RunAssertionObjectArrayDelivery(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberRowByRowObjectArrayBase subscriber)
{
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select TheString, IntPrimitive from SupportBean.std:unique(TheString)");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
subscriber.AssertOneAndReset(stmt, new object[] { "E1", 1 });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 10));
subscriber.AssertOneAndReset(stmt, new object[] { "E2", 10 });
stmt.Dispose();
}
private void RunAssertionOutputLimitNoJoin(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberRowByRowSpecificBase subscriber)
{
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select TheString, IntPrimitive from SupportBean output every 2 events");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
subscriber.AssertNoneReceived();
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
subscriber.AssertMultipleReceivedAndReset(stmt, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
stmt.Dispose();
}
private void RunAssertionInnerJoinLateStart(EventRepresentationEnum eventRepresentationEnum)
{
var stmtOne = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema Product (product string, size int)");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), 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.win:keepall() as Product");
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtTwo.EventType.UnderlyingType);
_epService.EPAdministrator.CreateEPL("insert into ProductWin select * from Product");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window PortfolioWin.win: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();
}
private void RunAssertionWidening(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberRowByRowSpecificBase subscriber)
{
var stmt = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select BytePrimitive, IntPrimitive, LongPrimitive, FloatPrimitive from SupportBean(TheString='E1')");
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
var bean = new SupportBean();
bean.TheString = "E1";
bean.BytePrimitive = (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 RunAssertionBindMap(EventRepresentationEnum eventRepresentationEnum, SupportSubscriberMultirowMapBase subscriber)
{
var stmtText = eventRepresentationEnum.GetAnnotationText() + " select irstream TheString, IntPrimitive from " + typeof(SupportBean).FullName + ".win:length_batch(2)";
var stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
subscriber.AssertNoneReceived();
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
subscriber.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 RunAssertionColDefPlain(EventRepresentationEnum eventRepresentationEnum)
{
EPStatement stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col1 string, col2 int, sbean " + typeof(SupportBean).FullName + ", col3.col4 int)");
AssertTypeColDef(stmtCreate.EventType);
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select * from MyEventType");
AssertTypeColDef(stmtSelect.EventType);
stmtSelect.Dispose();
stmtCreate.Dispose();
// destroy and create differently
stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col3 string, col4 int)");
Assert.AreEqual(typeof(int), stmtCreate.EventType.GetPropertyType("col4"));
Assert.AreEqual(2, stmtCreate.EventType.PropertyDescriptors.Count);
stmtCreate.Stop();
// destroy and create differently
stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col5 string, col6 int)");
Assert.AreEqual(stmtCreate.EventType.UnderlyingType, eventRepresentationEnum.GetOutputClass());
Assert.AreEqual(typeof(int), stmtCreate.EventType.GetPropertyType("col6"));
Assert.AreEqual(2, stmtCreate.EventType.PropertyDescriptors.Count);
stmtSelect = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select * from MyEventType");
stmtSelect.Events += _listener.Update;
Assert.AreEqual(stmtSelect.EventType.UnderlyingType, eventRepresentationEnum.GetOutputClass());
// send event
IDictionary <String, Object> data = new LinkedHashMap <String, Object>();
data.Put("col5", "abc");
data.Put("col6", 1);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(data.Values.ToArray(), "MyEventType");
}
else
{
_epService.EPRuntime.SendEvent(data, "MyEventType");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "col5,col6".Split(','), new Object[] { "abc", 1 });
// assert type information
EventTypeSPI typeSPI = (EventTypeSPI)stmtSelect.EventType;
Assert.AreEqual(TypeClass.APPLICATION, typeSPI.Metadata.TypeClass);
Assert.AreEqual(typeSPI.Name, typeSPI.Metadata.PublicName);
Assert.IsTrue(typeSPI.Metadata.IsApplicationConfigured);
Assert.IsFalse(typeSPI.Metadata.IsApplicationPreConfigured);
Assert.IsFalse(typeSPI.Metadata.IsApplicationPreConfiguredStatic);
Assert.AreEqual(typeSPI.Name, typeSPI.Metadata.PrimaryName);
// test non-enum create-schema
String epl = "create" + eventRepresentationEnum.GetOutputTypeCreateSchemaName() + " schema MyEventTypeTwo as (col1 string, col2 int, sbean " + typeof(SupportBean).FullName + ", col3.col4 int)";
EPStatement stmtCreateTwo = _epService.EPAdministrator.CreateEPL(epl);
AssertTypeColDef(stmtCreateTwo.EventType);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateTwo.EventType.UnderlyingType);
stmtCreateTwo.Dispose();
_epService.EPAdministrator.Configuration.RemoveEventType("MyEventTypeTwo", true);
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(model.ToEPL(), epl);
stmtCreateTwo = _epService.EPAdministrator.Create(model);
AssertTypeColDef(stmtCreateTwo.EventType);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateTwo.EventType.UnderlyingType);
_epService.Initialize();
}
private void RunAssertionBindObjectArr(EventRepresentationEnum eventRepresentationEnum)
{
var subscriber = new MySubscriberMultirowObjectArr();
String stmtText = eventRepresentationEnum.GetAnnotationText()
+ " select irstream TheString, IntPrimitive from "
+ typeof(SupportBean).FullName + ".win:length_batch(2)";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Subscriber = subscriber;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(),
stmt.EventType.UnderlyingType);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.AreEqual(0, subscriber.IndicateArr.Count);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
Assert.AreEqual(1, subscriber.IndicateArr.Count);
UniformPair <Object[][]> result = subscriber.GetAndResetIndicateArr()[0];
Assert.IsNull(result.Second);
Assert.AreEqual(2, result.First.Length);
EPAssertionUtil.AssertEqualsExactOrder(
result.First, _fields,
new Object[][]
{
new Object[]
{
"E1", 1
}
,
new Object[]
{
"E2", 2
}
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E3", 3));
Assert.AreEqual(0, subscriber.IndicateArr.Count);
_epService.EPRuntime.SendEvent(new SupportBean("E4", 4));
Assert.AreEqual(1, subscriber.IndicateArr.Count);
result = subscriber.GetAndResetIndicateArr()[0];
Assert.AreEqual(2, result.First.Length);
Assert.AreEqual(2, result.Second.Length);
EPAssertionUtil.AssertEqualsExactOrder(
result.First, _fields,
new Object[][]
{
new Object[]
{
"E3", 3
}
,
new Object[]
{
"E4", 4
}
}
);
EPAssertionUtil.AssertEqualsExactOrder(
result.Second, _fields,
new Object[][]
{
new Object[]
{
"E1", 1
}
,
new Object[]
{
"E2", 2
}
}
);
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionStaggered(EventRepresentationEnum outputType)
{
string[] fieldsOne = new string[] { "a1", "b1" };
string[] fieldsTwo = new string[] { "a2", "b2" };
// create window one
string stmtTextCreateOne = outputType.GetAnnotationText() + " create window MyWindowOne.win:keepall() as select TheString as a1, IntPrimitive as b1 from " + typeof(SupportBean).FullName;
EPStatement stmtCreateOne = _epService.EPAdministrator.CreateEPL(stmtTextCreateOne);
stmtCreateOne.AddListener(_listenerWindow);
Assert.AreEqual(0, GetCount("MyWindowOne"));
Assert.AreEqual(outputType.GetOutputClass(), stmtCreateOne.EventType.UnderlyingType);
// create window two
string stmtTextCreateTwo = outputType.GetAnnotationText() + " create window MyWindowTwo.win:keepall() as select TheString as a2, IntPrimitive as b2 from " + typeof(SupportBean).FullName;
EPStatement stmtCreateTwo = _epService.EPAdministrator.CreateEPL(stmtTextCreateTwo);
stmtCreateTwo.AddListener(_listenerWindowTwo);
Assert.AreEqual(0, GetCount("MyWindowTwo"));
Assert.AreEqual(outputType.GetOutputClass(), stmtCreateTwo.EventType.UnderlyingType);
// create delete stmt
string stmtTextDelete = "on MyWindowOne delete from MyWindowTwo where a1 = a2";
EPStatement stmtDelete = _epService.EPAdministrator.CreateEPL(stmtTextDelete);
stmtDelete.AddListener(_listenerDelete);
Assert.AreEqual(StatementType.ON_DELETE, ((EPStatementSPI)stmtDelete).StatementMetadata.StatementType);
// create insert into
string stmtTextInsert = "insert into MyWindowOne select TheString as a1, IntPrimitive as b1 from " + typeof(SupportBean).FullName + "(IntPrimitive > 0)";
_epService.EPAdministrator.CreateEPL(stmtTextInsert);
stmtTextInsert = "insert into MyWindowTwo select TheString as a2, IntPrimitive as b2 from " + typeof(SupportBean).FullName + "(IntPrimitive < 0)";
_epService.EPAdministrator.CreateEPL(stmtTextInsert);
SendSupportBean("E1", -10);
EPAssertionUtil.AssertProps(_listenerWindowTwo.AssertOneGetNewAndReset(), fieldsTwo, new object[] { "E1", -10 });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsTwo, new object[][] { new object[] { "E1", -10 } });
Assert.IsFalse(_listenerWindow.IsInvoked);
Assert.AreEqual(1, GetCount("MyWindowTwo"));
SendSupportBean("E2", 5);
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fieldsOne, new object[] { "E2", 5 });
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsOne, new object[][] { new object[] { "E2", 5 } });
Assert.IsFalse(_listenerWindowTwo.IsInvoked);
Assert.AreEqual(1, GetCount("MyWindowOne"));
SendSupportBean("E3", -1);
EPAssertionUtil.AssertProps(_listenerWindowTwo.AssertOneGetNewAndReset(), fieldsTwo, new object[] { "E3", -1 });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsTwo, new object[][] { new object[] { "E1", -10 }, new object[] { "E3", -1 } });
Assert.IsFalse(_listenerWindow.IsInvoked);
Assert.AreEqual(2, GetCount("MyWindowTwo"));
SendSupportBean("E3", 1);
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fieldsOne, new object[] { "E3", 1 });
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsOne, new object[][] { new object[] { "E2", 5 }, new object[] { "E3", 1 } });
EPAssertionUtil.AssertProps(_listenerWindowTwo.AssertOneGetOldAndReset(), fieldsTwo, new object[] { "E3", -1 });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsTwo, new object[][] { new object[] { "E1", -10 } });
Assert.AreEqual(2, GetCount("MyWindowOne"));
Assert.AreEqual(1, GetCount("MyWindowTwo"));
stmtDelete.Dispose();
stmtCreateOne.Dispose();
stmtCreateTwo.Dispose();
_listenerDelete.Reset();
_listenerSelect.Reset();
_listenerWindow.Reset();
_listenerWindowTwo.Reset();
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindowOne", true);
_epService.EPAdministrator.Configuration.RemoveEventType("MyWindowTwo", true);
}
private void RunAssertionSchemaCopyProperties(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseOne (prop1 String, prop2 int)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseTwo (prop3 long)");
// test define and send
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E1 () copyfrom BaseOne");
EPStatement stmtOne = _epService.EPAdministrator.CreateEPL("select * from E1");
stmtOne.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtOne.EventType.UnderlyingType);
Assert.AreEqual(typeof(string), stmtOne.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int), stmtOne.EventType.GetPropertyType("prop2"));
IDictionary <String, Object> eventE1 = new LinkedHashMap <String, Object>();
eventE1.Put("prop1", "v1");
eventE1.Put("prop2", 2);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(eventE1.Values.ToArray(), "E1");
}
else
{
_epService.EPRuntime.SendEvent(eventE1, "E1");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "prop1,prop2".Split(','), new Object[] { "v1", 2 });
// test two copy-from types
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E2 () copyfrom BaseOne, BaseTwo");
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL("select * from E2");
Assert.AreEqual(typeof(string), stmtTwo.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int), stmtTwo.EventType.GetPropertyType("prop2"));
Assert.AreEqual(typeof(long), stmtTwo.EventType.GetPropertyType("prop3"));
// test API-defined type
IDictionary <String, Object> def = new Dictionary <String, Object>();
def.Put("a", "string");
def.Put("b", typeof(String));
def.Put("c", "BaseOne");
def.Put("d", "BaseTwo[]");
_epService.EPAdministrator.Configuration.AddEventType("MyType", def);
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E3(e long, f BaseOne) copyfrom MyType");
EPStatement stmtThree = _epService.EPAdministrator.CreateEPL("select * from E3");
Assert.AreEqual(typeof(String), stmtThree.EventType.GetPropertyType("a"));
Assert.AreEqual(typeof(String), stmtThree.EventType.GetPropertyType("b"));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Assert.AreEqual(typeof(Object[]), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(Object[][]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(Object[]), stmtThree.EventType.GetPropertyType("f"));
}
else
{
Assert.AreEqual(typeof(DataMap), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(DataMap[]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(DataMap), stmtThree.EventType.GetPropertyType("f"));
}
Assert.AreEqual(typeof(long), stmtThree.EventType.GetPropertyType("e"));
// invalid tests
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(a long) copyFrom MyType",
"Error starting statement: Type by name 'MyType' contributes property 'a' defined as 'System.String' which overides the same property of type '" + typeof(long).FullName + "' [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom MyType",
"Error starting statement: Property by name 'c' is defined twice by adding type 'MyType' [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Type by name 'XYZ' could not be located [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4 as " + typeof(SupportBean).FullName + " copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with class-provided types [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create variant schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with variant types [");
// test SODA
String createEPL = eventRepresentationEnum.GetAnnotationText() + " create schema EX as () copyFrom BaseOne, BaseTwo";
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(createEPL);
Assert.AreEqual(createEPL.Trim(), model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(createEPL.Trim(), stmt.Text);
_epService.Initialize();
}
private void RunAssertionSingleRowSplitAndType(EventRepresentationEnum eventRepresentationEnum)
{
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitSentence", GetType().FullName, "SplitSentenceMethodReturnObjectArray");
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitSentenceBean", GetType().FullName, "SplitSentenceBeanMethodReturnObjectArray");
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitWord", GetType().FullName, "SplitWordMethodReturnObjectArray");
}
else
{
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitSentence", GetType().FullName, "SplitSentenceMethodReturnMap");
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitSentenceBean", GetType().FullName, "SplitSentenceBeanMethodReturnMap");
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("splitWord", GetType().FullName, "SplitWordMethodReturnMap");
}
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("invalidSentence", GetType().FullName, "InvalidSentenceMethod");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SentenceEvent(sentence String)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema WordEvent(word String)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema CharacterEvent(char String)");
string stmtText;
EPStatement stmt;
var fields = "word".Split(',');
// test single-row method
stmtText = "select * from SentenceEvent[splitSentence(sentence)@type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmt.EventType.UnderlyingType);
SendSentenceEvent(eventRepresentationEnum, "I am testing this code");
EPAssertionUtil.AssertPropsPerRow(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "I" },
new object[] { "am" },
new object[] { "testing" },
new object[] { "this" },
new object[] { "code" }
});
SendSentenceEvent(eventRepresentationEnum, "the second event");
EPAssertionUtil.AssertPropsPerRow(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "the" },
new object[] { "second" },
new object[] { "event" }
});
stmt.Dispose();
// test SODA
var model = _epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(stmtText, stmt.Text);
stmt.AddListener(_listener);
SendSentenceEvent(eventRepresentationEnum, "the third event");
EPAssertionUtil.AssertPropsPerRow(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "the" },
new object[] { "third" },
new object[] { "event" }
});
stmt.Dispose();
// test script
if (!eventRepresentationEnum.IsObjectArrayEvent())
{
stmtText = "expression com.espertech.esper.support.collections.ISupportDataMapCollection js:splitSentenceJS(sentence) [" +
" var words = clr.New('com.espertech.esper.support.collections.SupportDataMapList',[]);" +
" var factory = clr.New('com.espertech.esper.support.collections.SupportDataMapFactory',[]);" +
" words.Add(factory.Create('word', 'wordOne'));" +
" words.Add(factory.Create('word', 'wordTwo'));" +
" words;" +
"]" +
"select * from SentenceEvent[splitSentenceJS(sentence)@type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText).AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
_epService.EPRuntime.SendEvent(Collections.EmptyDataMap, "SentenceEvent");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "wordOne" },
new object[] { "wordTwo" }
});
stmt.Dispose();
}
// test multiple splitters
stmtText = "select * from SentenceEvent[splitSentence(sentence)@type(WordEvent)][splitWord(word)@type(CharacterEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("CharacterEvent", stmt.EventType.Name);
SendSentenceEvent(eventRepresentationEnum, "I am");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
_listener.GetAndResetLastNewData(), "char".Split(','),
new object[][]
{
new object[] { "I" },
new object[] { "a" },
new object[] { "m" }
});
stmt.Dispose();
// test wildcard parameter
stmtText = "select * from SentenceEvent[splitSentenceBean(*)@type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
SendSentenceEvent(eventRepresentationEnum, "another test sentence");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "another" },
new object[] { "test" },
new object[] { "sentence" }
});
stmt.Dispose();
// test property returning untyped collection
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPAdministrator.Configuration.AddEventType(typeof(ObjectArrayEvent));
stmtText = eventRepresentationEnum.GetAnnotationText() + " select * from ObjectArrayEvent[someObjectArray@type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
var rows = new object[][] { new object[] { "this" }, new object[] { "is" }, new object[] { "collection" } };
_epService.EPRuntime.SendEvent(new ObjectArrayEvent(rows));
EPAssertionUtil.AssertPropsPerRow(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "this" },
new object[] { "is" },
new object[] { "collection" }
});
}
else
{
_epService.EPAdministrator.Configuration.AddEventType <CollectionEvent <IDictionary <string, object> > >("CollectionEvent");
stmtText = eventRepresentationEnum.GetAnnotationText() + " select * from CollectionEvent[someCollection@type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
var coll = new List <IDictionary <string, object> >();
coll.Add(Collections.SingletonDataMap("word", "this"));
coll.Add(Collections.SingletonDataMap("word", "is"));
coll.Add(Collections.SingletonDataMap("word", "collection"));
_epService.EPRuntime.SendEvent(new CollectionEvent <IDictionary <string, object> >(coll));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
_listener.GetAndResetLastNewData(), fields,
new object[][]
{
new object[] { "this" },
new object[] { "is" },
new object[] { "collection" }
});
}
// invalid: event type not found
TryInvalid("select * from SentenceEvent[splitSentence(sentence)@type(XYZ)]",
"Event type by name 'XYZ' could not be found [select * from SentenceEvent[splitSentence(sentence)@type(XYZ)]]");
// invalid lib-function annotation
TryInvalid("select * from SentenceEvent[splitSentence(sentence)@dummy(WordEvent)]",
"Invalid annotation for property selection, expected 'type' but found 'dummy' in text '[splitSentence(sentence)@dummy(WordEvent)]' [select * from SentenceEvent[splitSentence(sentence)@dummy(WordEvent)]]");
// invalid type assignment to event type
if (eventRepresentationEnum.IsObjectArrayEvent())
{
TryInvalid("select * from SentenceEvent[invalidSentence(sentence)@type(WordEvent)]",
"Event type 'WordEvent' underlying type System.Object[] cannot be assigned a value of type");
}
else
{
TryInvalid("select * from SentenceEvent[invalidSentence(sentence)@type(WordEvent)]",
"Event type 'WordEvent' underlying type " + Name.Of <IDictionary <string, object> >() + " cannot be assigned a value of type");
}
// invalid subquery
TryInvalid("select * from SentenceEvent[splitSentence((select * from SupportBean.win:keepall()))@type(WordEvent)]",
"Invalid contained-event expression 'splitSentence(subselect_0)': Aggregation, sub-select, previous or prior functions are not supported in this context [select * from SentenceEvent[splitSentence((select * from SupportBean.win:keepall()))@type(WordEvent)]]");
_epService.Initialize();
}