public void Run(RegressionEnvironment env)
{
var stmtText = "select " +
"instanceof(TheString,string) as t0, " +
"instanceof(TheString,float,string,int) as t1 " +
"from SupportBean";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.Add(Expressions.InstanceOf("TheString", "string"), "t0")
.Add(Expressions.InstanceOf(Expressions.Property("TheString"), "float", "string", "int"), "t1");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0").Milestone(0);
env.SendEventBean(new SupportBean("abc", 100));
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.IsTrue((Boolean)theEvent.Get("t0"));
Assert.IsTrue((Boolean)theEvent.Get("t1"));
env.SendEventBean(new SupportBean(null, 100));
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.IsFalse((Boolean)theEvent.Get("t0"));
Assert.IsFalse((Boolean)theEvent.Get("t1"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var stmtText = "select rstream * from SupportBean#length(3)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard(StreamSelector.RSTREAM_ONLY);
var fromClause = FromClause.Create(
FilterStream.Create("SupportBean").AddView(View.Create("length", Expressions.Constant(3))));
model.FromClause = fromClause;
model = env.CopyMayFail(model);
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
var theEvent = SendEvent(env, "a", 2);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEvents(env, new[] {"a", "b"});
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEvent(env, "d", 2);
Assert.AreSame(theEvent, env.Listener("s0").LastNewData[0].Underlying); // receive 'a' as new data
Assert.IsNull(env.Listener("s0").LastOldData); // receive no more old data
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var copier = SerializableObjectCopier.GetInstance(env.Container);
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.Add(
Expressions.CaseWhenThen()
.Add(Expressions.Eq("Symbol", "GE"), Expressions.Property("Volume"))
.Add(Expressions.Eq("Symbol", "DELL"), Expressions.Sum("Price")),
"p1");
model.FromClause = FromClause.Create(
FilterStream
.Create(typeof(SupportMarketDataBean).Name)
.AddView("win", "length", Expressions.Constant(10)));
model = copier.Copy(model);
var epl = "select case" +
" when Symbol=\"GE\" then Volume" +
" when Symbol=\"DELL\" then sum(Price) " +
"end as p1 from SupportMarketDataBean.win:length(10)";
Assert.AreEqual(epl, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0").Milestone(0);
Assert.AreEqual(typeof(double?), env.Statement("s0").EventType.GetPropertyType("p1"));
RunCaseSyntax1Sum(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
SendTimer(env, 0);
var stmtText = "select current_timestamp() as t0 from SupportBean";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CurrentTimestamp(), "t0");
model.FromClause = FromClause.Create().Add(FilterStream.Create(typeof(SupportBean).Name));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0").Milestone(0);
Assert.AreEqual(typeof(long?), env.Statement("s0").EventType.GetPropertyType("t0"));
SendTimer(env, 777);
env.SendEventBean(new SupportBean());
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
AssertResults(theEvent, new object[] { 777L });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard()
.Add(Expressions.Concat("MyString", "MyString"), "concat");
model.FromClause =
FromClause.Create(
FilterStream.Create("SupportBeanSimple")
.AddView(View.Create("length", Expressions.Constant(5))));
model = env.CopyMayFail(model);
var text = "select *, MyString||MyString as concat from SupportBeanSimple#length(5)";
Assert.AreEqual(text, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
AssertSimple(env);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("MyString", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("MyInt", typeof(int), null, false, false, false, false, false),
new EventPropertyDescriptor("concat", typeof(string), typeof(char), false, false, true, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var subquery = new EPStatementObjectModel();
subquery.SelectClause = SelectClause.CreateWildcard();
subquery.FromClause = FromClause.Create(
FilterStream.Create("SupportBean_S1").AddView("length", Expressions.Constant(1000)));
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("Id");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_S0"));
model.WhereClause = Expressions.Not(Expressions.SubqueryExists(subquery));
model = env.CopyMayFail(model);
var stmtText =
"select Id from SupportBean_S0 where not exists (select * from SupportBean_S1#length(1000))";
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
env.SendEventBean(new SupportBean_S0(2));
Assert.AreEqual(2, env.Listener("s0").AssertOneGetNewAndReset().Get("Id"));
env.SendEventBean(new SupportBean_S1(-1));
env.SendEventBean(new SupportBean_S0(1));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean_S1(-2));
env.SendEventBean(new SupportBean_S0(3));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// every 15 minutes 8am to 5pm
SendTimeEvent(env, 1, 17, 10, 0, 0);
var expression = "select * from SupportMarketDataBean#lastevent output at (*/15, 8:17, *, *, *)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create("SupportMarketDataBean").AddView("lastevent"));
Expression[] crontabParams = {
Expressions.CrontabScheduleFrequency(15),
Expressions.CrontabScheduleRange(8, 17),
Expressions.CrontabScheduleWildcard(),
Expressions.CrontabScheduleWildcard(),
Expressions.CrontabScheduleWildcard()
};
model.OutputLimitClause = OutputLimitClause.CreateSchedule(crontabParams);
var epl = model.ToEPL();
Assert.AreEqual(expression, epl);
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
TryAssertionCrontab(env, 1);
}
public void Run(RegressionEnvironment env)
{
var epl = "@Name('s0') select {\"a\",\"b\"} as StringArray, " +
"{} as EmptyArray, " +
"{1} as OneEleArray, " +
"{1,2,3} as IntArray " +
"from " +
typeof(SupportBean).Name;
var model = new EPStatementObjectModel();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
model.SelectClause = SelectClause.Create()
.Add(Expressions.Array().Add(Expressions.Constant("a")).Add(Expressions.Constant("b")), "StringArray")
.Add(Expressions.Array(), "EmptyArray")
.Add(Expressions.Array().Add(Expressions.Constant(1)), "OneEleArray")
.Add(Expressions.Array().Add(Expressions.Constant(1)).Add(2).Add(3), "IntArray");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
Assert.AreEqual(epl, model.ToEPL());
env.CompileDeploy(model).AddListener("s0");
var bean = new SupportBean("a", 10);
env.SendEventBean(bean);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsExactOrder(theEvent.Get("StringArray").Unwrap <string>(), new[] { "a", "b" });
EPAssertionUtil.AssertEqualsExactOrder(theEvent.Get("EmptyArray").Unwrap <object>(), new object[0]);
EPAssertionUtil.AssertEqualsExactOrder(theEvent.Get("OneEleArray").Unwrap <int>(), new int[] { 1 });
EPAssertionUtil.AssertEqualsExactOrder(theEvent.Get("IntArray").Unwrap <int>(), new int[] { 1, 2, 3 });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string textOne = "@Name('s0') select irstream CONCATSTRING(TheString) as val from SupportBean#length(10) group by IntPrimitive";
TryGrouped(env, textOne, null);
string textTwo = "@Name('s0') select irstream concatstring(TheString) as val from SupportBean#win:length(10) group by IntPrimitive";
TryGrouped(env, textTwo, null);
string textThree = "@Name('s0') select irstream concatstring(TheString) as val from SupportBean#length(10) group by IntPrimitive";
EPStatementObjectModel model = env.EplToModel(textThree);
SerializableObjectCopier.CopyMayFail(env.Container, model);
Assert.AreEqual(textThree, model.ToEPL());
TryGrouped(env, null, model);
string textFour = "select irstream concatstring(TheString) as val from SupportBean#length(10) group by IntPrimitive";
EPStatementObjectModel modelTwo = new EPStatementObjectModel();
modelTwo.SelectClause = SelectClause
.Create(StreamSelector.RSTREAM_ISTREAM_BOTH)
.Add(Expressions.PlugInAggregation("concatstring", Expressions.Property("TheString")), "val");
modelTwo.FromClause = FromClause.Create(FilterStream.Create("SupportBean").AddView(null, "length", Expressions.Constant(10)));
modelTwo.GroupByClause = GroupByClause.Create("IntPrimitive");
Assert.AreEqual(textFour, modelTwo.ToEPL());
SerializableObjectCopier.CopyMayFail(env.Container, modelTwo);
modelTwo.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
TryGrouped(env, null, modelTwo);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var epl = "select coalesce(LongBoxed,IntBoxed,ShortBoxed) as result" +
" from SupportBean#length(1000)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.Add(
Expressions.Coalesce(
"LongBoxed",
"IntBoxed",
"ShortBoxed"),
"result");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name).AddView("length", Expressions.Constant(1000)));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(epl, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
Assert.AreEqual(typeof(long?), env.Statement("s0").EventType.GetPropertyType("result"));
TryCoalesceLong(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var stmtText = "@Name('s0') select S0.Id as idS0, S1.Id as idS1 " +
"from pattern [every S0=SupportBean_S0" +
" or every S1=SupportBean_S1] " +
"where S0.Id is not null and S0.Id<100 or S1.Id is not null and S1.Id>=100";
var model = env.EplToModel(stmtText);
model = env.CopyMayFail(model);
var reverse = model.ToEPL();
Assert.AreEqual(stmtText, reverse);
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
SendEventS0(env, 1);
AssertEventIds(env, 1, null);
SendEventS0(env, 101);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventS1(env, 1);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventS1(env, 100);
AssertEventIds(env, null, 100);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
var stmtOrigText = "@Name('split') on SupportBean " +
"insert into AStream2SP select * where IntPrimitive=1 " +
"insert into BStream2SP select * where IntPrimitive=1 or IntPrimitive=2";
env.CompileDeploy(stmtOrigText, path).AddListener("split");
TryAssertion(env, path);
path.Clear();
// statement object model
var model = new EPStatementObjectModel();
model.Annotations = Collections.SingletonList(new AnnotationPart("Audit"));
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean"));
model.InsertInto = InsertIntoClause.Create("AStream2SP");
model.SelectClause = SelectClause.CreateWildcard();
model.WhereClause = Expressions.Eq("IntPrimitive", 1);
var clause = OnClause.CreateOnInsertSplitStream();
model.OnExpr = clause;
var item = OnInsertSplitStreamItem.Create(
InsertIntoClause.Create("BStream2SP"),
SelectClause.CreateWildcard(),
Expressions.Or(Expressions.Eq("IntPrimitive", 1), Expressions.Eq("IntPrimitive", 2)));
clause.AddItem(item);
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("split"));
Assert.AreEqual(stmtOrigText, model.ToEPL());
env.CompileDeploy(model, path).AddListener("split");
TryAssertion(env, path);
path.Clear();
env.EplToModelCompileDeploy(stmtOrigText, path).AddListener("split");
TryAssertion(env, path);
}
public static void AddAnnotationForNonMap(
this EventRepresentationChoice enumValue,
EPStatementObjectModel model)
{
if (enumValue == EventRepresentationChoice.DEFAULT || enumValue == EventRepresentationChoice.MAP) {
return;
}
var part = new AnnotationPart("EventRepresentation");
switch (enumValue) {
case EventRepresentationChoice.OBJECTARRAY:
part.AddValue("objectarray");
break;
case EventRepresentationChoice.AVRO:
part.AddValue("avro");
break;
case EventRepresentationChoice.JSON:
case EventRepresentationChoice.JSONCLASSPROVIDED:
part.AddValue("json");
break;
}
model.Annotations = Collections.SingletonList(part);
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
var fromClause = FromClause.Create(
FilterStream.Create("SupportBean_A", "streamA")
.AddView(View.Create("length", Expressions.Constant(3))),
FilterStream.Create("SupportBean_B", "streamB")
.AddView(View.Create("length", Expressions.Constant(3))),
FilterStream.Create("SupportBean_C", "streamC")
.AddView(View.Create("length", Expressions.Constant(3))));
model.FromClause = fromClause;
model.WhereClause = Expressions.And(
Expressions.EqProperty("streamA.Id", "streamB.Id"),
Expressions.EqProperty("streamB.Id", "streamC.Id"),
Expressions.EqProperty("streamA.Id", "streamC.Id"));
model = env.CopyMayFail(model);
var epl = "select * from " +
"SupportBean_A#length(3) as streamA, " +
"SupportBean_B#length(3) as streamB, " +
"SupportBean_C#length(3) as streamC " +
"where streamA.Id=streamB.Id " +
"and streamB.Id=streamC.Id " +
"and streamA.Id=streamC.Id";
Assert.AreEqual(epl, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0").Milestone(0);
RunJoinUniquePerId(env);
env.UndeployAll();
}
private static void Validate(
RegressionEnvironment env,
string selectClause,
string groupByClause,
string[] expectedCSV)
{
var epl = PLAN_CALLBACK_HOOK +
" select " +
selectClause +
", count(*) from SupportEventABCProp group by " +
groupByClause;
SupportGroupRollupPlanHook.Reset();
env.Compile(epl);
ComparePlan(expectedCSV);
env.UndeployAll();
var model = env.EplToModel(epl);
Assert.AreEqual(epl, model.ToEPL());
SupportGroupRollupPlanHook.Reset();
model.Annotations.Add(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
ComparePlan(expectedCSV);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("Symbol", "Volume").Add(Expressions.Sum("Price"), "mySum");
model.FromClause = FromClause.Create(
FilterStream.Create(typeof(SupportMarketDataBean).Name)
.AddView(View.Create("length", Expressions.Constant(20))));
model.GroupByClause = GroupByClause.Create("Symbol");
model.OutputLimitClause = OutputLimitClause.Create(6);
model.OrderByClause = OrderByClause.Create(Expressions.Sum("Price")).Add("Symbol", false);
model = env.CopyMayFail(model);
var epl = "select Symbol, Volume, sum(Price) as mySum from " +
"SupportMarketDataBean#length(20) " +
"group by Symbol " +
"output every 6 events " +
"order by sum(Price), Symbol";
Assert.AreEqual(epl, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
TryAssertionDefault(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.AddStreamWildcard("S0")
.AddStreamWildcard("S1", "S1stream")
.AddWithAsProvidedName("TheString", "sym");
model.FromClause = FromClause.Create()
.Add(FilterStream.Create("SupportBean", "S0").AddView("keepall"))
.Add(FilterStream.Create("SupportMarketDataBean", "S1").AddView("keepall"));
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
var epl =
"@Name('s0') select S0.*, S1.* as S1stream, TheString as sym from SupportBean#keepall as S0, " +
"SupportMarketDataBean#keepall as S1";
Assert.AreEqual(epl, model.ToEPL());
var modelReverse = env.EplToModel(model.ToEPL());
Assert.AreEqual(epl, modelReverse.ToEPL());
var type = env.Statement("s0").EventType;
Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("S1stream"));
Assert.AreEqual(typeof(Pair<object, IDictionary<string, object>>), type.UnderlyingType);
SendBeanEvent(env, "E1");
Assert.IsFalse(env.Listener("s0").IsInvoked);
object theEvent = SendMarketEvent(env, "E1");
var outevent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreSame(theEvent, outevent.Get("S1stream"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var caseExpr = "@Name('s0') select TheString in (\"a\",\"b\",\"c\") as result from " + typeof(SupportBean).Name;
var model = new EPStatementObjectModel();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
model.SelectClause = SelectClause.Create().Add(Expressions.In("TheString", "a", "b", "c"), "result");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
TryString(
env,
model,
caseExpr,
new[] { "0", "a", "b", "c", "d", null },
new bool?[] { false, true, true, true, false, null });
model = new EPStatementObjectModel();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
model.SelectClause = SelectClause.Create().Add(Expressions.NotIn("TheString", "a", "b", "c"), "result");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
SerializableObjectCopier.GetInstance(env.Container).Copy(model);
TryString(
env,
"TheString not in ('a', 'b', 'c')",
new[] { "0", "a", "b", "c", "d", null },
new bool?[] { true, false, false, false, true, null });
}
public void Run(RegressionEnvironment env)
{
var stmtText = "@Name('s0') select P00 like P01 as r1, " +
"P00 like P01 escape \"!\" as r2, " +
"P02 regexp P03 as r3 " +
"from SupportBean_S0";
var model = new EPStatementObjectModel();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
model.SelectClause = SelectClause.Create()
.Add(Expressions.Like(Expressions.Property("P00"), Expressions.Property("P01")), "r1")
.Add(Expressions.Like(Expressions.Property("P00"), Expressions.Property("P01"), Expressions.Constant("!")), "r2")
.Add(Expressions.Regexp(Expressions.Property("P02"), Expressions.Property("P03")), "r3");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_S0"));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
var compiled = env.Compile(model, new CompilerArguments(env.Configuration));
env.Deploy(compiled).AddListener("s0").Milestone(0);
RunLikeRegexStringAndNull(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
SerializableObjectCopier.CopyMayFail(env.Container, model);
}
private void TryAssertionInsertWhereOMStaggered(
RegressionEnvironment env,
EventRepresentationChoice eventRepresentationEnum)
{
var path = new RegressionPath();
var stmtTextCreateOne = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyWindowIWOM>() +
" @Name('window') create window MyWindowIWOM#keepall as select a, b from MyMapAB";
env.CompileDeploy(stmtTextCreateOne, path);
Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("window").EventType.UnderlyingType));
env.AddListener("window");
// create insert into
var stmtTextInsertOne = "insert into MyWindowIWOM select a, b from MyMapAB";
env.CompileDeploy(stmtTextInsertOne, path);
// populate some data
env.SendEventMap(BuildMap(new[] {new object[] {"a", "E1"}, new object[] {"b", 2}}), "MyMapAB");
env.SendEventMap(BuildMap(new[] {new object[] {"a", "E2"}, new object[] {"b", 10}}), "MyMapAB");
env.SendEventMap(BuildMap(new[] {new object[] {"a", "E3"}, new object[] {"b", 10}}), "MyMapAB");
// create window with keep-all using OM
var model = new EPStatementObjectModel();
eventRepresentationEnum.AddAnnotationForNonMap(model);
Expression where = Expressions.Eq("b", 10);
model.CreateWindow =
CreateWindowClause.Create("MyWindowIWOMTwo", View.Create("keepall"))
.WithInsert(true)
.WithInsertWhereClause(where)
.WithAsEventTypeName("MyWindowIWOM");
model.SelectClause = SelectClause.CreateWildcard();
var text = eventRepresentationEnum.GetAnnotationTextForNonMap() +
" create window MyWindowIWOMTwo#keepall as select * from MyWindowIWOM insert where b=10";
Assert.AreEqual(text.Trim(), model.ToEPL());
var modelTwo = env.EplToModel(text);
Assert.AreEqual(text.Trim(), modelTwo.ToEPL());
modelTwo.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("windowTwo"));
env.CompileDeploy(modelTwo, path).AddListener("windowTwo");
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("windowTwo"),
new[] {"a", "b"},
new[] {new object[] {"E2", 10}, new object[] {"E3", 10}});
// test select individual fields and from an insert-from named window
env.CompileDeploy(
eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyWindowIWOMThree>() +
" @Name('windowThree') create window MyWindowIWOMThree#keepall as select a from MyWindowIWOMTwo insert where a = 'E2'",
path);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("windowThree"),
new[] {"a"},
new[] {new object[] {"E2"}});
env.UndeployAll();
}
public static void AddAnnotation(this EventRepresentationEnum value, EPStatementObjectModel model)
{
if (value == EventRepresentationEnum.DEFAULT)
{
return;
}
AnnotationPart part = new AnnotationPart(typeof(EventRepresentation).Name);
part.AddValue("Array", value == EventRepresentationEnum.OBJECTARRAY);
model.Annotations = Collections.SingletonList(part);
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("Symbol")
.Add(Expressions.Median("Price"), "myMedian")
.Add(Expressions.MedianDistinct("Price"), "myDistMedian")
.Add(Expressions.Stddev("Price"), "myStdev")
.Add(Expressions.Avedev("Price"), "myAvedev")
.SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH);
var fromClause = FromClause.Create(
FilterStream
.Create(typeof(SupportBeanString).Name, "one")
.AddView(View.Create("length", Expressions.Constant(100))),
FilterStream
.Create(typeof(SupportMarketDataBean).Name, "two")
.AddView(View.Create("length", Expressions.Constant(5))));
model.FromClause = fromClause;
model.WhereClause = Expressions.And()
.Add(
Expressions.Or()
.Add(Expressions.Eq("Symbol", "DELL"))
.Add(Expressions.Eq("Symbol", "IBM"))
.Add(Expressions.Eq("Symbol", "GE"))
)
.Add(Expressions.EqProperty("one.TheString", "two.Symbol"));
model.GroupByClause = GroupByClause.Create("Symbol");
model = env.CopyMayFail(model);
var epl = "select irstream Symbol, " +
"median(Price) as myMedian, " +
"median(distinct Price) as myDistMedian, " +
"stddev(Price) as myStdev, " +
"avedev(Price) as myAvedev " +
"from SupportBeanString#length(100) as one, " +
"SupportMarketDataBean#length(5) as two " +
"where (Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\") " +
"and one.TheString=two.Symbol " +
"group by Symbol";
Assert.AreEqual(epl, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
env.SendEventBean(new SupportBeanString(SYMBOL_DELL));
env.SendEventBean(new SupportBeanString(SYMBOL_IBM));
env.SendEventBean(new SupportBeanString("AAA"));
TryAssertionStmt(env, new AtomicLong());
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.AddWithAsProvidedName("S0.Id", "idS0")
.AddWithAsProvidedName("S1.Id", "idS1");
PatternExpr pattern = Patterns.Or()
.Add(Patterns.EveryFilter("SupportBean_S0", "S0"))
.Add(
Patterns.EveryFilter("SupportBean_S1", "S1")
);
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model.WhereClause = Expressions.Or()
.Add(
Expressions.And()
.Add(Expressions.IsNotNull("S0.Id"))
.Add(Expressions.Lt("S0.Id", 100))
)
.Add(
Expressions.And()
.Add(Expressions.IsNotNull("S1.Id"))
.Add(Expressions.Ge("S1.Id", 100))
);
model = env.CopyMayFail(model);
var reverse = model.ToEPL();
var stmtText = "select S0.Id as idS0, S1.Id as idS1 " +
"from pattern [every S0=SupportBean_S0" +
" or every S1=SupportBean_S1] " +
"where S0.Id is not null and S0.Id<100 or S1.Id is not null and S1.Id>=100";
Assert.AreEqual(stmtText, reverse);
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
SendEventS0(env, 1);
AssertEventIds(env, 1, null);
SendEventS0(env, 101);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventS1(env, 1);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventS1(env, 100);
AssertEventIds(env, null, 100);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var stmtText = "select * from SupportBean";
var model = env.EplToModel(stmtText);
SerializableObjectCopier.CopyMayFail(env.Container, model);
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
object theEvent = new SupportBean();
env.SendEventBean(theEvent);
Assert.AreEqual(theEvent, env.Listener("s0").AssertOneGetNewAndReset().Underlying);
Assert.AreEqual("@Name('s0') " + stmtText, env.Statement("s0").GetProperty(StatementProperty.EPL));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
env.Runtime.VariableService.SetVariableValue(null, "var_output_limit", 3L);
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CountStar(), "cnt");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
model.OutputLimitClause = OutputLimitClause.Create(OutputLimitSelector.LAST, "var_output_limit");
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
var stmtTextSelect =
"@Name('s0') select count(*) as cnt from SupportBean output last every var_output_limit events";
Assert.AreEqual(stmtTextSelect, model.ToEPL());
env.CompileDeploy(model, new RegressionPath()).AddListener("s0");
TryAssertionOutputRateEventsAll(env);
env.UndeployAll();
}
public static void AddAnnotationForNonMap(this EventRepresentationChoice enumValue, EPStatementObjectModel model)
{
if (enumValue == EventRepresentationChoice.DEFAULT || enumValue == EventRepresentationChoice.MAP)
{
return;
}
var part = new AnnotationPart("EventRepresentation");
if (enumValue == EventRepresentationChoice.ARRAY)
{
part.AddValue("objectarray");
}
if (enumValue == EventRepresentationChoice.AVRO)
{
part.AddValue("avro");
}
model.Annotations = Collections.SingletonList(part);
}
public void Run(RegressionEnvironment env)
{
var stmtText = "select exists(item?.IntBoxed) as t0 from SupportMarkerInterface";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.ExistsProperty("item?.IntBoxed"), "t0");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarkerInterface).Name));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
AssertStringAndNull(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("var1OM", "var2OM", "Id");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_A"));
var path = new RegressionPath();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model, path);
var stmtText = "@Name('s0') select var1OM, var2OM, Id from SupportBean_A";
Assert.AreEqual(stmtText, model.ToEPL());
env.AddListener("s0");
var fieldsSelect = new string[] { "var1OM", "var2OM", "Id" };
SendSupportBean_A(env, "E1");
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSelect, new object[] { 10d, 11L, "E1" });
model = new EPStatementObjectModel();
model.OnExpr = OnClause.CreateOnSet(Expressions.Eq(Expressions.Property("var1OM"), Expressions.Property("IntPrimitive")))
.AddAssignment(Expressions.Eq(Expressions.Property("var2OM"), Expressions.Property("IntBoxed")));
model.FromClause = FromClause.Create(FilterStream.Create(nameof(SupportBean)));
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("set"));
var stmtTextSet = "@Name('set') on SupportBean set var1OM=IntPrimitive, var2OM=IntBoxed";
env.CompileDeploy(model, path).AddListener("set");
Assert.AreEqual(stmtTextSet, model.ToEPL());
var typeSet = env.Statement("set").EventType;
Assert.AreEqual(typeof(double?), typeSet.GetPropertyType("var1OM"));
Assert.AreEqual(typeof(long?), typeSet.GetPropertyType("var2OM"));
Assert.AreEqual(typeof(IDictionary <string, object>), typeSet.UnderlyingType);
var fieldsVar = new string[] { "var1OM", "var2OM" };
EPAssertionUtil.AssertEqualsAnyOrder(fieldsVar, typeSet.PropertyNames);
EPAssertionUtil.AssertPropsPerRow(env.GetEnumerator("set"), fieldsVar, new object[][] { new object[] { 10d, 11L } });
SendSupportBean(env, "S1", 3, 4);
EPAssertionUtil.AssertProps(env.Listener("set").AssertOneGetNewAndReset(), fieldsVar, new object[] { 3d, 4L });
EPAssertionUtil.AssertPropsPerRow(env.GetEnumerator("set"), fieldsVar, new object[][] { new object[] { 3d, 4L } });
SendSupportBean_A(env, "E2");
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSelect, new object[] { 3d, 4L, "E2" });
env.UndeployModuleContaining("set");
env.UndeployModuleContaining("s0");
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create(new[] {"S0.Id", " S0.P00", " S0.P01", " S1.Id", " S1.P10", " S1.P11"});
var fromClause = FromClause.Create(
FilterStream.Create(typeof(SupportBean_S0).Name, "S0").AddView("keepall"),
FilterStream.Create(typeof(SupportBean_S1).Name, "S1").AddView("keepall"));
fromClause.Add(OuterJoinQualifier.Create("S0.P00", OuterJoinType.LEFT, "S1.P10").Add("S1.P11", "S0.P01"));
model.FromClause = fromClause;
model = env.CopyMayFail(model);
var stmtText =
"select S0.Id, S0.P00, S0.P01, S1.Id, S1.P10, S1.P11 from SupportBean_S0#keepall as S0 left outer join SupportBean_S1#keepall as S1 on S0.P00 = S1.P10 and S1.P11 = S0.P01";
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
AssertMultiColumnLeft(env);
var modelReverse = env.EplToModel(stmtText);
Assert.AreEqual(stmtText, modelReverse.ToEPL());
env.UndeployAll();
}
