public void TestCaseSyntax1WithElse_OM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CaseWhenThen()
.SetElse(Expressions.Property("Volume"))
.Add(Expressions.Eq("Symbol", "DELL"),
Expressions.Multiply(
Expressions.Property("Volume"),
Expressions.Constant(3))), "p1");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("win", "length",
Expressions.
Constant(10)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String caseExpr = "select case " +
"when Symbol=\"DELL\" then Volume*3 " +
"else Volume " +
"end as p1 from " + typeof(SupportMarketDataBean).FullName + ".win:length(10)";
Assert.AreEqual(caseExpr, model.ToEPL());
EPStatement selectTestCase = _epService.EPAdministrator.Create(model);
selectTestCase.Events += _testListener.Update;
Assert.AreEqual(typeof(long?), selectTestCase.EventType.GetPropertyType("p1"));
RunCaseSyntax1WithElse();
}
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 TestOutputCrontabAtOMCreate()
{
// every 15 minutes 8am to 5pm
SendTimeEvent(1, 17, 10, 0, 0);
var expression = "select * from MarketData#lastevent output at (*/15, 8:17, *, *, *)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create("MarketData").AddView("lastevent"));
var crontabParams = new Expression[] {
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);
var stmt = _epService.EPAdministrator.Create(model);
stmt.AddListener(_listener);
RunAssertionCrontab(1, stmt);
}
public void TestArrayWithArg()
{
var joinStatement = "select irstream id, theString from " +
typeof(SupportBean).Name + "().win:length(3) as s1, " +
" method:com.espertech.esper.support.epl.SupportStaticMethodLib.FetchArrayGen(intPrimitive)";
var stmt = _epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayWithArg(stmt);
joinStatement = "select irstream id, theString from " +
"method:com.espertech.esper.support.epl.SupportStaticMethodLib.FetchArrayGen(intPrimitive) as s0, " +
typeof(SupportBean).Name + ".win:length(3)";
stmt = _epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayWithArg(stmt);
var model = _epService.EPAdministrator.CompileEPL(joinStatement);
Assert.AreEqual(joinStatement, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
TryArrayWithArg(stmt);
model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("id", "theString").SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH);
model.FromClause = FromClause.Create()
.Add(MethodInvocationStream.Create(typeof(SupportStaticMethodLib).FullName, "FetchArrayGen", "s0")
.AddParameter(Expressions.Property("intPrimitive")))
.Add(FilterStream.Create(typeof(SupportBean).Name).AddView("win", "length", Expressions.Constant(3)));
stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(joinStatement, model.ToEPL());
TryArrayWithArg(stmt);
}
public void TestInstanceofStringAndNull_OM()
{
String stmtText = "select instanceof(TheString,string) as t0, " +
"instanceof(TheString,float,string,int) as t1 " +
"from " + typeof(SupportBean).FullName;
EPStatementObjectModel 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).FullName));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement selectTestCase = _epService.EPAdministrator.Create(model);
selectTestCase.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("abc", 100));
EventBean theEvent = _listener.AssertOneGetNewAndReset();
Assert.IsTrue(theEvent.Get("t0").AsBoolean());
Assert.IsTrue(theEvent.Get("t1").AsBoolean());
_epService.EPRuntime.SendEvent(new SupportBean(null, 100));
theEvent = _listener.AssertOneGetNewAndReset();
Assert.IsFalse(theEvent.Get("t0").AsBoolean());
Assert.IsFalse(theEvent.Get("t1").AsBoolean());
}
public void TestCastDoubleAndNull_OM()
{
String stmtText = "select exists(item?.IntBoxed) as t0 " +
"from " + typeof(SupportMarkerInterface).FullName;
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.ExistsProperty("item?.IntBoxed"), "t0");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarkerInterface).FullName));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement selectTestCase = epService.EPAdministrator.Create(model);
selectTestCase.Events += listener.Update;
Assert.AreEqual(typeof(bool?), selectTestCase.EventType.GetPropertyType("t0"));
epService.EPRuntime.SendEvent(new SupportBeanDynRoot(new SupportBean()));
Assert.AreEqual(true, listener.AssertOneGetNewAndReset().Get("t0"));
epService.EPRuntime.SendEvent(new SupportBeanDynRoot(null));
Assert.AreEqual(false, listener.AssertOneGetNewAndReset().Get("t0"));
epService.EPRuntime.SendEvent(new SupportBeanDynRoot("abc"));
Assert.AreEqual(false, listener.AssertOneGetNewAndReset().Get("t0"));
}
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 TestTimeBatchOM()
{
String[] fields = ALL_FIELDS.Split(',');
String sql = "select " + ALL_FIELDS + " from mytesttable where ${IntPrimitive} = mytesttable.mybigint";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create(fields);
FromClause fromClause = FromClause.Create(
SQLStream.Create("MyDB", sql, "s0"),
FilterStream.Create(typeof(SupportBean).FullName, "s1").AddView(View.Create("win", "time_batch",
Expressions.Constant(10))
));
model.FromClause = fromClause;
SerializableObjectCopier.Copy(model);
Assert.AreEqual(
"select mybigint, myint, myvarchar, mychar, mybool, mynumeric, mydecimal, mydouble, myreal from sql:MyDB[\"select mybigint, myint, myvarchar, mychar, mybool, mynumeric, mydecimal, mydouble, myreal from mytesttable where ${IntPrimitive} = mytesttable.mybigint\"] as s0, com.espertech.esper.support.bean.SupportBean.win:time_batch(10) as s1",
model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
RuntestTimeBatch(stmt);
stmt = _epService.EPAdministrator.CreateEPL(model.ToEPL());
}
public void TestArrayNoArg()
{
var joinStatement = "select id, theString from "
+ typeof(SupportBean).FullName + "#length(3) as s1, "
+ "method:" + typeof(SupportStaticMethodLib).FullName
+ ".FetchArrayNoArg";
var stmt = _epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayNoArg(stmt);
joinStatement = "select id, theString from "
+ typeof(SupportBean).FullName + "#length(3) as s1, "
+ "method:" + typeof(SupportStaticMethodLib).FullName
+ ".FetchArrayNoArg()";
stmt = _epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayNoArg(stmt);
var model = _epService.EPAdministrator.CompileEPL(joinStatement);
Assert.AreEqual(joinStatement, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
TryArrayNoArg(stmt);
model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("id", "theString");
model.FromClause = FromClause.Create()
.Add(FilterStream.Create(typeof(SupportBean).FullName, "s1").AddView("length", Expressions.Constant(3)))
.Add(MethodInvocationStream.Create(typeof(SupportStaticMethodLib).FullName, "FetchArrayNoArg"));
stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(joinStatement, model.ToEPL());
TryArrayNoArg(stmt);
}
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));
env.CopyMayFail(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 TestArrayExpressions_OM()
{
String stmtText = "select {\"a\",\"b\"} as stringArray, " +
"{} as emptyArray, " +
"{1} as oneEleArray, " +
"{1,2,3} as intArray " +
"from " + typeof(SupportBean).FullName;
EPStatementObjectModel model = new EPStatementObjectModel();
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).FullName));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
SupportUpdateListener listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SupportBean bean = new SupportBean("a", 10);
_epService.EPRuntime.SendEvent(bean);
EventBean theEvent = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsExactOrder((String[])theEvent.Get("stringArray"), new String[] { "a", "b" });
EPAssertionUtil.AssertEqualsExactOrder((Object[])theEvent.Get("emptyArray"), new Object[0]);
EPAssertionUtil.AssertEqualsExactOrder((int?[])theEvent.Get("oneEleArray"), new int?[] { 1 });
EPAssertionUtil.AssertEqualsExactOrder((int?[])theEvent.Get("intArray"), new int?[] { 1, 2, 3 });
}
private void RunAssertionArrayWithArg(EPServiceProvider epService)
{
string joinStatement = "select irstream id, TheString from " +
typeof(SupportBean).FullName + "()#length(3) as s1, " +
" method:" + typeof(SupportStaticMethodLib).FullName + ".FetchArrayGen(IntPrimitive)";
EPStatement stmt = epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayWithArg(epService, stmt);
joinStatement = "select irstream id, TheString from " +
"method:" + typeof(SupportStaticMethodLib).FullName + ".FetchArrayGen(IntPrimitive) as s0, " +
typeof(SupportBean).FullName + "#length(3)";
stmt = epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayWithArg(epService, stmt);
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(joinStatement);
Assert.AreEqual(joinStatement, model.ToEPL());
stmt = epService.EPAdministrator.Create(model);
TryArrayWithArg(epService, stmt);
model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("id", "TheString")
.SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH);
model.FromClause = FromClause.Create()
.Add(MethodInvocationStream.Create(typeof(SupportStaticMethodLib).FullName, "FetchArrayGen", "s0")
.AddParameter(Expressions.Property("IntPrimitive")))
.Add(FilterStream.Create(typeof(SupportBean).FullName).AddView("length", Expressions.Constant(3)));
stmt = epService.EPAdministrator.Create(model);
Assert.AreEqual(joinStatement, model.ToEPL());
TryArrayWithArg(epService, stmt);
}
private void RunAssertionArrayNoArg(EPServiceProvider epService)
{
string joinStatement = "select id, TheString from " +
typeof(SupportBean).FullName + "#length(3) as s1, " +
"method:" + typeof(SupportStaticMethodLib).FullName + ".FetchArrayNoArg";
EPStatement stmt = epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayNoArg(epService, stmt);
joinStatement = "select id, TheString from " +
typeof(SupportBean).FullName + "#length(3) as s1, " +
"method:" + typeof(SupportStaticMethodLib).FullName + ".FetchArrayNoArg()";
stmt = epService.EPAdministrator.CreateEPL(joinStatement);
TryArrayNoArg(epService, stmt);
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(joinStatement);
Assert.AreEqual(joinStatement, model.ToEPL());
stmt = epService.EPAdministrator.Create(model);
TryArrayNoArg(epService, stmt);
model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("id", "TheString");
model.FromClause = FromClause.Create()
.Add(FilterStream.Create(typeof(SupportBean).FullName, "s1").AddView("length", Expressions.Constant(3)))
.Add(MethodInvocationStream.Create(typeof(SupportStaticMethodLib).FullName, "FetchArrayNoArg"));
stmt = epService.EPAdministrator.Create(model);
Assert.AreEqual(joinStatement, model.ToEPL());
TryArrayNoArg(epService, stmt);
}
public void TestCaseSyntax2WithNull_OM()
{
String caseExpr = "select case IntPrimitive " +
"when 1 then null " +
"when 2 then 1.0d " +
"when 3 then null " +
"else 2 " +
"end as p1 from " + typeof(SupportBean).FullName + ".win:length(100)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CaseSwitch("IntPrimitive")
.SetElse(Expressions.Constant(2))
.Add(Expressions.Constant(1), Expressions.Constant(null))
.Add(Expressions.Constant(2), Expressions.Constant(1.0))
.Add(Expressions.Constant(3), Expressions.Constant(null)),
"p1");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView("win", "length",
Expressions.Constant(100)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(caseExpr, model.ToEPL());
EPStatement selectTestCase = _epService.EPAdministrator.Create(model);
selectTestCase.Events += _testListener.Update;
Assert.AreEqual(typeof(double?), selectTestCase.EventType.GetPropertyType("p1"));
RunCaseSyntax2WithNull();
}
public void TestCountOneViewOM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
.Add("Symbol")
.Add(Expressions.CountStar(), "countAll")
.Add(Expressions.CountDistinct("volume"), "countDistVol")
.Add(Expressions.Count("volume"), "countVol");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("win", "length", Expressions.Constant(3)));
model.WhereClause = Expressions.Or()
.Add(Expressions.Eq("Symbol", "DELL"))
.Add(Expressions.Eq("Symbol", "IBM"))
.Add(Expressions.Eq("Symbol", "GE"));
model.GroupByClause = GroupByClause.Create("Symbol");
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
var viewExpr = "select irstream Symbol, " +
"count(*) as countAll, " +
"count(distinct volume) as countDistVol, " +
"count(volume) as countVol" +
" from " + typeof(SupportMarketDataBean).FullName + ".win:length(3) " +
"where Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\" " +
"group by Symbol";
Assert.AreEqual(viewExpr, model.ToEPL());
_selectTestView = _epService.EPAdministrator.Create(model);
_selectTestView.AddListener(_testListener);
RunAssertion();
}
private void RunAssertionGetTimestamp_OM(EPServiceProvider epService)
{
SendTimer(epService, 0);
string stmtText = "select current_timestamp() as t0 from " + typeof(SupportBean).FullName;
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CurrentTimestamp(), "t0");
model.FromClause = FromClause.Create().Add(FilterStream.Create(typeof(SupportBean).FullName));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
Assert.AreEqual(typeof(long?), stmt.EventType.GetPropertyType("t0"));
SendTimer(epService, 777);
epService.EPRuntime.SendEvent(new SupportBean());
EventBean theEvent = listener.AssertOneGetNewAndReset();
AssertResults(theEvent, new object[] { 777L });
stmt.Dispose();
}
public void TestJoinUniquePerIdOM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(
FilterStream.Create(_eventA, "streamA").AddView(View.Create("win", "length", Expressions.Constant(3))),
FilterStream.Create(_eventB, "streamB").AddView(View.Create("win", "length", Expressions.Constant(3))),
FilterStream.Create(_eventC, "streamC").AddView(View.Create("win", "length", Expressions.Constant(3))));
model.WhereClause = Expressions.And(
Expressions.EqProperty("streamA.id", "streamB.id"),
Expressions.EqProperty("streamB.id", "streamC.id"),
Expressions.EqProperty("streamA.id", "streamC.id"));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String joinStatement = "select * from " +
_eventA + ".win:length(3) as streamA, " +
_eventB + ".win:length(3) as streamB, " +
_eventC + ".win:length(3) as streamC " +
"where streamA.id=streamB.id " +
"and streamB.id=streamC.id " +
"and streamA.id=streamC.id";
EPStatement joinView = _epService.EPAdministrator.Create(model);
joinView.Events += _updateListener.Update;
Assert.AreEqual(joinStatement, model.ToEPL());
RunJoinUniquePerId();
}
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 TestLikeRegexStringAndNull_OM()
{
String stmtText = "select p00 like p01 as r1, " +
"p00 like p01 escape \"!\" as r2, " +
"p02 regexp p03 as r3 " +
"from " + typeof(SupportBean_S0).FullName;
EPStatementObjectModel model = new EPStatementObjectModel();
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(typeof(SupportBean_S0).FullName));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement selectTestCase = _epService.EPAdministrator.Create(model);
selectTestCase.Events += _testListener.Update;
RunLikeRegexStringAndNull();
String epl = "select * from " + typeof(SupportBean).FullName + "(TheString not like \"foo%\")";
EPPreparedStatement eps = _epService.EPAdministrator.PrepareEPL(epl);
EPStatement statement = _epService.EPAdministrator.Create(eps);
Assert.AreEqual(epl, statement.Text);
epl = "select * from " + typeof(SupportBean).FullName + "(TheString not regexp \"foo\")";
eps = _epService.EPAdministrator.PrepareEPL(epl);
statement = _epService.EPAdministrator.Create(eps);
Assert.AreEqual(epl, statement.Text);
}
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();
}
private void RunAssertionAliasesAggregationOM(EPServiceProvider epService)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("symbol", "volume").Add(Expressions.Sum("price"), "mySum");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).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 = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
string statementString = "select symbol, volume, sum(price) as mySum from " +
typeof(SupportMarketDataBean).FullName + "#length(20) " +
"group by symbol " +
"output every 6 events " +
"order by sum(price), symbol";
Assert.AreEqual(statementString, model.ToEPL());
var testListener = new SupportUpdateListener();
EPStatement statement = epService.EPAdministrator.Create(model);
statement.Events += testListener.Update;
TryAssertionDefault(epService, testListener);
statement.Dispose();
}
private void RunAssertionWherePreviousOM(EPServiceProvider epService)
{
var subquery = new EPStatementObjectModel();
subquery.SelectClause = SelectClause.Create().Add(Expressions.Previous(1, "id"));
subquery.FromClause = FromClause.Create(FilterStream.Create("S1").AddView(View.Create("length", Expressions.Constant(1000))));
subquery.WhereClause = Expressions.EqProperty("id", "s0.id");
var model = new EPStatementObjectModel();
model.FromClause = FromClause.Create(FilterStream.Create("S0", "s0"));
model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "value");
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
string stmtText = "select (select prev(1,id) from S1#length(1000) where id=s0.id) as value from S0 as s0";
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
RunWherePrevious(epService, listener);
stmt.Dispose();
}
public void TestBeanEventWildcardSODA()
{
var fields = new string[] { "id" };
var statementText = "select distinct * from SupportBean_A.win:keepall()";
var stmt = _epService.EPAdministrator.CreateEPL(statementText);
stmt.AddListener(_listener);
_epService.EPRuntime.SendEvent(new SupportBean_A("E1"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" } });
_epService.EPRuntime.SendEvent(new SupportBean_A("E2"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E2" } });
_epService.EPRuntime.SendEvent(new SupportBean_A("E1"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E2" } });
var model = _epService.EPAdministrator.CompileEPL(statementText);
Assert.AreEqual(statementText, model.ToEPL());
model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard().Distinct(true);
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_A"));
Assert.AreEqual("select distinct * from SupportBean_A", model.ToEPL());
}
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 TestNotExists_OM()
{
EPStatementObjectModel subquery = new EPStatementObjectModel();
subquery.SelectClause = SelectClause.CreateWildcard();
subquery.FromClause = FromClause.Create(FilterStream.Create("S1").AddView("win", "length", Expressions.Constant(1000)));
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("id");
model.FromClause = FromClause.Create(FilterStream.Create("S0"));
model.WhereClause = Expressions.Not(Expressions.SubqueryExists(subquery));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String stmtText = "select id from S0 where not exists (select * from S1.win:length(1000))";
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean_S0(2));
Assert.AreEqual(2, listener.AssertOneGetNewAndReset().Get("id"));
epService.EPRuntime.SendEvent(new SupportBean_S1(-1));
epService.EPRuntime.SendEvent(new SupportBean_S0(1));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean_S1(-2));
epService.EPRuntime.SendEvent(new SupportBean_S0(3));
Assert.IsFalse(listener.IsInvoked);
}
public void TestRStreamOnly_OM()
{
_epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
String stmtText = "select rstream * from " + typeof(SupportBean).FullName + ".win:length(3)";
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard(StreamSelector.RSTREAM_ONLY);
FromClause fromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView(View.Create("win", "length", Expressions.Constant(3))));
model.FromClause = fromClause;
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement statement = _epService.EPAdministrator.Create(model);
statement.Events += _testListener.Update;
Object theEvent = SendEvent("a");
Assert.IsFalse(_testListener.IsInvoked);
SendEvents(new String[] { "a", "b" });
Assert.IsFalse(_testListener.IsInvoked);
SendEvent("d");
Assert.AreSame(theEvent, _testListener.LastNewData[0].Underlying); // receive 'a' as new data
Assert.IsNull(_testListener.LastOldData); // receive no more old data
_testListener.Reset();
}
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 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();
}
private void RunAssertionMinMaxWindowStats_OM(EPServiceProvider epService)
{
string epl = "select max(LongBoxed,IntBoxed) as myMax, " +
"max(LongBoxed,IntBoxed,ShortBoxed) as myMaxEx, " +
"min(LongBoxed,IntBoxed) as myMin, " +
"min(LongBoxed,IntBoxed,ShortBoxed) as myMinEx" +
" from " + typeof(SupportBean).FullName + "#length(3)";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.Add(Expressions.Max("LongBoxed", "IntBoxed"), "myMax")
.Add(Expressions.Max(Expressions.Property("LongBoxed"), Expressions.Property("IntBoxed"), Expressions.Property("ShortBoxed")), "myMaxEx")
.Add(Expressions.Min("LongBoxed", "IntBoxed"), "myMin")
.Add(Expressions.Min(Expressions.Property("LongBoxed"), Expressions.Property("IntBoxed"), Expressions.Property("ShortBoxed")), "myMinEx");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName)
.AddView("length", Expressions.Constant(3)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
Assert.AreEqual(epl, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
TryMinMaxWindowStats(epService, listener);
stmt.Dispose();
}
public void TestGrouped()
{
var textOne = "select irstream CONCATSTRING(TheString) as val from " + typeof(SupportBean).FullName + ".win:length(10) group by IntPrimitive";
TryGrouped(textOne, null);
var textTwo = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + ".win:length(10) group by IntPrimitive";
TryGrouped(textTwo, null);
var textThree = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + ".win:length(10) group by IntPrimitive";
var model = _epService.EPAdministrator.CompileEPL(textThree);
SerializableObjectCopier.Copy(model);
Assert.AreEqual(textThree, model.ToEPL());
TryGrouped(null, model);
var textFour = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + ".win:length(10) group by IntPrimitive";
var modelTwo = new EPStatementObjectModel();
modelTwo.SelectClause = SelectClause.Create().SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
.Add(Expressions.PlugInAggregation("concatstring", Expressions.Property("TheString")), "val");
modelTwo.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView("win", "length", Expressions.Constant(10)));
modelTwo.GroupByClause = GroupByClause.Create("IntPrimitive");
Assert.AreEqual(textFour, modelTwo.ToEPL());
SerializableObjectCopier.Copy(modelTwo);
TryGrouped(null, modelTwo);
var textFive = "select irstream concatstringTwo(TheString) as val from " + typeof(SupportBean).FullName + ".win:length(10) group by IntPrimitive";
TryGrouped(textFive, null);
}
