public void Run(RegressionEnvironment env)
{
var fieldsWin = new [] { "TheString","IntPrimitive" };
var fieldsSelect = new [] { "c0" };
var path = new RegressionPath();
var eplCreate = namedWindow
? "@Name('create') create window MyInfra#keepall as SupportBean"
: "@Name('create') create table MyInfra (TheString string primary key, IntPrimitive int primary key)";
env.CompileDeploy(eplCreate, path);
env.CompileDeploy("insert into MyInfra select TheString, IntPrimitive from SupportBean", path);
var eplSelectDelete = "@Name('s0') on SupportBean_S0 as S0 " +
"select and delete window(win.*).aggregate(0,(result,value) => result+value.IntPrimitive) as c0 " +
"from MyInfra as win where S0.P00=win.TheString";
env.CompileDeploy(eplSelectDelete, path).AddListener("s0");
env.SendEventBean(new SupportBean("E1", 1));
env.SendEventBean(new SupportBean("E2", 2));
if (namedWindow) {
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("create"),
fieldsWin,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
}
else {
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("create"),
fieldsWin,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
}
// select and delete bean E1
env.SendEventBean(new SupportBean_S0(100, "E1"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsSelect,
new object[] {1});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("create"),
fieldsWin,
new[] {new object[] {"E2", 2}});
env.Milestone(0);
// add some E2 events
env.SendEventBean(new SupportBean("E2", 3));
env.SendEventBean(new SupportBean("E2", 4));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("create"),
fieldsWin,
new[] {new object[] {"E2", 2}, new object[] {"E2", 3}, new object[] {"E2", 4}});
// select and delete beans E2
env.SendEventBean(new SupportBean_S0(101, "E2"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsSelect,
new object[] {2 + 3 + 4});
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("create"), fieldsWin, new object[0][]);
// test SODA
env.EplToModelCompileDeploy(eplSelectDelete, path);
env.UndeployAll();
}
private void RunAssertionSimpleColumn(EPStatement stmt, String[] fields)
{
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E1", 1
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E1", 1
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E2", 1
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
,
new Object[] {
"E1", 2
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E1", 2
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
,
new Object[] {
"E1", 2
}
,
new Object[] {
"E2", 2
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E2", 2
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
,
new Object[] {
"E1", 2
}
,
new Object[] {
"E2", 2
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E2", 2
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
,
new Object[] {
"E1", 2
}
,
new Object[] {
"E2", 2
}
}
);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] {
"E1", 1
}
);
}
private void RunAssertionSubquerySelfCheck(bool namedWindow)
{
string[] fields = { "key", "value" };
// create window
string stmtTextCreate = namedWindow ?
"create window MyInfra#keepall as select TheString as key, IntBoxed as value from " + typeof(SupportBean).FullName :
"create table MyInfra (key string primary key, value int)";
EPStatement stmtCreate = epService.EPAdministrator.CreateEPL(stmtTextCreate);
stmtCreate.AddListener(listenerWindow);
// create insert into (not does insert if key already exists)
string stmtTextInsertOne = "insert into MyInfra select TheString as key, IntBoxed as value from " + typeof(SupportBean).FullName + " as s0" +
" where not exists (select * from MyInfra as win where win.key = s0.TheString)";
epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
SendSupportBean("E1", 1);
if (namedWindow)
{
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E1", 1 });
}
else
{
Assert.IsFalse(listenerWindow.IsInvoked);
}
EPAssertionUtil.AssertPropsPerRow(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 } });
SendSupportBean("E2", 2);
if (namedWindow)
{
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E2", 2 });
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
SendSupportBean("E1", 3);
Assert.IsFalse(listenerWindow.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
SendSupportBean("E3", 4);
if (namedWindow)
{
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E3", 4 });
EPAssertionUtil.AssertPropsPerRow(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 }, new object[] { "E3", 4 } });
}
else
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 }, new object[] { "E3", 4 } });
}
// Add delete
string stmtTextDelete = "on " + typeof(SupportBean_A).FullName + " delete from MyInfra where key = id";
EPStatement stmtDelete = epService.EPAdministrator.CreateEPL(stmtTextDelete);
stmtDelete.AddListener(listenerStmtDelete);
// delete E2
epService.EPRuntime.SendEvent(new SupportBean_A("E2"));
if (namedWindow)
{
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetOldAndReset(), fields, new object[] { "E2", 2 });
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E3", 4 } });
SendSupportBean("E2", 5);
if (namedWindow)
{
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E2", 5 });
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E3", 4 }, new object[] { "E2", 5 } });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
}
private void RunAssertionStartStopConsumer(bool namedWindow)
{
// create window
string stmtTextCreate = namedWindow ?
"create window MyInfra#keepall as select TheString as a, IntPrimitive as b from " + typeof(SupportBean).FullName :
"create table MyInfra(a string primary key, b int primary key)";
EPStatement stmtCreate = _epService.EPAdministrator.CreateEPL(stmtTextCreate);
stmtCreate.AddListener(_listenerWindow);
// create insert into
string stmtTextInsertOne = "insert into MyInfra select TheString as a, IntPrimitive as b from " + typeof(SupportBean).FullName;
_epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
// create consumer
string[] fields = new string[] { "a", "b" };
string stmtTextSelect = "select a, b from MyInfra as s1";
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL(stmtTextSelect);
stmtSelect.AddListener(_listenerSelect);
// send 1 event
SendSupportBean("E1", 1);
if (namedWindow)
{
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E1", 1 });
EPAssertionUtil.AssertProps(_listenerSelect.AssertOneGetNewAndReset(), fields, new object[] { "E1", 1 });
}
EPAssertionUtil.AssertPropsPerRow(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 } });
// stop consumer
stmtSelect.Stop();
SendSupportBean("E2", 2);
if (namedWindow)
{
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E2", 2 });
}
Assert.IsFalse(_listenerSelect.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
// start consumer: the consumer has the last event even though he missed it
stmtSelect.Start();
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtSelect.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 } });
// consumer receives the next event
SendSupportBean("E3", 3);
if (namedWindow)
{
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E3", 3 });
EPAssertionUtil.AssertProps(_listenerSelect.AssertOneGetNewAndReset(), fields, new object[] { "E3", 3 });
EPAssertionUtil.AssertPropsPerRow(stmtSelect.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 }, new object[] { "E3", 3 } });
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 }, new object[] { "E3", 3 } });
// destroy consumer
stmtSelect.Dispose();
SendSupportBean("E4", 4);
if (namedWindow)
{
EPAssertionUtil.AssertProps(_listenerWindow.AssertOneGetNewAndReset(), fields, new object[] { "E4", 4 });
}
Assert.IsFalse(_listenerSelect.IsInvoked);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
}
public void Run(RegressionEnvironment env)
{
var eplDeclare =
"create table varagg as (k0 string primary key, k1 int primary key, v1 string, total sum(long))";
var eplPopulate =
"into table varagg select sum(LongPrimitive) as total from SupportBean group by TheString, IntPrimitive";
var eplQuery = "select total as value from SupportBean_S0 as S0 unidirectional";
string[] createIndexEmpty = { };
object[] preloadedEventsTwo = {
MakeEvent("G1", 10, 1000L), MakeEvent("G2", 20, 2000L),
MakeEvent("G3", 30, 3000L), MakeEvent("G4", 40, 4000L)
};
var milestone = new AtomicLong();
IndexAssertionEventSend eventSendAssertionRangeTwoExpected = () => {
env.SendEventBean(new SupportBean_S0(-1, null));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").NewDataListFlattened,
new[] {"value"},
new[] {new object[] {2000L}, new object[] {3000L}});
env.Listener("s0").Reset();
};
object[] preloadedEventsHash = {MakeEvent("G1", 10, 1000L)};
IndexAssertionEventSend eventSendAssertionHash = () => {
env.SendEventBean(new SupportBean_S0(10, "G1"));
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").NewDataListFlattened,
new[] {"value"},
new[] {new object[] {1000L}});
env.Listener("s0").Reset();
};
// no secondary indexes
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexEmpty,
preloadedEventsHash,
milestone,
new[] {
// primary index found
new IndexAssertion(
"k1 = Id and k0 = P00",
"varagg",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
new IndexAssertion(
"k0 = P00 and k1 = Id",
"varagg",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
new IndexAssertion(
"k0 = P00 and k1 = Id and v1 is null",
"varagg",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
// no index found
new IndexAssertion(
"k1 = Id",
"varagg",
typeof(FullTableScanUniquePerKeyLookupPlanForge),
eventSendAssertionHash)
}
);
// one secondary hash index on single field
string[] createIndexHashSingleK1 = {"create index idx_k1 on varagg (k1)"};
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexHashSingleK1,
preloadedEventsHash,
milestone,
new[] {
// primary index found
new IndexAssertion(
"k1 = Id and k0 = P00",
"varagg",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
// secondary index found
new IndexAssertion(
"k1 = Id",
"idx_k1",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
new IndexAssertion(
"Id = k1",
"idx_k1",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
// no index found
new IndexAssertion(
"k0 = P00",
"varagg",
typeof(FullTableScanUniquePerKeyLookupPlanForge),
eventSendAssertionHash)
}
);
// two secondary hash indexes on one field each
string[] createIndexHashTwoDiscrete =
{"create index idx_k1 on varagg (k1)", "create index idx_k0 on varagg (k0)"};
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexHashTwoDiscrete,
preloadedEventsHash,
milestone,
new[] {
// primary index found
new IndexAssertion(
"k1 = Id and k0 = P00",
"varagg",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
// secondary index found
new IndexAssertion(
"k0 = P00",
"idx_k0",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
new IndexAssertion(
"k1 = Id",
"idx_k1",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
new IndexAssertion(
"v1 is null and k1 = Id",
"idx_k1",
typeof(IndexedTableLookupPlanHashedOnlyForge),
eventSendAssertionHash),
// no index found
new IndexAssertion(
"1=1",
"varagg",
typeof(FullTableScanUniquePerKeyLookupPlanForge),
eventSendAssertionHash)
}
);
// one range secondary index
// no secondary indexes
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexEmpty,
preloadedEventsTwo,
milestone,
new[] {
// no index found
new IndexAssertion(
"k1 between 20 and 30",
"varagg",
typeof(FullTableScanUniquePerKeyLookupPlanForge),
eventSendAssertionRangeTwoExpected)
}
);
// single range secondary index, expecting two events
string[] createIndexRangeOne = {"create index b_k1 on varagg (k1 btree)"};
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexRangeOne,
preloadedEventsTwo,
milestone,
new[] {
new IndexAssertion(
"k1 between 20 and 30",
"b_k1",
typeof(SortedTableLookupPlanForge),
eventSendAssertionRangeTwoExpected),
new IndexAssertion(
"(k0 = 'G3' or k0 = 'G2') and k1 between 20 and 30",
"b_k1",
typeof(SortedTableLookupPlanForge),
eventSendAssertionRangeTwoExpected)
}
);
// single range secondary index, expecting single event
IndexAssertionEventSend eventSendAssertionRangeOneExpected = () => {
env.SendEventBean(new SupportBean_S0(-1, null));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").NewDataListFlattened,
new[] {"value"},
new[] {new object[] {2000L}});
env.Listener("s0").Reset();
};
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexRangeOne,
preloadedEventsTwo,
milestone,
new[] {
new IndexAssertion(
"k0 = 'G2' and k1 between 20 and 30",
"b_k1",
typeof(SortedTableLookupPlanForge),
eventSendAssertionRangeOneExpected),
new IndexAssertion(
"k1 between 20 and 30 and k0 = 'G2'",
"b_k1",
typeof(SortedTableLookupPlanForge),
eventSendAssertionRangeOneExpected)
}
);
// combined hash+range index
string[] createIndexRangeCombined = {"create index h_k0_b_k1 on varagg (k0 hash, k1 btree)"};
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexRangeCombined,
preloadedEventsTwo,
milestone,
new[] {
new IndexAssertion(
"k0 = 'G2' and k1 between 20 and 30",
"h_k0_b_k1",
typeof(CompositeTableLookupPlanForge),
eventSendAssertionRangeOneExpected),
new IndexAssertion(
"k1 between 20 and 30 and k0 = 'G2'",
"h_k0_b_k1",
typeof(CompositeTableLookupPlanForge),
eventSendAssertionRangeOneExpected)
}
);
string[] createIndexHashSingleK0 = {"create index idx_k0 on varagg (k0)"};
// in-keyword single-directional use
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexHashSingleK0,
preloadedEventsTwo,
milestone,
new[] {
new IndexAssertion(
"k0 in ('G2', 'G3')",
"idx_k0",
typeof(InKeywordTableLookupPlanSingleIdxForge),
eventSendAssertionRangeTwoExpected)
}
);
// in-keyword multi-directional use
AssertIndexChoice(
env,
eplDeclare,
eplPopulate,
eplQuery,
createIndexHashSingleK0,
preloadedEventsHash,
milestone,
new[] {
new IndexAssertion(
"'G1' in (k0)",
"varagg",
typeof(FullTableScanUniquePerKeyLookupPlanForge),
eventSendAssertionHash)
}
);
}
private void TryAssertionMultiIdx(EPServiceProvider epService, SupportUpdateListener listener)
{
var fields = "s0.Id,s1.Id".Split(',');
// single row tests
epService.EPRuntime.SendEvent(new SupportBean_S1(101, "a", "b", "c", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S0(0, "a", "x"));
epService.EPRuntime.SendEvent(new SupportBean_S0(0, "x", "c"));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S0(1, "a", "c"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {1, 101});
epService.EPRuntime.SendEvent(new SupportBean_S0(2, "b", "d"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {2, 101});
epService.EPRuntime.SendEvent(new SupportBean_S0(3, "a", "d"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {3, 101});
// 2-row tests
epService.EPRuntime.SendEvent(new SupportBean_S1(102, "a1", "a", "d1", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S0(0, "a", "x"));
epService.EPRuntime.SendEvent(new SupportBean_S0(0, "x", "c"));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S0(10, "a", "c"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {10, 101});
epService.EPRuntime.SendEvent(new SupportBean_S0(11, "a", "d"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {11, 101}, new object[] {11, 102}});
epService.EPRuntime.SendEvent(new SupportBean_S0(12, "a1", "d"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {12, 102}});
epService.EPRuntime.SendEvent(new SupportBean_S0(13, "a", "d1"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {13, 102}});
// 3-row tests
epService.EPRuntime.SendEvent(new SupportBean_S1(103, "a", "a2", "d", "d2"));
epService.EPRuntime.SendEvent(new SupportBean_S0(20, "a", "c"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {20, 101});
epService.EPRuntime.SendEvent(new SupportBean_S0(21, "a", "d"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
listener.GetAndResetLastNewData(), fields,
new[] {new object[] {21, 101}, new object[] {21, 102}, new object[] {21, 103}});
epService.EPRuntime.SendEvent(new SupportBean_S0(22, "a2", "d"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {22, 103}});
epService.EPRuntime.SendEvent(new SupportBean_S0(23, "a", "d2"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {23, 103}});
epService.EPAdministrator.DestroyAllStatements();
}
public void Run(RegressionEnvironment env)
{
var fields = new[] {"pkey", "sumint"};
var valueList = "E1,E2,E3";
var path = new RegressionPath();
var eplCreateTable =
"@Name('Create-Table') create table MyTable(pkey string primary key, sumint sum(int))";
env.CompileDeploy(eplCreateTable, path);
var eplIntoTable =
"@Name('Into-Table') into table MyTable select sum(IntPrimitive) as sumint from SupportBean group by TheString";
env.CompileDeploy(eplIntoTable, path);
var eplQueryTable =
"@Name('s0') select (select sumint from MyTable where pkey = S0.P00) as c0 from SupportBean_S0 as S0";
env.CompileDeploy(eplQueryTable, path).AddListener("s0");
env.Milestone(1);
AssertValues(env, valueList, new int?[] {null, null, null});
MakeSendBean(env, "E1", 10);
AssertValues(env, valueList, new int?[] {10, null, null});
env.Milestone(2);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 10}
});
MakeSendBean(env, "E2", 200);
AssertValues(env, valueList, new int?[] {10, 200, null});
env.Milestone(3);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 10},
new object[] {"E2", 200}
});
MakeSendBean(env, "E1", 11);
AssertValues(env, valueList, new int?[] {21, 200, null});
env.Milestone(4);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 21},
new object[] {"E2", 200}
});
MakeSendBean(env, "E3", 3000);
AssertValues(env, valueList, new int?[] {21, 200, 3000});
env.Milestone(5);
env.Milestone(6);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 21},
new object[] {"E2", 200},
new object[] {"E3", 3000}
});
MakeSendBean(env, "E2", 201);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 21},
new object[] {"E2", 401},
new object[] {"E3", 3000}
});
MakeSendBean(env, "E3", 3001);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 21},
new object[] {"E2", 401},
new object[] {"E3", 6001}
});
MakeSendBean(env, "E1", 12);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {"E1", 33},
new object[] {"E2", 401},
new object[] {"E3", 6001}
});
env.UndeployAll();
}
private void TryAssertionSeven(EPServiceProvider epService, string expression)
{
EPStatement stmt = epService.EPAdministrator.CreateEPL(expression);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "valh0,valh1,valh2".Split(',');
SendBeanInt(epService, "S00", 1, 1, 1);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"H01",
"H01-H11",
"H01-H11-H21"
}
});
SendBeanInt(epService, "S01", 0, 1, 1);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "S02", 1, 1, 0);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "S03", 1, 1, 2);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields,
new object[][] {
new object[] {
"H01",
"H01-H11",
"H01-H11-H21"
},
new object[] {
"H01",
"H01-H11",
"H01-H11-H22"
}
});
SendBeanInt(epService, "S04", 2, 2, 1);
var result = new object[][] {
new object[] {
"H01",
"H01-H11",
"H01-H11-H21"
},
new object[] {
"H02",
"H02-H11",
"H02-H11-H21"
},
new object[] {
"H01",
"H01-H12",
"H01-H12-H21"
},
new object[] {
"H02",
"H02-H12",
"H02-H12-H21"
}
};
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, result);
stmt.Dispose();
}
private void RunAssertionSingleRowSplitAndType(EventRepresentationChoice eventRepresentationEnum)
{
string[] methods;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
methods = "SplitSentenceMethodReturnObjectArray,SplitSentenceBeanMethodReturnObjectArray,SplitWordMethodReturnObjectArray".Split(',');
}
else if (eventRepresentationEnum.IsMapEvent())
{
methods = "SplitSentenceMethodReturnMap,SplitSentenceBeanMethodReturnMap,SplitWordMethodReturnMap".Split(',');
}
else if (eventRepresentationEnum.IsAvroEvent())
{
methods = "SplitSentenceMethodReturnAvro,SplitSentenceBeanMethodReturnAvro,SplitWordMethodReturnAvro".Split(',');
}
else
{
throw new IllegalStateException("Unrecognized enum " + eventRepresentationEnum);
}
var funcs = "SplitSentence,SplitSentenceBean,SplitWord".Split(',');
for (var i = 0; i < funcs.Length; i++)
{
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction(funcs[i], GetType().FullName, methods[i]);
}
_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.IsTrue(eventRepresentationEnum.MatchesClass(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.IsMapEvent())
{
stmtText = "expression System.Collections.IList jscript:SplitSentenceJS(sentence) [" +
" debug.Debug('test');" +
" var listType = host.type('System.Collections.ArrayList');" +
" var words = host.newObj(listType);" +
" debug.Debug(words);" +
" words.Add(Collections.SingletonDataMap('word', 'wordOne'));" +
" words.Add(Collections.SingletonDataMap('word', 'wordTwo'));" +
" return words;" +
"]" +
"select * from SentenceEvent[SplitSentenceJS(sentence)@Type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.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" }
});
stmt.Dispose();
}
else if (eventRepresentationEnum.IsMapEvent())
{
_epService.EPAdministrator.Configuration.AddEventType(typeof(MyCollectionEvent));
stmtText = eventRepresentationEnum.GetAnnotationText() + " select * from MyCollectionEvent[someCollection@Type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
var coll = new List <Map>();
coll.Add(Collections.SingletonDataMap("word", "this"));
coll.Add(Collections.SingletonDataMap("word", "is"));
coll.Add(Collections.SingletonDataMap("word", "collection"));
_epService.EPRuntime.SendEvent(new MyCollectionEvent(coll));
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields, new Object[][]
{
new object[] { "this" },
new object[] { "is" },
new object[] { "collection" }
});
stmt.Dispose();
}
else if (eventRepresentationEnum.IsAvroEvent())
{
_epService.EPAdministrator.Configuration.AddEventType(typeof(AvroArrayEvent));
stmtText = eventRepresentationEnum.GetAnnotationText() + " select * from AvroArrayEvent[someAvroArray@Type(WordEvent)]";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
Assert.AreEqual("WordEvent", stmt.EventType.Name);
var rows = new GenericRecord[3];
var words = "this,is,avro".Split(',');
for (var i = 0; i < words.Length; i++)
{
rows[i] = new GenericRecord(((AvroEventType)stmt.EventType).SchemaAvro);
rows[i].Put("word", words[i]);
}
_epService.EPRuntime.SendEvent(new AvroArrayEvent(rows));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), fields, new Object[][]
{
new object[] { "this" },
new object[] { "is" },
new object[] { "avro" }
});
stmt.Dispose();
}
else
{
throw new ArgumentException("Unrecognized enum " + eventRepresentationEnum);
}
// 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 '@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 if (eventRepresentationEnum.IsMapEvent())
{
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");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
TryInvalid("select * from SentenceEvent[InvalidSentence(sentence)@Type(WordEvent)]",
"Event type 'WordEvent' underlying type " + AvroConstantsNoDep.GENERIC_RECORD_CLASSNAME + " cannot be assigned a value of type");
}
else
{
Assert.Fail();
}
// invalid subquery
TryInvalid("select * from SentenceEvent[SplitSentence((select * from SupportBean#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#keepall))@type(WordEvent)]]");
_epService.Initialize();
}
private void RunAssertion1Stream2HistStarSubordinateCartesianLast(EPServiceProvider epService)
{
string expression;
expression = "select s0.id as id, h0.val as valh0, h1.val as valh1 " +
"from SupportBeanInt#lastevent as s0, " +
"method:SupportJoinMethods.FetchVal('H0', p00) as h0, " +
"method:SupportJoinMethods.FetchVal('H1', p01) as h1 " +
"order by h0.val, h1.val";
EPStatement stmt = epService.EPAdministrator.CreateEPL(expression);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "id,valh0,valh1".Split(',');
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "E1", 1, 1);
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H11"
}
});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H11"
}
});
SendBeanInt(epService, "E2", 2, 0);
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "E3", 0, 1);
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "E3", 2, 2);
var result = new object[][] {
new object[] {
"E3",
"H01",
"H11"
},
new object[] {
"E3",
"H01",
"H12"
},
new object[] {
"E3",
"H02",
"H11"
},
new object[] {
"E3",
"H02",
"H12"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, result);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, result);
SendBeanInt(epService, "E4", 2, 1);
result = new object[][] {
new object[] {
"E4",
"H01",
"H11"
},
new object[] {
"E4",
"H02",
"H11"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, result);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, result);
stmt.Dispose();
}
private void RunAssertion3Stream1HistSubordinate(EPServiceProvider epService)
{
string expression;
expression = "select s0.id as ids0, s1.id as ids1, s2.id as ids2, h0.val as valh0 " +
"from SupportBeanInt(id like 'S0%')#keepall as s0, " +
"SupportBeanInt(id like 'S1%')#lastevent as s1, " +
"SupportBeanInt(id like 'S2%')#lastevent as s2, " +
"method:SupportJoinMethods.FetchVal(s1.id||s2.id||'H1', s0.p00) as h0 " +
"order by s0.id, s1.id, s2.id, h0.val";
EPStatement stmt = epService.EPAdministrator.CreateEPL(expression);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "ids0,ids1,ids2,valh0".Split(',');
SendBeanInt(epService, "S00", 2);
SendBeanInt(epService, "S10", 1);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
Assert.IsFalse(listener.IsInvoked);
SendBeanInt(epService, "S20", 1);
var resultOne = new object[][] {
new object[] {
"S00",
"S10",
"S20",
"S10S20H11"
},
new object[] {
"S00",
"S10",
"S20",
"S10S20H12"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, resultOne);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, resultOne);
SendBeanInt(epService, "S01", 1);
var resultTwo = new object[][] {
new object[] {
"S01",
"S10",
"S20",
"S10S20H11"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, resultTwo);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, EPAssertionUtil.ConcatenateArray2Dim(resultOne, resultTwo));
SendBeanInt(epService, "S21", 1);
var resultThree = new object[][] {
new object[] {
"S00",
"S10",
"S21",
"S10S21H11"
},
new object[] {
"S00",
"S10",
"S21",
"S10S21H12"
},
new object[] {
"S01",
"S10",
"S21",
"S10S21H11"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, resultThree);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, EPAssertionUtil.ConcatenateArray2Dim(resultThree));
stmt.Dispose();
}
private void TryAssertionFour(EPServiceProvider epService, string expression)
{
EPStatement stmt = epService.EPAdministrator.CreateEPL(expression);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "id,valh0,valh1,valh2".Split(',');
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "E1", 2, 2, 2, 1);
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields,
new object[][] {
new object[] {
"E1",
"H01",
"H11",
"H01H21"
}
});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H11",
"H01H21"
}
});
SendBeanInt(epService, "E2", 4, 4, 4, 3);
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields,
new object[][] {
new object[] {
"E2",
"H03",
"H13",
"H03H23"
}
});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields,
new object[][] {
new object[] {
"E1",
"H01",
"H11",
"H01H21"
},
new object[] {
"E2",
"H03",
"H13",
"H03H23"
}
});
stmt.Dispose();
}
private void TryAssertionTwo(EPServiceProvider epService, string expression)
{
EPStatement stmt = epService.EPAdministrator.CreateEPL(expression);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "id,valh0,valh1".Split(',');
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendBeanInt(epService, "E1", 1, 1);
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H011"
}
});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H011"
}
});
SendBeanInt(epService, "E2", 0, 1);
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H011"
}
});
SendBeanInt(epService, "E3", 1, 0);
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields, new object[][] {
new object[] {
"E1",
"H01",
"H011"
}
});
SendBeanInt(epService, "E4", 2, 2);
object[][] result =
{
new object[] {
"E4",
"H01",
"H011"
}, new object[]{
"E4",
"H01",
"H012"
}, new object[]{
"E4",
"H02",
"H021"
}, new object[]{
"E4",
"H02",
"H022"
}
};
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, result);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
stmt.GetEnumerator(), fields,
EPAssertionUtil.ConcatenateArray2Dim(
result, new object[][] {
new object[] {
"E1",
"H01",
"H011"
}
}));
stmt.Dispose();
}
private void RunAssertionSelectIndexChoiceJoin(bool namedWindow)
{
var preloadedEventsOne = new object[] {
new SupportSimpleBeanOne("E1", 10, 1, 2),
new SupportSimpleBeanOne("E2", 11, 3, 4),
new SupportSimpleBeanTwo("E1", 20, 1, 2),
new SupportSimpleBeanTwo("E2", 21, 3, 4),
};
IndexAssertionFAF fafAssertion = (result) => {
var fields = "w1.s1,w2.s2,w1.i1,w2.i2".Split(',');
EPAssertionUtil.AssertPropsPerRowAnyOrder(result.Array, fields,
new object[][] { new object[] { "E1", "E1", 10, 20 }, new object[] { "E2", "E2", 11, 21 } });
};
var assertionsSingleProp = new IndexAssertion[] {
new IndexAssertion(null, "s1 = s2", true, fafAssertion),
new IndexAssertion(null, "s1 = s2 and l1 = l2", true, fafAssertion),
new IndexAssertion(null, "l1 = l2 and s1 = s2", true, fafAssertion),
new IndexAssertion(null, "d1 = d2 and l1 = l2 and s1 = s2", true, fafAssertion),
new IndexAssertion(null, "d1 = d2 and l1 = l2", false, fafAssertion),
};
// single prop, no index, both declared unique (named window only)
if (namedWindow)
{
AssertIndexChoiceJoin(namedWindow, new string[0], preloadedEventsOne, "std:unique(s1)", "std:unique(s2)", assertionsSingleProp);
}
// single prop, unique indexes, both declared keepall
var uniqueIndex = new string[] { "create unique index W1I1 on W1(s1)", "create unique index W1I2 on W2(s2)" };
AssertIndexChoiceJoin(namedWindow, uniqueIndex, preloadedEventsOne, "win:keepall()", "win:keepall()", assertionsSingleProp);
// single prop, mixed indexes, both declared keepall
var assertionsMultiProp = new IndexAssertion[] {
new IndexAssertion(null, "s1 = s2", false, fafAssertion),
new IndexAssertion(null, "s1 = s2 and l1 = l2", true, fafAssertion),
new IndexAssertion(null, "l1 = l2 and s1 = s2", true, fafAssertion),
new IndexAssertion(null, "d1 = d2 and l1 = l2 and s1 = s2", true, fafAssertion),
new IndexAssertion(null, "d1 = d2 and l1 = l2", false, fafAssertion),
};
if (namedWindow)
{
var mixedIndex = new string[] { "create index W1I1 on W1(s1, l1)", "create unique index W1I2 on W2(s2)" };
AssertIndexChoiceJoin(namedWindow, mixedIndex, preloadedEventsOne, "std:unique(s1)", "win:keepall()", assertionsSingleProp);
// multi prop, no index, both declared unique
AssertIndexChoiceJoin(namedWindow, new string[0], preloadedEventsOne, "std:unique(s1, l1)", "std:unique(s2, l2)", assertionsMultiProp);
}
// multi prop, unique indexes, both declared keepall
var uniqueIndexMulti = new string[] { "create unique index W1I1 on W1(s1, l1)", "create unique index W1I2 on W2(s2, l2)" };
AssertIndexChoiceJoin(namedWindow, uniqueIndexMulti, preloadedEventsOne, "win:keepall()", "win:keepall()", assertionsMultiProp);
// multi prop, mixed indexes, both declared keepall
if (namedWindow)
{
var mixedIndexMulti = new string[] { "create index W1I1 on W1(s1)", "create unique index W1I2 on W2(s2, l2)" };
AssertIndexChoiceJoin(namedWindow, mixedIndexMulti, preloadedEventsOne, "std:unique(s1, l1)", "win:keepall()", assertionsMultiProp);
}
}
private void RunAssertionJoinIndexChoice(EPServiceProvider epService)
{
string eplDeclare = "create table varagg as (k0 string primary key, k1 int primary key, v1 string, total sum(long))";
string eplPopulate = "into table varagg select sum(LongPrimitive) as total from SupportBean group by TheString, IntPrimitive";
string eplQuery = "select total as value from SupportBean_S0 as s0 unidirectional";
var createIndexEmpty = new string[] {};
var preloadedEventsTwo = new object[] { MakeEvent("G1", 10, 1000L), MakeEvent("G2", 20, 2000L),
MakeEvent("G3", 30, 3000L), MakeEvent("G4", 40, 4000L) };
var listener = new SupportUpdateListener();
var eventSendAssertionRangeTwoExpected = new IndexAssertionEventSend(() => {
epService.EPRuntime.SendEvent(new SupportBean_S0(-1, null));
EPAssertionUtil.AssertPropsPerRowAnyOrder(listener.GetNewDataListFlattened(), "value".Split(','),
new object[][] { new object[] { 2000L }, new object[] { 3000L } });
listener.Reset();
});
var preloadedEventsHash = new object[] { MakeEvent("G1", 10, 1000L) };
var eventSendAssertionHash = new IndexAssertionEventSend(() => {
epService.EPRuntime.SendEvent(new SupportBean_S0(10, "G1"));
EPAssertionUtil.AssertPropsPerRow(listener.GetNewDataListFlattened(), "value".Split(','),
new object[][] { new object[] { 1000L } });
listener.Reset();
});
// no secondary indexes
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexEmpty, preloadedEventsHash,
new IndexAssertion[] {
// primary index found
new IndexAssertion("k1 = id and k0 = p00", "varagg", typeof(IndexedTableLookupPlanMulti), eventSendAssertionHash),
new IndexAssertion("k0 = p00 and k1 = id", "varagg", typeof(IndexedTableLookupPlanMulti), eventSendAssertionHash),
new IndexAssertion("k0 = p00 and k1 = id and v1 is null", "varagg", typeof(IndexedTableLookupPlanMulti), eventSendAssertionHash),
// no index found
new IndexAssertion("k1 = id", "varagg", typeof(FullTableScanUniquePerKeyLookupPlan), eventSendAssertionHash)
}
);
// one secondary hash index on single field
var createIndexHashSingleK1 = new string[] { "create index idx_k1 on varagg (k1)" };
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexHashSingleK1, preloadedEventsHash,
new IndexAssertion[] {
// primary index found
new IndexAssertion("k1 = id and k0 = p00", "varagg", typeof(IndexedTableLookupPlanMulti), eventSendAssertionHash),
// secondary index found
new IndexAssertion("k1 = id", "idx_k1", typeof(IndexedTableLookupPlanSingle), eventSendAssertionHash),
new IndexAssertion("id = k1", "idx_k1", typeof(IndexedTableLookupPlanSingle), eventSendAssertionHash),
// no index found
new IndexAssertion("k0 = p00", "varagg", typeof(FullTableScanUniquePerKeyLookupPlan), eventSendAssertionHash)
}
);
// two secondary hash indexes on one field each
var createIndexHashTwoDiscrete = new string[] { "create index idx_k1 on varagg (k1)", "create index idx_k0 on varagg (k0)" };
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexHashTwoDiscrete, preloadedEventsHash,
new IndexAssertion[] {
// primary index found
new IndexAssertion("k1 = id and k0 = p00", "varagg", typeof(IndexedTableLookupPlanMulti), eventSendAssertionHash),
// secondary index found
new IndexAssertion("k0 = p00", "idx_k0", typeof(IndexedTableLookupPlanSingle), eventSendAssertionHash),
new IndexAssertion("k1 = id", "idx_k1", typeof(IndexedTableLookupPlanSingle), eventSendAssertionHash),
new IndexAssertion("v1 is null and k1 = id", "idx_k1", typeof(IndexedTableLookupPlanSingle), eventSendAssertionHash),
// no index found
new IndexAssertion("1=1", "varagg", typeof(FullTableScanUniquePerKeyLookupPlan), eventSendAssertionHash)
}
);
// one range secondary index
// no secondary indexes
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexEmpty, preloadedEventsTwo,
new IndexAssertion[] {
// no index found
new IndexAssertion("k1 between 20 and 30", "varagg", typeof(FullTableScanUniquePerKeyLookupPlan), eventSendAssertionRangeTwoExpected)
}
);
// single range secondary index, expecting two events
var createIndexRangeOne = new string[] { "create index b_k1 on varagg (k1 btree)" };
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexRangeOne, preloadedEventsTwo,
new IndexAssertion[] {
new IndexAssertion("k1 between 20 and 30", "b_k1", typeof(SortedTableLookupPlan), eventSendAssertionRangeTwoExpected),
new IndexAssertion("(k0 = 'G3' or k0 = 'G2') and k1 between 20 and 30", "b_k1", typeof(SortedTableLookupPlan), eventSendAssertionRangeTwoExpected),
}
);
// single range secondary index, expecting single event
var eventSendAssertionRangeOneExpected = new IndexAssertionEventSend(() => {
epService.EPRuntime.SendEvent(new SupportBean_S0(-1, null));
EPAssertionUtil.AssertPropsPerRowAnyOrder(listener.GetNewDataListFlattened(), "value".Split(','),
new object[][] { new object[] { 2000L } });
listener.Reset();
});
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexRangeOne, preloadedEventsTwo,
new IndexAssertion[] {
new IndexAssertion("k0 = 'G2' and k1 between 20 and 30", "b_k1", typeof(SortedTableLookupPlan), eventSendAssertionRangeOneExpected),
new IndexAssertion("k1 between 20 and 30 and k0 = 'G2'", "b_k1", typeof(SortedTableLookupPlan), eventSendAssertionRangeOneExpected),
}
);
// combined hash+range index
var createIndexRangeCombined = new string[] { "create index h_k0_b_k1 on varagg (k0 hash, k1 btree)" };
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexRangeCombined, preloadedEventsTwo,
new IndexAssertion[] {
new IndexAssertion("k0 = 'G2' and k1 between 20 and 30", "h_k0_b_k1", typeof(CompositeTableLookupPlan), eventSendAssertionRangeOneExpected),
new IndexAssertion("k1 between 20 and 30 and k0 = 'G2'", "h_k0_b_k1", typeof(CompositeTableLookupPlan), eventSendAssertionRangeOneExpected),
}
);
var createIndexHashSingleK0 = new string[] { "create index idx_k0 on varagg (k0)" };
// in-keyword single-directional use
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexHashSingleK0, preloadedEventsTwo,
new IndexAssertion[] {
new IndexAssertion("k0 in ('G2', 'G3')", "idx_k0", typeof(InKeywordTableLookupPlanSingleIdx), eventSendAssertionRangeTwoExpected),
}
);
// in-keyword multi-directional use
AssertIndexChoice(epService, listener, eplDeclare, eplPopulate, eplQuery, createIndexHashSingleK0, preloadedEventsHash,
new IndexAssertion[] {
new IndexAssertion("'G1' in (k0)", "varagg", typeof(FullTableScanUniquePerKeyLookupPlan), eventSendAssertionHash),
}
);
epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__internal", false);
epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__public", false);
}
private void RunAssertion(EPStatement selectTestView)
{
var fields = new string[] { "Symbol", "mySum", "myAvg" };
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, null);
// assert select result type
Assert.AreEqual(typeof(string), selectTestView.EventType.GetPropertyType("Symbol"));
Assert.AreEqual(typeof(double?), selectTestView.EventType.GetPropertyType("mySum"));
Assert.AreEqual(typeof(double?), selectTestView.EventType.GetPropertyType("myAvg"));
SendEvent(SYMBOL_DELL, 10);
AssertEvents(SYMBOL_DELL,
null, null,
10d, 10d);
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 10d, 10d } });
SendEvent(SYMBOL_DELL, 20);
AssertEvents(SYMBOL_DELL,
10d, 10d,
30d, 15d);
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 30d, 15d } });
SendEvent(SYMBOL_DELL, 100);
AssertEvents(SYMBOL_DELL,
30d, 15d,
130d, 130d / 3d);
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 130d, 130d / 3d } });
SendEvent(SYMBOL_DELL, 50);
AssertEvents(SYMBOL_DELL,
130d, 130 / 3d,
170d, 170 / 3d); // 20 + 100 + 50
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 170d, 170d / 3d } });
SendEvent(SYMBOL_DELL, 5);
AssertEvents(SYMBOL_DELL,
170d, 170 / 3d,
155d, 155 / 3d); // 100 + 50 + 5
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 155d, 155d / 3d } });
SendEvent("AAA", 1000);
AssertEvents(SYMBOL_DELL,
155d, 155d / 3,
55d, 55d / 2); // 50 + 5
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] { new object[] { "DELL", 55d, 55d / 2d } });
SendEvent(SYMBOL_IBM, 70);
AssertEvents(SYMBOL_DELL,
55d, 55 / 2d,
5, 5,
SYMBOL_IBM,
null, null,
70, 70); // Dell:5
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] {
new object[] { "DELL", 5d, 5d }, new object[] { "IBM", 70d, 70d }
});
SendEvent("AAA", 2000);
AssertEvents(SYMBOL_DELL,
5d, 5d,
null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, new object[][] {
new object[] { "IBM", 70d, 70d }
});
SendEvent("AAA", 3000);
Assert.IsFalse(_listener.IsInvoked);
SendEvent("AAA", 4000);
AssertEvents(SYMBOL_IBM,
70d, 70d,
null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(selectTestView.GetEnumerator(), fields, null);
}
private void TryAssertionSingleIdx(EPServiceProvider epService, SupportUpdateListener listener)
{
var fields = "s0.Id,s1.Id".Split(',');
// single row tests
epService.EPRuntime.SendEvent(new SupportBean_S0(100, "a", "c"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a1", "b", "c", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a", "b", "x", "d"));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S1(1, "a", "b", "c", "d"));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, new[] {new object[] {100, 1}});
epService.EPRuntime.SendEvent(new SupportBean_S1(2, "x", "a", "x", "c"));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields, new[] {new object[] {100, 2}});
// 2-rows available tests
epService.EPRuntime.SendEvent(new SupportBean_S0(101, "a", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a1", "b", "c", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a", "b", "x", "c1"));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S1(10, "a", "b", "c", "d"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {100, 10}, new object[] {101, 10}});
epService.EPRuntime.SendEvent(new SupportBean_S1(11, "x", "a", "x", "c"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {100, 11}});
epService.EPRuntime.SendEvent(new SupportBean_S1(12, "x", "a", "d", "x"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {101, 12}});
// 3-rows available tests
epService.EPRuntime.SendEvent(new SupportBean_S0(102, "b", "c"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a1", "b", "c1", "d"));
epService.EPRuntime.SendEvent(new SupportBean_S1(0, "a", "b", "x", "c1"));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S1(20, "a", "b", "c", "d"));
EPAssertionUtil.AssertPropsPerRow(
listener.GetAndResetLastNewData(), fields,
new[] {new object[] {100, 20}, new object[] {101, 20}, new object[] {102, 20}});
epService.EPRuntime.SendEvent(new SupportBean_S1(21, "b", "a", "x", "c"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {100, 21}, new object[] {102, 21}});
epService.EPRuntime.SendEvent(new SupportBean_S1(22, "b", "a", "d", "c"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
listener.GetAndResetLastNewData(), fields,
new[] {new object[] {100, 22}, new object[] {101, 22}, new object[] {102, 22}});
epService.EPRuntime.SendEvent(new SupportBean_S1(23, "b", "x", "x", "c"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
listener.GetAndResetLastNewData(), fields, new[] {new object[] {102, 23}});
epService.EPAdministrator.DestroyAllStatements();
}
private void AssertEvents(
RegressionEnvironment env,
object[][] expected)
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.Listener("s0").GetAndResetLastNewData(), "one.Id,two.Id".SplitCsv(), expected);
}
public void Run(RegressionEnvironment env)
{
var fields = new[] {"sumint"};
var path = new RegressionPath();
var eplCreateTable = "@Name('Create-Table') create table MyTable(sumint sum(int))";
env.CompileDeploy(eplCreateTable, path);
var eplIntoTable =
"@Name('Into-Table') into table MyTable select sum(IntPrimitive) as sumint from SupportBean";
env.CompileDeploy(eplIntoTable, path);
var eplQueryTable = "@Name('s0') select (select sumint from MyTable) as c0 from SupportBean_S0 as S0";
env.CompileDeploy(eplQueryTable, path).AddListener("s0");
env.Milestone(1);
AssertValue(env, null);
MakeSendBean(env, "E1", 10);
AssertValue(env, 10);
env.Milestone(2);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {10}
});
MakeSendBean(env, "E2", 200);
AssertValue(env, 210);
env.Milestone(3);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {210}
});
MakeSendBean(env, "E1", 11);
AssertValue(env, 221);
env.Milestone(4);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {221}
});
MakeSendBean(env, "E3", 3000);
AssertValue(env, 3221);
env.Milestone(5);
env.Milestone(6);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {3221}
});
MakeSendBean(env, "E2", 201);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {3422}
});
MakeSendBean(env, "E3", 3001);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {6423}
});
MakeSendBean(env, "E1", 12);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("Create-Table"),
fields,
new[] {
new object[] {6435}
});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
SetupStatement(env, "full");
// Send S0[0]
SendEvent(EVENTS_S0[0], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), 100, "0", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {100, "0", null, null}});
// Send S1[1]
SendEvent(EVENTS_S1[1], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 201, "1");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {100, "0", null, null}, new object[] {null, null, 201, "1"}});
// Send S1[2] and S0[2]
SendEvent(EVENTS_S1[2], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {100, "0", null, null}, new object[] {null, null, 201, "1"}, new object[] {null, null, 202, "2"}});
SendEvent(EVENTS_S0[2], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {100, "0", null, null}, new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"}});
// Send S0[3] and S1[3]
SendEvent(EVENTS_S0[3], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), 103, "3", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {100, "0", null, null}, new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"},
new object[] {103, "3", null, null}
});
SendEvent(EVENTS_S1[3], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), 103, "3", 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {100, "0", null, null}, new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"},
new object[] {103, "3", 203, "3"}
});
// Send S0[4], pushes S0[0] out of window
SendEvent(EVENTS_S0[4], env);
var oldEvent = env.Listener("s0").LastOldData[0];
var newEvent = env.Listener("s0").LastNewData[0];
CompareEvent(oldEvent, 100, "0", null, null);
CompareEvent(newEvent, 104, "4", null, null);
env.Listener("s0").Reset();
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"},
new object[] {104, "4", null, null}
});
// Send S1[4]
SendEvent(EVENTS_S1[4], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), 104, "4", 204, "4");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"},
new object[] {104, "4", 204, "4"}
});
// Send S1[5]
SendEvent(EVENTS_S1[5], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {null, null, 201, "1"}, new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"},
new object[] {104, "4", 204, "4"}, new object[] {null, null, 205, "5"}
});
// Send S1[6], pushes S1[1] out of window
SendEvent(EVENTS_S1[5], env);
oldEvent = env.Listener("s0").LastOldData[0];
newEvent = env.Listener("s0").LastNewData[0];
CompareEvent(oldEvent, null, null, 201, "1");
CompareEvent(newEvent, null, null, 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"}, new object[] {104, "4", 204, "4"},
new object[] {null, null, 205, "5"}, new object[] {null, null, 205, "5"}
});
env.UndeployAll();
}
private void RunAssertionGroupedWindow(EPServiceProvider epService)
{
SendTimer(epService, 20000);
EPStatement stmt = epService.EPAdministrator.CreateEPL(
"select irstream * from " + typeof(SupportBeanTimestamp).FullName +
"#groupwin(groupId)#time_order(timestamp, 10 sec)");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
// 1st event is old
SendEvent(epService, "E1", "G1", 10000);
Assert.AreEqual(1, listener.NewDataList.Count);
Assert.AreEqual(1, listener.LastNewData.Length);
Assert.AreEqual("E1", listener.LastNewData[0].Get("id"));
Assert.AreEqual(1, listener.LastOldData.Length);
Assert.AreEqual("E1", listener.LastOldData[0].Get("id"));
listener.Reset();
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, null);
// 2nd just fits
SendEvent(epService, "E2", "G2", 10001);
Assert.AreEqual("E2", listener.AssertOneGetNewAndReset().Get("id"));
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E2" } });
SendEvent(epService, "E3", "G3", 20000);
Assert.AreEqual("E3", listener.AssertOneGetNewAndReset().Get("id"));
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E2" }, new object[] { "E3" } });
SendEvent(epService, "E4", "G2", 20000);
Assert.AreEqual("E4", listener.AssertOneGetNewAndReset().Get("id"));
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E2" }, new object[] { "E4" }, new object[] { "E3" } });
SendTimer(epService, 20001);
Assert.IsNull(listener.LastNewData);
Assert.AreEqual(1, listener.OldDataList.Count);
Assert.AreEqual(1, listener.LastOldData.Length);
Assert.AreEqual("E2", listener.LastOldData[0].Get("id"));
listener.Reset();
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E4" }, new object[] { "E3" } });
SendTimer(epService, 22000);
SendEvent(epService, "E5", "G2", 19000);
Assert.AreEqual("E5", listener.AssertOneGetNewAndReset().Get("id"));
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E5" }, new object[] { "E4" }, new object[] { "E3" } });
SendTimer(epService, 29000);
Assert.IsNull(listener.LastNewData);
Assert.AreEqual(1, listener.OldDataList.Count);
Assert.AreEqual(1, listener.LastOldData.Length);
Assert.AreEqual("E5", listener.LastOldData[0].Get("id"));
listener.Reset();
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, new object[][] { new object[] { "E4" }, new object[] { "E3" } });
SendTimer(epService, 30000);
Assert.IsNull(listener.LastNewData);
Assert.AreEqual(1, listener.OldDataList.Count);
Assert.AreEqual(2, listener.LastOldData.Length);
EPAssertionUtil.AssertPropsPerRowAnyOrder(listener.LastOldData, "id".Split(','), new object[][] { new object[] { "E4" }, new object[] { "E3" } });
listener.Reset();
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), new string[] { "id" }, null);
SendTimer(epService, 100000);
Assert.IsFalse(listener.IsInvoked);
epService.EPAdministrator.DestroyAllStatements();
}
public void Run(RegressionEnvironment env)
{
SetupStatement(env, "right");
// Send S0 events, no events expected
SendEvent(EVENTS_S0[0], env);
SendEvent(EVENTS_S0[1], env);
Assert.IsFalse(env.Listener("s0").IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, null);
// Send S1[2]
SendEvent(EVENTS_S1[2], env);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, null, null, 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {null, null, 202, "2"}});
// Send S0[2] events, joined event expected
SendEvent(EVENTS_S0[2], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {102, "2", 202, "2"}});
// Send S1[3]
SendEvent(EVENTS_S1[3], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, null, null, 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", 202, "2"}, new object[] {null, null, 203, "3"}});
// Send some more S0 events
SendEvent(EVENTS_S0[3], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 103, "3", 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"}});
// Send some more S0 events
SendEvent(EVENTS_S0[4], env);
Assert.IsFalse(env.Listener("s0").IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", 202, "2"}, new object[] {103, "3", 203, "3"}});
// Push S0[2] out of the window
SendEvent(EVENTS_S0[5], env);
theEvent = env.Listener("s0").AssertOneGetOldAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {null, null, 202, "2"}, new object[] {103, "3", 203, "3"}});
// Some more S1 events
SendEvent(EVENTS_S1[6], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 206, "6");
SendEvent(EVENTS_S1[7], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 207, "7");
SendEvent(EVENTS_S1[8], env);
CompareEvent(env.Listener("s0").AssertOneGetNewAndReset(), null, null, 208, "8");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {null, null, 202, "2"}, new object[] {103, "3", 203, "3"}, new object[] {null, null, 206, "6"},
new object[] {null, null, 207, "7"}, new object[] {null, null, 208, "8"}
});
// Push S1[2] out of the window
SendEvent(EVENTS_S1[9], env);
var oldEvent = env.Listener("s0").LastOldData[0];
var newEvent = env.Listener("s0").LastNewData[0];
CompareEvent(oldEvent, null, null, 202, "2");
CompareEvent(newEvent, null, null, 209, "9");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {
new object[] {103, "3", 203, "3"}, new object[] {null, null, 206, "6"}, new object[] {null, null, 207, "7"},
new object[] {null, null, 208, "8"}, new object[] {null, null, 209, "9"}
});
env.UndeployAll();
}
private void RunAssertionDeleteCondition(EPServiceProvider epService, bool isNamedWindow)
{
// create infra
string stmtTextCreate = isNamedWindow ?
"create window MyInfra#keepall as select TheString as a, IntPrimitive as b from SupportBean" :
"create table MyInfra (a string primary key, b int)";
EPStatement stmtCreate = epService.EPAdministrator.CreateEPL(stmtTextCreate);
var listenerInfra = new SupportUpdateListener();
stmtCreate.Events += listenerInfra.Update;
// create delete stmt
string stmtTextDelete = "on SupportBean_A delete from MyInfra where 'X' || a || 'X' = id";
epService.EPAdministrator.CreateEPL(stmtTextDelete);
// create delete stmt
stmtTextDelete = "on SupportBean_B delete from MyInfra where b < 5";
epService.EPAdministrator.CreateEPL(stmtTextDelete);
// create insert into
string stmtTextInsertOne = "insert into MyInfra select TheString as a, IntPrimitive as b from SupportBean";
epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
// send 3 event
SendSupportBean(epService, "E1", 1);
SendSupportBean(epService, "E2", 2);
SendSupportBean(epService, "E3", 3);
Assert.AreEqual(3, GetCount(epService, "MyInfra"));
listenerInfra.Reset();
var fields = new string[] { "a", "b" };
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E2", 2 }, new object[] { "E3", 3 } });
// delete E2
SendSupportBean_A(epService, "XE2X");
if (isNamedWindow)
{
Assert.AreEqual(1, listenerInfra.LastOldData.Length);
EPAssertionUtil.AssertProps(listenerInfra.LastOldData[0], fields, new object[] { "E2", 2 });
}
listenerInfra.Reset();
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E3", 3 } });
Assert.AreEqual(2, GetCount(epService, "MyInfra"));
SendSupportBean(epService, "E7", 7);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1", 1 }, new object[] { "E3", 3 }, new object[] { "E7", 7 } });
Assert.AreEqual(3, GetCount(epService, "MyInfra"));
// delete all under 5
SendSupportBean_B(epService, "B1");
if (isNamedWindow)
{
Assert.AreEqual(2, listenerInfra.LastOldData.Length);
EPAssertionUtil.AssertProps(listenerInfra.LastOldData[0], fields, new object[] { "E1", 1 });
EPAssertionUtil.AssertProps(listenerInfra.LastOldData[1], fields, new object[] { "E3", 3 });
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E7", 7 } });
Assert.AreEqual(1, GetCount(epService, "MyInfra"));
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
}
public void Run(RegressionEnvironment env)
{
SetupStatement(env, "left");
// Send S1 events, no events expected
SendEvent(EVENTS_S1[0], env);
SendEvent(EVENTS_S1[1], env);
SendEvent(EVENTS_S1[3], env);
Assert.IsNull(env.Listener("s0").LastNewData); // No events expected
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, null);
// Send S0 event, expect event back from outer join
SendEvent(EVENTS_S0[2], env);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {102, "2", null, null}});
// Send S1 event matching S0, expect event back
SendEvent(EVENTS_S1[2], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {102, "2", 202, "2"}});
// Send some more unmatched events
SendEvent(EVENTS_S1[4], env);
SendEvent(EVENTS_S1[5], env);
SendEvent(EVENTS_S1[6], env);
Assert.IsNull(env.Listener("s0").LastNewData); // No events expected
EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("s0"), FIELDS, new[] {new object[] {102, "2", 202, "2"}});
// Send event, expect a join result
SendEvent(EVENTS_S0[5], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 105, "5", 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", 202, "2"}, new object[] {105, "5", 205, "5"}});
// Let S1[2] go out of the window (lenght 5), expected old join event
SendEvent(EVENTS_S1[7], env);
SendEvent(EVENTS_S1[8], env);
theEvent = env.Listener("s0").AssertOneGetOldAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", null, null}, new object[] {105, "5", 205, "5"}});
// S0[9] should generate an outer join event
SendEvent(EVENTS_S0[9], env);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
CompareEvent(theEvent, 109, "9", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {102, "2", null, null}, new object[] {109, "9", null, null}, new object[] {105, "5", 205, "5"}});
// S0[2] Should leave the window (length 3), should get OLD and NEW event
SendEvent(EVENTS_S0[10], env);
var oldEvent = env.Listener("s0").LastOldData[0];
var newEvent = env.Listener("s0").LastNewData[0];
CompareEvent(oldEvent, 102, "2", null, null); // S1[2] has left the window already
CompareEvent(newEvent, 110, "10", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.GetEnumerator("s0"),
FIELDS,
new[] {new object[] {110, "10", null, null}, new object[] {109, "9", null, null}, new object[] {105, "5", 205, "5"}});
env.UndeployAll();
}
public void TestBatchWindow()
{
String[] fields = new String[]
{
"TheString", "IntPrimitive"
}
;
String statementText = "select distinct TheString, IntPrimitive from SupportBean.win:length_batch(3)";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
statementText);
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
}
);
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(),
fields, new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(),
fields, new Object[][] {
new Object[] {
"E2", 2
}
,
new Object[] {
"E1", 1
}
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 3));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 3));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 3));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(),
fields, new Object[][] {
new Object[] {
"E2", 3
}
}
);
stmt.Dispose();
// test batch window with aggregation
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(0));
String[] fieldsTwo = new String[] {
"c1", "c2"
}
;
String epl = "insert into ABC select distinct TheString as c1, First(IntPrimitive) as c2 from SupportBean.win:time_batch(1 second)";
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL(epl);
stmtTwo.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(1000));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(),
fieldsTwo, new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 1
}
}
);
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(2000));
Assert.IsFalse(_listener.IsInvoked);
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
SendCurrentTime(env, "2002-02-01T09:00:00.000");
env.CompileDeploy(
"create context MyTermByTimeout partition by TheString from SupportBean terminated (*, *, *, *, *)",
path);
env.CompileDeploy(
"@Name('s0') context MyTermByTimeout select TheString, count(*) as cnt from SupportBean output last when terminated",
path);
env.AddListener("s0");
env.SendEventBean(new SupportBean("A", 0));
env.Milestone(0);
SendCurrentTime(env, "2002-02-01T09:00:05.000");
env.SendEventBean(new SupportBean("B", 0));
env.Milestone(1);
env.SendEventBean(new SupportBean("A", 0));
SendCurrentTime(env, "2002-02-01T09:00:59.999");
env.Milestone(2);
env.SendEventBean(new SupportBean("B", 0));
env.SendEventBean(new SupportBean("A", 0));
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendCurrentTime(env, "2002-02-01T09:01:00.000");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").GetAndResetLastNewData(),
new [] { "TheString","cnt" },
new[] {new object[] {"A", 3L}, new object[] {"B", 2L}});
env.Milestone(3);
env.SendEventBean(new SupportBean("C", 0));
env.SendEventBean(new SupportBean("A", 0));
SendCurrentTime(env, "2002-02-01T09:01:30.000");
env.SendEventBean(new SupportBean("D", 0));
env.Milestone(4);
env.SendEventBean(new SupportBean("C", 0));
SendCurrentTime(env, "2002-02-01T09:02:00.000");
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").GetAndResetLastNewData(),
new [] { "TheString","cnt" },
new[] {new object[] {"A", 1L}, new object[] {"C", 2L}, new object[] {"D", 1L}});
SendCurrentTime(env, "2002-02-01T09:03:00.000");
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.UndeployAll();
}
private void RunAssertionSnapshotColumn(EPStatement stmt, String[] fields)
{
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
}
);
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRow(_listener.LastNewData, fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
}
);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
}
);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
}
);
EPAssertionUtil.AssertPropsPerRow(_listener.LastNewData, fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
}
);
_listener.Reset();
_epService.EPRuntime.SendEvent(new SupportBean("E3", 3));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
,
new Object[] {
"E3", 3
}
}
);
EPAssertionUtil.AssertPropsPerRow(_listener.LastNewData, fields,
new Object[][] {
new Object[] {
"E1", 1
}
,
new Object[] {
"E2", 2
}
,
new Object[] {
"E3", 3
}
}
);
_listener.Reset();
}
private void AssertValuesIterate(string[] fields, object[][] objects)
{
var result = _epService.EPRuntime.ExecuteQuery("select * from MyTable");
EPAssertionUtil.AssertPropsPerRowAnyOrder(result.Array, fields, objects);
}
private void RunAssertsFullJoin_2sides(EPStatement joinView)
{
// Test s0 outer join to 2 streams, 2 results for each (cartesian product)
//
Object[] s1Events = SupportBean_S1.MakeS1("A", new String[] { "A-s1-1", "A-s1-2" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { null, s1Events[1], null } }, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { null, null, "A", "A-s1-1", null, null },
new Object[] { null, null, "A", "A-s1-2", null, null } });
Object[] s2Events = SupportBean_S2.MakeS2("A", new String[] { "A-s2-1", "A-s2-2" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { null, null, s2Events[1] } }, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { null, null, "A", "A-s1-1", null, null },
new Object[] { null, null, "A", "A-s1-2", null, null },
new Object[] { null, null, null, null, "A", "A-s2-1" },
new Object[] { null, null, null, null, "A", "A-s2-2" } });
Object[] s0Events = SupportBean_S0.MakeS0("A", new String[] { "A-s0-1" });
SendEvent(s0Events);
Object[][] expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[1], s2Events[0] },
new Object[] { s0Events[0], s1Events[0], s2Events[1] },
new Object[] { s0Events[0], s1Events[1], s2Events[1] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-2" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-2" } });
// Test s0 outer join to s1 and s2, no results for each s1 and s2
//
s0Events = SupportBean_S0.MakeS0("B", new String[] { "B-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, null } }, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-2" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-2" },
new Object[] { "B", "B-s0-1", null, null, null, null } });
s0Events = SupportBean_S0.MakeS0("B", new String[] { "B-s0-2" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, null } }, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-2" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-2" },
new Object[] { "B", "B-s0-1", null, null, null, null },
new Object[] { "B", "B-s0-2", null, null, null, null } });
// Test s0 outer join to s1 and s2, one row for s1 and no results for s2
//
s1Events = SupportBean_S1.MakeS1("C", new String[] { "C-s1-1" });
SendEventsAndReset(s1Events);
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-2" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-2" },
new Object[] { "B", "B-s0-1", null, null, null, null },
new Object[] { "B", "B-s0-2", null, null, null, null },
new Object[] { null, null, "C", "C-s1-1", null, null } });
s0Events = SupportBean_S0.MakeS0("C", new String[] { "C-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], s1Events[0], null } }, GetAndResetNewEvents());
EPAssertionUtil.AssertPropsPerRowAnyOrder(joinView.GetEnumerator(), Fields,
new Object[][] { new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-1" },
new Object[] { "A", "A-s0-1", "A", "A-s1-1", "A", "A-s2-2" },
new Object[] { "A", "A-s0-1", "A", "A-s1-2", "A", "A-s2-2" },
new Object[] { "B", "B-s0-1", null, null, null, null },
new Object[] { "B", "B-s0-2", null, null, null, null },
new Object[] { "C", "C-s0-1", "C", "C-s1-1", null, null } });
// Test s0 outer join to s1 and s2, two rows for s1 and no results for s2
//
s1Events = SupportBean_S1.MakeS1("D", new String[] { "D-s1-1", "D-s1-2" });
SendEventsAndReset(s1Events);
s0Events = SupportBean_S0.MakeS0("D", new String[] { "D-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] {
new Object[] { s0Events[0], s1Events[0], null },
new Object[] { s0Events[0], s1Events[1], null }
}, GetAndResetNewEvents());
// Test s0 outer join to s1 and s2, one row for s2 and no results for s1
//
s2Events = SupportBean_S2.MakeS2("E", new String[] { "E-s2-1" });
SendEventsAndReset(s2Events);
s0Events = SupportBean_S0.MakeS0("E", new String[] { "E-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, s2Events[0] } }, GetAndResetNewEvents());
// Test s0 outer join to s1 and s2, two rows for s2 and no results for s1
//
s2Events = SupportBean_S2.MakeS2("F", new String[] { "F-s2-1", "F-s2-2" });
SendEventsAndReset(s2Events);
s0Events = SupportBean_S0.MakeS0("F", new String[] { "F-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] {
new Object[] { s0Events[0], null, s2Events[0] },
new Object[] { s0Events[0], null, s2Events[1] }
}, GetAndResetNewEvents());
// Test s0 outer join to s1 and s2, one row for s1 and two rows s2
//
s1Events = SupportBean_S1.MakeS1("G", new String[] { "G-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("G", new String[] { "G-s2-1", "G-s2-2" });
SendEventsAndReset(s2Events);
s0Events = SupportBean_S0.MakeS0("G", new String[] { "G-s0-2" });
SendEvent(s0Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[0], s2Events[1] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s0 outer join to s1 and s2, one row for s2 and two rows s1
//
s1Events = SupportBean_S1.MakeS1("H", new String[] { "H-s1-1", "H-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("H", new String[] { "H-s2-1" });
SendEventsAndReset(s2Events);
s0Events = SupportBean_S0.MakeS0("H", new String[] { "H-s0-2" });
SendEvent(s0Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[1], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s0 outer join to s1 and s2, one row for each s1 and s2
//
s1Events = SupportBean_S1.MakeS1("I", new String[] { "I-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("I", new String[] { "I-s2-1" });
SendEventsAndReset(s2Events);
s0Events = SupportBean_S0.MakeS0("I", new String[] { "I-s0-2" });
SendEvent(s0Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 1 rows, s2 with 2 rows
//
s0Events = SupportBean_S0.MakeS0("Q", new String[] { "Q-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, null } }, GetAndResetNewEvents());
s2Events = SupportBean_S2.MakeS2("Q", new String[] { "Q-s2-1", "Q-s2-2" });
SendEvent(s2Events[0]);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, s2Events[0] } }, GetAndResetNewEvents());
SendEvent(s2Events[1]);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, s2Events[1] } }, GetAndResetNewEvents());
s1Events = SupportBean_S1.MakeS1("Q", new String[] { "Q-s1-1" });
SendEvent(s1Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[0], s2Events[1] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 0 rows, s2 with 2 rows
//
s2Events = SupportBean_S2.MakeS2("R", new String[] { "R-s2-1", "R-s2-2" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { null, null, s2Events[1] } }, GetAndResetNewEvents());
s1Events = SupportBean_S1.MakeS1("R", new String[] { "R-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { null, s1Events[0], null } }, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 1 rows, s2 with 0 rows
//
s0Events = SupportBean_S0.MakeS0("S", new String[] { "S-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, null } }, GetAndResetNewEvents());
s1Events = SupportBean_S1.MakeS1("S", new String[] { "S-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], s1Events[0], null } }, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 1 rows, s2 with 1 rows
//
s0Events = SupportBean_S0.MakeS0("T", new String[] { "T-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, null } }, GetAndResetNewEvents());
s2Events = SupportBean_S2.MakeS2("T", new String[] { "T-s2-1" });
SendEventsAndReset(s2Events);
s1Events = SupportBean_S1.MakeS1("T", new String[] { "T-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], s1Events[0], s2Events[0] } }, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 2 rows, s2 with 0 rows
//
s0Events = SupportBean_S0.MakeS0("U", new String[] { "U-s0-1", "U-s0-1" });
SendEventsAndReset(s0Events);
s1Events = SupportBean_S1.MakeS1("U", new String[] { "U-s1-1" });
SendEvent(s1Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], null },
new Object[] { s0Events[1], s1Events[0], null },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 2 rows, s2 with 1 rows
//
s0Events = SupportBean_S0.MakeS0("V", new String[] { "V-s0-1", "V-s0-1" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("V", new String[] { "V-s2-1" });
SendEventsAndReset(s2Events);
s1Events = SupportBean_S1.MakeS1("V", new String[] { "V-s1-1" });
SendEvent(s1Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[1], s1Events[0], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s1 inner join to s0 and outer to s2: s0 with 2 rows, s2 with 2 rows
//
s0Events = SupportBean_S0.MakeS0("W", new String[] { "W-s0-1", "W-s0-2" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("W", new String[] { "W-s2-1", "W-s2-2" });
SendEventsAndReset(s2Events);
s1Events = SupportBean_S1.MakeS1("W", new String[] { "W-s1-1" });
SendEvent(s1Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[1], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[0], s2Events[1] },
new Object[] { s0Events[1], s1Events[0], s2Events[1] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 1 rows, s1 with 2 rows
//
s0Events = SupportBean_S0.MakeS0("J", new String[] { "J-s0-1" });
SendEventsAndReset(s0Events);
s1Events = SupportBean_S1.MakeS1("J", new String[] { "J-s1-1", "J-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("J", new String[] { "J-s2-1" });
SendEvent(s2Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[1], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 0 rows, s1 with 2 rows
//
s1Events = SupportBean_S1.MakeS1("K", new String[] { "K-s1-1", "K-s1-2" });
SendEventsAndReset(s2Events);
s2Events = SupportBean_S2.MakeS2("K", new String[] { "K-s2-1" });
SendEventsAndReset(s2Events);
// Test s2 inner join to s0 and outer to s1: s0 with 1 rows, s1 with 0 rows
//
s0Events = SupportBean_S0.MakeS0("L", new String[] { "L-s0-1" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("L", new String[] { "L-s2-1" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], null, s2Events[0] } }, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 1 rows, s1 with 1 rows
//
s0Events = SupportBean_S0.MakeS0("M", new String[] { "M-s0-1" });
SendEventsAndReset(s0Events);
s1Events = SupportBean_S1.MakeS1("M", new String[] { "M-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("M", new String[] { "M-s2-1" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new Object[][] { new Object[] { s0Events[0], s1Events[0], s2Events[0] } }, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 2 rows, s1 with 0 rows
//
s0Events = SupportBean_S0.MakeS0("Count", new String[] { "Count-s0-1", "Count-s0-1" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("Count", new String[] { "Count-s2-1" });
SendEvent(s2Events);
expected = new Object[][] {
new Object[] { s0Events[0], null, s2Events[0] },
new Object[] { s0Events[1], null, s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 2 rows, s1 with 1 rows
//
s0Events = SupportBean_S0.MakeS0("O", new String[] { "O-s0-1", "O-s0-1" });
SendEventsAndReset(s0Events);
s1Events = SupportBean_S1.MakeS1("O", new String[] { "O-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("O", new String[] { "O-s2-1" });
SendEvent(s2Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[1], s1Events[0], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
// Test s2 inner join to s0 and outer to s1: s0 with 2 rows, s1 with 2 rows
//
s0Events = SupportBean_S0.MakeS0("P", new String[] { "P-s0-1", "P-s0-2" });
SendEventsAndReset(s0Events);
s1Events = SupportBean_S1.MakeS1("P", new String[] { "P-s1-1", "P-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("P", new String[] { "P-s2-1" });
SendEvent(s2Events);
expected = new Object[][] {
new Object[] { s0Events[0], s1Events[0], s2Events[0] },
new Object[] { s0Events[1], s1Events[0], s2Events[0] },
new Object[] { s0Events[0], s1Events[1], s2Events[0] },
new Object[] { s0Events[1], s1Events[1], s2Events[0] },
};
EPAssertionUtil.AssertSameAnyOrder(expected, GetAndResetNewEvents());
}
private void RunAssertion_A_Bstar(bool allMatches)
{
EPServiceProviderIsolated isolated = _epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
String[] fields = "a,b0,b1,b2".Split(',');
String text = "select * from MyEvent.win:keepall() " +
"match_recognize (" +
" measures A.TheString as a, B[0].TheString as b0, B[1].TheString as b1, B[2].TheString as b2" +
(allMatches ? " all matches" : "") +
" pattern (A B*)" +
" interval 10 seconds or terminated" +
" define" +
" A as A.TheString like \"A%\"," +
" B as B.TheString like \"B%\"" +
")";
EPStatement stmt = isolated.EPAdministrator.CreateEPL(text, "stmt1", null);
stmt.Events += _listener.Update;
// test output by terminated because of misfit event
isolated.EPRuntime.SendEvent(new SupportRecogBean("A1"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B1"));
Assert.IsFalse(_listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("X1"));
if (!allMatches)
{
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A1", "B1", null, null });
}
else
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "A1", "B1", null, null }, new Object[] { "A1", null, null, null } });
}
SendTimer(isolated, 20000);
Assert.IsFalse(_listener.IsInvoked);
// test output by timer expiry
isolated.EPRuntime.SendEvent(new SupportRecogBean("A2"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B2"));
Assert.IsFalse(_listener.IsInvoked);
SendTimer(isolated, 29999);
SendTimer(isolated, 30000);
if (!allMatches)
{
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A2", "B2", null, null });
}
else
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "A2", "B2", null, null }, new Object[] { "A2", null, null, null } });
}
// destroy
stmt.Dispose();
isolated.Dispose();
EPStatement stmtFromModel = SupportModelHelper.CompileCreate(_epService, text);
stmtFromModel.Dispose();
}