public void TestWithDate()
{
_epService.EPAdministrator.CreateEPL("create variable int varyear");
_epService.EPAdministrator.CreateEPL("create variable int varmonth");
_epService.EPAdministrator.CreateEPL("create variable int varday");
String startTime = "2002-05-30 09:00:00.000";
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(DateTimeParser.ParseDefaultMSec(startTime)));
String[] fields = "val0,val1,val2".Split(',');
String eplFragment = "select " +
"current_timestamp.withDate(varyear, varmonth, varday) as val0," +
"utildate.withDate(varyear, varmonth, varday) as val1," +
"msecdate.withDate(varyear, varmonth, varday) as val2" +
" from SupportDateTime";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(long?), typeof(DateTimeOffset?), typeof(long?) });
_epService.EPRuntime.SendEvent(SupportDateTime.Make(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { SupportDateTime.GetValueCoerced(startTime, "msec"), null, null });
String expectedTime = "2004-09-03 09:00:00.000";
_epService.EPRuntime.SetVariableValue("varyear", 2004);
_epService.EPRuntime.SetVariableValue("varmonth", 9);
_epService.EPRuntime.SetVariableValue("varday", 3);
_epService.EPRuntime.SendEvent(SupportDateTime.Make(startTime));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
SupportDateTime.GetArrayCoerced(expectedTime, "msec", "util", "msec"));
expectedTime = "2002-09-30 09:00:00.000";
_epService.EPRuntime.SetVariableValue("varyear", null);
_epService.EPRuntime.SetVariableValue("varmonth", 9);
_epService.EPRuntime.SetVariableValue("varday", null);
_epService.EPRuntime.SendEvent(SupportDateTime.Make(startTime));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
SupportDateTime.GetArrayCoerced(expectedTime, "msec", "util", "msec"));
}
private static void RunAssertion(
RegressionEnvironment env,
AtomicLong milestone)
{
var fields = new [] { "val" };
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {false});
env.MilestoneInc(milestone);
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {false});
env.SendEventBean(new SupportBean("E3", 3));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {false});
env.MilestoneInc(milestone);
env.SendEventBean(new SupportBean("E4", 4));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {true});
env.MilestoneInc(milestone);
env.SendEventBean(new SupportBean("E5", 5));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {true});
}
public void RunAssertionDispatchBackQueue(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema StartValueEvent as (dummy string)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TestForwardEvent as (prop1 string)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TestInputEvent as (dummy string)");
_epService.EPAdministrator.CreateEPL("insert into TestForwardEvent select'V1' as prop1 from TestInputEvent");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window NamedWin.std:unique(prop1) (prop1 string, prop2 string)");
_epService.EPAdministrator.CreateEPL("insert into NamedWin select 'V1' as prop1, 'O1' as prop2 from StartValueEvent");
_epService.EPAdministrator.CreateEPL("on TestForwardEvent update NamedWin as work set prop2 = 'U1' where work.prop1 = 'V1'");
string[] fields = "prop1,prop2".Split(',');
string eplSelect = "select irstream prop1, prop2 from NamedWin";
_epService.EPAdministrator.CreateEPL(eplSelect).AddListener(_listener);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new object[] { "dummyValue" }, "StartValueEvent");
}
else
{
_epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "StartValueEvent");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "V1", "O1" });
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new object[] { "dummyValue" }, "TestInputEvent");
}
else
{
_epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "TestInputEvent");
}
EPAssertionUtil.AssertProps(_listener.LastOldData[0], fields, new object[] { "V1", "O1" });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[0], fields, new object[] { "V1", "U1" });
_epService.Initialize();
}
private void RunAssertionArrayPropertySizeAndGet(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType(
"SupportBeanComplexProps", typeof(SupportBeanComplexProps));
var epl = "select " +
"(arrayProperty).size() as size, " +
"(arrayProperty).get(0) as get0, " +
"(arrayProperty).get(1) as get1, " +
"(arrayProperty).get(2) as get2, " +
"(arrayProperty).get(3) as get3 " +
"from SupportBeanComplexProps";
var stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var bean = SupportBeanComplexProps.MakeDefaultBean();
var rows = new[]
{
new object[] {"size", typeof(int?)},
new object[] {"get0", typeof(int)},
new object[] {"get1", typeof(int)},
new object[] {"get2", typeof(int)},
new object[] {"get3", typeof(int)}
};
for (var i = 0; i < rows.Length; i++)
{
var prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, "failed for " + rows[i][0]);
Assert.AreEqual(rows[i][1], prop.PropertyType, "failed for " + rows[i][0]);
}
epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(
listener.AssertOneGetNew(), "size,get0,get1,get2,get3".Split(','),
new object[]
{
bean.ArrayProperty.Length, bean.ArrayProperty[0], bean.ArrayProperty[1], bean.ArrayProperty[2], null
});
stmt.Dispose();
}
private void RunAssertionUngroupedRowRemove()
{
var cols = "TheString,IntPrimitive,c0,c1".Split(',');
var epl = "create window MyWindow#keepall as SupportBean;\n" +
"insert into MyWindow select * from SupportBean;\n" +
"on SupportBean_S0 delete from MyWindow where p00 = TheString and id = IntPrimitive;\n" +
"on SupportBean_S1 delete from MyWindow;\n" +
"@Name('out') select TheString, IntPrimitive, sum(LongPrimitive) as c0, " +
" sum(LongPrimitive, group_by:TheString) as c1 from MyWindow;\n";
var result = _epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl);
_epService.EPAdministrator.GetStatement("out").AddListener(_listener);
MakeSendEvent("E1", 10, 101);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E1", 10, 101L, 101L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(10, "E1")); // delete event {"E1", 10}
Assert.IsFalse(_listener.IsInvoked);
MakeSendEvent("E1", 20, 102);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E1", 20, 102L, 102L });
MakeSendEvent("E2", 30, 103);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E2", 30, 102 + 103L, 103L });
MakeSendEvent("E1", 40, 104);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E1", 40, 102 + 103 + 104L, 102 + 104L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(40, "E1")); // delete event {"E1", 40}
Assert.IsFalse(_listener.IsInvoked);
MakeSendEvent("E1", 50, 105);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E1", 50, 102 + 103 + 105L, 102 + 105L });
_epService.EPRuntime.SendEvent(new SupportBean_S1(-1)); // delete all
Assert.IsFalse(_listener.IsInvoked);
MakeSendEvent("E1", 60, 106);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), cols, new object[] { "E1", 60, 106L, 106L });
_epService.EPAdministrator.DeploymentAdmin.Undeploy(result.DeploymentId);
}
private void RunAssertionGroupLength(EPServiceProvider epService)
{
EPStatement stmtCreateWin = epService.EPAdministrator.CreateEPL
("create window RevQuote#groupwin(P1)#length(2) as select * from RevisableQuote");
epService.EPAdministrator.CreateEPL
("insert into RevQuote select * from FullEvent");
epService.EPAdministrator.CreateEPL
("insert into RevQuote select * from D1");
epService.EPAdministrator.CreateEPL
("insert into RevQuote select * from D5");
EPStatement consumerOne = epService.EPAdministrator.CreateEPL
("select irstream * from RevQuote order by K0 asc");
var listenerOne = new SupportUpdateListener();
consumerOne.Events += listenerOne.Update;
epService.EPRuntime.SendEvent(new SupportRevisionFull("a", "P1", "a50"));
epService.EPRuntime.SendEvent(new SupportDeltaFive("a", "P1", "a51"));
epService.EPRuntime.SendEvent(new SupportRevisionFull("b", "P2", "b50"));
epService.EPRuntime.SendEvent(new SupportRevisionFull("c", "P3", "c50"));
epService.EPRuntime.SendEvent(new SupportDeltaFive("d", "P3", "d50"));
listenerOne.Reset();
EPAssertionUtil.AssertPropsPerRow(stmtCreateWin.GetEnumerator(), _fields, new object[][] { new object[] { "a", "P1", "a51" }, new object[] { "b", "P2", "b50" }, new object[] { "c", "P3", "c50" } });
epService.EPRuntime.SendEvent(new SupportDeltaFive("b", "P1", "b51"));
EPAssertionUtil.AssertProps(listenerOne.LastNewData[0], _fields, new object[] { "b", "P1", "b51" });
EPAssertionUtil.AssertProps(listenerOne.LastOldData[0], _fields, new object[] { "b", "P2", "b50" });
listenerOne.Reset();
EPAssertionUtil.AssertPropsPerRow(stmtCreateWin.GetEnumerator(), _fields, new object[][] { new object[] { "a", "P1", "a51" }, new object[] { "b", "P1", "b51" }, new object[] { "c", "P3", "c50" } });
epService.EPRuntime.SendEvent(new SupportDeltaFive("c", "P1", "c51"));
EPAssertionUtil.AssertProps(listenerOne.LastNewData[0], _fields, new object[] { "c", "P1", "c51" });
EPAssertionUtil.AssertProps(listenerOne.LastOldData[1], _fields, new object[] { "c", "P3", "c50" });
EPAssertionUtil.AssertProps(listenerOne.LastOldData[0], _fields, new object[] { "a", "P1", "a51" });
listenerOne.Reset();
EPAssertionUtil.AssertPropsPerRow(stmtCreateWin.GetEnumerator(), _fields, new object[][] { new object[] { "b", "P1", "b51" }, new object[] { "c", "P1", "c51" } });
epService.EPAdministrator.DestroyAllStatements();
}
private void RunRangeAssertion(EPServiceProvider epService, bool indexShare, bool buildIndex)
{
string createEpl = "create window MyWindow#keepall as select * from SupportBean";
if (indexShare)
{
createEpl = "@Hint('enable_window_subquery_indexshare') " + createEpl;
}
epService.EPAdministrator.CreateEPL(createEpl);
if (buildIndex)
{
epService.EPAdministrator.CreateEPL("create index idx1 on MyWindow(IntPrimitive btree)");
}
epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean");
// preload
for (int i = 0; i < 10000; i++)
{
epService.EPRuntime.SendEvent(new SupportBean("E1", i));
}
string[] fields = "cols.mini,cols.maxi".Split(',');
string queryEpl = "select (select min(IntPrimitive) as mini, max(IntPrimitive) as maxi from MyWindow where IntPrimitive between sbr.rangeStart and sbr.rangeEnd) as cols from SupportBeanRange sbr";
EPStatement stmt = epService.EPAdministrator.CreateEPL(queryEpl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
long startTime = DateTimeHelper.CurrentTimeMillis;
for (int i = 0; i < 1000; i++)
{
epService.EPRuntime.SendEvent(new SupportBeanRange("R1", "K", 300, 312));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 300, 312 });
}
long delta = DateTimeHelper.CurrentTimeMillis - startTime;
Assert.IsTrue(delta < 500, "delta=" + delta);
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionEventTypeColumnDef(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum)
{
EPStatement stmtSchema = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema SchemaOne(col1 int, col2 int)");
Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtSchema.EventType.UnderlyingType));
EPStatement stmt = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window SchemaWindow#lastevent as (s1 SchemaOne)");
Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmt.EventType.UnderlyingType));
var listenerWindow = new SupportUpdateListener();
stmt.Events += listenerWindow.Update;
epService.EPAdministrator.CreateEPL("insert into SchemaWindow (s1) select sone from SchemaOne as sone");
if (eventRepresentationEnum.IsObjectArrayEvent())
{
epService.EPRuntime.SendEvent(new object[] { 10, 11 }, "SchemaOne");
}
else if (eventRepresentationEnum.IsMapEvent())
{
var theEvent = new LinkedHashMap <string, object>();
theEvent.Put("col1", 10);
theEvent.Put("col2", 11);
epService.EPRuntime.SendEvent(theEvent, "SchemaOne");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var theEvent = new GenericRecord(SupportAvroUtil.GetAvroSchema(epService, "SchemaOne").AsRecordSchema());
theEvent.Put("col1", 10);
theEvent.Put("col2", 11);
epService.EPRuntime.SendEventAvro(theEvent, "SchemaOne");
}
else
{
Assert.Fail();
}
EPAssertionUtil.AssertProps(listenerWindow.AssertOneGetNewAndReset(), "s1.col1,s1.col2".Split(','), new object[] { 10, 11 });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("SchemaOne", true);
epService.EPAdministrator.Configuration.RemoveEventType("SchemaWindow", true);
}
private void RunAssertionHash(String ctx, EPStatementSPI statement, HashCodeFunc codeFunc)
{
var fields = "c0,c1,c2".Split(',');
_epService.EPRuntime.SendEvent(new SupportBean("E1", 5));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E1", 5 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E1", 5 } });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 6));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E2", 6 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E1", 5 }, new Object[] { ctx, "E2", 6 } });
_epService.EPRuntime.SendEvent(new SupportBean("E3", 7));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E3", 7 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E1", 5 }, new Object[] { ctx, "E3", 7 }, new Object[] { ctx, "E2", 6 } });
_epService.EPRuntime.SendEvent(new SupportBean("E4", 8));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E4", 8 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E1", 5 }, new Object[] { ctx, "E3", 7 }, new Object[] { ctx, "E4", 8 }, new Object[] { ctx, "E2", 6 } });
_epService.EPRuntime.SendEvent(new SupportBean("E5", 9));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E5", 9 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E5", 9 }, new Object[] { ctx, "E1", 5 }, new Object[] { ctx, "E3", 7 }, new Object[] { ctx, "E4", 8 }, new Object[] { ctx, "E2", 6 } });
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E1", 15 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E5", 9 }, new Object[] { ctx, "E1", 15 }, new Object[] { ctx, "E3", 7 }, new Object[] { ctx, "E4", 8 }, new Object[] { ctx, "E2", 6 } });
_epService.EPRuntime.SendEvent(new SupportBean("E4", 11));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { ctx, "E4", 19 });
AssertIterator(statement, fields, new Object[][] { new Object[] { ctx, "E5", 9 }, new Object[] { ctx, "E1", 15 }, new Object[] { ctx, "E3", 7 }, new Object[] { ctx, "E4", 19 }, new Object[] { ctx, "E2", 6 } });
statement.Stop();
AgentInstanceAssertionUtil.AssertInstanceCounts(statement.StatementContext, 0, 0, 0, 0);
Assert.AreEqual(1, _spi.ContextManagementService.ContextCount);
_epService.EPAdministrator.GetStatement("context").Dispose();
Assert.AreEqual(1, _spi.ContextManagementService.ContextCount);
statement.Dispose();
Assert.AreEqual(0, _spi.ContextManagementService.ContextCount);
}
public void TestEngineMetrics()
{
_epService = EPServiceProviderManager.GetProvider("MyURI", GetConfig(10000, -1, true));
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
String[] engineFields = "engineURI,timestamp,inputCount,inputCountDelta,scheduleDepth".Split(',');
SendTimer(1000);
String text = "select * from " + typeof(EngineMetric).FullName;
EPStatement stmt = _epService.EPAdministrator.CreateEPL(text);
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean());
SendTimer(10999);
Assert.IsFalse(_listener.IsInvoked);
_epService.EPAdministrator.CreateEPL("select * from pattern[timer:interval(5 sec)]");
SendTimer(11000);
EventBean theEvent = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, engineFields, new Object[] { "MyURI", 11000L, 1L, 1L, 1L });
_epService.EPRuntime.SendEvent(new SupportBean());
_epService.EPRuntime.SendEvent(new SupportBean());
SendTimer(20000);
SendTimer(21000);
theEvent = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, engineFields, new Object[] { "MyURI", 21000L, 4L, 3L, 0L });
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestOuterJoin1Access()
{
_epService.EPAdministrator.Configuration.AddEventType("S0", typeof(SupportBean_S0));
_epService.EPAdministrator.Configuration.AddEventType("S1", typeof(SupportBean_S1));
string epl = "select " +
"sa.id as aid, " +
"sb.id as bid, " +
"first(sb.p10) as fb, " +
"window(sb.p10) as wb, " +
"last(sb.p10) as lb " +
"from S0#keepall as sa " +
"left outer join " +
"S1#keepall as sb " +
"on sa.id = sb.id";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_listener);
string[] fields = "aid,bid,fb,wb,lb".Split(',');
_epService.EPRuntime.SendEvent(new SupportBean_S0(1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new object[] { 1, null, null, null, null });
_epService.EPRuntime.SendEvent(new SupportBean_S1(1, "A"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new object[] { 1, 1, "A", Split("A"), "A" });
_epService.EPRuntime.SendEvent(new SupportBean_S1(2, "B"));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "A"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new object[] { 2, 2, "A", Split("A,B"), "B" });
_epService.EPRuntime.SendEvent(new SupportBean_S1(3, "C"));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(3, "C"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new object[] { 3, 3, "A", Split("A,B,C"), "C" });
}
public void TestIntersectSorted()
{
Init(false);
var fields = new String[] { "TheString" };
var stmt = _epService.EPAdministrator.CreateEPL("select irstream TheString from SupportBean#sort(2, IntPrimitive)#sort(2, IntBoxed) retain-intersection");
stmt.Events += _listener.Update;
SendEvent("E1", 1, 10);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E1" });
SendEvent("E2", 2, 9);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E1", "E2"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E2" });
SendEvent("E3", 0, 0);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E3"));
Object[] result = { _listener.LastOldData[0].Get("TheString"), _listener.LastOldData[1].Get("TheString") };
EPAssertionUtil.AssertEqualsAnyOrder(result, new String[] { "E1", "E2" });
EPAssertionUtil.AssertProps(_listener.AssertOneGetNew(), fields, new Object[] { "E3" });
_listener.Reset();
SendEvent("E4", -1, -1);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E3", "E4"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E4" });
SendEvent("E5", 1, 1);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E3", "E4"));
Assert.AreEqual(1, _listener.LastOldData.Length);
EPAssertionUtil.AssertProps(_listener.AssertOneGetOld(), fields, new Object[] { "E5" });
EPAssertionUtil.AssertProps(_listener.AssertOneGetNew(), fields, new Object[] { "E5" });
_listener.Reset();
SendEvent("E6", 0, 0);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, ToArr("E4", "E6"));
Assert.AreEqual(1, _listener.LastOldData.Length);
EPAssertionUtil.AssertProps(_listener.AssertOneGetOld(), fields, new Object[] { "E3" });
EPAssertionUtil.AssertProps(_listener.AssertOneGetNew(), fields, new Object[] { "E6" });
_listener.Reset();
}
private void TryAssertionFromClauseOutputFirstWhere(EPServiceProvider epService, bool soda)
{
var fieldsOrderId = "oe.orderdetail.OrderId".Split(',');
var epl = "on OrderEvent as oe " +
"insert into HeaderEvent select orderdetail.OrderId as OrderId where 1=2 " +
"insert into StreamOne select * from [select oe, * from orderdetail.Items] where productId=\"10020\" " +
"insert into StreamTwo select * from [select oe, * from orderdetail.Items] where productId=\"10022\" " +
"insert into StreamThree select * from [select oe, * from orderdetail.Items] where productId in (\"10020\",\"10025\",\"10022\")";
SupportModelHelper.CreateByCompileOrParse(epService, soda, epl);
var listeners = GetListeners();
var listenerEPL = new[] { "select * from StreamOne", "select * from StreamTwo", "select * from StreamThree" };
for (var i = 0; i < listenerEPL.Length; i++)
{
epService.EPAdministrator.CreateEPL(listenerEPL[i]).Events += listeners[i].Update;
listeners[i].Reset();
}
epService.EPRuntime.SendEvent(OrderBeanFactory.MakeEventOne());
EPAssertionUtil.AssertProps(listeners[0].AssertOneGetNewAndReset(), fieldsOrderId, new object[] { "PO200901" });
Assert.IsFalse(listeners[1].IsInvoked);
Assert.IsFalse(listeners[2].IsInvoked);
epService.EPRuntime.SendEvent(OrderBeanFactory.MakeEventTwo());
Assert.IsFalse(listeners[0].IsInvoked);
EPAssertionUtil.AssertProps(listeners[1].AssertOneGetNewAndReset(), fieldsOrderId, new object[] { "PO200902" });
Assert.IsFalse(listeners[2].IsInvoked);
epService.EPRuntime.SendEvent(OrderBeanFactory.MakeEventThree());
Assert.IsFalse(listeners[0].IsInvoked);
Assert.IsFalse(listeners[1].IsInvoked);
EPAssertionUtil.AssertProps(listeners[2].AssertOneGetNewAndReset(), fieldsOrderId, new object[] { "PO200903" });
epService.EPRuntime.SendEvent(OrderBeanFactory.MakeEventFour());
Assert.IsFalse(listeners[0].IsInvoked);
Assert.IsFalse(listeners[1].IsInvoked);
Assert.IsFalse(listeners[2].IsInvoked);
epService.EPAdministrator.DestroyAllStatements();
}
public void TestGroupByEventPerGroupUnidirectionalJoin()
{
_epService.EPAdministrator.CreateEPL("@Name('context') create context SegmentedByString partition by TheString from SupportBean");
var fieldsOne = "IntPrimitive,col1".Split(',');
var stmtOne = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString " +
"select IntPrimitive, Count(*) as col1 " +
"from SupportBean unidirectional, SupportBean_S0.win:keepall() " +
"group by IntPrimitive order by IntPrimitive asc");
stmtOne.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
_epService.EPRuntime.SendEvent(new SupportBean_S0(1));
_epService.EPRuntime.SendEvent(new SupportBean_S0(2));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 10, 2L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(3));
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 10, 3L });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 20));
_epService.EPRuntime.SendEvent(new SupportBean_S0(4));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G2", 20));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 20, 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(5));
_epService.EPRuntime.SendEvent(new SupportBean("G2", 20));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 20, 2L });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 10, 5L });
stmtOne.Dispose();
}
public void TestJoin()
{
SendTimeEvent("2002-05-01T08:00:00.000");
_epService.EPAdministrator.CreateEPL("create context NineToFive as start (0, 9, *, *, *) end (0, 17, *, *, *)");
var fields = "col1,col2,col3,col4".Split(',');
var listener = new SupportUpdateListener();
var statement = _epService.EPAdministrator.CreateEPL("context NineToFive " +
"select sb.theString as col1, sb.intPrimitive as col2, s0.id as col3, s0.p00 as col4 " +
"from SupportBean#keepall as sb full outer join SupportBean_S0#keepall as s0 on p00 = theString", listener);
statement.AddListener(listener);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "E1"));
Assert.IsFalse(listener.IsInvoked);
// now started
SendTimeEvent("2002-05-01T09:00:00.000");
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "E1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, null, 1, "E1" });
_epService.EPRuntime.SendEvent(new SupportBean("E1", 5));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", 5, 1, "E1" });
// now gone
SendTimeEvent("2002-05-01T17:00:00.000");
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "E1"));
Assert.IsFalse(listener.IsInvoked);
// now started
SendTimeEvent("2002-05-02T09:00:00.000");
SendTimeEvent("2002-05-01T09:00:00.000");
_epService.EPRuntime.SendEvent(new SupportBean("E1", 4));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", 4, null, null });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "E1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", 4, 2, "E1" });
}
public void Run(RegressionEnvironment env)
{
var fields = new [] { "cb","cnb","c","pct" };
var epl =
"@Name('s0') select count(*,BoolPrimitive) as cb, count(*,not BoolPrimitive) as cnb, count(*) as c, count(*,BoolPrimitive)/count(*) as pct from SupportBean#length(3)";
env.CompileDeploy(epl).AddListener("s0");
AssertStatelessStmt(env, "s0", false);
env.SendEventBean(MakeSB(true));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {1L, 0L, 1L, 1d});
env.Milestone(0);
env.SendEventBean(MakeSB(false));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {1L, 1L, 2L, 0.5d});
env.SendEventBean(MakeSB(false));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {1L, 2L, 3L, 1 / 3d});
env.Milestone(1);
env.SendEventBean(MakeSB(false));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {0L, 3L, 3L, 0d});
env.UndeployAll();
env.EplToModelCompileDeploy(epl);
env.UndeployAll();
}
private void TryAssertionHaving(EPServiceProvider epService, SupportUpdateListener listener)
{
SendEvent(epService, "SYM1", 10d);
SendEvent(epService, "SYM1", 11d);
SendEvent(epService, "SYM1", 9);
SendTimer(epService, 1000);
string[] fields = "symbol,avgPrice".Split(',');
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "SYM1", 10.5 });
SendEvent(epService, "SYM1", 13d);
SendEvent(epService, "SYM1", 10d);
SendEvent(epService, "SYM1", 9);
SendTimer(epService, 2000);
Assert.AreEqual(3, listener.LastNewData.Length);
Assert.IsNull(listener.LastOldData);
EPAssertionUtil.AssertPropsPerRow(listener.LastNewData, fields,
new object[][] { new object[] { "SYM1", 43 / 4.0 }, new object[] { "SYM1", 53.0 / 5.0 }, new object[] { "SYM1", 62 / 6.0 } });
}
public void TestUpdateNonPropertySet() {
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("increaseIntCopyDouble", this.GetType().FullName, "IncreaseIntCopyDouble");
_epService.EPAdministrator.CreateEPL("create window MyWindow.win:keepall() as SupportBean");
_epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean");
EPStatement stmt = _epService.EPAdministrator.CreateEPL("on SupportBean_S0 as sb " +
"merge MyWindow as mywin when matched then " +
"update set mywin.set_DoublePrimitive(id), increaseIntCopyDouble(initial, mywin)");
stmt.AddListener(_mergeListener);
string[] fields = "IntPrimitive,DoublePrimitive,DoubleBoxed".Split(',');
_epService.EPRuntime.SendEvent(MakeSupportBean("E1", 10, 2));
_epService.EPRuntime.SendEvent(new SupportBean_S0(5, "E1"));
EPAssertionUtil.AssertProps(_mergeListener.GetAndResetLastNewData()[0], fields, new object[]{11, 5d, 5d});
// try a case-statement
string eplCase = "on SupportBean_S0 merge MyWindow " +
"when matched then update set TheString = " +
"case IntPrimitive when 1 then 'a' else 'b' end";
_epService.EPAdministrator.CreateEPL(eplCase);
}
public void Run(RegressionEnvironment env)
{
var fields = "resOne, resTwo".SplitCsv();
var epl = "@Name('s0') select 1 in (IntCol, LongCol) as resOne, 1 not in (LongCol, IntCol) as resTwo from SupportBeanArrayCollMap";
env.CompileDeploy(epl).AddListener("s0");
SendArrayCollMap(env, new SupportBeanArrayCollMap(true, new[] { 10, 20, 30 }, null));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, false, true);
SendArrayCollMap(env, new SupportBeanArrayCollMap(true, new[] { 10, 20, 1 }, null));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, true, false);
SendArrayCollMap(env, new SupportBeanArrayCollMap(true, new[] { 30 }, new long?[] { 20L, 1L }));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, false, true);
SendArrayCollMap(env, new SupportBeanArrayCollMap(true, new int[] { }, new long?[] { null, 1L }));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, false, true);
SendArrayCollMap(env, new SupportBeanArrayCollMap(true, null, new long?[] { 1L, 100L }));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, false, true);
env.UndeployAll();
}
public void TestModelAfterMap()
{
// create window
var stmtTextCreate = "create window MyWindow#keepall select * from MyMap";
var stmtCreate = _epService.EPAdministrator.CreateEPL(stmtTextCreate);
Assert.IsTrue(stmtCreate.EventType is MapEventType);
// create insert into
var stmtTextInsertOne = "insert into MyWindow select * from MyMap";
var stmt = _epService.EPAdministrator.CreateEPL(stmtTextInsertOne);
stmt.AddListener(_listenerWindow);
SendMap("k1", 100L, 200L);
var theEvent = _listenerWindow.AssertOneGetNewAndReset();
Assert.IsTrue(theEvent is MappedEventBean);
EPAssertionUtil.AssertProps(theEvent, "key,primitive".Split(','), new object[] { "k1", 100L });
}
private static void TryReturnObject(
RegressionEnvironment env,
string dialect)
{
var expression =
$"@Name('s0') expression {typeof(SupportBean).FullName} {dialect}" +
$":callIt() [ var beanType = host.resolveType('{typeof(SupportBean).FullName}'); return host.newObj(beanType, 'E1', 10); ]";
env.CompileDeploy(
expression + " select callIt() as val0, callIt().GetTheString() as val1 from SupportBean as sb")
.AddListener("s0");
Assert.AreEqual(typeof(SupportBean), env.Statement("s0").EventType.GetPropertyType("val0"));
env.SendEventBean(new SupportBean());
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
new[] {"val0.TheString", "val0.IntPrimitive", "val1"},
new object[] {"E1", 10, "E1"});
env.UndeployAll();
}
public void TestObjectWithArg()
{
var joinStatement = "select id, theString from " +
typeof(SupportBean).Name + "().win:length(3) as s1, " +
" method:com.espertech.esper.support.epl.SupportStaticMethodLib.FetchObject(theString)";
var stmt = _epService.EPAdministrator.CreateEPL(joinStatement);
stmt.AddListener(_listener);
var fields = new string[] { "id", "theString" };
SendBeanEvent("E1");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "|E1|", "E1" });
SendBeanEvent(null);
Assert.IsFalse(_listener.IsInvoked);
SendBeanEvent("E2");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "|E2|", "E2" });
}
public void TestWhereClauseNoIndexNoCache()
{
String stmtText = "select id, mycol3, mycol2 from " +
typeof(SupportBean_S0).FullName + "#keepall as s0," +
" sql:MyDB ['select mycol3, mycol2 from mytesttable_large'] as s1 where s0.id = s1.mycol3";
EPStatement statement = _epServiceRetained.EPAdministrator.CreateEPL(stmtText);
_listener = new SupportUpdateListener();
statement.Events += _listener.Update;
for (int i = 0; i < 20; i++)
{
var num = i + 1;
var col2 = Convert.ToString(Math.Round((float)num / 10, MidpointRounding.AwayFromZero));
var bean = new SupportBean_S0(num);
_epServiceRetained.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), new String[] { "id", "mycol3", "mycol2" }, new Object[] { num, num, col2 });
}
}
public void TestNoJoinNoAliasWithProperties()
{
var viewExpr = "select IntPrimitive as a, string.*, IntPrimitive as b from " + typeof(SupportBean).FullName + ".win:length(3) as string";
var selectTestView = _epService.EPAdministrator.CreateEPL(viewExpr);
selectTestView.AddListener(_testListener);
var type = selectTestView.EventType;
Assert.AreEqual(22, type.PropertyNames.Length);
Assert.AreEqual(typeof(Pair <object, DataMap>), type.UnderlyingType);
Assert.AreEqual(typeof(int?), type.GetPropertyType("a"));
Assert.AreEqual(typeof(int?), type.GetPropertyType("b"));
Assert.AreEqual(typeof(string), type.GetPropertyType("TheString"));
SendBeanEvent("E1", 10);
var fields = new string[] { "a", "TheString", "IntPrimitive", "b" };
EPAssertionUtil.AssertProps(_testListener.AssertOneGetNewAndReset(), fields, new object[] { 10, "E1", 10, 10 });
}
public void TestArrayParameter()
{
_epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
_epService.EPAdministrator.Configuration.AddImport(typeof(SupportStaticMethodLib));
var text = "select " +
"SupportStaticMethodLib.ArraySumIntBoxed({1,2,null,3,4}) as v1, " +
"SupportStaticMethodLib.ArraySumDouble({1,2,3,4.0}) as v2, " +
"SupportStaticMethodLib.ArraySumString({'1','2','3','4'}) as v3, " +
"SupportStaticMethodLib.ArraySumObject({'1',2,3.0,'4.0'}) as v4 " +
" from " + typeof(SupportBean).FullName;
_listener = new SupportUpdateListener();
var stmt = _epService.EPAdministrator.CreateEPL(text);
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "v1,v2,v3,v4".Split(','), new Object[] { 10, 10d, 10d, 10d });
}
private void RunAssertionJoinWInnerKeywordWOOnClause(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType<SupportBean>();
var fields = "a.TheString,b.TheString".Split(',');
var epl =
"select * from SupportBean(TheString like 'A%')#length(3) as a inner join SupportBean(TheString like 'B%')#length(3) as b " +
"where a.IntPrimitive = b.IntPrimitive";
var stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendEvent(epService, "A1", 1);
SendEvent(epService, "A2", 2);
SendEvent(epService, "A3", 3);
SendEvent(epService, "B2", 2);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] {"A2", "B2"});
stmt.Dispose();
}
private static void TryOverloaded(
RegressionEnvironment env,
string dialect)
{
var epl =
"@Name('s0') " +
$"expression int {dialect}:abc() [return 10;]\n" +
$"expression int {dialect}:abc(p1) [return p1*10;]\n" +
$"expression int {dialect}:abc(p1, p2) [return p1*p2*10]\n" +
"select abc() as c0, abc(2) as c1, abc(2,3) as c2 from SupportBean";
env.CompileDeploy(epl).AddListener("s0");
env.SendEventBean(new SupportBean());
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
new[] {"c0", "c1", "c2"},
new object[] {10, 20, 60});
env.UndeployAll();
}
public void TestPropertyInsertBean()
{
EPStatement stmtWindow = _epService.EPAdministrator.CreateEPL("create window MergeWindow.std:unique(TheString) as SupportBean");
string epl = "on SupportBean as up merge MergeWindow as mv where mv.TheString=up.TheString when not matched then insert select IntPrimitive";
EPStatement stmtMerge = _epService.EPAdministrator.CreateEPL(epl);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
EventBean theEvent = stmtWindow.First();
EPAssertionUtil.AssertProps(theEvent, "TheString,IntPrimitive".Split(','), new object[] { null, 10 });
stmtMerge.Dispose();
epl = "on SupportBean as up merge MergeWindow as mv where mv.TheString=up.TheString when not matched then insert select TheString, IntPrimitive";
_epService.EPAdministrator.CreateEPL(epl);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 20));
EPAssertionUtil.AssertPropsPerRow(stmtWindow.GetEnumerator(), "TheString,IntPrimitive".Split(','), new object[][] { new object[] { null, 10 }, new object[] { "E2", 20 } });
}
public void TestObjectArrayWithMap()
{
_epService.EPAdministrator.Configuration.AddEventType("MapType", Collections.SingletonDataMap("im", typeof(String)));
_epService.EPAdministrator.Configuration.AddEventType("OAType", "p0,p1,p2,p3".Split(','), new Object[] { typeof(String), "MapType", "MapType[]", Collections.SingletonDataMap("om", typeof(String)) });
EPStatement stmt = _epService.EPAdministrator.CreateEPL("select p0 as c0, p1.im as c1, p2[0].im as c2, p3.om as c3 from OAType");
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new Object[] { "E1", Collections.SingletonDataMap("im", "IM1"), new Map[] { Collections.SingletonDataMap("im", "IM2") }, Collections.SingletonDataMap("om", "OM1") }, "OAType");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "c0,c1,c2,c3".Split(','), new Object[] { "E1", "IM1", "IM2", "OM1" });
_epService.EPAdministrator.DestroyAllStatements();
// test inserting from array to map
_epService.EPAdministrator.CreateEPL("insert into MapType(im) select p0 from OAType").Events += _listener.Update;
_epService.EPRuntime.SendEvent(new Object[] { "E1", null, null, null }, "OAType");
Assert.That(_listener.AssertOneGetNew(), Is.InstanceOf <MappedEventBean>());
Assert.AreEqual("E1", _listener.AssertOneGetNew().Get("im"));
}
public void Run(RegressionEnvironment env)
{
var epl = "@Name('s0') select " +
"LevelOne.GetCustomLevelOne(10) as val0, " +
"LevelOne.LevelTwo.GetCustomLevelTwo(20) as val1, " +
"LevelOne.LevelTwo.LevelThree.GetCustomLevelThree(30) as val2 " +
"from SupportLevelZero";
env.CompileDeploy(epl).AddListener("s0");
env.SendEventBean(new SupportLevelZero(new SupportLevelOne(new SupportLevelTwo(new SupportLevelThree()))));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
"val0,val1,val2".SplitCsv(),
"level1:10",
"level2:20",
"level3:30");
env.UndeployAll();
}