public void TestGrouped()
{
var textOne = "select irstream CONCATSTRING(TheString) as val from " + typeof(SupportBean).FullName + "#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 + "#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 + "#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(null, "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 + "#length(10) group by IntPrimitive";
TryGrouped(textFive, null);
}
private void RunAssertionStatementOM(EPServiceProvider epService)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("symbol", "price")
.SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
.Add(Expressions.Avg("price"), "avgPrice");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName)
.AddView("length", Expressions.Constant(5)));
model.HavingClause = Expressions.Lt(Expressions.Property("price"), Expressions.Avg("price"));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
string epl = "select irstream symbol, price, avg(price) as avgPrice " +
"from " + typeof(SupportMarketDataBean).FullName + "#length(5) " +
"having price<avg(price)";
Assert.AreEqual(epl, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
TryAssertion(epService, listener, stmt);
stmt.Dispose();
}
private void RunAssertionInterval(EPServiceProvider epService)
{
SendTimer(0, epService);
string text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a, B[0].TheString as b0, B[1].TheString as b1, last(B.TheString) as lastb" +
" pattern (A B*)" +
" interval 10 seconds" +
" define" +
" A as A.TheString like \"A%\"," +
" B as B.TheString like \"B%\"" +
") order by a, b0, b1, lastb";
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
TryAssertionInterval(epService, listener, stmt);
stmt.Dispose();
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(text);
SerializableObjectCopier.Copy(epService.Container, model);
Assert.AreEqual(text, model.ToEPL());
stmt = epService.EPAdministrator.Create(model);
stmt.Events += listener.Update;
Assert.AreEqual(text, stmt.Text);
TryAssertionInterval(epService, listener, stmt);
stmt.Dispose();
}
private void RunAssertionCaseSyntax2WithNull_OM(EPServiceProvider epService)
{
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 + "#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("length", Expressions.Constant(100)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
Assert.AreEqual(caseExpr, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
Assert.AreEqual(typeof(double?), stmt.EventType.GetPropertyType("p1"));
RunCaseSyntax2WithNull(epService, listener);
stmt.Dispose();
}
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"));
}
private void RunAssertionCastStringAndNull_Compile(EPServiceProvider epService)
{
string stmtText = "select exists(item?.IntBoxed) as t0 " +
"from " + typeof(SupportMarkerInterface).FullName;
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(stmtText);
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(bool?), stmt.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"));
stmt.Dispose();
}
private void RunAssertionMultiColumnLeft_OM(EPServiceProvider epService)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("s0.id, s0.p00, s0.p01, s1.id, s1.p10, s1.p11".Split(','));
FromClause fromClause = FromClause.Create(
FilterStream.Create(typeof(SupportBean_S0).FullName, "s0").AddView("keepall"),
FilterStream.Create(typeof(SupportBean_S1).FullName, "s1").AddView("keepall"));
fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s1.p10").Add("s1.p11", "s0.p01"));
model.FromClause = fromClause;
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
string stmtText = "select s0.id, s0.p00, s0.p01, s1.id, s1.p10, s1.p11 from " + typeof(SupportBean_S0).FullName + "#keepall as s0 left outer join " + typeof(SupportBean_S1).FullName + "#keepall as s1 on s0.p00 = s1.p10 and s1.p11 = s0.p01";
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
AssertMultiColumnLeft(epService, listener);
EPStatementObjectModel modelReverse = epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, modelReverse.ToEPL());
stmt.Dispose();
}
private static void TryNotInKeywordPattern(
RegressionEnvironment env,
string field,
SupportInKeywordBean prototype,
AtomicLong milestone)
{
var epl = "@Name('s0') select * from pattern[every a=SupportInKeywordBean -> SupportBean(IntPrimitive not in (a." + field + "))]";
env.CompileDeployAddListenerMile(epl, "s0", milestone.GetAndIncrement());
AssertInKeywordReceivedPattern(env, SerializableObjectCopier.CopyMayFail(env.Container, prototype), 0, true);
AssertInKeywordReceivedPattern(env, SerializableObjectCopier.CopyMayFail(env.Container, prototype), 3, true);
AssertInKeywordReceivedPattern(env, SerializableObjectCopier.CopyMayFail(env.Container, prototype), 1, false);
if (HasFilterIndexPlanBasicOrMore(env)) {
SupportFilterServiceHelper.AssertFilterSvcByTypeMulti(
env.Statement("s0"),
"SupportBean",
new[] {
new[] {
new FilterItem("IntPrimitive", FilterOperator.NOT_IN_LIST_OF_VALUES)
},
});
}
env.UndeployAll();
}
private ConfigurationInformation TakeSnapshot(Configuration configuration)
{
try
{
// Allow variables to have non-serializable values by copying their initial value
IDictionary <string, Object> variableInitialValues = null;
if (!configuration.Variables.IsEmpty())
{
variableInitialValues = new Dictionary <string, object>();
foreach (var variable in configuration.Variables)
{
var initializationValue = variable.Value.InitializationValue;
if (initializationValue != null)
{
variableInitialValues.Put(variable.Key, initializationValue);
variable.Value.InitializationValue = null;
}
}
}
// Avro schemas are not serializable
IDictionary <string, ConfigurationEventTypeAvro> avroSchemas = null;
if (!configuration.EventTypesAvro.IsEmpty())
{
avroSchemas = new Dictionary <string, ConfigurationEventTypeAvro>(configuration.EventTypesAvro);
configuration.EventTypesAvro.Clear();
}
var copy = (Configuration)SerializableObjectCopier.Copy(configuration);
copy.TransientConfiguration = configuration.TransientConfiguration;
// Restore variable with initial values
if (variableInitialValues != null && !variableInitialValues.IsEmpty())
{
foreach (var entry in variableInitialValues)
{
var config = copy.Variables.Get(entry.Key);
config.InitializationValue = entry.Value;
}
}
// Restore Avro schemas
if (avroSchemas != null)
{
copy.EventTypesAvro.PutAll(avroSchemas);
}
return(copy);
}
catch (IOException e)
{
throw new ConfigurationException(
"Failed to snapshot configuration instance through serialization : " + e.Message, e);
}
catch (TypeLoadException e)
{
throw new ConfigurationException(
"Failed to snapshot configuration instance through serialization : " + e.Message, e);
}
}
public void TestCastStringAndNull_Compile()
{
var stmtText = "select cast(item?,System.String) as t0 " +
"from " + typeof(SupportMarkerInterface).FullName;
var model = _epService.EPAdministrator.CompileEPL(stmtText);
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
var selectTestCase = _epService.EPAdministrator.Create(model);
Assert.AreEqual(stmtText, model.ToEPL());
selectTestCase.Events += _listener.Update;
Assert.AreEqual(typeof(string), selectTestCase.EventType.GetPropertyType("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot(100));
Assert.AreEqual("100", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot((byte)2));
Assert.AreEqual("2", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot(77.7777));
Assert.AreEqual("77.7777", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot(6L));
Assert.AreEqual("6", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot(null));
Assert.AreEqual(null, _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBeanDynRoot("abc"));
Assert.AreEqual("abc", _listener.AssertOneGetNewAndReset().Get("t0"));
}
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 TestMinMaxView_OM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
.Add("Symbol")
.Add(Expressions.Min("Volume"), "minVol")
.Add(Expressions.Max("Volume"), "maxVol")
.Add(Expressions.MinDistinct("Volume"), "minDistVol")
.Add(Expressions.MaxDistinct("Volume"), "maxDistVol");
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);
String viewExpr = "select irstream Symbol, " +
"min(Volume) as minVol, " +
"max(Volume) as maxVol, " +
"min(distinct Volume) as minDistVol, " +
"max(distinct Volume) as maxDistVol " +
"from " + typeof(SupportMarketDataBean).FullName + ".win:length(3) " +
"where Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\" " +
"group by Symbol";
Assert.AreEqual(viewExpr, model.ToEPL());
EPStatement selectTestView = _epService.EPAdministrator.Create(model);
selectTestView.Events += _testListener.Update;
RunAssertion(selectTestView);
}
public void TestJoinSortWindow()
{
SendTimer(0);
var viewExpr = "select irstream max(Price) as maxVol" +
" from " + typeof(SupportMarketDataBean).FullName + ".ext:sort(1,Volume desc) as s0, " +
typeof(SupportBean).FullName + ".win:keepall() as s1 where s1.TheString=s0.Symbol " +
"output every 1.0d seconds";
var stmt = _epService.EPAdministrator.CreateEPL(viewExpr);
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("JOIN_KEY", -1));
SendEvent("JOIN_KEY", 1d);
SendEvent("JOIN_KEY", 2d);
_listener.Reset();
// moves all events out of the window,
SendTimer(1000); // newdata is 2 eventa, old data is the same 2 events, therefore the sum is null
var result = _listener.GetDataListsFlattened();
Assert.AreEqual(2, result.First.Length);
Assert.AreEqual(1.0, result.First[0].Get("maxVol"));
Assert.AreEqual(2.0, result.First[1].Get("maxVol"));
Assert.AreEqual(2, result.Second.Length);
Assert.AreEqual(null, result.Second[0].Get("maxVol"));
Assert.AreEqual(1.0, result.Second[1].Get("maxVol"));
// statement object model test
var model = _epService.EPAdministrator.CompileEPL(viewExpr);
SerializableObjectCopier.Copy(model);
Assert.AreEqual(viewExpr, model.ToEPL());
}
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)
{
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 TestSingleOM()
{
String eventName = typeof(SupportBeanSimple).FullName;
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard().Add(Expressions.Concat("MyString", "MyString"), "concat");
model.FromClause = FromClause.Create(FilterStream.Create(eventName).AddView(View.Create("win", "length", Expressions.Constant(5))));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String text = "select *, MyString||MyString as concat from " + eventName + ".win:length(5)";
Assert.AreEqual(text, model.ToEPL());
EPStatement statement = _epService.EPAdministrator.Create(model);
statement.Events += _listener.Update;
AssertSimple();
EPAssertionUtil.AssertEqualsAnyOrder(new[] {
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),
}, statement.EventType.PropertyDescriptors);
}
public void TestMultiColumnLeft_OM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("s0.id, s0.p00, s0.p01, s1.id, s1.p10, s1.p11".SplitCsv());
var fromClause = FromClause.Create(
FilterStream.Create(typeof(SupportBean_S0).FullName, "s0").AddView("keepall"),
FilterStream.Create(typeof(SupportBean_S1).FullName, "s1").AddView("keepall"));
fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s1.p10").Add("s1.p11", "s0.p01"));
model.FromClause = fromClause;
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
var stmtText = "select s0.id, s0.p00, s0.p01, s1.id, s1.p10, s1.p11 from " + typeof(SupportBean_S0).FullName + "#keepall as s0 left outer join " + typeof(SupportBean_S1).FullName + "#keepall as s1 on s0.p00 = s1.p10 and s1.p11 = s0.p01";
Assert.AreEqual(stmtText, model.ToEPL());
var outerJoinView = _epService.EPAdministrator.Create(model);
outerJoinView.AddListener(_listener);
AssertMultiColumnLeft();
var modelReverse = _epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, modelReverse.ToEPL());
}
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 RunAssertionInstanceofStringAndNull_OM(EPServiceProvider epService)
{
string stmtText = "select instanceof(TheString,string) as t0, " +
"instanceof(TheString,float,string,int) as t1 " +
"from " + typeof(SupportBean).FullName;
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).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;
epService.EPRuntime.SendEvent(new SupportBean("abc", 100));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.IsTrue((bool?)theEvent.Get("t0"));
Assert.IsTrue((bool?)theEvent.Get("t1"));
epService.EPRuntime.SendEvent(new SupportBean(null, 100));
theEvent = listener.AssertOneGetNewAndReset();
Assert.IsFalse((bool?)theEvent.Get("t0"));
Assert.IsFalse((bool?)theEvent.Get("t1"));
stmt.Dispose();
}
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 TestMultiColumnLeft_OM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("s0.id, s0.P00, s0.p01, s1.id, s1.p10, s1.p11".Split(','));
FromClause fromClause = FromClause.Create(
FilterStream.Create(typeof(SupportBean_S0).FullName, "s0").AddView("win", "keepall"),
FilterStream.Create(typeof(SupportBean_S1).FullName, "s1").AddView("win", "keepall"));
fromClause.Add(OuterJoinQualifier.Create("s0.P00", OuterJoinType.LEFT, "s1.p10").Add("s1.p11", "s0.p01"));
model.FromClause = fromClause;
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String stmtText =
"select s0.id, s0.P00, s0.p01, s1.id, s1.p10, s1.p11 from com.espertech.esper.support.bean.SupportBean_S0.win:keepall() as s0 left outer join com.espertech.esper.support.bean.SupportBean_S1.win:keepall() as s1 on s0.P00 = s1.p10 and s1.p11 = s0.p01";
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement outerJoinView = _epService.EPAdministrator.Create(model);
outerJoinView.Events += _listener.Update;
AssertMultiColumnLeft();
EPStatementObjectModel modelReverse = _epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, modelReverse.ToEPL());
}
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());
}
private void RunAssertionCaseSyntax1Sum_OM(EPServiceProvider epService)
{
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).FullName).AddView("win", "length", Expressions.Constant(10)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
string caseExpr = "select case" +
" when symbol=\"GE\" then volume" +
" when symbol=\"DELL\" then sum(price) " +
"end as p1 from " + typeof(SupportMarketDataBean).FullName + ".win:length(10)";
Assert.AreEqual(caseExpr, model.ToEPL());
EPStatement stmt = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
Assert.AreEqual(typeof(double?), stmt.EventType.GetPropertyType("p1"));
RunCaseSyntax1Sum(epService, listener);
stmt.Dispose();
}
public void TestMinMaxWindowStats_OM()
{
String viewExpr = "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 + ".win: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("win", "length", Expressions.Constant(3)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(viewExpr, model.ToEPL());
EPStatement selectTestView = _epService.EPAdministrator.Create(model);
selectTestView.Events += _testListener.Update;
_testListener.Reset();
RunMinMaxWindowStats();
}
public void TestCastStringAndNull_Compile()
{
String stmtText = "select exists(item?.IntBoxed) as t0 " +
"from " + typeof(SupportMarkerInterface).FullName;
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtText);
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 TestBitWiseOperators_OM()
{
String viewExpr = "select BytePrimitive&ByteBoxed as myFirstProperty, " +
"ShortPrimitive|ShortBoxed as mySecondProperty, " +
"IntPrimitive|IntBoxed as myThirdProperty, " +
"LongPrimitive^LongBoxed as myFourthProperty, " +
"BoolPrimitive&BoolBoxed as myFifthProperty " +
"from " + typeof(SupportBean).FullName + ".win:length(3)";
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create()
.Add(Expressions.BinaryAnd().Add("BytePrimitive").Add("ByteBoxed"), "myFirstProperty")
.Add(Expressions.BinaryOr().Add("ShortPrimitive").Add("ShortBoxed"), "mySecondProperty")
.Add(Expressions.BinaryOr().Add("IntPrimitive").Add("IntBoxed"), "myThirdProperty")
.Add(Expressions.BinaryXor().Add("LongPrimitive").Add("LongBoxed"), "myFourthProperty")
.Add(Expressions.BinaryAnd().Add("BoolPrimitive").Add("BoolBoxed"), "myFifthProperty");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView("win", "length", Expressions.Constant(3)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(viewExpr, model.ToEPL());
EPStatement selectTestView = _epService.EPAdministrator.CreateEPL(viewExpr);
selectTestView.Events += _listener.Update;
RunBitWiseOperators();
}
public void TestSameEventOM()
{
EPStatementObjectModel subquery = new EPStatementObjectModel();
subquery.SelectClause = SelectClause.CreateWildcard();
subquery.FromClause = FromClause.Create(FilterStream.Create("S1").AddView(View.Create("win", "length", Expressions.Constant(1000))));
EPStatementObjectModel model = new EPStatementObjectModel();
model.FromClause = FromClause.Create(FilterStream.Create("S1"));
model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "events1");
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String stmtText = "select (select * from S1.win:length(1000)) as events1 from S1";
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
stmt.Events += _listener.Update;
EventType type = stmt.EventType;
Assert.AreEqual(typeof(SupportBean_S1), type.GetPropertyType("events1"));
Object theEvent = new SupportBean_S1(-1, "Y");
_epService.EPRuntime.SendEvent(theEvent);
EventBean result = _listener.AssertOneGetNewAndReset();
Assert.AreSame(theEvent, result.Get("events1"));
}
public void TestRStreamOnly_Compile()
{
_epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, this.GetType(), this.GetType().FullName);
}
string stmtText = "select rstream * from " + typeof(SupportBean).FullName + ".win:length(3)";
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtText);
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
EPStatement statement = _epService.EPAdministrator.Create(model);
statement.AddListener(_testListener);
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 TestAliasesAggregationOM()
{
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(model);
var 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());
_testListener = new SupportUpdateListener();
var statement = _epService.EPAdministrator.Create(model);
statement.AddListener(_testListener);
RunAssertionDefault();
}
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 });
}
