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(); }