public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
env.CompileDeploy(
"create table varaggMS (eventset window(*) @type(SupportBean), total sum(int))",
path);
env.CompileDeploy(
"into table varaggMS select window(*) as eventset, " +
"sum(IntPrimitive) as total from SupportBean#length(2)",
path);
env.CompileDeploy(
"on SupportBean_S0 merge varaggMS " +
"when matched then insert into ResultStream select eventset, total, eventset.takeLast(1) as c0",
path);
env.CompileDeploy("@Name('s0') select * from ResultStream", path).AddListener("s0");
var e1 = new SupportBean("E1", 15);
env.SendEventBean(e1);
AssertResultAggRead(
env,
new object[] {e1},
15);
env.Milestone(0);
var e2 = new SupportBean("E2", 20);
env.SendEventBean(e2);
AssertResultAggRead(
env,
new object[] {e1, e2},
35);
env.Milestone(1);
var e3 = new SupportBean("E3", 30);
env.SendEventBean(e3);
AssertResultAggRead(
env,
new object[] {e2, e3},
50);
env.UndeployAll();
}
private static IEnumerator <EventBean> MakeEnumerator(int[] values)
{
IList <EventBean> events = new List <EventBean>();
for (int i = 0; i < values.Length; i++)
{
var bean = new SupportBean();
bean.IntPrimitive = values[i];
EventBean theEvent = SupportEventBeanFactory.CreateObject(bean);
events.Add(theEvent);
}
return(TransformEventUtil.Transform(
events.GetEnumerator(),
eventBean => SupportEventBeanFactory.CreateObject(
new SupportBean_S0((int)eventBean.Get("IntPrimitive")))));
}
public void Run(RegressionEnvironment env)
{
var epl = "@Name('s0') select * from pattern[a=SupportBean() -> b=SupportBean(myCustomDecimalEquals(a.DecimalPrimitive, b.DecimalPrimitive))]";
env.CompileDeploy(epl).AddListener("s0");
var beanOne = new SupportBean("E1", 0);
beanOne.DecimalPrimitive = 13m;
env.SendEventBean(beanOne);
var beanTwo = new SupportBean("E2", 0);
beanTwo.DecimalPrimitive = 13m;
env.SendEventBean(beanTwo);
Assert.IsTrue(env.Listener("s0").IsInvoked);
env.UndeployAll();
}
public void TestConfiguredViaPropsAndXML()
{
var configuration = SupportConfigFactory.GetConfiguration();
configuration.EngineDefaults.EventMetaConfig.DefaultEventRepresentation =
EventRepresentation.OBJECTARRAY;
configuration.AddEventType(
"MyOAType",
"bean,TheString,map".Split(','),
new Object[]
{
typeof(SupportBean).FullName,
typeof(String).FullName,
typeof(Map).FullName
});
var epService = EPServiceProviderManager.GetDefaultProvider(configuration);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var eventType = epService.EPAdministrator.Configuration.GetEventType("MyOAType");
Assert.AreEqual(typeof(Object[]), eventType.UnderlyingType);
Assert.AreEqual(typeof(String), eventType.GetPropertyType("TheString"));
Assert.AreEqual(typeof(Map), eventType.GetPropertyType("map"));
Assert.AreEqual(typeof(SupportBean), eventType.GetPropertyType("bean"));
var stmt = epService.EPAdministrator.CreateEPL("select bean, TheString, map('key'), bean.TheString from MyOAType");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
Assert.AreEqual(typeof(Object[]), stmt.EventType.UnderlyingType);
var bean = new SupportBean("E1", 1);
epService.EPRuntime.SendEvent(new Object[] { bean, "abc", Collections.SingletonDataMap("key", "value") }, "MyOAType");
EPAssertionUtil.AssertProps(listener.AssertOneGetNew(), "bean,TheString,map('key'),bean.TheString".Split(','), new Object[] { bean, "abc", "value", "E1" });
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
private static void AssertReceived(
SupportListener listenerStmtOne,
SupportBean[] beans,
int[] indexesAll,
int[] indexesWhere,
string[] mapKeys,
object[] mapValues)
{
var received = listenerStmtOne.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsExactOrder(
SupportBean.GetBeansPerIndex(beans, indexesAll),
(object[]) received.Get("c0"));
EPAssertionUtil.AssertEqualsExactOrder(
SupportBean.GetBeansPerIndex(beans, indexesWhere),
(ICollection<object>) received.Get("c1"));
EPAssertionUtil.AssertPropsMap((IDictionary<object, object>) received.Get("c2"), mapKeys, mapValues);
}
private void SendEventWithDouble(byte?byteBoxed,
short?shortBoxed,
int?intBoxed,
long?longBoxed,
float?floatBoxed,
double?doubleBoxed)
{
var bean = new SupportBean();
bean.ByteBoxed = byteBoxed;
bean.ShortBoxed = shortBoxed;
bean.IntBoxed = intBoxed;
bean.LongBoxed = longBoxed;
bean.FloatBoxed = floatBoxed;
bean.DoubleBoxed = doubleBoxed;
_epService.EPRuntime.SendEvent(bean);
}
public static IList<FilterTestMultiStmtExecution> Executions(bool withStats)
{
IList<FilterTestMultiStmtPermutable> cases = new List<FilterTestMultiStmtPermutable>();
// no filter
AddCase(
cases,
MakeSingleStat("P0=(fh:1,fi:0),P1=(fh:0,fi:0)"),
"",
MakeItem(SupportBean.MakeBean("E1"), true)); // no filter
return FilterTestMultiStmtRunner.ComputePermutations(
typeof(ExprFilterPlanNoFilter),
new PermutationSpec(true),
cases,
withStats);
}
private static void SendAndAssert1(
RegressionEnvironment env,
int? intBoxed,
float? floatBoxed,
double doublePrimitive,
bool? result)
{
var bean = new SupportBean();
bean.IntBoxed = intBoxed;
bean.FloatBoxed = floatBoxed;
bean.DoublePrimitive = doublePrimitive;
env.SendEventBean(bean);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreEqual(result, theEvent.Get("result"));
}
private static void SendAndAssert3(
RegressionEnvironment env,
int intPrimitive,
int shortBoxed,
long? longBoxed,
bool? result)
{
var bean = new SupportBean();
bean.IntPrimitive = intPrimitive;
bean.ShortBoxed = (short) shortBoxed;
bean.LongBoxed = longBoxed;
env.SendEventBean(bean);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreEqual(result, theEvent.Get("result"));
}
public void Run(RegressionEnvironment env)
{
var stmtTextSet =
"@Name('set') on SupportBean set p_1 = TheString, p_2 = BoolBoxed, p_3 = IntBoxed, p_4 = IntBoxed";
env.CompileDeploy(stmtTextSet).AddListener("set");
string[] fieldsVar = {"p_1", "p_2", "p_3", "p_4"};
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("set"),
fieldsVar,
new[] {new object[] {null, true, 10L, 11.1d}});
var typeSet = env.Statement("set").EventType;
Assert.AreEqual(typeof(string), typeSet.GetPropertyType("p_1"));
Assert.AreEqual(typeof(bool?), typeSet.GetPropertyType("p_2"));
Assert.AreEqual(typeof(long?), typeSet.GetPropertyType("p_3"));
Assert.AreEqual(typeof(double?), typeSet.GetPropertyType("p_4"));
Array.Sort(typeSet.PropertyNames);
CollectionAssert.AreEquivalent(fieldsVar, typeSet.PropertyNames);
var bean = new SupportBean();
bean.TheString = "text";
bean.BoolBoxed = false;
bean.IntBoxed = 200;
env.SendEventBean(bean);
EPAssertionUtil.AssertProps(
env.Listener("set").AssertOneGetNewAndReset(),
fieldsVar,
new object[] {"text", false, 200L, 200d});
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("set"),
fieldsVar,
new[] {new object[] {"text", false, 200L, 200d}});
bean = new SupportBean(); // leave all fields null
env.SendEventBean(bean);
EPAssertionUtil.AssertProps(
env.Listener("set").AssertOneGetNewAndReset(),
fieldsVar,
new object[] {null, null, null, null});
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("set"),
fieldsVar,
new[] {new object[] {null, null, null, null}});
env.UndeployAll();
}
private void RunAssertionAddNameClass(EPServiceProvider epService)
{
TryInvalid(epService, "AddedName");
// First statement with new name
epService.EPAdministrator.Configuration.AddEventType("AddedName", typeof(SupportBean));
Assert.IsTrue(epService.EPAdministrator.Configuration.IsEventTypeExists("AddedName"));
EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from AddedName");
var testListener = new SupportUpdateListener();
stmt.Events += testListener.Update;
var eventOne = new SupportBean("a", 1);
epService.EPRuntime.SendEvent(eventOne);
Assert.AreSame(eventOne, testListener.AssertOneGetNewAndReset().Underlying);
TryInvalid(epService, "AddedNameSecond");
// Second statement using a new alias to the same type, should both receive
epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean));
var testListenerTwo = new SupportUpdateListener();
stmt = epService.EPAdministrator.CreateEPL("select * from AddedNameSecond");
stmt.Events += testListenerTwo.Update;
var eventTwo = new SupportBean("b", 2);
epService.EPRuntime.SendEvent(eventTwo);
Assert.AreSame(eventTwo, testListener.AssertOneGetNewAndReset().Underlying);
Assert.AreSame(eventTwo, testListenerTwo.AssertOneGetNewAndReset().Underlying);
// Add the same name and type again
epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean));
// Add the same name and a different type
try {
epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean_A));
Assert.Fail();
} catch (ConfigurationException) {
// expected
}
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("AddedNameSecond", true);
}
public void TestPropertiesSimplePattern()
{
SetupSimplePattern("a, a as myEvent, a.IntPrimitive as MyInt, a.TheString");
SupportBean theEvent = new SupportBean();
theEvent.IntPrimitive = 1;
theEvent.TheString = "test";
_epService.EPRuntime.SendEvent(theEvent);
EventBean eventBean = _updateListener.AssertOneGetNewAndReset();
Assert.AreSame(theEvent, eventBean.Get("a"));
Assert.AreSame(theEvent, eventBean.Get("myEvent"));
Assert.AreEqual(1, eventBean.Get("MyInt"));
Assert.AreEqual("test", eventBean.Get("a.TheString"));
}
public void TestMultirowUnderlyingCorrelated()
{
String stmtText = "select p00, " +
"(select Window(sb.*) from SupportBean.win:keepall() sb where TheString = s0.P00) as val " +
"from S0 as s0";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
Object[][] rows = new Object[][] {
new Object[] { "p00", typeof(string) },
new Object[] { "val", typeof(SupportBean[]) }
};
for (int i = 0; i < rows.Length; i++)
{
String message = "Failed assertion for " + rows[i][0];
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "T1"));
Assert.IsNull(_listener.AssertOneGetNewAndReset().Get("val"));
SupportBean sb1 = new SupportBean("T1", 10);
_epService.EPRuntime.SendEvent(sb1);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "T1"));
EventBean received = _listener.AssertOneGetNewAndReset();
Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType());
EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb1 });
SupportBean sb2 = new SupportBean("T2", 20);
_epService.EPRuntime.SendEvent(sb2);
SupportBean sb3 = new SupportBean("T2", 30);
_epService.EPRuntime.SendEvent(sb3);
_epService.EPRuntime.SendEvent(new SupportBean_S0(3, "T2"));
received = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb2, sb3 });
}
private void RunAssertionOnSelectEqualsAndRangePerformance(EPServiceProvider epService)
{
// create window one
epService.EPAdministrator.CreateEPL("create window MyWindow#keepall as SupportBean");
epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean");
// insert X rows
int maxRows = 10000; //for performance testing change to int maxRows = 100000;
for (int i = 0; i < maxRows; i++)
{
var bean = new SupportBean((i < 5000) ? "A" : "B", i);
bean.LongPrimitive = i;
bean.LongBoxed = (i + 1);
epService.EPRuntime.SendEvent(bean);
}
epService.EPRuntime.SendEvent(new SupportBean("B", 100));
string eplIdx1One = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive = sbr.rangeStart";
RunOnDemandAssertion(epService, eplIdx1One, 1, new SupportBeanRange("R", 5501, 0), 5501);
string eplIdx1Two = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive between sbr.rangeStart and sbr.rangeEnd";
RunOnDemandAssertion(epService, eplIdx1Two, 1, new SupportBeanRange("R", 5501, 5503), 5501 + 5502 + 5503);
string eplIdx1Three = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where TheString = key and IntPrimitive between sbr.rangeStart and sbr.rangeEnd";
RunOnDemandAssertion(epService, eplIdx1Three, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998 + 4999);
string eplIdx1Four = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " +
"where TheString = key and LongPrimitive = rangeStart and IntPrimitive between rangeStart and rangeEnd " +
"and LongBoxed between rangeStart and rangeEnd";
RunOnDemandAssertion(epService, eplIdx1Four, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998);
string eplIdx1Five = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " +
"where IntPrimitive between rangeStart and rangeEnd " +
"and LongBoxed between rangeStart and rangeEnd";
RunOnDemandAssertion(epService, eplIdx1Five, 1, new SupportBeanRange("R", "A", 4998, 5001), 4998 + 4999 + 5000);
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
}
public void TestOnSelectEqualsAndRangePerformance()
{
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
_epService.EPAdministrator.Configuration.AddEventType("SupportBeanRange", typeof(SupportBeanRange));
// create window one
_epService.EPAdministrator.CreateEPL("create window MyWindow.win:keepall() as SupportBean");
_epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean");
// insert X rows
int maxRows = 10000; //for performance testing change to int maxRows = 100000;
for (int i = 0; i < maxRows; i++)
{
SupportBean bean = new SupportBean((i < 5000) ? "A" : "B", i);
bean.LongPrimitive = i;
bean.LongBoxed = ((long)i + 1);
_epService.EPRuntime.SendEvent(bean);
}
_epService.EPRuntime.SendEvent(new SupportBean("B", 100));
String eplIdx1One = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive = sbr.rangeStart";
RunOnDemandAssertion(eplIdx1One, 1, new SupportBeanRange("R", 5501, 0), 5501);
String eplIdx1Two = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive between sbr.rangeStart and sbr.rangeEnd";
RunOnDemandAssertion(eplIdx1Two, 1, new SupportBeanRange("R", 5501, 5503), 5501 + 5502 + 5503);
String eplIdx1Three = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where TheString = key and IntPrimitive between sbr.rangeStart and sbr.rangeEnd";
RunOnDemandAssertion(eplIdx1Three, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998 + 4999);
String eplIdx1Four = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " +
"where TheString = key and LongPrimitive = rangeStart and IntPrimitive between rangeStart and rangeEnd " +
"and LongBoxed between rangeStart and rangeEnd";
RunOnDemandAssertion(eplIdx1Four, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998);
String eplIdx1Five = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " +
"where IntPrimitive between rangeStart and rangeEnd " +
"and LongBoxed between rangeStart and rangeEnd";
RunOnDemandAssertion(eplIdx1Five, 1, new SupportBeanRange("R", "A", 4998, 5001), 4998 + 4999 + 5000);
}
private void RunAssertionUnmatchedSendEvent(EPServiceProvider epService)
{
var listener = new MyUnmatchedListener();
epService.EPRuntime.UnmatchedEvent += listener.Update;
// no statement, should be unmatched
SupportBean theEvent = SendEvent(epService, "E1");
Assert.AreEqual(1, listener.Received.Count);
Assert.AreSame(theEvent, listener.Received[0].Underlying);
listener.Reset();
// no unmatched listener
epService.EPRuntime.RemoveAllUnmatchedEventHandlers();
SendEvent(epService, "E1");
Assert.AreEqual(0, listener.Received.Count);
// create statement and re-register unmatched listener
EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from " + typeof(SupportBean).FullName);
epService.EPRuntime.UnmatchedEvent += listener.Update;
SendEvent(epService, "E1");
Assert.AreEqual(0, listener.Received.Count);
// stop statement
stmt.Stop();
theEvent = SendEvent(epService, "E1");
Assert.AreEqual(1, listener.Received.Count);
Assert.AreSame(theEvent, listener.Received[0].Underlying);
listener.Reset();
// start statement
stmt.Start();
SendEvent(epService, "E1");
Assert.AreEqual(0, listener.Received.Count);
// destroy statement
stmt.Dispose();
theEvent = SendEvent(epService, "E1");
Assert.AreEqual(1, listener.Received.Count);
Assert.AreSame(theEvent, listener.Received[0].Underlying);
epService.EPRuntime.RemoveAllUnmatchedEventHandlers();
}
public bool Call()
{
try
{
for (int loop = 0; loop < _numRepeats; loop++)
{
Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " sending event " + loop);
String id = Convert.ToString(_threadNum * 100000000 + loop);
SupportBean bean = new SupportBean(id, 0);
_engine.EPRuntime.SendEvent(bean);
for (int i = 0; i < _stmt.Length; i++)
{
Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " starting enumerator " + loop);
bool found = false;
using (var en = _stmt[i].GetSafeEnumerator())
{
while (en.MoveNext())
{
EventBean theEvent = en.Current;
if (theEvent.Get("TheString").Equals(id))
{
found = true;
}
}
}
Assert.IsTrue(found);
Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " end enumerator " + loop);
}
}
}
catch (AssertionException ex)
{
Log.Fatal("Assertion error in thread " + Thread.CurrentThread.ManagedThreadId, ex);
return(false);
}
catch (Exception e)
{
Log.Fatal("Error in thread " + Thread.CurrentThread.ManagedThreadId, e);
return(false);
}
return(true);
}
private void RunAssertionOuterJoinPlusWhere(EPServiceProvider epService)
{
var stmtText = "select TheString, mycol3, mycol1 from " +
" sql:MyDB ['select mycol1, mycol3 from mytesttable_large'] as s1 right outer join " +
typeof(SupportBean).FullName +
" as s0 on TheString = mycol1 where s1.mycol3 = s0.IntPrimitive";
var statement = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
statement.AddListener(listener);
// Send events which all perform the join
var startTime = PerformanceObserver.MilliTime;
for (var i = 0; i < 200; i++)
{
var beanX = new SupportBean();
beanX.TheString = ("50");
beanX.IntPrimitive = (50);
epService.EPRuntime.SendEvent(beanX);
EPAssertionUtil.AssertProps(
listener.AssertOneGetNewAndReset(), new string[] { "TheString", "mycol3", "mycol1" },
new object[] { "50", 50, "50" });
}
var endTime = PerformanceObserver.MilliTime;
// no matching on-clause
var bean = new SupportBean();
Assert.IsFalse(listener.IsInvoked);
// matching on-clause not matching where
bean = new SupportBean();
bean.TheString = ("50");
bean.IntPrimitive = (49);
epService.EPRuntime.SendEvent(bean);
Assert.IsFalse(listener.IsInvoked);
Log.Info("delta=" + (endTime - startTime));
Assert.IsTrue(endTime - startTime < 500);
statement.Dispose();
}
public void TestEPLtoOMtoStmt()
{
var stmtText = "select * from " + typeof(SupportBean).FullName;
var model = _epService.EPAdministrator.CompileEPL(stmtText);
SerializableObjectCopier.Copy(model);
EPStatement stmt = _epService.EPAdministrator.Create(model, "s1");
stmt.Events += _listener.Update;
Object theEvent = new SupportBean();
_epService.EPRuntime.SendEvent(theEvent);
Assert.AreEqual(theEvent, _listener.AssertOneGetNewAndReset().Underlying);
Assert.AreEqual(stmtText, stmt.Text);
Assert.AreEqual("s1", stmt.Name);
}
public void TestBindWildcardPlusProperties()
{
var subscriber = new MySubscriberRowByRowSpecific();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
"select *, IntPrimitive + 2, 'x'||TheString||'x' from "
+ typeof(SupportBean).FullName);
stmt.Subscriber = subscriber;
var s0 = new SupportBean("E1", 100);
_epService.EPRuntime.SendEvent(s0);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
s0, 102, "xE1x"
}
, subscriber.GetAndResetIndicate()[0]);
}
public void TestWildcardOrPattern()
{
SetupOrPattern("*");
Object theEvent = new SupportBean();
_epService.EPRuntime.SendEvent(theEvent);
EventBean eventBean = _updateListener.AssertOneGetNewAndReset();
Assert.AreSame(theEvent, eventBean.Get("a"));
Assert.IsNull(eventBean.Get("b"));
theEvent = SupportBeanComplexProps.MakeDefaultBean();
_epService.EPRuntime.SendEvent(theEvent);
eventBean = _updateListener.AssertOneGetNewAndReset();
Assert.AreSame(theEvent, eventBean.Get("b"));
Assert.IsNull(eventBean.Get("a"));
}
private void RunAssertionLookupSPI(RegressionEnvironment env)
{
var path = new RegressionPath();
env.CompileDeploy("create window MyVDW.test:vdwnoparam() as SupportBean", path);
var window = (SupportVirtualDW) GetFromContext(env, "/virtualdw/MyVDW");
var supportBean = new SupportBean("E1", 100);
window.Data = Collections.SingletonSet<object>(supportBean);
env.CompileDeploy(
"@Name('s0') select (select sum(IntPrimitive) from MyVDW vdw where vdw.TheString = S0.P00) from SupportBean_S0 S0",
path);
env.AddListener("s0");
var spiContext = (VirtualDataWindowLookupContextSPI) window.LastRequestedLookup;
Assert.IsNotNull(spiContext);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "BigInteger = any (null, 1)")
.WithExpression(fields[1], "BigInteger = any (2, 3)")
.WithExpression(fields[2], "DecimalPrimitive = any (null, 1)")
.WithExpression(fields[3], "DecimalPrimitive = any (2, 3)");
var bean = new SupportBean();
bean.BigInteger = BigInteger.One;
bean.DecimalPrimitive = 1.0m;
builder.WithAssertion(bean).Expect(fields, true, false, true, false);
builder.Run(env);
env.UndeployAll();
}
public void TestLateConsumerNoIterate()
{
// client-side
_epService.EPAdministrator.CreateEPL("create window MyVDW.test:vdw() as SupportBean");
var window = (SupportVirtualDW)GetFromContext("/virtualdw/MyVDW");
var supportBean = new SupportBean("E1", 100);
window.Data = Collections.SingletonSet <object>(supportBean);
var stmt = _epService.EPAdministrator.CreateEPL("select (select sum(IntPrimitive) from MyVDW vdw where vdw.TheString = s0.p00) from SupportBean_S0 s0");
stmt.AddListener(_listener);
var spiContext = (VirtualDataWindowLookupContextSPI)window.LastRequestedIndex;
// CM side
_epService.EPAdministrator.CreateEPL("create window MyWin.std:unique(TheString) as SupportBean");
_epService.EPAdministrator.CreateEPL("insert into MyWin select * from SupportBean");
}
private void TryCoalesceBeans(String viewExpr)
{
_epService.Initialize();
EPStatement selectTestView = _epService.EPAdministrator.CreateEPL(viewExpr);
selectTestView.Events += _testListener.Update;
SupportBean theEvent = SendEvent("s0");
EventBean eventReceived = _testListener.AssertOneGetNewAndReset();
Assert.AreEqual("s0", eventReceived.Get("MyString"));
Assert.AreSame(theEvent, eventReceived.Get("myBean"));
theEvent = SendEvent("s1");
eventReceived = _testListener.AssertOneGetNewAndReset();
Assert.AreEqual("s1", eventReceived.Get("MyString"));
Assert.AreSame(theEvent, eventReceived.Get("myBean"));
}
private void SendEventSetAssert(
RegressionEnvironment env,
string[] fieldSetOne)
{
SendBean(env, "E1", 10);
SendBean(env, "E2", 10);
SupportBean e3 = SendBean(env, "E3", 30);
EventBean row = env.GetEnumerator("table").Advance();
EPAssertionUtil.AssertProps(
row,
fieldSetOne,
new object[] {8.88888888888889d, 3L, 2L, 30, 10.0, 11.547005383792515d, "E1", 3L, e3});
Assert.AreEqual(-3, row.Get("myPluginAggSingle"));
Assert.AreEqual(3, (row.Get("myPluginAggAccess").AsObjectDictionary()).Count);
AssertCountMinSketch(env, "E1", 1);
}
public bool Call()
{
try {
for (int loop = 0; loop < _numRepeats; loop++)
{
var eventOne = new SupportBean();
eventOne.TheString = "E1_" + _threadKey;
_engine.EPRuntime.SendEvent(eventOne);
var eventTwo = new SupportMarketDataBean("E2_" + _threadKey, 0d, null, null);
_engine.EPRuntime.SendEvent(eventTwo);
}
} catch (Exception ex) {
Log.Error("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex);
return(false);
}
return(true);
}
public void TestBindWildcardIRStream()
{
var subscriber = new MySubscriberMultirowUnderlying();
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
"select irstream * from SupportBean.win:length_batch(2)");
stmt.Subscriber = subscriber;
var s0 = new SupportBean("E1", 100);
var s1 = new SupportBean("E2", 200);
_epService.EPRuntime.SendEvent(s0);
_epService.EPRuntime.SendEvent(s1);
Assert.AreEqual(1, subscriber.IndicateArr.Count);
UniformPair <SupportBean[]> beans = subscriber.GetAndResetIndicateArr()[0];
Assert.AreEqual(2, beans.First.Length);
Assert.AreEqual(null, beans.Second);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
s0, s1
}
, beans.First);
var s2 = new SupportBean("E3", 300);
var s3 = new SupportBean("E4", 400);
_epService.EPRuntime.SendEvent(s2);
_epService.EPRuntime.SendEvent(s3);
Assert.AreEqual(1, subscriber.IndicateArr.Count);
beans = subscriber.GetAndResetIndicateArr()[0];
Assert.AreEqual(2, beans.First.Length);
Assert.AreEqual(2, beans.Second.Length);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
s2, s3
}
, beans.First);
EPAssertionUtil.AssertEqualsExactOrder(new Object[]
{
s0, s1
}
, beans.Second);
}
public void Run(RegressionEnvironment env)
{
var stmtText = "@Name('s0') select P00, " +
"(select window(sb.*) from SupportBean#keepall sb where TheString = S0.P00) as val " +
"from SupportBean_S0 as S0";
env.CompileDeployAddListenerMileZero(stmtText, "s0");
object[][] rows = {
new object[] {"P00", typeof(string)},
new object[] {"val", typeof(SupportBean[])}
};
for (var i = 0; i < rows.Length; i++) {
var message = "Failed assertion for " + rows[i][0];
var prop = env.Statement("s0").EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
env.SendEventBean(new SupportBean_S0(1, "T1"));
Assert.IsNull(env.Listener("s0").AssertOneGetNewAndReset().Get("val"));
var sb1 = new SupportBean("T1", 10);
env.SendEventBean(sb1);
env.SendEventBean(new SupportBean_S0(2, "T1"));
var received = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType());
EPAssertionUtil.AssertEqualsAnyOrder(
(object[]) received.Get("val"),
new object[] {sb1});
var sb2 = new SupportBean("T2", 20);
env.SendEventBean(sb2);
var sb3 = new SupportBean("T2", 30);
env.SendEventBean(sb3);
env.SendEventBean(new SupportBean_S0(3, "T2"));
received = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsAnyOrder(
(object[]) received.Get("val"),
new object[] {sb2, sb3});
env.UndeployAll();
}
public void TestInsertConsume()
{
_epService.EPAdministrator.CreateEPL("create window MyVDW.test:vdw() as SupportBean");
var window = (SupportVirtualDW)GetFromContext("/virtualdw/MyVDW");
var supportBean = new SupportBean("S1", 100);
window.Data = supportBean.AsSingleton();
_epService.EPAdministrator.CreateEPL("insert into MyVDW select * from SupportBean");
// test aggregated consumer - wherein the virtual data window does not return an iterator that prefills the aggregation state
var fields = "val0".Split(',');
var stmtAggregate = _epService.EPAdministrator.CreateEPL("@Name('ABC') select sum(IntPrimitive) as val0 from MyVDW");
stmtAggregate.Events += _listener.Update;
EPAssertionUtil.AssertProps(stmtAggregate.First(), fields, new Object[] { 100 });
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 110 });
_epService.EPRuntime.SendEvent(new SupportBean("E1", 20));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 130 });
// assert events received for add-consumer and remove-consumer
stmtAggregate.Dispose();
var addConsumerEvent = (VirtualDataWindowEventConsumerAdd)window.Events[0];
var removeConsumerEvent = (VirtualDataWindowEventConsumerRemove)window.Events[1];
foreach (var @base in new VirtualDataWindowEventConsumerBase[] { addConsumerEvent, removeConsumerEvent })
{
Assert.AreEqual(-1, @base.AgentInstanceId);
Assert.AreEqual("MyVDW", @base.NamedWindowName);
Assert.AreEqual("ABC", @base.StatementName);
}
Assert.AreSame(removeConsumerEvent.ConsumerObject, addConsumerEvent.ConsumerObject);
window.Events.Clear();
// test filter criteria passed to event
var stmtAggregateWFilter = _epService.EPAdministrator.CreateEPL("@Name('ABC') select sum(IntPrimitive) as val0 from MyVDW(TheString = 'A')");
var eventWithFilter = (VirtualDataWindowEventConsumerAdd)window.Events[0];
Assert.AreEqual(1, eventWithFilter.FilterExpressions.Length);
Assert.IsNotNull(eventWithFilter.ExprEvaluatorContext);
stmtAggregateWFilter.Dispose();
}
