private void AssertTypeColDef(EventType eventType)
{
Assert.AreEqual(typeof(string), eventType.GetPropertyType("col1"));
Assert.AreEqual(typeof(int?), eventType.GetPropertyType("col2").GetBoxedType());
Assert.AreEqual(typeof(int?), eventType.GetPropertyType("col3_col4").GetBoxedType());
Assert.AreEqual(3, eventType.PropertyDescriptors.Count);
}
public Pair <IndexMultiKey, EventTable> GetFireAndForgetDesc(
ISet <String> keysAvailable,
ISet <String> rangesAvailable)
{
IList <VirtualDataWindowLookupFieldDesc> hashFields = new List <VirtualDataWindowLookupFieldDesc>();
IList <IndexedPropDesc> hashIndexedFields = new List <IndexedPropDesc>();
foreach (var hashprop in keysAvailable)
{
hashFields.Add(new VirtualDataWindowLookupFieldDesc(hashprop, VirtualDataWindowLookupOp.EQUALS, null));
hashIndexedFields.Add(new IndexedPropDesc(hashprop, _eventType.GetPropertyType(hashprop)));
}
IList <VirtualDataWindowLookupFieldDesc> btreeFields = new List <VirtualDataWindowLookupFieldDesc>();
IList <IndexedPropDesc> btreeIndexedFields = new List <IndexedPropDesc>();
foreach (var btreeprop in rangesAvailable)
{
btreeFields.Add(new VirtualDataWindowLookupFieldDesc(btreeprop, null, null));
btreeIndexedFields.Add(new IndexedPropDesc(btreeprop, _eventType.GetPropertyType(btreeprop)));
}
var noopTable = new VirtualDWEventTable(false, hashFields, btreeFields, TABLE_ORGANIZATION);
var imk = new IndexMultiKey(false, hashIndexedFields, btreeIndexedFields, null);
return(new Pair <IndexMultiKey, EventTable>(imk, noopTable));
}
public override void Run(EPServiceProvider epService)
{
string statementText = "select " +
"explicitFNested.fieldNestedClassValue as fnested, " +
"explicitMNested.ReadNestedClassValue as mnested" +
" from MyLegacyEvent#length(5)";
EPStatement statement = epService.EPAdministrator.CreateEPL(statementText);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
EventType eventType = statement.EventType;
Assert.AreEqual(typeof(string), eventType.GetPropertyType("fnested"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mnested"));
SupportLegacyBean legacyBean = ExecEventBeanPublicAccessors.MakeSampleEvent();
epService.EPRuntime.SendEvent(legacyBean);
Assert.AreEqual(legacyBean.fieldNested.ReadNestedValue(), listener.LastNewData[0].Get("fnested"));
Assert.AreEqual(legacyBean.fieldNested.ReadNestedValue(), listener.LastNewData[0].Get("mnested"));
try {
// invalid statement, JavaBean-style getters not exposed
statementText = "select IntPrimitive from MySupportBean#length(5)";
epService.EPAdministrator.CreateEPL(statementText);
} catch (EPStatementException) {
// expected
}
}
private void RunAssertionNoJoinNoAliasWithProperties(EPServiceProvider epService)
{
string epl = "select IntPrimitive as a, string.*, IntPrimitive as b from " + typeof(SupportBean).FullName +
"#length(3) as string";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var testListener = new SupportUpdateListener();
stmt.Events += testListener.Update;
EventType type = stmt.EventType;
Assert.AreEqual(22, type.PropertyNames.Length);
Assert.AreEqual(typeof(Pair <object, Map>), type.UnderlyingType);
Assert.AreEqual(typeof(int), type.GetPropertyType("a"));
Assert.AreEqual(typeof(int), type.GetPropertyType("b"));
Assert.AreEqual(typeof(string), type.GetPropertyType("TheString"));
SendBeanEvent(epService, "E1", 10);
var fields = new string[] { "a", "TheString", "IntPrimitive", "b" };
EPAssertionUtil.AssertProps(
testListener.AssertOneGetNewAndReset(), fields, new object[] { 10, "E1", 10, 10 });
stmt.Dispose();
}
private void RunAssertionStreamInstanceMethodNoAlias(EPServiceProvider epService)
{
string textOne = "select s0.Volume, s0.GetPriceTimesVolume(3) from " +
typeof(SupportMarketDataBean).FullName + " as s0 ";
EPStatement stmtOne = epService.EPAdministrator.CreateEPL(textOne);
var listener = new SupportUpdateListener();
stmtOne.Events += listener.Update;
EventType type = stmtOne.EventType;
Assert.AreEqual(2, type.PropertyNames.Length);
Assert.AreEqual(typeof(long?), type.GetPropertyType("s0.Volume"));
Assert.AreEqual(typeof(double), type.GetPropertyType("s0.GetPriceTimesVolume(3)"));
var eventA = new SupportMarketDataBean("ACME", 4, 2L, null);
epService.EPRuntime.SendEvent(eventA);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), new string[] { "s0.Volume", "s0.GetPriceTimesVolume(3)" }, new object[] { 2L, 4d * 2L * 3d });
// try instance method that accepts EventBean
epService.EPAdministrator.Configuration.AddEventType("MyTestEvent", typeof(MyTestEvent));
EPStatement stmt = epService.EPAdministrator.CreateEPL("select " +
"s0.GetValueAsInt(s0, 'id') as c0," +
"s0.GetValueAsInt(*, 'id') as c1" +
" from MyTestEvent as s0");
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new MyTestEvent(10));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "c0,c1".Split(','), new object[] { 10, 10 });
stmtOne.Dispose();
}
private void RunAssertionJoinWithAliasWithProperties(EPServiceProvider epService)
{
string epl = "select IntPrimitive, s1.* as s1stream, TheString, symbol as sym, s0.* as s0stream from " +
typeof(SupportBean).FullName + "#length(3) as s0, " +
typeof(SupportMarketDataBean).FullName + "#keepall as s1";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var testListener = new SupportUpdateListener();
stmt.Events += testListener.Update;
EventType type = stmt.EventType;
Assert.AreEqual(5, type.PropertyNames.Length);
Assert.AreEqual(typeof(int), type.GetPropertyType("IntPrimitive"));
Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("s1stream"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s0stream"));
Assert.AreEqual(typeof(string), type.GetPropertyType("sym"));
Assert.AreEqual(typeof(string), type.GetPropertyType("TheString"));
Assert.AreEqual(typeof(Map), type.UnderlyingType);
object eventOne = SendBeanEvent(epService, "E1", 13);
Assert.IsFalse(testListener.IsInvoked);
object eventTwo = SendMarketEvent(epService, "E2");
var fields = new string[] { "IntPrimitive", "sym", "TheString", "s0stream", "s1stream" };
EventBean received = testListener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(received, fields, new object[] { 13, "E2", "E1", eventOne, eventTwo });
EventBean theEvent = (EventBean)((Map)received.Underlying).Get("s0stream");
Assert.AreSame(eventOne, theEvent.Underlying);
stmt.Dispose();
}
private void RunAssertionNoJoinWithAliasWithProperties(EPServiceProvider epService)
{
string epl = "select TheString.* as s0, IntPrimitive as a, TheString.* as s1, IntPrimitive as b from " +
typeof(SupportBean).FullName + "#length(3) as TheString";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var testListener = new SupportUpdateListener();
stmt.Events += testListener.Update;
EventType type = stmt.EventType;
Assert.AreEqual(4, type.PropertyNames.Length);
Assert.AreEqual(typeof(Map), type.UnderlyingType);
Assert.AreEqual(typeof(int), type.GetPropertyType("a"));
Assert.AreEqual(typeof(int), type.GetPropertyType("b"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s0"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s1"));
object theEvent = SendBeanEvent(epService, "E1", 12);
var fields = new string[] { "s0", "s1", "a", "b" };
EPAssertionUtil.AssertProps(
testListener.AssertOneGetNewAndReset(), fields, new object[] { theEvent, theEvent, 12, 12 });
stmt.Dispose();
}
private void RunAssertionJoinWildcardNoAlias(EPServiceProvider epService)
{
string epl = "select *, s1.* from " + typeof(SupportBean).FullName + "#length(3) as s0, " +
typeof(SupportMarketDataBean).FullName + "#keepall as s1";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var testListener = new SupportUpdateListener();
stmt.Events += testListener.Update;
EventType type = stmt.EventType;
Assert.AreEqual(7, type.PropertyNames.Length);
Assert.AreEqual(typeof(long?), type.GetPropertyType("volume"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s0"));
Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("s1"));
Assert.AreEqual(typeof(Pair <object, Map>), type.UnderlyingType);
object eventOne = SendBeanEvent(epService, "E1", 13);
Assert.IsFalse(testListener.IsInvoked);
object eventTwo = SendMarketEvent(epService, "E2");
var fields = new string[] { "s0", "s1", "symbol", "volume" };
EventBean received = testListener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(received, fields, new object[] { eventOne, eventTwo, "E2", 0L });
stmt.Dispose();
}
private void RunAssertionTypeValidProp(EPServiceProvider epService, string typeName, object underlying)
{
EventType eventType = epService.EPAdministrator.Configuration.GetEventType(typeName);
var expectedType = new[]
{
new object[] { "indexed", typeof(string[]), null, null },
new object[] { "mapped", typeof(StringMap), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new[] { "indexed", "mapped" }, eventType.PropertyNames);
Assert.IsNotNull(eventType.GetGetter("mapped"));
Assert.IsNotNull(eventType.GetGetter("mapped('a')"));
Assert.IsNotNull(eventType.GetGetter("indexed"));
Assert.IsNotNull(eventType.GetGetter("indexed[0]"));
Assert.IsTrue(eventType.IsProperty("mapped"));
Assert.IsTrue(eventType.IsProperty("mapped('a')"));
Assert.IsTrue(eventType.IsProperty("indexed"));
Assert.IsTrue(eventType.IsProperty("indexed[0]"));
Assert.AreEqual(typeof(StringMap), eventType.GetPropertyType("mapped"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mapped('a')"));
Assert.AreEqual(typeof(string[]), eventType.GetPropertyType("indexed"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("indexed[0]"));
Assert.AreEqual(new EventPropertyDescriptor("indexed", typeof(string[]), typeof(string), false, false, true, false, false), eventType.GetPropertyDescriptor("indexed"));
Assert.AreEqual(new EventPropertyDescriptor("mapped", typeof(StringMap), typeof(string), false, false, false, true, false), eventType.GetPropertyDescriptor("mapped"));
Assert.IsNull(eventType.GetFragmentType("indexed"));
Assert.IsNull(eventType.GetFragmentType("mapped"));
}
public void TestJoinSelect()
{
String eventA = typeof(SupportBean).FullName;
String eventB = typeof(SupportBean).FullName;
String joinStatement = "select s0.DoubleBoxed, s1.IntPrimitive*s1.IntBoxed/2.0 as div from " +
eventA + "(TheString='s0').win:length(3) as s0," +
eventB + "(TheString='s1').win:length(3) as s1" +
" where s0.DoubleBoxed = s1.DoubleBoxed";
EPStatement joinView = _epService.EPAdministrator.CreateEPL(joinStatement);
joinView.Events += _updateListener.Update;
EventType result = joinView.EventType;
Assert.AreEqual(typeof(double?), result.GetPropertyType("s0.DoubleBoxed"));
Assert.AreEqual(typeof(double?), result.GetPropertyType("div"));
Assert.AreEqual(2, joinView.EventType.PropertyNames.Length);
Assert.IsNull(_updateListener.LastNewData);
SendEvent("s0", 1, 4, 5);
SendEvent("s1", 1, 3, 2);
EventBean[] newEvents = _updateListener.LastNewData;
Assert.AreEqual(1d, newEvents[0].Get("s0.DoubleBoxed"));
Assert.AreEqual(3d, newEvents[0].Get("div"));
IEnumerator <EventBean> iterator = joinView.GetEnumerator();
EventBean theEvent = iterator.Advance();
Assert.AreEqual(1d, theEvent.Get("s0.DoubleBoxed"));
Assert.AreEqual(3d, theEvent.Get("div"));
}
public void TestEventType()
{
EPStatement outerJoinView = SetupStatement("");
EventType type = outerJoinView.EventType;
Assert.AreEqual(typeof(SupportBean_S0), type.GetPropertyType("s0"));
Assert.AreEqual(typeof(SupportBean_S1), type.GetPropertyType("s1"));
}
private void RunAssertionEventType(EPServiceProvider epService)
{
EPStatement outerJoinView = SetupStatement(epService, "");
EventType type = outerJoinView.EventType;
Assert.AreEqual(typeof(SupportBean_S0), type.GetPropertyType("s0"));
Assert.AreEqual(typeof(SupportBean_S1), type.GetPropertyType("s1"));
}
private void AssertTypeColDef(EventType eventType)
{
Assert.AreEqual(typeof(string), eventType.GetPropertyType("col1"));
Assert.AreEqual(typeof(int), eventType.GetPropertyType("col2"));
Assert.AreEqual(typeof(SupportBean), eventType.GetPropertyType("sbean"));
Assert.AreEqual(typeof(int), eventType.GetPropertyType("col3.col4"));
Assert.AreEqual(4, eventType.PropertyDescriptors.Count);
}
private static void AssertConsistencyProperties(EventType eventType)
{
IList <String> propertyNames = new List <String>();
var properties = eventType.PropertyDescriptors;
for (var i = 0; i < properties.Count; i++)
{
var propertyName = properties[i].PropertyName;
propertyNames.Add(propertyName);
var failedMessage = "failed assertion for property '" + propertyName + "' ";
// assert presence of descriptor
Assert.AreSame(properties[i], eventType.GetPropertyDescriptor(propertyName));
// test properties that can simply be in a property expression
if ((!properties[i].RequiresIndex) && (!properties[i].RequiresMapKey))
{
Assert.IsTrue(eventType.IsProperty(propertyName), failedMessage);
Assert.AreSame(eventType.GetPropertyType(propertyName), properties[i].PropertyType, failedMessage);
Assert.NotNull(eventType.GetGetter(propertyName), failedMessage);
}
// test indexed property
if (properties[i].IsIndexed)
{
var propertyNameIndexed = propertyName + "[0]";
Assert.IsTrue(eventType.IsProperty(propertyNameIndexed), failedMessage);
Assert.NotNull(eventType.GetPropertyType(propertyNameIndexed), failedMessage);
Assert.NotNull(eventType.GetGetter(propertyNameIndexed), failedMessage);
}
// test mapped property
if (properties[i].RequiresMapKey)
{
var propertyNameMapped = propertyName + "('a')";
Assert.IsTrue(eventType.IsProperty(propertyNameMapped), failedMessage);
Assert.NotNull(eventType.GetPropertyType(propertyNameMapped), failedMessage);
Assert.NotNull(eventType.GetGetter(propertyNameMapped), failedMessage);
}
// consistent flags
Assert.IsFalse(properties[i].IsIndexed && properties[i].IsMapped, failedMessage);
if (properties[i].RequiresIndex)
{
Assert.IsTrue(properties[i].IsIndexed, failedMessage);
}
if (properties[i].RequiresMapKey)
{
Assert.IsTrue(properties[i].IsMapped, failedMessage);
}
}
// assert same property names
EPAssertionUtil.AssertEqualsAnyOrder(eventType.PropertyNames, propertyNames.ToArray());
}
private static void AssertConsistencyProperties(EventType eventType)
{
var propertyNames = new List<string>();
IList<EventPropertyDescriptor> properties = eventType.PropertyDescriptors;
for (int i = 0; i < properties.Count; i++)
{
string propertyName = properties[i].PropertyName;
propertyNames.Add(propertyName);
string failedMessage = "failed assertion for property '" + propertyName + "' ";
// assert presence of descriptor
ScopeTestHelper.AssertSame(properties[i], eventType.GetPropertyDescriptor(propertyName));
// test properties that can simply be in a property expression
if ((!properties[i].RequiresIndex) && (!properties[i].RequiresMapKey))
{
ScopeTestHelper.AssertTrue(failedMessage, eventType.IsProperty(propertyName));
ScopeTestHelper.AssertSame(
failedMessage, eventType.GetPropertyType(propertyName), properties[i].PropertyType);
ScopeTestHelper.AssertNotNull(failedMessage, eventType.GetGetter(propertyName));
}
// test indexed property
if (properties[i].IsIndexed)
{
string propertyNameIndexed = propertyName + "[0]";
ScopeTestHelper.AssertTrue(failedMessage, eventType.IsProperty(propertyNameIndexed));
ScopeTestHelper.AssertNotNull(failedMessage, eventType.GetPropertyType(propertyNameIndexed));
ScopeTestHelper.AssertNotNull(failedMessage, eventType.GetGetter(propertyNameIndexed));
}
// test mapped property
if (properties[i].RequiresMapKey)
{
string propertyNameMapped = propertyName + "('a')";
ScopeTestHelper.AssertTrue(failedMessage, eventType.IsProperty(propertyNameMapped));
ScopeTestHelper.AssertNotNull(failedMessage, eventType.GetPropertyType(propertyNameMapped));
ScopeTestHelper.AssertNotNull(failedMessage, eventType.GetGetter(propertyNameMapped));
}
// consistent flags
ScopeTestHelper.AssertFalse(failedMessage, properties[i].IsIndexed && properties[i].IsMapped);
if (properties[i].RequiresIndex)
{
ScopeTestHelper.AssertTrue(failedMessage, properties[i].IsIndexed);
}
if (properties[i].RequiresMapKey)
{
ScopeTestHelper.AssertTrue(failedMessage, properties[i].IsMapped);
}
}
// assert same property names
EPAssertionUtil.AssertEqualsAnyOrder(eventType.PropertyNames, propertyNames.ToArray());
}
public void TestMappedIndexedNestedProperty()
{
EventType eventType = _beanEventTypeFactory.CreateBeanType("e", typeof(SupportBeanComplexProps), true, true, true);
Assert.AreEqual(typeof(IDictionary <string, string>), eventType.GetPropertyType("MapProperty"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("Mapped('x')"));
Assert.AreEqual(typeof(int), eventType.GetPropertyType("Indexed[1]"));
Assert.AreEqual(typeof(SupportBeanComplexProps.SupportBeanSpecialGetterNested), eventType.GetPropertyType("Nested"));
Assert.AreEqual(typeof(int[]), eventType.GetPropertyType("ArrayProperty"));
}
public void TestSimpleJoinRight()
{
String stmtText = "select " + ALL_FIELDS + " from " +
" sql:MyDB ['select " + ALL_FIELDS +
" from mytesttable where ${id} = mytesttable.mybigint'] as s0," +
typeof(SupportBean_S0).FullName + " as s1";
EPStatement statement = _epService.EPAdministrator.CreateEPL(stmtText);
_listener = new SupportUpdateListener();
statement.Events += _listener.Update;
EventType eventType = statement.EventType;
Assert.AreEqual(typeof(long?), eventType.GetPropertyType("mybigint"));
Assert.AreEqual(typeof(int?), eventType.GetPropertyType("myint"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("myvarchar"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mychar"));
Assert.AreEqual(typeof(bool?), eventType.GetPropertyType("mybool"));
Assert.AreEqual(typeof(decimal?), eventType.GetPropertyType("mynumeric"));
Assert.AreEqual(typeof(decimal?), eventType.GetPropertyType("mydecimal"));
Assert.AreEqual(typeof(double?), eventType.GetPropertyType("mydouble"));
Assert.AreEqual(typeof(double?), eventType.GetPropertyType("myreal"));
SendEventS0(1);
AssertReceived(1, 10, "A", "Z", true, 5000, 100, 1.2, 1.3);
}
private void RunAssertionSimpleJoinRight(EPServiceProvider epService)
{
string stmtText = "select " + ALL_FIELDS + " from " +
" sql:MyDB ['select " + ALL_FIELDS + " from mytesttable where ${id} = mytesttable.mybigint'] as s0," +
typeof(SupportBean_S0).FullName + " as s1";
EPStatement statement = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
EventType eventType = statement.EventType;
Assert.AreEqual(typeof(long?), eventType.GetPropertyType("mybigint"));
Assert.AreEqual(typeof(int?), eventType.GetPropertyType("myint"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("myvarchar"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mychar"));
Assert.AreEqual(typeof(bool?), eventType.GetPropertyType("mybool"));
Assert.AreEqual(typeof(decimal?), eventType.GetPropertyType("mynumeric"));
Assert.AreEqual(typeof(decimal?), eventType.GetPropertyType("mydecimal"));
Assert.AreEqual(typeof(double?), eventType.GetPropertyType("mydouble"));
Assert.AreEqual(typeof(float?), eventType.GetPropertyType("myreal"));
SendEventS0(epService, 1);
AssertReceived(listener, 1, 10, "A", "Z", true, 5000.0m, 100.0m, 1.2, 1.3f);
statement.Dispose();
}
public void TestMinMaxEventType()
{
EPStatement selectTestView = SetUpMinMax();
EventType type = selectTestView.EventType;
Log.Debug(".testGetEventType properties=" + type.PropertyNames.Render());
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMax"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMin"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMinEx"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMaxEx"));
}
private void RunAssertionJoinStreamSelectNoWildcard(EPServiceProvider epService)
{
// try with alias
string textOne = "select s0 as s0stream, s1 as s1stream from " +
typeof(SupportMarketDataBean).FullName + "#keepall as s0, " +
typeof(SupportBean).FullName + "#keepall as s1";
// Attach listener to feed
EPStatement stmtOne = epService.EPAdministrator.CreateEPL(textOne);
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(stmtOne.Text);
Assert.AreEqual(textOne, model.ToEPL());
var listenerOne = new SupportUpdateListener();
stmtOne.Events += listenerOne.Update;
EventType type = stmtOne.EventType;
Assert.AreEqual(2, type.PropertyNames.Length);
Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("s0stream"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s1stream"));
var eventA = new SupportMarketDataBean("ACME", 0, 0L, null);
epService.EPRuntime.SendEvent(eventA);
var eventB = new SupportBean();
epService.EPRuntime.SendEvent(eventB);
EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), new string[] { "s0stream", "s1stream" }, new object[] { eventA, eventB });
stmtOne.Dispose();
// try no alias
textOne = "select s0, s1 from " +
typeof(SupportMarketDataBean).FullName + "#keepall as s0, " +
typeof(SupportBean).FullName + "#keepall as s1";
// Attach listener to feed
stmtOne = epService.EPAdministrator.CreateEPL(textOne);
stmtOne.Events += listenerOne.Update;
type = stmtOne.EventType;
Assert.AreEqual(2, type.PropertyNames.Length);
Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("s0"));
Assert.AreEqual(typeof(SupportBean), type.GetPropertyType("s1"));
epService.EPRuntime.SendEvent(eventA);
epService.EPRuntime.SendEvent(eventB);
EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), new string[] { "s0", "s1" }, new object[] { eventA, eventB });
stmtOne.Dispose();
}
public static Type GetCoercionTypeRange(EventType indexedType, String indexedProp, SubordPropRangeKey rangeKey)
{
QueryGraphValueEntryRange desc = rangeKey.RangeInfo;
if (desc.RangeType.IsRange())
{
var rangeIn = (QueryGraphValueEntryRangeIn)desc;
return(GetCoercionTypeRangeIn(indexedType.GetPropertyType(indexedProp), rangeIn.ExprStart, rangeIn.ExprEnd));
}
var relOp = (QueryGraphValueEntryRangeRelOp)desc;
return(GetCoercionType(indexedType.GetPropertyType(indexedProp), relOp.Expression.ExprEvaluator.ReturnType));
}
public void RunAssertionNestableMapArray(EventRepresentationEnum eventRepresentationEnum)
{
EPStatement stmtInner = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyInnerType as (col1 string[], col2 int[])");
EventType inner = stmtInner.EventType;
Assert.AreEqual(typeof(string[]), inner.GetPropertyType("col1"));
Assert.IsTrue(inner.GetPropertyDescriptor("col1").IsIndexed);
Assert.AreEqual(typeof(int[]), inner.GetPropertyType("col2"));
Assert.IsTrue(inner.GetPropertyDescriptor("col2").IsIndexed);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), inner.UnderlyingType);
EPStatement stmtOuter = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyOuterType as (col1 MyInnerType, col2 MyInnerType[])");
FragmentEventType type = stmtOuter.EventType.GetFragmentType("col1");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsFalse(type.IsIndexed);
Assert.IsFalse(type.IsNative);
type = stmtOuter.EventType.GetFragmentType("col2");
Assert.AreEqual("MyInnerType", type.FragmentType.Name);
Assert.IsTrue(type.IsIndexed);
Assert.IsFalse(type.IsNative);
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL("select * from MyOuterType");
stmtSelect.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtSelect.EventType.UnderlyingType);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Object[] innerData = { "abc,def".Split(','), new int[] { 1, 2 } };
Object[] outerData = { innerData, new Object[] { innerData, innerData } };
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
else
{
IDictionary <String, Object> innerData = new Dictionary <String, Object>();
innerData.Put("col1", "abc,def".Split(','));
innerData.Put("col2", new int[] { 1, 2 });
IDictionary <String, Object> outerData = new Dictionary <String, Object>();
outerData.Put("col1", innerData);
outerData.Put("col2", new DataMap[] { innerData, innerData });
_epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "col1.col1[1],col2[1].col2[1]".Split(','), new Object[] { "def", 2 });
_epService.EPAdministrator.Configuration.RemoveEventType("MyInnerType", true);
_epService.EPAdministrator.Configuration.RemoveEventType("MyOuterType", true);
_epService.EPAdministrator.DestroyAllStatements();
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PollResultIndexingStrategyInKeywordMulti), GetType(), classScope);
method.Block.DeclareVar<EventPropertyValueGetter[]>(
"getters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(propertyNames.Length)));
for (var i = 0; i < propertyNames.Length; i++) {
var getter = ((EventTypeSPI) eventType).GetGetterSPI(propertyNames[i]);
var getterType = eventType.GetPropertyType(propertyNames[i]);
var eval = EventTypeUtility.CodegenGetterWCoerce(
getter,
getterType,
getterType,
method,
GetType(),
classScope);
method.Block.AssignArrayElement(Ref("getters"), Constant(i), eval);
}
method.Block
.DeclareVar<PollResultIndexingStrategyInKeywordMulti>(
"strat",
NewInstance(typeof(PollResultIndexingStrategyInKeywordMulti)))
.SetProperty(Ref("strat"), "StreamNum", Constant(streamNum))
.SetProperty(Ref("strat"), "PropertyNames", Constant(propertyNames))
.SetProperty(Ref("strat"), "ValueGetters", Ref("getters"))
.ExprDotMethod(Ref("strat"), "Init")
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
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 static void AssertTypes(EventType type, String[] fields, Type[] classes)
{
for (int ii = 0; ii < fields.Length; ii++)
{
Assert.That(type.GetPropertyType(fields[ii]), Is.EqualTo(classes[ii]), "position " + ii);
}
}
public ExprDotDTForge(
IList<CalendarForge> calendarForges,
TimeAbacus timeAbacus,
ReformatForge reformatForge,
IntervalForge intervalForge,
Type inputType,
EventType inputEventType)
{
if (intervalForge != null) {
TypeInfo = EPTypeHelper.SingleValue(typeof(bool?));
}
else if (reformatForge != null) {
TypeInfo = EPTypeHelper.SingleValue(reformatForge.ReturnType);
}
else { // only calendar op
if (inputEventType != null) {
TypeInfo = EPTypeHelper.SingleValue(
inputEventType.GetPropertyType(inputEventType.StartTimestampPropertyName));
}
else {
TypeInfo = EPTypeHelper.SingleValue(inputType);
}
}
forge = GetForge(calendarForges, timeAbacus, inputType, inputEventType, reformatForge, intervalForge);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (validationContext.ContextDescriptor == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' cannot be used in the expression as provided");
}
EventType eventType = validationContext.ContextDescriptor.ContextPropertyRegistry.ContextEventType;
if (eventType == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' cannot be used in the expression as provided");
}
_getter = eventType.GetGetter(_propertyName);
if (_getter == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' is not a known property, known properties are " +
eventType.PropertyNames.Render());
}
_returnType = eventType.GetPropertyType(_propertyName);
return(null);
}
public ExprDotEvalDT(
IList <CalendarOp> calendarOps,
TimeZoneInfo timeZone,
ReformatOp reformatOp,
IntervalOp intervalOp,
Type inputType,
EventType inputEventType)
{
_evaluator = GetEvaluator(calendarOps, timeZone, inputType, inputEventType, reformatOp, intervalOp);
if (intervalOp != null)
{
_returnType = EPTypeHelper.SingleValue(typeof(bool?));
}
else if (reformatOp != null)
{
_returnType = EPTypeHelper.SingleValue(reformatOp.ReturnType);
}
else
{
// only calendar ops
if (inputEventType != null)
{
_returnType = EPTypeHelper.SingleValue(
inputEventType.GetPropertyType(inputEventType.StartTimestampPropertyName));
}
else
{
_returnType = EPTypeHelper.SingleValue(inputType);
}
}
}
public static CoercionDesc GetCoercionTypesHash(EventType viewableEventType, String[] indexProps, IList <SubordPropHashKey> hashKeys)
{
if (indexProps.Length == 0 && hashKeys.Count == 0)
{
return(new CoercionDesc(false, NULL_ARRAY));
}
if (indexProps.Length != hashKeys.Count)
{
throw new IllegalStateException("Mismatch in the number of key and index properties");
}
var coercionTypes = new Type[indexProps.Length];
bool mustCoerce = false;
for (int i = 0; i < hashKeys.Count; i++)
{
Type keyPropType = hashKeys[i].HashKey.KeyExpr.ExprEvaluator.ReturnType.GetBoxedType();
Type indexedPropType = viewableEventType.GetPropertyType(indexProps[i]).GetBoxedType();
Type coercionType = indexedPropType;
if (keyPropType != indexedPropType)
{
coercionType = keyPropType.GetCompareToCoercionType(indexedPropType);
mustCoerce = true;
}
coercionTypes[i] = coercionType;
}
return(new CoercionDesc(mustCoerce, coercionTypes));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PollResultIndexingStrategySorted), GetType(), classScope);
var propertyGetter = ((EventTypeSPI) eventType).GetGetterSPI(propertyName);
var propertyType = eventType.GetPropertyType(propertyName);
var valueGetter = EventTypeUtility.CodegenGetterWCoerce(
propertyGetter,
propertyType,
valueType,
method,
GetType(),
classScope);
method.Block
.DeclareVar<PollResultIndexingStrategySorted>(
"strat",
NewInstance(typeof(PollResultIndexingStrategySorted)))
.SetProperty(Ref("strat"), "StreamNum", Constant(streamNum))
.SetProperty(Ref("strat"), "PropertyName", Constant(propertyName))
.SetProperty(Ref("strat"), "ValueGetter", valueGetter)
.SetProperty(Ref("strat"), "ValueType", Constant(valueType))
.ExprDotMethod(Ref("strat"), "Init")
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}