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();
}
private void AssertNotAProperty(
EventType type,
String propertyName)
{
Assert.IsFalse(type.IsProperty(propertyName));
Assert.IsNull(type.GetPropertyType(propertyName));
Assert.IsNull(type.GetGetter(propertyName));
Assert.IsNull(type.GetPropertyDescriptor(propertyName));
}
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());
}
private void AssertFragment(String prop, EventType eventType, String fragmentTypeName, bool indexed)
{
var desc = eventType.GetPropertyDescriptor(prop);
Assert.AreEqual(true, desc.IsFragment);
var fragment = eventType.GetFragmentType(prop);
Assert.AreEqual(fragmentTypeName, fragment.FragmentType.Name);
Assert.AreEqual(false, fragment.IsNative);
Assert.AreEqual(indexed, fragment.IsIndexed);
}
private void RunAssertionTypeInvalidProp(EPServiceProvider epService, string typeName)
{
EventType eventType = epService.EPAdministrator.Configuration.GetEventType(typeName);
foreach (string prop in Collections.List("xxxx", "myString[0]", "indexed('a')", "indexed.x", "mapped[0]", "mapped.x"))
{
Assert.AreEqual(false, eventType.IsProperty(prop));
Assert.AreEqual(null, eventType.GetPropertyType(prop));
Assert.IsNull(eventType.GetPropertyDescriptor(prop));
}
}
private void AssertPropertyType(
Type expectedType,
Type expectedComponentType,
EventType eventType,
String propertyName)
{
Assert.AreEqual(expectedType, eventType.GetPropertyType(propertyName));
Assert.IsTrue(eventType.IsProperty(propertyName));
if (!propertyName.Contains("."))
{
var descriptor = eventType.GetPropertyDescriptor(propertyName);
Assert.AreEqual(expectedType, descriptor.PropertyType);
Assert.AreEqual(expectedComponentType, descriptor.PropertyComponentType);
}
}
public override void Run(EPServiceProvider epService)
{
string stmtSelectWild = "select * from TestTypesEvent";
EPStatement wildStmt = epService.EPAdministrator.CreateEPL(stmtSelectWild);
EventType type = wildStmt.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(type);
var types = new object[][] {
new object[] { "attrNonPositiveInteger", typeof(int?) },
new object[] { "attrNonNegativeInteger", typeof(int?) },
new object[] { "attrNegativeInteger", typeof(int?) },
new object[] { "attrPositiveInteger", typeof(int?) },
new object[] { "attrLong", typeof(long?) },
new object[] { "attrUnsignedLong", typeof(ulong?) },
new object[] { "attrInt", typeof(int?) },
new object[] { "attrUnsignedInt", typeof(uint?) },
new object[] { "attrDecimal", typeof(double?) },
new object[] { "attrInteger", typeof(int?) },
new object[] { "attrFloat", typeof(float?) },
new object[] { "attrDouble", typeof(double?) },
new object[] { "attrString", typeof(string) },
new object[] { "attrShort", typeof(short?) },
new object[] { "attrUnsignedShort", typeof(ushort?) },
new object[] { "attrByte", typeof(byte?) },
new object[] { "attrUnsignedByte", typeof(byte?) },
new object[] { "attrBoolean", typeof(bool?) },
new object[] { "attrDateTime", typeof(string) },
new object[] { "attrDate", typeof(string) },
new object[] { "attrTime", typeof(string) }
};
for (int i = 0; i < types.Length; i++)
{
string name = types[i][0].ToString();
EventPropertyDescriptor desc = type.GetPropertyDescriptor(name);
Type expected = (Type)types[i][1];
Assert.AreEqual(expected, desc.PropertyType, "Failed for " + name);
}
}
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"));
}
private PropertyResolutionDescriptor FindByStreamNameOnly(String propertyName, String streamName, bool explicitPropertiesOnly, bool obtainFragment)
{
var index = 0;
EventType streamType = null;
// Stream name resultion examples:
// A) select A1.price from Event.price as A2 => mismatch stream name, cannot resolve
// B) select Event1.price from Event2.price => mismatch event type name, cannot resolve
// C) select default.Event2.price from Event2.price => possible prefix of engine name
for (var i = 0; i < _eventTypes.Length; i++)
{
if (_eventTypes[i] == null)
{
index++;
continue;
}
if ((_streamNames[i] != null) && (_streamNames[i].Equals(streamName)))
{
streamType = _eventTypes[i];
break;
}
// If the stream name is the event type name, that is also acceptable
if ((_eventTypes[i].Name != null) && (_eventTypes[i].Name.Equals(streamName)))
{
streamType = _eventTypes[i];
break;
}
index++;
}
if (streamType == null)
{
var message = "Failed to find a stream named '" + streamName + "'";
var msgGen = new StreamNotFoundExceptionSuggestionGen(_eventTypes, _streamNames, streamName);
throw new StreamNotFoundException(message, msgGen.GetSuggestion);
}
Type propertyType = null;
FragmentEventType fragmentEventType = null;
if (!explicitPropertiesOnly)
{
propertyType = streamType.GetPropertyType(propertyName);
if (propertyType == null)
{
var desc = streamType.GetPropertyDescriptor(propertyName);
if (desc == null)
{
throw HandlePropertyNotFound(propertyName, streamName, streamType);
}
propertyType = desc.PropertyType;
if (obtainFragment && desc.IsFragment)
{
fragmentEventType = streamType.GetFragmentType(propertyName);
}
}
else
{
if (obtainFragment)
{
fragmentEventType = streamType.GetFragmentType(propertyName);
}
}
}
else
{
var explicitProps = streamType.PropertyDescriptors;
var found = false;
foreach (var prop in explicitProps)
{
if (prop.PropertyName.Equals(propertyName))
{
propertyType = prop.PropertyType;
if (obtainFragment && prop.IsFragment)
{
fragmentEventType = streamType.GetFragmentType(propertyName);
}
found = true;
break;
}
}
if (!found)
{
throw HandlePropertyNotFound(propertyName, streamName, streamType);
}
}
return(new PropertyResolutionDescriptor(streamName, streamType, propertyName, index, propertyType, fragmentEventType));
}
public void TestSchemaXMLTypes()
{
Configuration configuration = SupportConfigFactory.GetConfiguration();
ConfigurationEventTypeXMLDOM eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "typesEvent";
String schemaUri = ResourceManager.ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
eventTypeMeta.SchemaResource = schemaUri;
configuration.AddEventType("TestTypesEvent", eventTypeMeta);
_epService = EPServiceProviderManager.GetProvider("TestSchemaXML", configuration);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
String stmtSelectWild = "select * from TestTypesEvent";
EPStatement wildStmt = _epService.EPAdministrator.CreateEPL(stmtSelectWild);
EventType type = wildStmt.EventType;
EventTypeAssertionUtil.AssertConsistency(type);
Object[][] types = new Object[][] {
new object[] { "attrNonPositiveInteger", typeof(int?) },
new object[] { "attrNonNegativeInteger", typeof(int?) },
new object[] { "attrNegativeInteger", typeof(int?) },
new object[] { "attrPositiveInteger", typeof(int?) },
new object[] { "attrLong", typeof(long?) },
new object[] { "attrUnsignedLong", typeof(ulong?) },
new object[] { "attrInt", typeof(int?) },
new object[] { "attrUnsignedInt", typeof(uint?) },
new object[] { "attrDecimal", typeof(double?) },
new object[] { "attrInteger", typeof(int?) },
new object[] { "attrFloat", typeof(float?) },
new object[] { "attrDouble", typeof(double?) },
new object[] { "attrString", typeof(string) },
new object[] { "attrShort", typeof(short?) },
new object[] { "attrUnsignedShort", typeof(ushort?) },
new object[] { "attrByte", typeof(byte?) },
new object[] { "attrUnsignedByte", typeof(byte?) },
new object[] { "attrBoolean", typeof(bool?) },
new object[] { "attrDateTime", typeof(string) },
new object[] { "attrDate", typeof(string) },
new object[] { "attrTime", typeof(string) }
};
for (int i = 0; i < types.Length; i++)
{
String name = types[i][0].ToString();
EventPropertyDescriptor desc = type.GetPropertyDescriptor(name);
Type expected = (Type)types[i][1];
Assert.AreEqual(expected, desc.PropertyType, "Failed for " + name);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void RunAssertionNestableMapArray(EventRepresentationChoice eventRepresentationEnum)
{
EPStatement stmtInner = epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyInnerType as (inn1 string[], inn2 int[])");
EventType inner = stmtInner.EventType;
Assert.AreEqual(typeof(string[]), inner.GetPropertyType("inn1"));
Assert.IsTrue(inner.GetPropertyDescriptor("inn1").IsIndexed);
Assert.AreEqual(typeof(int[]), inner.GetPropertyType("inn2"));
Assert.IsTrue(inner.GetPropertyDescriptor("inn2").IsIndexed);
Assert.IsTrue(eventRepresentationEnum.MatchesClass(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.AddListener(listener);
Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtSelect.EventType.UnderlyingType));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
var innerData = new Object[] { "abc,def".SplitCsv(), new int[] { 1, 2 } };
var outerData = new Object[] { innerData, new Object[] { innerData, innerData } };
epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
else if (eventRepresentationEnum.IsMapEvent())
{
var innerData = new Dictionary <string, Object>();
innerData.Put("inn1", "abc,def".SplitCsv());
innerData.Put("inn2", new int[] { 1, 2 });
var outerData = new Dictionary <string, Object>();
outerData.Put("col1", innerData);
outerData.Put("col2", new Map[] { innerData, innerData });
epService.EPRuntime.SendEvent(outerData, "MyOuterType");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var innerData = new GenericRecord(SupportAvroUtil.GetAvroSchema(epService, "MyInnerType").AsRecordSchema());
innerData.Put("inn1", Collections.List("abc", "def"));
innerData.Put("inn2", Collections.List(1, 2));
var outerData = new GenericRecord(SupportAvroUtil.GetAvroSchema(epService, "MyOuterType").AsRecordSchema());
outerData.Put("col1", innerData);
outerData.Put("col2", Collections.List(innerData, innerData));
epService.EPRuntime.SendEventAvro(outerData, "MyOuterType");
}
else
{
Assert.Fail();
}
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "col1.inn1[1],col2[1].inn2[1]".SplitCsv(), new Object[] { "def", 2 });
epService.EPAdministrator.Configuration.RemoveEventType("MyInnerType", true);
epService.EPAdministrator.Configuration.RemoveEventType("MyOuterType", true);
epService.EPAdministrator.DestroyAllStatements();
}