public void TestInvalidInsertInto() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStream", variant); try { _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from " + typeof(SupportBean_A).FullName); Assert.Fail(); } catch (EPStatementException ex) { Assert.AreEqual("Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStream' [insert into MyVariantStream select * from com.espertech.esper.support.bean.SupportBean_A]", ex.Message); } try { _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select IntPrimitive as k0 from " + typeof(SupportBean).FullName); Assert.Fail(); } catch (EPStatementException ex) { Assert.AreEqual("Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStream' [insert into MyVariantStream select IntPrimitive as k0 from com.espertech.esper.support.bean.SupportBean]", ex.Message); } }
private void RunAssertionAnyTypeStaggered(EPServiceProvider epService) { // test insert into staggered with map var configVariantStream = new ConfigurationVariantStream(); configVariantStream.TypeVariance = TypeVarianceEnum.ANY; epService.EPAdministrator.Configuration.AddVariantStream("VarStream", configVariantStream); epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); epService.EPAdministrator.Configuration.AddEventType("SupportMarketDataBean", typeof(SupportMarketDataBean)); epService.EPAdministrator.CreateEPL("insert into MyStream select TheString, IntPrimitive from SupportBean"); epService.EPAdministrator.CreateEPL("insert into VarStream select TheString as abc from MyStream"); epService.EPAdministrator.CreateEPL("@Name('Target') select * from VarStream#keepall"); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); EventBean[] arr = EPAssertionUtil.EnumeratorToArray(epService.EPAdministrator.GetStatement("Target").GetEnumerator()); EPAssertionUtil.AssertPropsPerRow(arr, new string[] { "abc" }, new object[][] { new object[] { "E1" } }); epService.EPAdministrator.CreateEPL("insert into MyStream2 select feed from SupportMarketDataBean"); epService.EPAdministrator.CreateEPL("insert into VarStream select feed as abc from MyStream2"); epService.EPRuntime.SendEvent(new SupportMarketDataBean("IBM", 1, 1L, "E2")); arr = EPAssertionUtil.EnumeratorToArray(epService.EPAdministrator.GetStatement("Target").GetEnumerator()); EPAssertionUtil.AssertPropsPerRow(arr, new string[] { "abc" }, new object[][] { new object[] { "E1" }, new object[] { "E2" } }); epService.EPAdministrator.DestroyAllStatements(); }
/// <summary>Validate the variant stream definition. </summary> /// <param name="variantStreamname">the stream name</param> /// <param name="variantStreamConfig">the configuration information</param> /// <param name="eventAdapterService">the event adapters</param> /// <returns>specification for variant streams</returns> public static VariantSpec ValidateVariantStream(String variantStreamname, ConfigurationVariantStream variantStreamConfig, EventAdapterService eventAdapterService) { if (variantStreamConfig.TypeVariance == TypeVarianceEnum.PREDEFINED) { if (variantStreamConfig.VariantTypeNames.IsEmpty()) { throw new ConfigurationException("Invalid variant stream configuration, no event type name has been added and default type variance requires at least one type, for name '" + variantStreamname + "'"); } } ICollection <EventType> types = new LinkedHashSet <EventType>(); foreach (String typeName in variantStreamConfig.VariantTypeNames) { EventType type = eventAdapterService.GetEventTypeByName(typeName); if (type == null) { throw new ConfigurationException("Event type by name '" + typeName + "' could not be found for use in variant stream configuration by name '" + variantStreamname + "'"); } types.Add(type); } EventType[] eventTypes = types.ToArray(); return(new VariantSpec(variantStreamname, eventTypes, variantStreamConfig.TypeVariance)); }
public void TestDynamicMapType() { IDictionary <String, Object> types = new Dictionary <String, Object>(); types["someprop"] = typeof(string); _epService.EPAdministrator.Configuration.AddEventType("MyEvent", types); _epService.EPAdministrator.Configuration.AddEventType("MySecondEvent", types); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("MyEvent"); variant.AddEventTypeName("MySecondEvent"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariant", variant); _epService.EPAdministrator.CreateEPL("insert into MyVariant select * from MyEvent"); _epService.EPAdministrator.CreateEPL("insert into MyVariant select * from MySecondEvent"); EPStatement stmt = _epService.EPAdministrator.CreateEPL("select * from MyVariant"); stmt.Events += _listenerOne.Update; _epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "MyEvent"); Assert.NotNull(_listenerOne.AssertOneGetNewAndReset()); _epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "MySecondEvent"); Assert.NotNull(_listenerOne.AssertOneGetNewAndReset()); }
private void RunAssertionDynamicMapType(EPServiceProvider epService) { var types = new Dictionary <string, Object>(); types.Put("someprop", typeof(string)); epService.EPAdministrator.Configuration.AddEventType("MyEvent", types); epService.EPAdministrator.Configuration.AddEventType("MySecondEvent", types); var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("MyEvent"); variant.AddEventTypeName("MySecondEvent"); epService.EPAdministrator.Configuration.AddVariantStream("MyVariant", variant); epService.EPAdministrator.CreateEPL("insert into MyVariant select * from MyEvent"); epService.EPAdministrator.CreateEPL("insert into MyVariant select * from MySecondEvent"); EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from MyVariant"); var listenerOne = new SupportUpdateListener(); stmt.Events += listenerOne.Update; epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "MyEvent"); Assert.IsNotNull(listenerOne.AssertOneGetNewAndReset()); epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "MySecondEvent"); Assert.IsNotNull(listenerOne.AssertOneGetNewAndReset()); epService.EPAdministrator.DestroyAllStatements(); }
public void TestAnyTypeStaggered() { // test insert into staggered with map ConfigurationVariantStream configVariantStream = new ConfigurationVariantStream(); configVariantStream.TypeVariance = TypeVarianceEnum.ANY; _epService.EPAdministrator.Configuration.AddVariantStream("VarStream", configVariantStream); _epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean)); _epService.EPAdministrator.Configuration.AddEventType("SupportMarketDataBean", typeof(SupportMarketDataBean)); _epService.EPAdministrator.CreateEPL("insert into MyStream select TheString, IntPrimitive from SupportBean"); _epService.EPAdministrator.CreateEPL("insert into VarStream select TheString as abc from MyStream"); _epService.EPAdministrator.CreateEPL("@Name('Target') select * from VarStream.win:keepall()"); _epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); EventBean[] arr = EPAssertionUtil.EnumeratorToArray(_epService.EPAdministrator.GetStatement("Target").GetEnumerator()); EPAssertionUtil.AssertPropsPerRow(arr, new String[] { "abc" }, new Object[][] { new Object[] { "E1" } }); _epService.EPAdministrator.CreateEPL("insert into MyStream2 select Feed from SupportMarketDataBean"); _epService.EPAdministrator.CreateEPL("insert into VarStream select Feed as abc from MyStream2"); _epService.EPRuntime.SendEvent(new SupportMarketDataBean("IBM", 1, 1L, "E2")); arr = EPAssertionUtil.EnumeratorToArray(_epService.EPAdministrator.GetStatement("Target").GetEnumerator()); EPAssertionUtil.AssertPropsPerRow(arr, new String[] { "abc" }, new Object[][] { new Object[] { "E1" }, new Object[] { "E2" } }); }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.TypeVariance = TypeVarianceEnum.ANY; config.AddVariantStream("MyVariantStream", variant); Assert.IsTrue(config.IsVariantStreamExists("MyVariantStream")); _epService = EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); _listener = new SupportUpdateListener(); // assert type metadata EventTypeSPI type = (EventTypeSPI)((EPServiceProviderSPI)_epService).ValueAddEventService.GetValueAddProcessor("MyVariantStream").ValueAddEventType; Assert.AreEqual(null, type.Metadata.OptionalApplicationType); Assert.AreEqual(null, type.Metadata.OptionalSecondaryNames); Assert.AreEqual("MyVariantStream", type.Metadata.PrimaryName); Assert.AreEqual("MyVariantStream", type.Metadata.PublicName); Assert.AreEqual("MyVariantStream", type.Name); Assert.AreEqual(TypeClass.VARIANT, type.Metadata.TypeClass); Assert.AreEqual(true, type.Metadata.IsApplicationConfigured); Assert.AreEqual(true, type.Metadata.IsApplicationPreConfigured); Assert.AreEqual(true, type.Metadata.IsApplicationPreConfiguredStatic); EventType[] valueAddTypes = ((EPServiceProviderSPI)_epService).ValueAddEventService.ValueAddedTypes; Assert.AreEqual(1, valueAddTypes.Length); Assert.AreSame(type, valueAddTypes[0]); Assert.AreEqual(0, type.PropertyNames.Length); Assert.AreEqual(0, type.PropertyDescriptors.Count); }
public override void Configure(Configuration configuration) { var variant = new ConfigurationVariantStream(); variant.TypeVariance = TypeVarianceEnum.ANY; configuration.AddVariantStream("MyVariantStream", variant); Assert.IsTrue(configuration.IsVariantStreamExists("MyVariantStream")); }
public void AddVariantStream(String variantStreamname, ConfigurationVariantStream variantStreamConfig, EventAdapterService eventAdapterService, EventTypeIdGenerator eventTypeIdGenerator) { var variantSpec = ValidateVariantStream(variantStreamname, variantStreamConfig, eventAdapterService); var processor = new VAEVariantProcessor(eventAdapterService, variantSpec, eventTypeIdGenerator, variantStreamConfig, _lockManager); eventAdapterService.AddTypeByName(variantStreamname, processor.ValueAddEventType); VariantProcessors.Put(variantStreamname, processor); }
private void TryInvalidConfig(EPServiceProvider epService, string name, ConfigurationVariantStream config, string message) { try { epService.EPAdministrator.Configuration.AddVariantStream(name, config); Assert.Fail(); } catch (ConfigurationException ex) { Assert.AreEqual(message, ex.Message); } }
private void RunAssertionInvalidConfig(EPServiceProvider epService) { var config = new ConfigurationVariantStream(); TryInvalidConfig(epService, "abc", config, "Invalid variant stream configuration, no event type name has been added and default type variance requires at least one type, for name 'abc'"); config.AddEventTypeName("dummy"); TryInvalidConfig(epService, "abc", config, "Event type by name 'dummy' could not be found for use in variant stream configuration by name 'abc'"); }
public void TestInvalidConfig() { ConfigurationVariantStream config = new ConfigurationVariantStream(); TryInvalidConfig("abc", config, "Invalid variant stream configuration, no event type name has been added and default type variance requires at least one type, for name 'abc'"); config.AddEventTypeName("dummy"); TryInvalidConfig("abc", config, "Event type by name 'dummy' could not be found for use in variant stream configuration by name 'abc'"); _epService.EPAdministrator.Configuration.AddEventType("MyEvent", typeof(SupportBean)); }
private void RunAssertionSuperTypesInterfaces(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantOne", typeof(SupportBeanVariantOne)); epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantTwo", typeof(SupportBeanVariantTwo)); var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBeanVariantOne"); variant.AddEventTypeName("SupportBeanVariantTwo"); epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStreamTwo", variant); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamTwo select * from SupportBeanVariantOne"); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamTwo select * from SupportBeanVariantTwo"); EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from MyVariantStreamTwo"); var listenerOne = new SupportUpdateListener(); stmt.Events += listenerOne.Update; EventType eventType = stmt.EventType; string[] expected = "P0,P1,P2,P3,P4,P5,Indexed,Mapped,Inneritem".Split(','); string[] propertyNames = eventType.PropertyNames; EPAssertionUtil.AssertEqualsAnyOrder(expected, propertyNames); Assert.AreEqual(typeof(ISupportBaseAB), eventType.GetPropertyType("P0")); Assert.AreEqual(typeof(ISupportAImplSuperG), eventType.GetPropertyType("P1")); Assert.AreEqual(typeof(object), eventType.GetPropertyType("P2")); Assert.AreEqual(typeof(IList <object>), eventType.GetPropertyType("P3")); Assert.AreEqual(typeof(ICollection <object>), eventType.GetPropertyType("P4")); Assert.AreEqual(typeof(ICollection <object>), eventType.GetPropertyType("P5")); Assert.AreEqual(typeof(int[]), eventType.GetPropertyType("Indexed")); Assert.AreEqual(typeof(IDictionary <string, string>), eventType.GetPropertyType("Mapped")); Assert.AreEqual(typeof(SupportBeanVariantOne.SupportBeanVariantOneInner), eventType.GetPropertyType("Inneritem")); stmt.Dispose(); stmt = epService.EPAdministrator.CreateEPL("select P0,P1,P2,P3,P4,P5,Indexed[0] as P6,IndexArr[1] as P7,MappedKey('a') as P8,inneritem as P9,inneritem.val as P10 from MyVariantStreamTwo"); stmt.Events += listenerOne.Update; eventType = stmt.EventType; Assert.AreEqual(typeof(int?), eventType.GetPropertyType("P6")); Assert.AreEqual(typeof(int?), eventType.GetPropertyType("P7")); Assert.AreEqual(typeof(string), eventType.GetPropertyType("P8")); Assert.AreEqual(typeof(SupportBeanVariantOne.SupportBeanVariantOneInner), eventType.GetPropertyType("P9")); Assert.AreEqual(typeof(string), eventType.GetPropertyType("P10")); var ev1 = new SupportBeanVariantOne(); epService.EPRuntime.SendEvent(ev1); EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), "P6,P7,P8,P9,P10".Split(','), new object[] { 1, 2, "val1", ev1.Inneritem, ev1.Inneritem.Val }); var ev2 = new SupportBeanVariantTwo(); epService.EPRuntime.SendEvent(ev2); EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), "P6,P7,P8,P9,P10".Split(','), new object[] { 10, 20, "val2", ev2.Inneritem, ev2.Inneritem.Val }); epService.EPAdministrator.DestroyAllStatements(); }
private EventType HandleCreateSchema( EPServicesContext services, StatementContext statementContext, CreateSchemaDesc spec) { EventType eventType; try { if (spec.AssignedType != AssignedType.VARIANT) { eventType = EventTypeUtility.CreateNonVariantType( false, spec, statementContext.Annotations, services.ConfigSnapshot, services.EventAdapterService, services.EngineImportService); } else { if (spec.CopyFrom != null && !spec.CopyFrom.IsEmpty()) { throw new ExprValidationException("Copy-from types are not allowed with variant types"); } var isAny = false; var config = new ConfigurationVariantStream(); foreach (var typeName in spec.Types) { if (typeName.Trim().Equals("*")) { isAny = true; break; } config.AddEventTypeName(typeName); } if (!isAny) { config.TypeVariance = TypeVarianceEnum.PREDEFINED; } else { config.TypeVariance = TypeVarianceEnum.ANY; } services.ValueAddEventService.AddVariantStream( spec.SchemaName, config, services.EventAdapterService, services.EventTypeIdGenerator); eventType = services.ValueAddEventService.GetValueAddProcessor(spec.SchemaName).ValueAddEventType; } } catch (Exception ex) { throw new ExprValidationException(ex.Message, ex); } return(eventType); }
/// <summary> /// Ctor. /// </summary> /// <param name="eventAdapterService">The event adapter service.</param> /// <param name="metadata">event type metadata</param> /// <param name="eventTypeId">The event type id.</param> /// <param name="variantSpec">the variant specification</param> /// <param name="propertyResStrategy">stragegy for resolving properties</param> /// <param name="config">The config.</param> public VariantEventType( EventAdapterService eventAdapterService, EventTypeMetadata metadata, int eventTypeId, VariantSpec variantSpec, VariantPropResolutionStrategy propertyResStrategy, ConfigurationVariantStream config) { _eventAdapterService = eventAdapterService; _metadata = metadata; _eventTypeId = eventTypeId; _variants = variantSpec.EventTypes; _propertyResStrategy = propertyResStrategy; _config = config; _propertyDesc = new Dictionary <String, VariantPropertyDesc>(); foreach (EventType type in _variants) { IList <string> properties = type.PropertyNames; properties = PropertyUtility.CopyAndSort(properties); foreach (String property in properties) { if (!_propertyDesc.ContainsKey(property)) { FindProperty(property); } } } ICollection <String> propertyNameKeySet = _propertyDesc.Keys; _propertyNames = propertyNameKeySet.ToArray(); // for each of the properties in each type, attempt to load the property to build a property list _propertyDescriptors = new EventPropertyDescriptor[_propertyDesc.Count]; _propertyDescriptorMap = new Dictionary <String, EventPropertyDescriptor>(); int count = 0; foreach (var desc in _propertyDesc) { var type = desc.Value.PropertyType; var indexType = type.GetIndexType(); var isIndexed = indexType != null; var descriptor = new EventPropertyDescriptor(desc.Key, type, indexType, false, false, isIndexed, false, desc.Value.PropertyType.IsFragmentableType()); _propertyDescriptors[count++] = descriptor; _propertyDescriptorMap.Put(desc.Key, descriptor); } }
private void RunAssertionInvalidInsertInto(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStreamFive", variant); SupportMessageAssertUtil.TryInvalid(epService, "insert into MyVariantStreamFive select * from " + typeof(SupportBean_A).FullName, "Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStreamFive'"); SupportMessageAssertUtil.TryInvalid(epService, "insert into MyVariantStreamFive select IntPrimitive as k0 from " + typeof(SupportBean).FullName, "Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStreamFive' "); }
public void TestInvalidInsertInto() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStream", variant); SupportMessageAssertUtil.TryInvalid(_epService, "insert into MyVariantStream select * from " + Name.Of <SupportBean_A>(), "Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStream'"); SupportMessageAssertUtil.TryInvalid(_epService, "insert into MyVariantStream select intPrimitive as k0 from " + Name.Of <SupportBean>(), "Error starting statement: Selected event type is not a valid event type of the variant stream 'MyVariantStream' "); }
private void RunAssertionNamedWin(EPServiceProvider epService) { var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBeanVariantStream"); variant.AddEventTypeName("SupportBean"); epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStreamThree", variant); // test named window EPStatement stmt = epService.EPAdministrator.CreateEPL("create window MyVariantWindow#unique(TheString) as select * from MyVariantStreamThree"); var listenerOne = new SupportUpdateListener(); stmt.Events += listenerOne.Update; epService.EPAdministrator.CreateEPL("insert into MyVariantWindow select * from MyVariantStreamThree"); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamThree select * from SupportBeanVariantStream"); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamThree select * from SupportBean"); var eventOne = new SupportBean("E1", -1); epService.EPRuntime.SendEvent(eventOne); Assert.AreSame(eventOne, listenerOne.AssertOneGetNewAndReset().Underlying); var eventTwo = new SupportBeanVariantStream("E2"); epService.EPRuntime.SendEvent(eventTwo); Assert.AreSame(eventTwo, listenerOne.AssertOneGetNewAndReset().Underlying); var eventThree = new SupportBean("E2", -1); epService.EPRuntime.SendEvent(eventThree); Assert.AreSame(eventThree, listenerOne.LastNewData[0].Underlying); Assert.AreSame(eventTwo, listenerOne.LastOldData[0].Underlying); listenerOne.Reset(); var eventFour = new SupportBeanVariantStream("E1"); epService.EPRuntime.SendEvent(eventFour); Assert.AreSame(eventFour, listenerOne.LastNewData[0].Underlying); Assert.AreSame(eventOne, listenerOne.LastOldData[0].Underlying); listenerOne.Reset(); epService.EPAdministrator.DestroyAllStatements(); }
public void TestNamedWin() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBeanVariantStream"); variant.AddEventTypeName("SupportBean"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStream", variant); // test named window EPStatement stmt = _epService.EPAdministrator.CreateEPL("create window MyVariantWindow.std:unique(TheString) as select * from MyVariantStream"); stmt.Events += _listenerOne.Update; _epService.EPAdministrator.CreateEPL("insert into MyVariantWindow select * from MyVariantStream"); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBeanVariantStream"); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBean"); Object eventOne = new SupportBean("E1", -1); _epService.EPRuntime.SendEvent(eventOne); Assert.AreSame(eventOne, _listenerOne.AssertOneGetNewAndReset().Underlying); Object eventTwo = new SupportBeanVariantStream("E2"); _epService.EPRuntime.SendEvent(eventTwo); Assert.AreSame(eventTwo, _listenerOne.AssertOneGetNewAndReset().Underlying); Object eventThree = new SupportBean("E2", -1); _epService.EPRuntime.SendEvent(eventThree); Assert.AreSame(eventThree, _listenerOne.LastNewData[0].Underlying); Assert.AreSame(eventTwo, _listenerOne.LastOldData[0].Underlying); _listenerOne.Reset(); Object eventFour = new SupportBeanVariantStream("E1"); _epService.EPRuntime.SendEvent(eventFour); Assert.AreSame(eventFour, _listenerOne.LastNewData[0].Underlying); Assert.AreSame(eventOne, _listenerOne.LastOldData[0].Underlying); _listenerOne.Reset(); }
private void RunAssertionSingleColumnConversion(EPServiceProvider epService) { var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); epService.EPAdministrator.Configuration.AddVariantStream("AllEvents", variant); epService.EPAdministrator.CreateEPL("insert into AllEvents select * from SupportBean"); epService.EPAdministrator.CreateEPL("create window MainEventWindow#length(10000) as AllEvents"); epService.EPAdministrator.CreateEPL("insert into MainEventWindow select " + GetType().Name + ".PreProcessEvent(event) from AllEvents as event"); EPStatement statement = epService.EPAdministrator.CreateEPL("select * from MainEventWindow where TheString = 'E'"); statement.AddEventHandlerWithReplay((new SupportUpdateListener()).Update); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionPatternSubquery(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddEventType("SupportBean_A", typeof(SupportBean_A)); var variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBeanVariantStream"); variant.AddEventTypeName("SupportBean"); epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStreamFour", variant); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamFour select * from SupportBeanVariantStream"); epService.EPAdministrator.CreateEPL("insert into MyVariantStreamFour select * from SupportBean"); // test pattern EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from pattern [a=MyVariantStreamFour -> b=MyVariantStreamFour]"); var listenerOne = new SupportUpdateListener(); stmt.Events += listenerOne.Update; object[] events = { new SupportBean("E1", -1), new SupportBeanVariantStream("E2") }; epService.EPRuntime.SendEvent(events[0]); epService.EPRuntime.SendEvent(events[1]); EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), "a,b".Split(','), events); // test subquery stmt.Dispose(); stmt = epService.EPAdministrator.CreateEPL("select * from SupportBean_A as a where Exists(select * from MyVariantStreamFour#lastevent as b where b.TheString=a.id)"); stmt.Events += listenerOne.Update; events = new object[] { new SupportBean("E1", -1), new SupportBeanVariantStream("E2"), new SupportBean_A("E2") }; epService.EPRuntime.SendEvent(events[0]); epService.EPRuntime.SendEvent(events[2]); Assert.IsFalse(listenerOne.IsInvoked); epService.EPRuntime.SendEvent(events[1]); epService.EPRuntime.SendEvent(events[2]); Assert.IsTrue(listenerOne.IsInvoked); epService.EPAdministrator.DestroyAllStatements(); }
public void TestSingleColumnConversion() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); _epService.EPAdministrator.Configuration.AddImport(GetType().FullName); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); _epService.EPAdministrator.Configuration.AddVariantStream("AllEvents", variant); _epService.EPAdministrator.CreateEPL("insert into AllEvents select * from SupportBean"); _epService.EPAdministrator.CreateEPL("create window MainEventWindow.win:length(10000) as AllEvents"); _epService.EPAdministrator.CreateEPL("insert into MainEventWindow select " + GetType().Name + ".PreProcessEvent(event) from AllEvents as event"); EPStatement statement = _epService.EPAdministrator.CreateEPL("select * from MainEventWindow where TheString = 'E'"); statement.AddEventHandlerWithReplay(new SupportUpdateListener().Update); _epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); }
public void TestPatternSubquery() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean_A>(); _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBeanVariantStream"); variant.AddEventTypeName("SupportBean"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStream", variant); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBeanVariantStream"); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBean"); // test pattern EPStatement stmt = _epService.EPAdministrator.CreateEPL("select * from pattern [a=MyVariantStream -> b=MyVariantStream]"); stmt.Events += _listenerOne.Update; Object[] events = { new SupportBean("E1", -1), new SupportBeanVariantStream("E2") }; _epService.EPRuntime.SendEvent(events[0]); _epService.EPRuntime.SendEvent(events[1]); EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), "a,b".Split(','), events); // test subquery stmt.Dispose(); stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBean_A as a where Exists(select * from MyVariantStream.std:lastevent() as b where b.TheString=a.id)"); stmt.Events += _listenerOne.Update; events = new Object[] { new SupportBean("E1", -1), new SupportBeanVariantStream("E2"), new SupportBean_A("E2") }; _epService.EPRuntime.SendEvent(events[0]); _epService.EPRuntime.SendEvent(events[2]); Assert.IsFalse(_listenerOne.IsInvoked); _epService.EPRuntime.SendEvent(events[1]); _epService.EPRuntime.SendEvent(events[2]); Assert.IsTrue(_listenerOne.IsInvoked); }
public void TestVariantStream() { epService.EPAdministrator.Configuration.AddEventType("SupportBean_A", typeof(SupportBean_A)); epService.EPAdministrator.Configuration.AddEventType("SupportBean_B", typeof(SupportBean_B)); ConfigurationVariantStream config = new ConfigurationVariantStream(); //config.setTypeVariance(ConfigurationVariantStream.TypeVariance.ANY); config.AddEventTypeName("SupportBean_A"); config.AddEventTypeName("SupportBean_B"); epService.EPAdministrator.Configuration.AddVariantStream("VarStream", config); epService.EPAdministrator.CreateEPL("create window MyWindow.win:keepall() as select * from VarStream"); EPStatement stmt = epService.EPAdministrator.CreateEPL("create window MyWindowTwo.win:keepall() as MyWindow"); epService.EPAdministrator.CreateEPL("insert into VarStream select * from SupportBean_A"); epService.EPAdministrator.CreateEPL("insert into VarStream select * from SupportBean_B"); epService.EPAdministrator.CreateEPL("insert into MyWindowTwo select * from VarStream"); epService.EPRuntime.SendEvent(new SupportBean_A("A1")); epService.EPRuntime.SendEvent(new SupportBean_B("B1")); EventBean[] events = EPAssertionUtil.EnumeratorToArray(stmt.GetEnumerator()); Assert.AreEqual("A1", events[0].Get("id?")); EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "id?".Split(','), new object[][] { new object[] { "A1" }, new object[] { "B1" } }); }
private void RunAssertionVariantStream(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddEventType("SupportBean_A", typeof(SupportBean_A)); epService.EPAdministrator.Configuration.AddEventType("SupportBean_B", typeof(SupportBean_B)); var config = new ConfigurationVariantStream(); //config.TypeVariance = TypeVarianceEnum.ANY; config.AddEventTypeName("SupportBean_A"); config.AddEventTypeName("SupportBean_B"); epService.EPAdministrator.Configuration.AddVariantStream("VarStream", config); epService.EPAdministrator.CreateEPL("create window MyWindowVS#keepall as select * from VarStream"); EPStatement stmt = epService.EPAdministrator.CreateEPL("create window MyWindowVSTwo#keepall as MyWindowVS"); epService.EPAdministrator.CreateEPL("insert into VarStream select * from SupportBean_A"); epService.EPAdministrator.CreateEPL("insert into VarStream select * from SupportBean_B"); epService.EPAdministrator.CreateEPL("insert into MyWindowVSTwo select * from VarStream"); epService.EPRuntime.SendEvent(new SupportBean_A("A1")); epService.EPRuntime.SendEvent(new SupportBean_B("B1")); EventBean[] events = EPAssertionUtil.EnumeratorToArray(stmt.GetEnumerator()); Assert.AreEqual("A1", events[0].Get("id?")); EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), "id?".Split(','), new[] { new object[] { "A1" }, new object[] { "B1" } }); }
/// <summary> /// Ctor. /// </summary> /// <param name="eventAdapterService">The event adapter service.</param> /// <param name="variantSpec">specifies how to handle the disparate events</param> /// <param name="eventTypeIdGenerator">The event type id generator.</param> /// <param name="config">The config.</param> /// <param name="lockManager">The lock manager.</param> public VAEVariantProcessor( EventAdapterService eventAdapterService, VariantSpec variantSpec, EventTypeIdGenerator eventTypeIdGenerator, ConfigurationVariantStream config, ILockManager lockManager) { VariantSpec = variantSpec; VariantPropResolutionStrategy strategy; if (variantSpec.TypeVariance == TypeVarianceEnum.ANY) { strategy = new VariantPropResolutionStrategyAny(lockManager, variantSpec); } else { strategy = new VariantPropResolutionStrategyDefault(lockManager, variantSpec); } EventTypeMetadata metadata = EventTypeMetadata.CreateValueAdd(variantSpec.VariantStreamName, TypeClass.VARIANT); VariantEventType = new VariantEventType(eventAdapterService, metadata, eventTypeIdGenerator.GetTypeId(variantSpec.VariantStreamName), variantSpec, strategy, config); }
public void AddVariantStream(String variantEventTypeName, ConfigurationVariantStream variantStreamConfig, EventAdapterService eventAdapterService, EventTypeIdGenerator eventTypeIdGenerator) { }
public void AddVariantStream(String variantEventTypeName, ConfigurationVariantStream variantStreamConfig) { CheckTableExists(variantEventTypeName); _valueAddEventService.AddVariantStream(variantEventTypeName, variantStreamConfig, _eventAdapterService, _eventTypeIdGenerator); }
public void TestCoercionBoxedTypeMatch() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanVariantStream", typeof(SupportBeanVariantStream)); ConfigurationVariantStream variant = new ConfigurationVariantStream(); variant.AddEventTypeName("SupportBean"); variant.AddEventTypeName("SupportBeanVariantStream"); _epService.EPAdministrator.Configuration.AddVariantStream("MyVariantStream", variant); EPStatement stmt = _epService.EPAdministrator.CreateEPL("select * from MyVariantStream"); stmt.Events += _listenerOne.Update; EventType typeSelectAll = stmt.EventType; AssertEventTypeDefault(typeSelectAll); Assert.AreEqual(typeof(Object), stmt.EventType.UnderlyingType); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBean"); _epService.EPAdministrator.CreateEPL("insert into MyVariantStream select * from SupportBeanVariantStream"); // try wildcard Object eventOne = new SupportBean("E0", -1); _epService.EPRuntime.SendEvent(eventOne); Assert.AreSame(eventOne, _listenerOne.AssertOneGetNewAndReset().Underlying); Object eventTwo = new SupportBeanVariantStream("E1"); _epService.EPRuntime.SendEvent(eventTwo); Assert.AreSame(eventTwo, _listenerOne.AssertOneGetNewAndReset().Underlying); stmt.Dispose(); String fields = "TheString,BoolBoxed,IntPrimitive,LongPrimitive,DoublePrimitive,EnumValue"; stmt = _epService.EPAdministrator.CreateEPL("select " + fields + " from MyVariantStream"); stmt.Events += _listenerOne.Update; AssertEventTypeDefault(stmt.EventType); // coerces to the higher resolution type, accepts boxed versus not boxed _epService.EPRuntime.SendEvent(new SupportBeanVariantStream("s1", true, 1, 20, 30, SupportEnum.ENUM_VALUE_1)); EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields.Split(','), new Object[] { "s1", true, 1, 20L, 30d, SupportEnum.ENUM_VALUE_1 }); SupportBean bean = new SupportBean("s2", 99); bean.LongPrimitive = 33; bean.DoublePrimitive = 50; bean.EnumValue = SupportEnum.ENUM_VALUE_3; _epService.EPRuntime.SendEvent(bean); EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields.Split(','), new Object[] { "s2", null, 99, 33L, 50d, SupportEnum.ENUM_VALUE_3 }); // make sure a property is not known since the property is not found on SupportBeanVariantStream try { _epService.EPAdministrator.CreateEPL("select CharBoxed from MyVariantStream"); Assert.Fail(); } catch (EPStatementException ex) { Assert.AreEqual("Error starting statement: Failed to validate select-clause expression 'CharBoxed': Property named 'CharBoxed' is not valid in any stream [select CharBoxed from MyVariantStream]", ex.Message); } // try dynamic property: should exists but not show up as a declared property stmt.Dispose(); fields = "v1,v2,v3"; stmt = _epService.EPAdministrator.CreateEPL("select LongBoxed? as v1,CharBoxed? as v2,DoubleBoxed? as v3 from MyVariantStream"); stmt.Events += _listenerOne.Update; AssertEventTypeDefault(typeSelectAll); // asserts prior "select *" event type bean = new SupportBean(); bean.LongBoxed = 33L; bean.CharBoxed = 'a'; bean.DoubleBoxed = Double.NaN; _epService.EPRuntime.SendEvent(bean); EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields.Split(','), new Object[] { 33L, 'a', Double.NaN }); _epService.EPRuntime.SendEvent(new SupportBeanVariantStream("s2")); EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields.Split(','), new Object[] { null, null, null }); }