private void RunAssertionSimpleNoParameter(EPServiceProvider epService)
{
string stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=\"e1\")";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmt);
EPStatement statement = epService.EPAdministrator.Create(prepared);
var listenerOne = new SupportUpdateListener();
statement.Events += listenerOne.Update;
Assert.AreEqual("select * from " + typeof(SupportBean).FullName + "(TheString=\"e1\")", statement.Text);
statement = epService.EPAdministrator.Create(prepared);
var listenerTwo = new SupportUpdateListener();
statement.Events += listenerTwo.Update;
Assert.AreEqual("select * from com.espertech.esper.supportregression.bean.SupportBean(TheString=\"e1\")", statement.Text);
epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsFalse(listenerTwo.IsInvoked);
epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
Assert.IsTrue(listenerTwo.GetAndClearIsInvoked());
statement.Dispose();
}
public void TestInvalidSetObject()
{
String stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(stmt);
try
{
prepared.SetObject(0, "");
Assert.Fail();
}
catch (ArgumentException ex)
{
Assert.AreEqual("Substitution parameter index starts at 1", ex.Message);
}
try
{
prepared.SetObject(2, "");
Assert.Fail();
}
catch (ArgumentException ex)
{
Assert.AreEqual("Invalid substitution parameter index of 2 supplied, the maximum for this statement is 1", ex.Message);
}
}
public void TestPattern()
{
String stmt = typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = _epService.EPAdministrator.PreparePattern(stmt);
prepared.SetObject(1, "e1");
EPStatement statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerOne.Update;
Assert.AreEqual("select * from pattern [com.espertech.esper.support.bean.SupportBean(TheString=\"e1\")]", statement.Text);
prepared.SetObject(1, "e2");
statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerTwo.Update;
Assert.AreEqual("select * from pattern [com.espertech.esper.support.bean.SupportBean(TheString=\"e2\")]", statement.Text);
_epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(_listenerOne.IsInvoked);
Assert.IsTrue(_listenerTwo.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsFalse(_listenerTwo.IsInvoked);
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
statement.Dispose();
prepared = _epService.EPAdministrator.PrepareEPL("create window MyWindow.win:time(?) as " + typeof(SupportBean).FullName);
prepared.SetObject(1, 300);
statement = _epService.EPAdministrator.Create(prepared);
Assert.AreEqual("create window MyWindow.win:time(300) as select * from com.espertech.esper.support.bean.SupportBean", statement.Text);
}
private void RunAssertionNamedParameter(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
string epl = "select ?:my/value/int as c0 from SupportBean(TheString = ?:somevalue, IntPrimitive=?:my/value/int, LongPrimitive=?:/my/value/long)";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(epl);
prepared.SetObject("somevalue", "E1");
prepared.SetObject("my/value/int", 10);
prepared.SetObject("/my/value/long", 100L);
var listenerOne = new SupportUpdateListener();
epService.EPAdministrator.Create(prepared).Events += listenerOne.Update;
SupportBean @event = new SupportBean("E1", 10);
@event.LongPrimitive = 100;
epService.EPRuntime.SendEvent(@event);
EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), "c0".Split(','), new object[] { 10 });
SupportMessageAssertUtil.TryInvalid(epService, "select ?,?:a from SupportBean",
"Inconsistent use of substitution parameters, expecting all substitutions to either all provide a name or provide no name");
SupportMessageAssertUtil.TryInvalid(epService, "select ?:select from SupportBean",
"Incorrect syntax near ':' ('select' is a reserved keyword) at line 1 column 8 near reserved keyword 'select' [");
epService.EPAdministrator.DestroyAllStatements();
}
/// <summary>
/// Creates and starts a prepared statement.
/// <para/>
/// The statement name is optimally a unique name. If a statement of the same name
/// has already been created, the engine assigns a postfix to create a unique
/// statement name.
/// <para/>
/// Accepts an application defined user data object associated with the statement.
/// The <em>user object</em> is a single, unnamed field that is stored with every
/// statement. Applications may put arbitrary objects in this field or a null value.
/// </summary>
/// <param name="prepared">is the prepared statement for which all substitution values have been provided</param>
/// <param name="statementName">is the name to assign to the statement for use in managing the statement</param>
/// <param name="userObject">is the application-defined user object</param>
/// <returns>
/// EPStatement to poll data from or to add listeners to
/// </returns>
/// <throws>EPException when the prepared statement was not valid</throws>
public EPStatement Create(EPPreparedStatement prepared, string statementName, object userObject)
{
if (prepared == null)
{
throw new ArgumentNullException("prepared");
}
var cprepared = prepared as CatalystPreparedStatement;
if (cprepared == null)
{
throw new ArgumentException("prepared statement was of incorrect type", "prepared");
}
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
statementArgs.PreparedStatementId = cprepared.Id;
statementArgs.StatementName = statementName;
statementArgs.StatementText = null;
var statement = controlManager.CreatePrepared(_instanceId, statementArgs);
var statementWrapper = new CatalystStatement(_adapter, statement, userObject);
BindStatement(statementWrapper);
return statementWrapper;
}));
}
}
private void RunAssertionPattern(EPServiceProvider epService)
{
string stmt = typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = epService.EPAdministrator.PreparePattern(stmt);
prepared.SetObject(1, "e1");
EPStatement statement = epService.EPAdministrator.Create(prepared);
var listenerOne = new SupportUpdateListener();
statement.Events += listenerOne.Update;
Assert.AreEqual("select * from pattern [" + typeof(SupportBean).FullName + "(TheString=\"e1\")]", statement.Text);
prepared.SetObject(1, "e2");
statement = epService.EPAdministrator.Create(prepared);
var listenerTwo = new SupportUpdateListener();
statement.Events += listenerTwo.Update;
Assert.AreEqual("select * from pattern [com.espertech.esper.supportregression.bean.SupportBean(TheString=\"e2\")]", statement.Text);
epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsTrue(listenerTwo.GetAndClearIsInvoked());
epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsFalse(listenerTwo.IsInvoked);
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
statement.Dispose();
prepared = epService.EPAdministrator.PrepareEPL("create window MyWindow#time(?) as " + typeof(SupportBean).FullName);
prepared.SetObject(1, 300);
statement = epService.EPAdministrator.Create(prepared);
Assert.AreEqual("create window MyWindow#time(300) as select * from " + typeof(SupportBean).FullName, statement.Text);
}
private void RunAssertionIntervalPrepared(EPServiceProvider epService)
{
// External clocking
SendTimer(0, epService);
// Set up a timer:within
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(
"select * from pattern [(every " + typeof(SupportBean).FullName +
") where timer:within(? days ? hours ? minutes ? seconds ? milliseconds)]");
prepared.SetObject(1, 1);
prepared.SetObject(2, 2);
prepared.SetObject(3, 3);
prepared.SetObject(4, 4);
prepared.SetObject(5, 5);
EPStatement statement = epService.EPAdministrator.Create(prepared);
var testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
TryAssertion(epService, testListener);
statement.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);
}
private void RunAssertionInvalidParameterNotSet(EPServiceProvider epService)
{
string stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmt);
try {
epService.EPAdministrator.Create(prepared);
Assert.Fail();
} catch (EPException ex) {
Assert.AreEqual("Substitution parameter value for index 1 not set, please provide a value for this parameter", ex.Message);
}
stmt = "select * from " + typeof(SupportBean).FullName + "(TheString in (?, ?))";
prepared = epService.EPAdministrator.PrepareEPL(stmt);
try {
epService.EPAdministrator.Create(prepared);
Assert.Fail();
} catch (EPException) {
// expected
}
try {
prepared.SetObject(1, "");
epService.EPAdministrator.Create(prepared);
Assert.Fail();
} catch (EPException) {
// expected
}
// success
prepared.SetObject(2, "");
epService.EPAdministrator.Create(prepared).Dispose();
}
public EPStatement Create(EPPreparedStatement prepared, string statementName, object userobject, int?optionalStatementId)
{
var impl = (EPPreparedStatementImpl)prepared;
var statementSpec = MapSODAToRaw(impl.Model);
var eplStatement = impl.Model.ToEPL();
return(_services.StatementLifecycleSvc.CreateAndStart(statementSpec, eplStatement, false, statementName, userobject, null, optionalStatementId, impl.Model));
}
public EPStatement Create(EPPreparedStatement prepared, String statementName, Object userObject, String statementId)
{
EPPreparedStatementImpl impl = (EPPreparedStatementImpl)prepared;
StatementSpecRaw statementSpec = MapSODAToRaw(impl.Model);
String eplStatement = impl.Model.ToEPL();
return(_services.StatementLifecycleSvc.CreateAndStart(statementSpec, eplStatement, false, statementName, userObject, null, statementId, impl.Model));
}
private void RunSimpleTwoParameter(EPServiceProvider epService, string stmtText, string statementName, bool compareText)
{
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmtText);
prepared.SetObject(1, "e1");
prepared.SetObject(2, 1);
EPStatement statement;
if (statementName != null)
{
statement = epService.EPAdministrator.Create(prepared, statementName);
}
else
{
statement = epService.EPAdministrator.Create(prepared);
}
var listenerOne = new SupportUpdateListener();
statement.Events += listenerOne.Update;
if (compareText)
{
Assert.AreEqual("select * from " + typeof(SupportBean).FullName + "(TheString=\"e1\" and IntPrimitive=1)", statement.Text);
}
prepared.SetObject(1, "e2");
prepared.SetObject(2, 2);
if (statementName != null)
{
statement = epService.EPAdministrator.Create(prepared, statementName + "_1");
}
else
{
statement = epService.EPAdministrator.Create(prepared);
}
var listenerTwo = new SupportUpdateListener();
statement.Events += listenerTwo.Update;
if (compareText)
{
Assert.AreEqual("select * from " + typeof(SupportBean).FullName + "(TheString=\"e2\" and IntPrimitive=2)", statement.Text);
}
epService.EPRuntime.SendEvent(new SupportBean("e2", 2));
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsTrue(listenerTwo.GetAndClearIsInvoked());
epService.EPRuntime.SendEvent(new SupportBean("e1", 1));
Assert.IsFalse(listenerTwo.IsInvoked);
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
epService.EPRuntime.SendEvent(new SupportBean("e1", 2));
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsFalse(listenerTwo.IsInvoked);
statement.Dispose();
}
private void RunAssertionSimpleOneParameter(EPServiceProvider epService)
{
string stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmt);
prepared.SetObject(1, "e1");
EPStatement statement = epService.EPAdministrator.Create(prepared);
var listenerOne = new SupportUpdateListener();
statement.Events += listenerOne.Update;
Assert.AreEqual("select * from " + typeof(SupportBean).FullName + "(TheString=\"e1\")", statement.Text);
prepared.SetObject(1, "e2");
statement = epService.EPAdministrator.Create(prepared);
var listenerTwo = new SupportUpdateListener();
statement.Events += listenerTwo.Update;
Assert.AreEqual("select * from com.espertech.esper.supportregression.bean.SupportBean(TheString=\"e2\")", statement.Text);
epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsTrue(listenerTwo.GetAndClearIsInvoked());
epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsFalse(listenerTwo.IsInvoked);
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
// Test substitution parameter and inheritance in key matching
epService.EPAdministrator.Configuration.AddEventType("MyEventOne", typeof(MyEventOne));
string epl = "select * from MyEventOne(key = ?)";
EPPreparedStatement preparedStatement = epService.EPAdministrator.PrepareEPL(epl);
var lKey = new MyObjectKeyInterface();
preparedStatement.SetObject(1, lKey);
statement = epService.EPAdministrator.Create(preparedStatement);
statement.Events += listenerOne.Update;
epService.EPRuntime.SendEvent(new MyEventOne(lKey));
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
// Test substitution parameter and concrete subclass in key matching
epService.EPAdministrator.Configuration.AddEventType("MyEventTwo", typeof(MyEventTwo));
epl = "select * from MyEventTwo where key = ?";
preparedStatement = epService.EPAdministrator.PrepareEPL(epl);
var cKey = new MyObjectKeyConcrete();
preparedStatement.SetObject(1, cKey);
statement = epService.EPAdministrator.Create(preparedStatement);
statement.Events += listenerOne.Update;
epService.EPRuntime.SendEvent(new MyEventTwo(cKey));
Assert.IsTrue(listenerOne.GetAndClearIsInvoked());
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionInvalidNoParameters(EPServiceProvider epService)
{
string stmt = "select * from " + typeof(SupportBean).FullName + "(TheString='ABC')";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmt);
try {
prepared.SetObject(1, -1);
Assert.Fail();
} catch (ArgumentException ex) {
Assert.AreEqual("Statement does not have substitution parameters indicated by the '?' character", ex.Message);
}
}
private void RunAssertionInvalidParameterType(EPServiceProvider epService)
{
string stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(stmt);
try {
prepared.SetObject(1, -1);
epService.EPAdministrator.Create(prepared);
Assert.Fail();
} catch (EPException ex) {
SupportMessageAssertUtil.AssertMessage(ex, "Failed to validate filter expression 'TheString=-1': Implicit conversion from datatype '" + Name.Clean <int>() + "' to '" + Name.Clean <string>() + "' is not allowed [");
}
}
private void RunSimpleTwoParameter(String stmtText, String statementName, bool compareText)
{
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(stmtText);
prepared.SetObject(1, "e1");
prepared.SetObject(2, 1);
EPStatement statement;
if (statementName != null)
{
statement = _epService.EPAdministrator.Create(prepared, statementName);
}
else
{
statement = _epService.EPAdministrator.Create(prepared);
}
statement.Events += _listenerOne.Update;
if (compareText)
{
Assert.AreEqual("select * from com.espertech.esper.support.bean.SupportBean(TheString=\"e1\" and IntPrimitive=1)", statement.Text);
}
prepared.SetObject(1, "e2");
prepared.SetObject(2, 2);
if (statementName != null)
{
statement = _epService.EPAdministrator.Create(prepared, statementName + "_1");
}
else
{
statement = _epService.EPAdministrator.Create(prepared);
}
statement.Events += _listenerTwo.Update;
if (compareText)
{
Assert.AreEqual("select * from com.espertech.esper.support.bean.SupportBean(TheString=\"e2\" and IntPrimitive=2)", statement.Text);
}
_epService.EPRuntime.SendEvent(new SupportBean("e2", 2));
Assert.IsFalse(_listenerOne.IsInvoked);
Assert.IsTrue(_listenerTwo.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("e1", 1));
Assert.IsFalse(_listenerTwo.IsInvoked);
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("e1", 2));
Assert.IsFalse(_listenerOne.IsInvoked);
Assert.IsFalse(_listenerTwo.IsInvoked);
}
public void TestSimpleOneParameter()
{
String stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(stmt);
prepared.SetObject(1, "e1");
EPStatement statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerOne.Update;
Assert.AreEqual("select * from " + Name.Of <SupportBean>() + "(TheString=\"e1\")", statement.Text);
prepared.SetObject(1, "e2");
statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerTwo.Update;
Assert.AreEqual("select * from " + Name.Of <SupportBean>() + "(TheString=\"e2\")", statement.Text);
_epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(_listenerOne.IsInvoked);
Assert.IsTrue(_listenerTwo.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsFalse(_listenerTwo.IsInvoked);
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
// Test substitution parameter and inheritance in key matching
_epService.EPAdministrator.Configuration.AddEventType("MyEventOne", typeof(MyEventOne));
String epl = "select * from MyEventOne(key = ?)";
EPPreparedStatement preparedStatement = _epService.EPAdministrator.PrepareEPL(epl);
MyObjectKeyInterface lKey = new MyObjectKeyInterface();
preparedStatement.SetObject(1, lKey);
statement = _epService.EPAdministrator.Create(preparedStatement);
statement.Events += _listenerOne.Update;
_epService.EPRuntime.SendEvent(new MyEventOne(lKey));
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
// Test substitution parameter and concrete subclass in key matching
_epService.EPAdministrator.Configuration.AddEventType("MyEventTwo", typeof(MyEventTwo));
epl = "select * from MyEventTwo where key = ?";
preparedStatement = _epService.EPAdministrator.PrepareEPL(epl);
MyObjectKeyConcrete cKey = new MyObjectKeyConcrete();
preparedStatement.SetObject(1, cKey);
statement = _epService.EPAdministrator.Create(preparedStatement);
statement.Events += _listenerOne.Update;
_epService.EPRuntime.SendEvent(new MyEventTwo(cKey));
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
}
public void TestInvalidParameterType()
{
String stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=?)";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(stmt);
try
{
prepared.SetObject(1, -1);
_epService.EPAdministrator.Create(prepared);
Assert.Fail();
}
catch (EPException ex)
{
Assert.AreEqual(string.Format("Failed to validate filter expression 'TheString=-1': Implicit conversion from datatype '{0}' to 'System.String' is not allowed [select * from com.espertech.esper.support.bean.SupportBean(TheString=-1)]", typeof(int?).FullName), ex.Message);
}
}
private void RunAssertionMethodInvocation(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(
"select * from SupportBean(TheString = ?.get_TheString())");
prepared.SetObject(1, new SupportBean("E1", 0));
var listenerOne = new SupportUpdateListener();
epService.EPAdministrator.Create(prepared).Events += listenerOne.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 0));
Assert.IsTrue(listenerOne.IsInvoked);
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionSubselect(EPServiceProvider epService)
{
string stmtText = "select (" +
"select symbol from " + typeof(SupportMarketDataBean).FullName + "(symbol=?)#lastevent) as mysymbol from " +
typeof(SupportBean).FullName;
EPPreparedStatement preparedStmt = epService.EPAdministrator.PrepareEPL(stmtText);
preparedStmt.SetObject(1, "S1");
EPStatement stmtS1 = epService.EPAdministrator.Create(preparedStmt);
var listenerOne = new SupportUpdateListener();
stmtS1.Events += listenerOne.Update;
preparedStmt.SetObject(1, "S2");
EPStatement stmtS2 = epService.EPAdministrator.Create(preparedStmt);
var listenerTwo = new SupportUpdateListener();
stmtS2.Events += listenerTwo.Update;
// test no event, should return null
epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual(null, listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test one non-matching event
epService.EPRuntime.SendEvent(new SupportMarketDataBean("XX", 0, 0L, ""));
epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual(null, listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test S2 matching event
epService.EPRuntime.SendEvent(new SupportMarketDataBean("S2", 0, 0L, ""));
epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual("S2", listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test S1 matching event
epService.EPRuntime.SendEvent(new SupportMarketDataBean("S1", 0, 0L, ""));
epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual("S1", listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual("S2", listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
epService.EPAdministrator.DestroyAllStatements();
}
private void TrySubstitutionParameter(Object parameter)
{
SupportUpdateListener listener = new SupportUpdateListener();
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL("select * from SupportBean(?.sequenceEqual({1, IntPrimitive, 100}))");
prepared.SetObject(1, parameter);
_epService.EPAdministrator.Create(prepared).Events += listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
Assert.IsTrue(listener.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("E2", 20));
Assert.IsFalse(listener.GetAndClearIsInvoked());
_epService.EPAdministrator.DestroyAllStatements();
}
public void TestSubselect()
{
String stmtText = "select (" +
"select symbol from " + typeof(SupportMarketDataBean).FullName + "(symbol=?).std:lastevent()) as mysymbol from " +
typeof(SupportBean).FullName;
EPPreparedStatement preparedStmt = _epService.EPAdministrator.PrepareEPL(stmtText);
preparedStmt.SetObject(1, "S1");
EPStatement stmtS1 = _epService.EPAdministrator.Create(preparedStmt);
stmtS1.Events += _listenerOne.Update;
preparedStmt.SetObject(1, "S2");
EPStatement stmtS2 = _epService.EPAdministrator.Create(preparedStmt);
stmtS2.Events += _listenerTwo.Update;
// test no event, should return null
_epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, _listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual(null, _listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test one non-matching event
_epService.EPRuntime.SendEvent(new SupportMarketDataBean("XX", 0, 0L, ""));
_epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, _listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual(null, _listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test S2 matching event
_epService.EPRuntime.SendEvent(new SupportMarketDataBean("S2", 0, 0L, ""));
_epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual(null, _listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual("S2", _listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
// test S1 matching event
_epService.EPRuntime.SendEvent(new SupportMarketDataBean("S1", 0, 0L, ""));
_epService.EPRuntime.SendEvent(new SupportBean("e1", -1));
Assert.AreEqual("S1", _listenerOne.AssertOneGetNewAndReset().Get("mysymbol"));
Assert.AreEqual("S2", _listenerTwo.AssertOneGetNewAndReset().Get("mysymbol"));
}
public void TestTimeWindowPreparedStmt()
{
SendTimer(0);
String text = "select rstream TheString from SupportBean.win:time(?)";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(
text);
prepared.SetObject(1, 4);
EPStatement stmtOne = _epService.EPAdministrator.Create(prepared);
SupportUpdateListener listenerOne = new SupportUpdateListener();
stmtOne.Events += listenerOne.Update;
prepared.SetObject(1, 3);
EPStatement stmtTwo = _epService.EPAdministrator.Create(prepared);
SupportUpdateListener listenerTwo = new SupportUpdateListener();
stmtTwo.Events += listenerTwo.Update;
RunAssertion(listenerOne, listenerTwo);
}
public void TestSimpleNoParameter()
{
String stmt = "select * from " + typeof(SupportBean).FullName + "(TheString=\"e1\")";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(stmt);
EPStatement statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerOne.Update;
Assert.AreEqual("select * from com.espertech.esper.support.bean.SupportBean(TheString=\"e1\")", statement.Text);
statement = _epService.EPAdministrator.Create(prepared);
statement.Events += _listenerTwo.Update;
Assert.AreEqual("select * from com.espertech.esper.support.bean.SupportBean(TheString=\"e1\")", statement.Text);
_epService.EPRuntime.SendEvent(new SupportBean("e2", 10));
Assert.IsFalse(_listenerOne.IsInvoked);
Assert.IsFalse(_listenerTwo.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("e1", 10));
Assert.IsTrue(_listenerOne.GetAndClearIsInvoked());
Assert.IsTrue(_listenerTwo.GetAndClearIsInvoked());
}
private void RunAssertionTimeWindowPreparedStmt(EPServiceProvider epService)
{
SendTimer(epService, 0);
string text = "select rstream TheString from SupportBean#time(?)";
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(text);
prepared.SetObject(1, 4);
EPStatement stmtOne = epService.EPAdministrator.Create(prepared);
var listenerOne = new SupportUpdateListener();
stmtOne.Events += listenerOne.Update;
prepared.SetObject(1, 3);
EPStatement stmtTwo = epService.EPAdministrator.Create(prepared);
var listenerTwo = new SupportUpdateListener();
stmtTwo.Events += listenerTwo.Update;
RunAssertion(epService, listenerOne, listenerTwo);
stmtOne.Dispose();
stmtTwo.Dispose();
}
private void RunAssertionSimpleIntAndEnumWrite(EPServiceProvider epService)
{
string expr = "select * from " + typeof(SupportBean).FullName + "(IntPrimitive in (1, 10))";
EPStatement stmt = epService.EPAdministrator.CreateEPL(expr);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendBeanInt(epService, 10);
Assert.IsTrue(listener.GetAndClearIsInvoked());
SendBeanInt(epService, 11);
Assert.IsFalse(listener.GetAndClearIsInvoked());
SendBeanInt(epService, 1);
Assert.IsTrue(listener.GetAndClearIsInvoked());
stmt.Dispose();
// try enum - ESPER-459
var types = new HashSet <SupportEnum>();
types.Add(SupportEnum.ENUM_VALUE_2);
EPPreparedStatement inPstmt = epService.EPAdministrator.PrepareEPL("select * from " + typeof(SupportBean).FullName + " ev " + "where ev.enumValue in (?)");
inPstmt.SetObject(1, types);
EPStatement inStmt = epService.EPAdministrator.Create(inPstmt);
inStmt.Events += listener.Update;
var theEvent = new SupportBean();
theEvent.EnumValue = SupportEnum.ENUM_VALUE_2;
epService.EPRuntime.SendEvent(theEvent);
Assert.IsTrue(listener.IsInvoked);
inStmt.Dispose();
}
public void TestIntervalPrepared()
{
Configuration config = SupportConfigFactory.GetConfiguration();
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
// External clocking
SendTimer(0, epService);
// Set up a timer:within
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(
"select * from pattern [(every " + typeof(SupportBean).FullName +
") where timer:within(? days ? hours ? minutes ? seconds ? milliseconds)]");
prepared.SetObject(1, 1);
prepared.SetObject(2, 2);
prepared.SetObject(3, 3);
prepared.SetObject(4, 4);
prepared.SetObject(5, 5);
EPStatement statement = epService.EPAdministrator.Create(prepared);
SupportUpdateListener testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
RunAssertion(epService, testListener);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestIntervalSpecPreparedStmt()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
// External clocking
SendTimer(0, epService);
// Set up a timer:within
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(
"select * from pattern [timer:interval(? minute ? seconds)]");
prepared.SetObject(1, 1);
prepared.SetObject(2, 2);
EPStatement statement = epService.EPAdministrator.Create(prepared);
SupportUpdateListener testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
SendTimer(62 * 1000 - 1, epService);
Assert.IsFalse(testListener.IsInvoked);
SendTimer(62 * 1000, epService);
Assert.IsTrue(testListener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestInArraySubstitution()
{
_epService.EPAdministrator.Configuration.AddEventType(
"SupportBean", typeof(SupportBean));
String stmtText = "select IntPrimitive in (?) as result from SupportBean";
EPPreparedStatement prepared = _epService.EPAdministrator.PrepareEPL(
stmtText);
prepared.SetObject(
1, new int[]
{
10, 20, 30
}
);
EPStatement stmt = _epService.EPAdministrator.Create(prepared);
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
Assert.IsTrue((bool)_listener.AssertOneGetNewAndReset().Get("result"));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 9));
Assert.IsFalse((bool)_listener.AssertOneGetNewAndReset().Get("result"));
}
public void TestSimpleIntAndEnumWrite()
{
String expr = "select * from " + typeof(SupportBean).FullName
+ "(IntPrimitive in (1, 10))";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(expr);
stmt.Events += _testListener.Update;
SendBeanInt(10);
Assert.IsTrue(_testListener.GetAndClearIsInvoked());
SendBeanInt(11);
Assert.IsFalse(_testListener.GetAndClearIsInvoked());
SendBeanInt(1);
Assert.IsTrue(_testListener.GetAndClearIsInvoked());
stmt.Dispose();
// try enum - ESPER-459
ICollection <SupportEnum> types = new HashSet <SupportEnum>();
types.Add(SupportEnum.ENUM_VALUE_2);
EPPreparedStatement inPstmt = _epService.EPAdministrator.PrepareEPL(
string.Format("select * from {0} ev where ev.EnumValue in (?)", typeof(SupportBean).FullName));
inPstmt.SetObject(1, types);
EPStatement inStmt = _epService.EPAdministrator.Create(inPstmt);
inStmt.Events += _testListener.Update;
var theEvent = new SupportBean();
theEvent.EnumValue = SupportEnum.ENUM_VALUE_2;
_epService.EPRuntime.SendEvent(theEvent);
Assert.IsTrue(_testListener.IsInvoked);
}
