private EventType GetAssignAnonymousType( StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { IDictionary<string, object> rowType = RowType; var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousTypeSubselectMultirow(SubselectNumber); var metadata = new EventTypeMetadata( eventTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.SUBQDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var maptype = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, rowType, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(maptype); subselectMultirowType = maptype; return maptype; }
private static EventType GetDefineMultimatchEventType( LinkedHashMap<string, Pair<int, bool>> variableStreams, EventType parentEventType, StatementBaseInfo @base, StatementCompileTimeServices services) { IDictionary<string, object> multievent = new LinkedHashMap<string, object>(); foreach (var entry in variableStreams) { if (entry.Value.Second) { multievent.Put(entry.Key, new[] {parentEventType}); } } var multimatchAllTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogMultimatchAllName; var multimatchAllTypeMetadata = new EventTypeMetadata( multimatchAllTypeName, @base.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var multimatchAllEventType = BaseNestableEventUtil.MakeOATypeCompileTime( multimatchAllTypeMetadata, multievent, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(multimatchAllEventType); return multimatchAllEventType; }
/// <summary>Initializes a new instance of the <see cref="SupportEventTypeFactory"/> class.</summary> /// <param name="container">The container.</param> public SupportEventTypeFactory(IContainer container) { Container = container; STEM_BUILDER = new BeanEventTypeStemBuilder(null, PropertyResolutionStyle.CASE_SENSITIVE); BEAN_STEM_SVC = new BeanEventTypeStemService( null, null, PropertyResolutionStyle.CASE_SENSITIVE, AccessorStyle.NATIVE); BEAN_EVENT_TYPE_FACTORY = new BeanEventTypeFactoryPrivate( new EventBeanTypedEventFactoryRuntime(null), EventTypeFactoryImpl.GetInstance(container), BEAN_STEM_SVC); METADATA_CLASS = name => new EventTypeMetadata( name, null, EventTypeTypeClass.STREAM, EventTypeApplicationType.CLASS, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); SUPPORTBEAN_EVENTTTPE = MakeType(typeof(SupportBean)); SUPPORTBEAN_S0_EVENTTTPE = MakeType(typeof(SupportBean_S0)); SUPPORTBEAN_S1_EVENTTTPE = MakeType(typeof(SupportBean_S1)); SUPPORTBEAN_S2_EVENTTTPE = MakeType(typeof(SupportBean_S2)); SUPPORTBEAN_A_EVENTTTPE = MakeType(typeof(SupportBean_A)); SUPPORTBEANCOMPLEXPROPS_EVENTTTPE = MakeType(typeof(SupportBeanComplexProps)); SUPPORTBEANSIMPLE_EVENTTTPE = MakeType(typeof(SupportBeanSimple)); }
public static EventType NewType( string name, LinkedHashMap<string, object> schemaMap, ViewForgeEnv env, int streamNum) { string outputEventTypeName = env.StatementCompileTimeServices.EventTypeNameGeneratorStatement.GetViewDerived(name, streamNum); EventTypeMetadata metadata = new EventTypeMetadata( outputEventTypeName, env.ModuleName, EventTypeTypeClass.VIEWDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); IDictionary<string, object> propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(schemaMap); EventType resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, propertyTypes, null, null, null, null, env.BeanEventTypeFactoryProtected, env.EventTypeCompileTimeResolver); env.EventTypeModuleCompileTimeRegistry.NewType(resultEventType); return resultEventType; }
public static ObjectArrayEventType MakeTransientOAType( string enumMethod, string propertyName, Type type, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { IDictionary<string, object> propsResult = new Dictionary<string, object>(); propsResult.Put(propertyName, Boxing.GetBoxedType(type)); var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, propertyName); var metadata = new EventTypeMetadata( eventTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.ENUMDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var oatype = BaseNestableEventUtil.MakeOATypeCompileTime( metadata, propsResult, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(oatype); return oatype; }
private static ObjectArrayEventType MakeTransientOATypeInternal( string enumMethod, IDictionary <string, object> boxedPropertyTypes, string eventTypeNameUUid, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, eventTypeNameUUid); var metadata = new EventTypeMetadata( eventTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.ENUMDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var oatype = BaseNestableEventUtil.MakeOATypeCompileTime( metadata, boxedPropertyTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(oatype); return(oatype); }
private static BeanEventType MakeBeanType( string methodName, Type clazz, ExprValidationContext validationContext) { var eventTypeName = validationContext.StatementCompileTimeService.EventTypeNameGeneratorStatement .GetAnonymousTypeNameUDFMethod(methodName, clazz.Name); var metadata = new EventTypeMetadata( eventTypeName, validationContext.ModuleName, EventTypeTypeClass.UDFDERIVED, EventTypeApplicationType.CLASS, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var stem = validationContext.StatementCompileTimeService.BeanEventTypeStemService .GetCreateStem(clazz, null); var beantype = new BeanEventType( validationContext.Container, stem, metadata, validationContext.StatementCompileTimeService.BeanEventTypeFactoryPrivate, null, null, null, null); validationContext.StatementCompileTimeService.EventTypeCompileTimeRegistry.NewType(beantype); return beantype; }
static ExcludePlanHintExprUtil() { LinkedHashMap<string, object> properties = new LinkedHashMap<string, object>(); properties.Put("from_streamnum", typeof(int?)); properties.Put("to_streamnum", typeof(int?)); properties.Put("from_streamname", typeof(string)); properties.Put("to_streamname", typeof(string)); properties.Put("opname", typeof(string)); properties.Put("exprs", typeof(string[])); string eventTypeName = EventTypeNameUtil.GetAnonymousTypeNameExcludePlanHint(); EventTypeMetadata eventTypeMetadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.EXCLUDEPLANHINTDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); OAEXPRESSIONTYPE = BaseNestableEventUtil.MakeOATypeCompileTime( eventTypeMetadata, properties, null, null, null, null, new BeanEventTypeFactoryDisallow(EventBeanTypedEventFactoryCompileTime.INSTANCE), null); }
private EventType HandleVariantType( CreateSchemaDesc spec, StatementCompileTimeServices services) { if (spec.CopyFrom != null && !spec.CopyFrom.IsEmpty()) { throw new ExprValidationException("Copy-from types are not allowed with variant types"); } var eventTypeName = spec.SchemaName; // determine typing var isAny = false; ISet<EventType> types = new LinkedHashSet<EventType>(); foreach (var typeName in spec.Types) { if (typeName.Trim().Equals("*")) { isAny = true; } else { var eventType = services.EventTypeCompileTimeResolver.GetTypeByName(typeName); if (eventType == null) { throw new ExprValidationException( "Event type by name '" + typeName + "' could not be found for use in variant stream by name '" + eventTypeName + "'"); } types.Add(eventType); } } var eventTypes = types.ToArray(); var variantSpec = new VariantSpec(eventTypes, isAny ? TypeVariance.ANY : TypeVariance.PREDEFINED); var visibility = services.ModuleVisibilityRules.GetAccessModifierEventType(@base.StatementRawInfo, spec.SchemaName); var eventBusVisibility = services.ModuleVisibilityRules.GetBusModifierEventType(@base.StatementRawInfo, eventTypeName); EventTypeUtility.ValidateModifiers(spec.SchemaName, eventBusVisibility, visibility); var metadata = new EventTypeMetadata( eventTypeName, @base.ModuleName, EventTypeTypeClass.VARIANT, EventTypeApplicationType.VARIANT, visibility, eventBusVisibility, false, EventTypeIdPair.Unassigned()); var variantEventType = new VariantEventType(metadata, variantSpec); services.EventTypeCompileTimeRegistry.NewType(variantEventType); return variantEventType; }
public EventType CreateMapType(IDictionary <string, object> map) { var metadata = new EventTypeMetadata( UuidGenerator.Generate(), null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); return(new MapEventType(metadata, map, null, null, null, null, BEAN_EVENT_TYPE_FACTORY)); }
public static AvroEventType MakeAvroSupportEventType(Schema schema) { EventTypeMetadata metadata = new EventTypeMetadata( "typename", null, EventTypeTypeClass.STREAM, EventTypeApplicationType.AVRO, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); return new AvroEventType(metadata, schema, null, null, null, null, null, new EventTypeAvroHandlerImpl()); }
private static StreamTypeService GetStreamTypeService( IDictionary<string, Pair<EventType, string>> taggedEventTypes, IDictionary<string, Pair<EventType, string>> arrayEventTypes, EvalForgeNode forge, int streamNum, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var filterTypes = new LinkedHashMap<string, Pair<EventType, string>>(); filterTypes.PutAll(taggedEventTypes); // handle array tags (match-until clause) if (arrayEventTypes != null) { var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousPatternName(streamNum, forge.FactoryNodeId); var metadata = new EventTypeMetadata( eventTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.PATTERNDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var mapProperties = GetMapProperties( new Dictionary<string, Pair<EventType, string>>(), arrayEventTypes); var mapEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, mapProperties, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(mapEventType); EventType arrayTagCompositeEventType = mapEventType; foreach (var entry in arrayEventTypes) { var tag = entry.Key; if (!filterTypes.ContainsKey(tag)) { var pair = new Pair<EventType, string>(arrayTagCompositeEventType, tag); filterTypes.Put(tag, pair); } } } return new StreamTypeServiceImpl(filterTypes, true, false); }
public BeanEventType MakeBeanEventTypeAnonymous(Type beanType) { var metadata = new EventTypeMetadata( beanType.Name, null, EventTypeTypeClass.STREAM, EventTypeApplicationType.CLASS, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var stem = _stemSvc.GetCreateStem(beanType, null); return(new BeanEventType(_container, stem, metadata, _factoryPrivate, null, null, null, null)); }
internal static FragmentEventType GetFragmentEventTypeForField( Schema fieldSchema, string moduleName, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeAvroHandler eventTypeAvroHandler, AvroEventTypeFragmentTypeCache fragmentTypeCache) { Schema recordSchema; var indexed = false; if (fieldSchema.Tag == Schema.Type.Record) { recordSchema = fieldSchema; } else if (fieldSchema.Tag == Schema.Type.Array && fieldSchema.AsArraySchema().ItemSchema.Tag == Schema.Type.Record) { recordSchema = fieldSchema.AsArraySchema().ItemSchema; indexed = true; } else { return null; } var cached = fragmentTypeCache.Get(recordSchema.Name); if (cached != null) { return new FragmentEventType(cached, indexed, false); } var metadata = new EventTypeMetadata( recordSchema.Name, moduleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.AVRO, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var config = new ConfigurationCommonEventTypeAvro(); config.AvroSchema = recordSchema; var fragmentType = eventTypeAvroHandler.NewEventTypeFromSchema( metadata, eventBeanTypedEventFactory, config, null, null); fragmentTypeCache.Add(recordSchema.Name, fragmentType); return new FragmentEventType(fragmentType, indexed, false); }
private DataFlowOpForgeInitializeResult InitializeTypeUndeclared(DataFlowOpForgeInitializeContext context) { // No type has been declared, we can create one var types = new LinkedHashMap<string, object>(); var props = allProperties.Keys; props.RemoveAll(PARAMETER_PROPERTIES); var count = 0; evaluatorForges = new ExprForge[props.Count]; foreach (var propertyName in props) { var exprNode = allProperties.Get(propertyName); var validated = EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.DATAFLOWBEACON, exprNode, null, false, context.StatementRawInfo, context.Services); types.Put(propertyName, validated.Forge.EvaluationType); evaluatorForges[count] = validated.Forge; count++; } var eventTypeName = context.Services.EventTypeNameGeneratorStatement.GetDataflowOperatorTypeName(context.OperatorNumber); var metadata = new EventTypeMetadata( eventTypeName, context.Base.ModuleName, EventTypeTypeClass.DBDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); outputEventType = BaseNestableEventUtil.MakeOATypeCompileTime( metadata, types, null, null, null, null, context.Services.BeanEventTypeFactoryPrivate, context.Services.EventTypeCompileTimeResolver); context.Services.EventTypeCompileTimeRegistry.NewType(outputEventType); return new DataFlowOpForgeInitializeResult(new[] {new GraphTypeDesc(false, true, outputEventType)}); }
private SupportEventTypeFactory(IContainer container) { _container = container; STEM_BUILDER = new BeanEventTypeStemBuilder( null, PropertyResolutionStyle.CASE_SENSITIVE); BEAN_STEM_SVC = new BeanEventTypeStemService( null, null, PropertyResolutionStyle.CASE_SENSITIVE, AccessorStyle.NATIVE); BEAN_EVENT_TYPE_FACTORY = new BeanEventTypeFactoryPrivate( new EventBeanTypedEventFactoryRuntime(null), EventTypeFactoryImpl.GetInstance(container), BEAN_STEM_SVC); METADATA_CLASS = name => new EventTypeMetadata( name, null, EventTypeTypeClass.STREAM, EventTypeApplicationType.CLASS, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); SUPPORTBEAN_EVENTTTPE = MakeType(typeof(SupportBean)); SUPPORTBEAN_S0_EVENTTTPE = MakeType(typeof(SupportBean_S0)); SUPPORTBEAN_S1_EVENTTTPE = MakeType(typeof(SupportBean_S1)); SUPPORTBEAN_S2_EVENTTTPE = MakeType(typeof(SupportBean_S2)); SUPPORTBEAN_S3_EVENTTTPE = MakeType(typeof(SupportBean_S3)); SUPPORTBEAN_S4_EVENTTTPE = MakeType(typeof(SupportBean_S4)); SUPPORTBEAN_A_EVENTTTPE = MakeType(typeof(SupportBean_A)); SUPPORTMARKETDATABEAN_EVENTTTPE = MakeType(typeof(SupportMarketDataBean)); SUPPORTBEANSTRING_EVENTTTPE = MakeType(typeof(SupportBeanString)); SUPPORTBEANCOMPLEXPROPS_EVENTTTPE = MakeType(typeof(SupportBeanComplexProps)); SUPPORTLEGACYBEAN_EVENTTTPE = MakeType(typeof(SupportLegacyBean)); SUPPORTBEANCOMBINEDPROPS_EVENTTTPE = MakeType(typeof(SupportBeanCombinedProps)); SUPPORTBEANPROPERTYNAMES_EVENTTTPE = MakeType(typeof(SupportBeanPropertyNames)); SUPPORTBEANSIMPLE_EVENTTTPE = MakeType(typeof(SupportBeanSimple)); SUPPORTBEANITERABLEPROPS_EVENTTTPE = MakeType(typeof(SupportBeanIterableProps)); SUPPORTABCDEEVENT_EVENTTTPE = MakeType(typeof(SupportABCDEEvent)); SUPPORTBEANITERABLEPROPSCONTAINER_EVENTTYPE = MakeType(typeof(SupportBeanIterablePropsContainer)); }
public void TestEquals() { var metadata = new EventTypeMetadata( "MyType", null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); IDictionary <string, object> mapTwo = new LinkedHashMap <string, object>(); mapTwo.Put("MyInt", typeof(int)); mapTwo.Put("MySupportBean", typeof(SupportBean)); mapTwo.Put("MyNullableSupportBean", typeof(SupportBean)); mapTwo.Put("MyComplexBean", typeof(SupportBeanComplexProps)); Assert.IsFalse( new MapEventType(metadata, mapTwo, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY).Equals(eventType)); mapTwo.Put("MyString", typeof(string)); mapTwo.Put("MyNullableString", typeof(string)); mapTwo.Put("MyNullType", null); // compare, should equal Assert.IsNull( new MapEventType(metadata, mapTwo, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY).EqualsCompareType( eventType)); Assert.AreEqual( null, new MapEventType(metadata, mapTwo, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY).EqualsCompareType( eventType)); // Test boxed and primitive compatible IDictionary <string, object> mapOne = new LinkedHashMap <string, object>(); mapOne.Put("MyInt", typeof(int)); mapTwo = new LinkedHashMap <string, object>(); mapTwo.Put("MyInt", typeof(int?)); Assert.IsNull( new MapEventType(metadata, mapOne, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY).EqualsCompareType( new MapEventType(metadata, mapTwo, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY))); }
public static MapEventType MakeRegisterPatternType( StatementBaseInfo @base, int stream, PatternStreamSpecCompiled patternStreamSpec, StatementCompileTimeServices services) { var patternEventTypeName = services.EventTypeNameGeneratorStatement.GetPatternTypeName(stream); var metadata = new EventTypeMetadata( patternEventTypeName, @base.ModuleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.PRIVATE, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); IDictionary<string, object> propertyTypes = new LinkedHashMap<string, object>(); foreach (var entry in patternStreamSpec.TaggedEventTypes) { propertyTypes.Put(entry.Key, entry.Value.First); } foreach (var entry in patternStreamSpec.ArrayEventTypes) { propertyTypes.Put(entry.Key, new[] {entry.Value.First}); } var patternType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, propertyTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(patternType); return patternType; }
public void SetUp() { var metadata = new EventTypeMetadata( "MyType", null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); IDictionary <string, object> testTypesMap = new Dictionary <string, object>(); testTypesMap.Put("MyInt", typeof(int?)); testTypesMap.Put("MyString", typeof(string)); testTypesMap.Put("MyNullableString", typeof(string)); testTypesMap.Put("MySupportBean", typeof(SupportBean)); testTypesMap.Put("MyComplexBean", typeof(SupportBeanComplexProps)); testTypesMap.Put("MyNullableSupportBean", typeof(SupportBean)); testTypesMap.Put("MyNullType", null); eventType = new MapEventType(metadata, testTypesMap, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY); }
public static EventType GetBuiltInEventType( string moduleName, BeanEventTypeFactory beanEventTypeFactory) { var metadata = new EventTypeMetadata( "anonymous", moduleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); return(BaseNestableEventUtil.MakeOATypeCompileTime( metadata, TYPEINFO, null, null, null, null, beanEventTypeFactory, null)); }
private static void ValidateMergeDesc( OnTriggerMergeDesc mergeDesc, EventType namedWindowType, string namedWindowName, EventType triggerStreamType, string triggerStreamName, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var exprNodeErrorMessage = "Aggregation functions may not be used within an merge-clause"; var dummyTypeNoPropertiesMeta = new EventTypeMetadata( "merge_named_window_insert", statementRawInfo.ModuleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); EventType dummyTypeNoProperties = BaseNestableEventUtil.MakeMapTypeCompileTime( dummyTypeNoPropertiesMeta, Collections.GetEmptyMap<string, object>(), null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); StreamTypeService insertOnlyTypeSvc = new StreamTypeServiceImpl( new[] {dummyTypeNoProperties, triggerStreamType}, new[] {UuidGenerator.Generate(), triggerStreamName}, new[] {true, true}, true, false); var twoStreamTypeSvc = new StreamTypeServiceImpl( new[] {namedWindowType, triggerStreamType}, new[] {namedWindowName, triggerStreamName}, new[] {true, true}, true, false); foreach (var matchedItem in mergeDesc.Items) { // we may provide an additional stream "initial" for the prior value, unless already defined StreamTypeServiceImpl assignmentStreamTypeSvc; if (namedWindowName.Equals(INITIAL_VALUE_STREAM_NAME) || triggerStreamName.Equals(INITIAL_VALUE_STREAM_NAME)) { assignmentStreamTypeSvc = twoStreamTypeSvc; } else { assignmentStreamTypeSvc = new StreamTypeServiceImpl( new[] {namedWindowType, triggerStreamType, namedWindowType}, new[] {namedWindowName, triggerStreamName, INITIAL_VALUE_STREAM_NAME}, new[] {true, true, true}, false, false); assignmentStreamTypeSvc.IsStreamZeroUnambigous = true; } if (matchedItem.OptionalMatchCond != null) { var matchValidStreams = matchedItem.IsMatchedUnmatched ? twoStreamTypeSvc : insertOnlyTypeSvc; matchedItem.OptionalMatchCond = EPStatementStartMethodHelperValidate.ValidateExprNoAgg( ExprNodeOrigin.MERGEMATCHCOND, matchedItem.OptionalMatchCond, matchValidStreams, exprNodeErrorMessage, true, statementRawInfo, services); if (!matchedItem.IsMatchedUnmatched) { EPStatementStartMethodHelperValidate.ValidateSubqueryExcludeOuterStream( matchedItem.OptionalMatchCond); } } foreach (var item in matchedItem.Actions) { if (item is OnTriggerMergeActionDelete) { var delete = (OnTriggerMergeActionDelete) item; if (delete.OptionalWhereClause != null) { delete.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg( ExprNodeOrigin.MERGEMATCHWHERE, delete.OptionalWhereClause, twoStreamTypeSvc, exprNodeErrorMessage, true, statementRawInfo, services); } } else if (item is OnTriggerMergeActionUpdate) { var update = (OnTriggerMergeActionUpdate) item; if (update.OptionalWhereClause != null) { update.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg( ExprNodeOrigin.MERGEMATCHWHERE, update.OptionalWhereClause, twoStreamTypeSvc, exprNodeErrorMessage, true, statementRawInfo, services); } foreach (var assignment in update.Assignments) { assignment.Expression = EPStatementStartMethodHelperValidate.ValidateExprNoAgg( ExprNodeOrigin.UPDATEASSIGN, assignment.Expression, assignmentStreamTypeSvc, exprNodeErrorMessage, true, statementRawInfo, services); } } else if (item is OnTriggerMergeActionInsert) { var insert = (OnTriggerMergeActionInsert) item; var insertTypeSvc = GetInsertStreamService( insert.OptionalStreamName, namedWindowName, insertOnlyTypeSvc, twoStreamTypeSvc); if (insert.OptionalWhereClause != null) { insert.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg( ExprNodeOrigin.MERGEMATCHWHERE, insert.OptionalWhereClause, insertTypeSvc, exprNodeErrorMessage, true, statementRawInfo, services); } var compiledSelect = ValidateInsertSelect( insert.SelectClause, insertTypeSvc, insert.Columns, statementRawInfo, services); insert.SelectClauseCompiled = compiledSelect; } else { throw new ArgumentException("Unrecognized merge item '" + item.GetType().Name + "'"); } } } if (mergeDesc.OptionalInsertNoMatch != null) { var insertTypeSvc = GetInsertStreamService( mergeDesc.OptionalInsertNoMatch.OptionalStreamName, namedWindowName, insertOnlyTypeSvc, twoStreamTypeSvc); var compiledSelect = ValidateInsertSelect( mergeDesc.OptionalInsertNoMatch.SelectClause, insertTypeSvc, mergeDesc.OptionalInsertNoMatch.Columns, statementRawInfo, services); mergeDesc.OptionalInsertNoMatch.SelectClauseCompiled = compiledSelect; } }
public void TestNestedMap() { IDictionary <string, object> levelThree = new Dictionary <string, object>(); levelThree.Put("simpleThree", typeof(long)); levelThree.Put("objThree", typeof(SupportBean_D)); levelThree.Put("nodefmapThree", typeof(IDictionary <string, object>)); IDictionary <string, object> levelTwo = new Dictionary <string, object>(); levelTwo.Put("simpleTwo", typeof(float)); levelTwo.Put("objTwo", typeof(SupportBean_C)); levelTwo.Put("nodefmapTwo", typeof(IDictionary <string, object>)); levelTwo.Put("mapTwo", levelThree); IDictionary <string, object> levelOne = new Dictionary <string, object>(); levelOne.Put("simpleOne", typeof(int?)); levelOne.Put("objOne", typeof(SupportBean_B)); levelOne.Put("nodefmapOne", typeof(IDictionary <string, object>)); levelOne.Put("mapOne", levelTwo); IDictionary <string, object> levelZero = new Dictionary <string, object>(); levelZero.Put("simple", typeof(double?)); levelZero.Put("obj", typeof(SupportBean_A)); levelZero.Put("nodefmap", typeof(IDictionary <string, object>)); levelZero.Put("map", levelOne); var metadata = new EventTypeMetadata( "MyType", null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var mapType = new MapEventType(metadata, levelZero, null, null, null, null, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY); var testData = GetTestData(); var theEvent = new MapEventBean(testData, mapType); object[][] expected = { new object[] { "map.mapOne.simpleTwo", typeof(float?), 300f }, new object[] { "nodefmap.item?", typeof(object), "|nodefmap.item|" }, new object[] { "map.objOne", typeof(SupportBean_B), new SupportBean_B("B1") }, new object[] { "map.simpleOne", typeof(int?), 20 }, new[] { "map.mapOne", typeof(IDictionary <string, object>), testData.Get("map").AsDataMap().Get("mapOne") }, new object[] { "map.mapOne.objTwo", typeof(SupportBean_C), new SupportBean_C("C1") }, new[] { "map.mapOne.mapTwo", typeof(IDictionary <string, object>), testData.Get("map").AsDataMap().Get("mapOne").AsDataMap().Get("mapTwo") }, new object[] { "map.mapOne.mapTwo.simpleThree", typeof(long?), 4000L }, new object[] { "map.mapOne.mapTwo.objThree", typeof(SupportBean_D), new SupportBean_D("D1") }, new object[] { "simple", typeof(double?), 1d }, new object[] { "obj", typeof(SupportBean_A), new SupportBean_A("A1") }, new[] { "nodefmap", typeof(IDictionary <string, object>), testData.Get("nodefmap")}, new[] { "map", typeof(IDictionary <string, object>), testData.Get("map")} }; // assert getter available for all properties for (var i = 0; i < expected.Length; i++) { var propName = (string)expected[i][0]; Assert.IsNotNull(mapType.GetGetter(propName), "failed for property:" + propName); } // assert property types for (var i = 0; i < expected.Length; i++) { var propName = (string)expected[i][0]; var propType = (Type)expected[i][1]; var mapPropType = mapType.GetPropertyType(propName); Assert.AreEqual(propType, mapPropType, "failed for property:" + propName); } // assert property names string[] expectedPropNames = { "simple", "obj", "map", "nodefmap" }; var receivedPropNames = mapType.PropertyNames; EPAssertionUtil.AssertEqualsAnyOrder(expectedPropNames, receivedPropNames); // assert get value through (1) type getter (2) event-get for (var i = 0; i < expected.Length; i++) { var propName = (string)expected[i][0]; var valueExpected = expected[i][2]; Assert.AreEqual(valueExpected, mapType.GetGetter(propName).Get(theEvent), "failed for property type-getter:" + propName); Assert.AreEqual(valueExpected, theEvent.Get(propName), "failed for property event-getter:" + propName); } // assert access to objects nested within expected = new[] { new object[] { "map.objOne.Id", typeof(string), "B1" }, new object[] { "map.mapOne.objTwo.Id", typeof(string), "C1" }, new object[] { "obj.Id", typeof(string), "A1" } }; for (var i = 0; i < expected.Length; i++) { var propName = (string)expected[i][0]; var propType = (Type)expected[i][1]; var valueExpected = expected[i][2]; var getter = mapType.GetGetter(propName); Assert.AreEqual(propType, mapType.GetPropertyType(propName), "failed for property:" + propName); Assert.AreEqual(valueExpected, getter.Get(theEvent), "failed for property type-getter:" + propName); Assert.AreEqual(valueExpected, theEvent.Get(propName), "failed for property event-getter:" + propName); } }
private InfraOnMergeActionInsForge SetupInsert( string infraName, EventType infraType, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementRawInfo statementRawInfo, StatementCompileTimeServices services, bool isTable) { // Compile insert-into info var streamName = desc.OptionalStreamName != null ? desc.OptionalStreamName : infraName; InsertIntoDesc insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns); // rewrite any wildcards to use "stream.wildcard" if (triggeringStreamName == null) { triggeringStreamName = UuidGenerator.Generate(); } var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled); // Set up event types for select-clause evaluation: The first type does not contain anything as its the named-window or table row which is not present for insert var eventTypeMetadata = new EventTypeMetadata( "merge_infra_insert", statementRawInfo.ModuleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); EventType dummyTypeNoProperties = BaseNestableEventUtil.MakeMapTypeCompileTime( eventTypeMetadata, Collections.GetEmptyMap<string, object>(), null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); var eventTypes = new EventType[] {dummyTypeNoProperties, triggeringEventType}; var streamNames = new string[] {UuidGenerator.Generate(), triggeringStreamName}; StreamTypeService streamTypeService = new StreamTypeServiceImpl( eventTypes, streamNames, new bool[eventTypes.Length], false, false); // Get select expr processor var selectClause = selectNoWildcard.ToArray(); var args = new SelectProcessorArgs( selectClause, null, false, null, null, streamTypeService, null, false, statementRawInfo.Annotations, statementRawInfo, services); if (isTable && streamName.Equals(infraName)) { args.OptionalInsertIntoEventType = infraType; } SelectExprProcessorForge insertHelperForge = SelectExprProcessorFactory.GetProcessor(args, insertIntoDesc, false).Forge; ExprNode filterEval = desc.OptionalWhereClause; var route = !streamName.Equals(infraName); bool audit = AuditEnum.INSERT.GetAudit(statementRawInfo.Annotations) != null; TableMetaData insertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName); return new InfraOnMergeActionInsForge(filterEval, insertHelperForge, insertIntoTable, audit, route); }
public static HistoricalEventViewableMethodForge CreateMethodStatementView( int stream, MethodStreamSpec methodStreamSpec, StatementBaseInfo @base, StatementCompileTimeServices services) { var variableMetaData = services.VariableCompileTimeResolver.Resolve(methodStreamSpec.ClassName); MethodPollingExecStrategyEnum strategy; MethodInfo methodReflection = null; string eventTypeNameProvidedUDFOrScript = null; var contextName = @base.StatementSpec.Raw.OptionalContextName; var classpathImportService = services.ImportServiceCompileTime; // see if this is a script in the from-clause ExprNodeScript scriptExpression = null; if (methodStreamSpec.ClassName == null && methodStreamSpec.MethodName != null) { var script = services.ScriptCompileTimeResolver.Resolve( methodStreamSpec.MethodName, methodStreamSpec.Expressions.Count); if (script != null) { scriptExpression = new ExprNodeScript( services.Configuration.Compiler.Scripts.DefaultDialect, script, methodStreamSpec.Expressions); } } try { if (scriptExpression != null) { eventTypeNameProvidedUDFOrScript = scriptExpression.EventTypeNameAnnotation; strategy = MethodPollingExecStrategyEnum.TARGET_SCRIPT; EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.METHODINVJOIN, scriptExpression, null, false, @base.StatementRawInfo, services); } else if (variableMetaData != null) { var variableName = variableMetaData.VariableName; if (variableMetaData.OptionalContextName != null) { if (contextName == null || !contextName.Equals(variableMetaData.OptionalContextName)) { throw new ExprValidationException( "Variable by name '" + variableMetaData.VariableName + "' has been declared for context '" + variableMetaData.OptionalContextName + "' and can only be used within the same context"); } strategy = MethodPollingExecStrategyEnum.TARGET_VAR_CONTEXT; } else { if (variableMetaData.IsConstant) { strategy = MethodPollingExecStrategyEnum.TARGET_CONST; } else { strategy = MethodPollingExecStrategyEnum.TARGET_VAR; } } methodReflection = classpathImportService.ResolveNonStaticMethodOverloadChecked( variableMetaData.Type, methodStreamSpec.MethodName); } else if (methodStreamSpec.ClassName == null) { // must be either UDF or script Pair<Type, ImportSingleRowDesc> udf; try { udf = classpathImportService.ResolveSingleRow( methodStreamSpec.MethodName, services.ClassProvidedExtension); } catch (ImportException ex) { throw new ExprValidationException( "Failed to find user-defined function '" + methodStreamSpec.MethodName + "': " + ex.Message, ex); } methodReflection = classpathImportService.ResolveMethodOverloadChecked( udf.First, methodStreamSpec.MethodName); eventTypeNameProvidedUDFOrScript = udf.Second.OptionalEventTypeName; strategy = MethodPollingExecStrategyEnum.TARGET_CONST; } else { methodReflection = classpathImportService.ResolveMethodOverloadChecked( methodStreamSpec.ClassName, methodStreamSpec.MethodName, services.ClassProvidedExtension); strategy = MethodPollingExecStrategyEnum.TARGET_CONST; } } catch (ExprValidationException) { throw; } catch (Exception e) { throw new ExprValidationException(e.Message, e); } Type methodProviderClass = null; Type beanClass; IDictionary<string, object> oaType = null; IDictionary<string, object> mapType = null; var isCollection = false; var isEnumerator = false; EventType eventType; EventType eventTypeWhenMethodReturnsEventBeans = null; var isStaticMethod = false; if (methodReflection != null) { methodProviderClass = methodReflection.DeclaringType; isStaticMethod = variableMetaData == null; // Determine object type returned by method beanClass = methodReflection.ReturnType; if (beanClass == typeof(void) || beanClass == typeof(void) || beanClass.IsBuiltinDataType()) { throw new ExprValidationException( "Invalid return type for static method '" + methodReflection.Name + "' of class '" + methodStreamSpec.ClassName + "', expecting a type"); } if (methodReflection.ReturnType.IsArray && methodReflection.ReturnType.GetElementType() != typeof(EventBean)) { beanClass = methodReflection.ReturnType.GetElementType(); } isCollection = beanClass.IsGenericCollection() && !beanClass.IsGenericDictionary(); Type collectionClass = null; if (isCollection) { collectionClass = TypeHelper.GetGenericReturnType(methodReflection, true); beanClass = collectionClass; } isEnumerator = beanClass.IsGenericEnumerator(); Type enumerator = null; if (isEnumerator) { enumerator = TypeHelper.GetGenericReturnType(methodReflection, true); beanClass = enumerator; } // If the method returns a Map, look up the map type string mapTypeName = null; if (methodReflection.ReturnType.IsGenericDictionary() || methodReflection.ReturnType.IsArray && methodReflection.ReturnType.GetElementType().IsGenericDictionary() || isCollection && collectionClass.IsGenericDictionary() || isEnumerator && enumerator.IsGenericDictionary()) { MethodMetadataDesc metadata; if (variableMetaData != null) { metadata = GetCheckMetadataVariable( methodStreamSpec.MethodName, variableMetaData, classpathImportService, typeof(IDictionary<string, object>)); } else { metadata = GetCheckMetadataNonVariable( methodStreamSpec.MethodName, methodStreamSpec.ClassName, classpathImportService, typeof(IDictionary<string, object>)); } mapTypeName = metadata.TypeName; mapType = (IDictionary<string, object>) metadata.TypeMetadata; } // If the method returns an Object[] or Object[][], look up the type information string oaTypeName = null; if (methodReflection.ReturnType == typeof(object[]) || methodReflection.ReturnType == typeof(object[][]) || isCollection && collectionClass == typeof(object[]) || isEnumerator && enumerator == typeof(object[])) { MethodMetadataDesc metadata; if (variableMetaData != null) { metadata = GetCheckMetadataVariable( methodStreamSpec.MethodName, variableMetaData, classpathImportService, typeof(IDictionary<string, object>)); } else { metadata = GetCheckMetadataNonVariable( methodStreamSpec.MethodName, methodStreamSpec.ClassName, classpathImportService, typeof(IDictionary<string, object>)); } oaTypeName = metadata.TypeName; oaType = (IDictionary<string, object>) metadata.TypeMetadata; } // Determine event type from class and method name // If the method returns EventBean[], require the event type Func<EventTypeApplicationType, EventTypeMetadata> metadataFunction = apptype => { var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousMethodHistorical(stream); return new EventTypeMetadata( eventTypeName, @base.ModuleName, EventTypeTypeClass.METHODPOLLDERIVED, apptype, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); }; if (methodReflection.ReturnType.IsArray && methodReflection.ReturnType.GetElementType() == typeof(EventBean) || isCollection && collectionClass == typeof(EventBean) || isEnumerator && enumerator == typeof(EventBean)) { var typeName = methodStreamSpec.EventTypeName == null ? eventTypeNameProvidedUDFOrScript : methodStreamSpec.EventTypeName; eventType = EventTypeUtility.RequireEventType( "Method", methodReflection.Name, typeName, services.EventTypeCompileTimeResolver); eventTypeWhenMethodReturnsEventBeans = eventType; } else if (mapType != null) { eventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadataFunction.Invoke(EventTypeApplicationType.MAP), mapType, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(eventType); } else if (oaType != null) { eventType = BaseNestableEventUtil.MakeOATypeCompileTime( metadataFunction.Invoke(EventTypeApplicationType.OBJECTARR), oaType, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(eventType); } else { var stem = services.BeanEventTypeStemService.GetCreateStem(beanClass, null); eventType = new BeanEventType( services.Container, stem, metadataFunction.Invoke(EventTypeApplicationType.CLASS), services.BeanEventTypeFactoryPrivate, null, null, null, null); services.EventTypeCompileTimeRegistry.NewType(eventType); } // the @type is only allowed in conjunction with EventBean return types if (methodStreamSpec.EventTypeName != null && eventTypeWhenMethodReturnsEventBeans == null) { throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage()); } } else { var eventTypeName = methodStreamSpec.EventTypeName == null ? scriptExpression.EventTypeNameAnnotation : methodStreamSpec.EventTypeName; eventType = EventTypeUtility.RequireEventType( "Script", scriptExpression.Script.Name, eventTypeName, services.EventTypeCompileTimeResolver); } // metadata var meta = new MethodPollingViewableMeta( methodProviderClass, isStaticMethod, mapType, oaType, strategy, isCollection, isEnumerator, variableMetaData, eventTypeWhenMethodReturnsEventBeans, scriptExpression); return new HistoricalEventViewableMethodForge(stream, eventType, methodStreamSpec, meta); }
private TableAccessAnalysisResult AnalyzePlanAggregations( string tableName, IList<TableColumnDesc> columns, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // once upfront: obtains aggregation factories for each aggregation // we do this once as a factory may be a heavier object IDictionary<TableColumnDesc, AggregationForgeFactory> aggregationFactories = new Dictionary<TableColumnDesc, AggregationForgeFactory>(); foreach (var column in columns) { if (column is TableColumnDescAgg) { var agg = (TableColumnDescAgg) column; var factory = agg.Aggregation.Factory; aggregationFactories.Put(column, factory); } } // sort into these categories: // plain / method-agg / access-agg // compile all-column public types IList<TableColumnDescTyped> plainColumns = new List<TableColumnDescTyped>(); IList<TableColumnDescAgg> methodAggColumns = new List<TableColumnDescAgg>(); IList<TableColumnDescAgg> accessAggColumns = new List<TableColumnDescAgg>(); var allColumnsPublicTypes = new LinkedHashMap<string, object>(); foreach (var column in columns) { // handle plain types if (column is TableColumnDescTyped) { var typed = (TableColumnDescTyped) column; plainColumns.Add(typed); allColumnsPublicTypes.Put(column.ColumnName, typed.UnresolvedType); continue; } // handle aggs var agg = (TableColumnDescAgg) column; var aggFactory = aggregationFactories.Get(agg); if (aggFactory.IsAccessAggregation) { accessAggColumns.Add(agg); } else { methodAggColumns.Add(agg); } allColumnsPublicTypes.Put(column.ColumnName, agg.Aggregation.EvaluationType); } // determine column metadata // var columnMetadata = new LinkedHashMap<string, TableMetadataColumn>(); // handle typed columns var allColumnsInternalTypes = new LinkedHashMap<string, object>(); allColumnsInternalTypes.Put(INTERNAL_RESERVED_PROPERTY, typeof(object)); var indexPlain = 1; var assignPairsPlain = new TableMetadataColumnPairPlainCol[plainColumns.Count]; foreach (var typedColumn in plainColumns) { allColumnsInternalTypes.Put(typedColumn.ColumnName, typedColumn.UnresolvedType); columnMetadata.Put( typedColumn.ColumnName, new TableMetadataColumnPlain(typedColumn.ColumnName, typedColumn.IsKey, indexPlain)); assignPairsPlain[indexPlain - 1] = new TableMetadataColumnPairPlainCol( typedColumn.PositionInDeclaration, indexPlain); indexPlain++; } // determine internally-used event type var visibility = services.ModuleVisibilityRules.GetAccessModifierTable(@base, tableName); var internalName = EventTypeNameUtil.GetTableInternalTypeName(tableName); var internalMetadata = new EventTypeMetadata( internalName, @base.ModuleName, EventTypeTypeClass.TABLE_INTERNAL, EventTypeApplicationType.OBJECTARR, visibility, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var internalEventType = BaseNestableEventUtil.MakeOATypeCompileTime( internalMetadata, allColumnsInternalTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(internalEventType); // for use by indexes and lookups var publicName = EventTypeNameUtil.GetTablePublicTypeName(tableName); var publicMetadata = new EventTypeMetadata( publicName, @base.ModuleName, EventTypeTypeClass.TABLE_PUBLIC, EventTypeApplicationType.OBJECTARR, visibility, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var publicEventType = BaseNestableEventUtil.MakeOATypeCompileTime( publicMetadata, allColumnsPublicTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(publicEventType); // handle aggregation-methods single-func first. var methodFactories = new AggregationForgeFactory[methodAggColumns.Count]; var index = 0; var assignPairsMethod = new TableMetadataColumnPairAggMethod[methodAggColumns.Count]; foreach (var column in methodAggColumns) { var factory = aggregationFactories.Get(column); var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr( statementRawInfo, services, column.Aggregation); methodFactories[index] = factory; var bindingInfo = factory.AggregationPortableValidation; var expression = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression); columnMetadata.Put( column.ColumnName, new TableMetadataColumnAggregation( column.ColumnName, false, index, bindingInfo, expression, true, optionalEnumerationType)); assignPairsMethod[index] = new TableMetadataColumnPairAggMethod(column.PositionInDeclaration); index++; } // handle access-aggregation (sharable, multi-value) aggregations var stateFactories = new AggregationStateFactoryForge[accessAggColumns.Count]; var accessAccessorForges = new AggregationAccessorSlotPairForge[accessAggColumns.Count]; var assignPairsAccess = new TableMetadataColumnPairAggAccess[accessAggColumns.Count]; var accessNum = 0; foreach (var column in accessAggColumns) { var factory = aggregationFactories.Get(column); var forge = factory.GetAggregationStateFactory(false); stateFactories[accessNum] = forge; var accessor = factory.AccessorForge; var bindingInfo = factory.AggregationPortableValidation; accessAccessorForges[accessNum] = new AggregationAccessorSlotPairForge(accessNum, accessor); var expression = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression); var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr( statementRawInfo, services, column.Aggregation); columnMetadata.Put( column.ColumnName, new TableMetadataColumnAggregation( column.ColumnName, false, index, bindingInfo, expression, false, optionalEnumerationType)); assignPairsAccess[accessNum] = new TableMetadataColumnPairAggAccess(column.PositionInDeclaration, accessor); index++; accessNum++; } // determine primary key index information var primaryKeyColumns = new List<string>(); var primaryKeyTypes = new List<Type>(); var primaryKeyGetters = new List<EventPropertyGetterSPI>(); var primaryKeyColNums = new List<int>(); var colNum = -1; foreach (var typedColumn in plainColumns) { colNum++; if (typedColumn.IsKey) { primaryKeyColumns.Add(typedColumn.ColumnName); primaryKeyTypes.Add(internalEventType.GetPropertyType(typedColumn.ColumnName)); primaryKeyGetters.Add(internalEventType.GetGetterSPI(typedColumn.ColumnName)); primaryKeyColNums.Add(colNum + 1); } } string[] primaryKeyColumnArray = null; Type[] primaryKeyTypeArray = null; EventPropertyGetterSPI[] primaryKeyGetterArray = null; int[] primaryKeyColNumsArray = null; if (!primaryKeyColumns.IsEmpty()) { primaryKeyColumnArray = primaryKeyColumns.ToArray(); primaryKeyTypeArray = primaryKeyTypes.ToArray(); primaryKeyGetterArray = primaryKeyGetters.ToArray(); primaryKeyColNumsArray = primaryKeyColNums.ToArray(); } var forgeDesc = new AggregationRowStateForgeDesc( methodFactories, null, stateFactories, accessAccessorForges, new AggregationUseFlags(false, false, false)); var multiKeyPlan = MultiKeyPlanner.PlanMultiKey( primaryKeyTypeArray, false, statementRawInfo, services.SerdeResolver); var propertyForges = new DataInputOutputSerdeForge[internalEventType.PropertyNames.Length - 1]; var additionalForgeables = new List<StmtClassForgeableFactory>(multiKeyPlan.MultiKeyForgeables); for (var i = 1; i < internalEventType.PropertyNames.Length; i++) { var propertyName = internalEventType.PropertyNames[i]; var propertyType = internalEventType.Types.Get(propertyName); var desc = SerdeEventPropertyUtility.ForgeForEventProperty( publicEventType, propertyName, propertyType, statementRawInfo, services.SerdeResolver); propertyForges[i - 1] = desc.Forge; // plan serdes for nested types foreach (var eventType in desc.NestedTypes) { var serdeForgeables = SerdeEventTypeUtility.Plan( eventType, statementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver); additionalForgeables.AddAll(serdeForgeables); } } return new TableAccessAnalysisResult( columnMetadata, internalEventType, propertyForges, publicEventType, assignPairsPlain, assignPairsMethod, assignPairsAccess, forgeDesc, primaryKeyColumnArray, primaryKeyGetterArray, primaryKeyTypeArray, primaryKeyColNumsArray, multiKeyPlan.ClassRef, additionalForgeables); }
private static void RecursiveCompile( EvalForgeNode evalNode, ISet<string> eventTypeReferences, bool isInsertInto, MatchEventSpec tags, Stack<EvalForgeNode> parentNodeStack, ISet<string> allTagNamesOrdered, int streamNum, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { parentNodeStack.Push(evalNode); foreach (var child in evalNode.ChildNodes) { RecursiveCompile( child, eventTypeReferences, isInsertInto, tags, parentNodeStack, allTagNamesOrdered, streamNum, statementRawInfo, services); } parentNodeStack.Pop(); IDictionary<string, Pair<EventType, string>> newTaggedEventTypes = null; IDictionary<string, Pair<EventType, string>> newArrayEventTypes = null; if (evalNode is EvalFilterForgeNode) { var filterNode = (EvalFilterForgeNode) evalNode; var eventName = filterNode.RawFilterSpec.EventTypeName; if (services.TableCompileTimeResolver.Resolve(eventName) != null) { throw new ExprValidationException("Tables cannot be used in pattern filter atoms"); } var resolvedEventType = ResolveTypeName(eventName, services.EventTypeCompileTimeResolver); var finalEventType = resolvedEventType; var optionalTag = filterNode.EventAsName; var isPropertyEvaluation = false; var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack); // obtain property event type, if final event type is properties if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) { var optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator( filterNode.RawFilterSpec.OptionalPropertyEvalSpec, resolvedEventType, filterNode.EventAsName, statementRawInfo, services); finalEventType = optionalPropertyEvaluator.FragmentEventType; isPropertyEvaluation = true; } // If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no if (optionalTag != null) { var pair = tags.TaggedEventTypes.Get(optionalTag); EventType existingType = null; if (pair != null) { existingType = pair.First; } if (existingType == null) { pair = tags.ArrayEventTypes.Get(optionalTag); if (pair != null) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' used in the repeat-until operator cannot also appear in other filter expressions"); } } if (existingType != null && existingType != finalEventType) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' has already been declared for events of type " + existingType.UnderlyingType.Name); } pair = new Pair<EventType, string>(finalEventType, eventName); // add tagged type if (isPropertyEvaluation || isParentMatchUntil) { newArrayEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(); newArrayEventTypes.Put(optionalTag, pair); } else { newTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(); newTaggedEventTypes.Put(optionalTag, pair); } } // For this filter, filter types are all known tags at this time, // and additionally stream 0 (self) is our event type. // Stream type service allows resolution by property name event if that name appears in other tags. // by defaulting to stream zero. // Stream zero is always the current event type, all others follow the order of the map (stream 1 to N). var selfStreamName = optionalTag; if (selfStreamName == null) { selfStreamName = "s_" + UuidGenerator.Generate(); } var filterTypes = new LinkedHashMap<string, Pair<EventType, string>>(); var typePair = new Pair<EventType, string>(finalEventType, eventName); filterTypes.Put(selfStreamName, typePair); filterTypes.PutAll(tags.TaggedEventTypes); // for the filter, specify all tags used var filterTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(tags.TaggedEventTypes); filterTaggedEventTypes.Remove(optionalTag); // handle array tags (match-until clause) IDictionary<string, Pair<EventType, string>> arrayCompositeEventTypes = null; if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) { arrayCompositeEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(); foreach (var entry in tags.ArrayEventTypes) { var specificArrayType = new LinkedHashMap<string, Pair<EventType, string>>(); specificArrayType.Put(entry.Key, entry.Value); var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousPatternNameWTag( streamNum, evalNode.FactoryNodeId, entry.Key); var mapProps = GetMapProperties( Collections.GetEmptyMap<string, Pair<EventType, string>>(), specificArrayType); var metadata = new EventTypeMetadata( eventTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.PATTERNDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var mapEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, mapProps, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(mapEventType); var tag = entry.Key; if (!filterTypes.ContainsKey(tag)) { var pair = new Pair<EventType, string>(mapEventType, tag); filterTypes.Put(tag, pair); arrayCompositeEventTypes.Put(tag, pair); } } } StreamTypeService streamTypeService = new StreamTypeServiceImpl(filterTypes, true, false); var exprNodes = filterNode.RawFilterSpec.FilterExpressions; var spec = FilterSpecCompiler.MakeFilterSpec( resolvedEventType, eventName, exprNodes, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, filterTaggedEventTypes, arrayCompositeEventTypes, streamTypeService, null, statementRawInfo, services); filterNode.FilterSpec = spec; } else if (evalNode is EvalObserverForgeNode) { var observerNode = (EvalObserverForgeNode) evalNode; try { var observerForge = services.PatternResolutionService.Create(observerNode.PatternObserverSpec); var streamTypeService = GetStreamTypeService( tags.TaggedEventTypes, tags.ArrayEventTypes, observerNode, streamNum, statementRawInfo, services); var validationContext = new ExprValidationContextBuilder( streamTypeService, statementRawInfo, services).Build(); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters, validationContext); var convertor = new MatchedEventConvertorForge( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered); observerNode.ObserverFactory = observerForge; observerForge.SetObserverParameters(validated, convertor, validationContext); } catch (ObserverParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalGuardForgeNode) { var guardNode = (EvalGuardForgeNode) evalNode; try { var guardForge = services.PatternResolutionService.Create(guardNode.PatternGuardSpec); var streamTypeService = GetStreamTypeService( tags.TaggedEventTypes, tags.ArrayEventTypes, guardNode, streamNum, statementRawInfo, services); var validationContext = new ExprValidationContextBuilder( streamTypeService, statementRawInfo, services).Build(); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext); var convertor = new MatchedEventConvertorForge( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered); guardNode.GuardForge = guardForge; guardForge.SetGuardParameters(validated, convertor, services); } catch (GuardParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalEveryDistinctForgeNode) { var distinctNode = (EvalEveryDistinctForgeNode) evalNode; var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode); var streamTypeService = GetStreamTypeService( matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, distinctNode, streamNum, statementRawInfo, services); var validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build(); IList<ExprNode> validated; try { validated = ValidateExpressions( ExprNodeOrigin.PATTERNEVERYDISTINCT, distinctNode.Expressions, validationContext); } catch (ExprValidationPropertyException ex) { throw new ExprValidationPropertyException( ex.Message + ", every-distinct requires that all properties resolve from sub-expressions to the every-distinct", ex.InnerException); } var convertor = new MatchedEventConvertorForge( matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, allTagNamesOrdered); distinctNode.Convertor = convertor; // Determine whether some expressions are constants or time period IList<ExprNode> distinctExpressions = new List<ExprNode>(); TimePeriodComputeForge timePeriodComputeForge = null; ExprNode expiryTimeExp = null; var count = -1; var last = validated.Count - 1; foreach (var expr in validated) { count++; if (count == last && expr is ExprTimePeriod) { expiryTimeExp = expr; var timePeriodExpr = (ExprTimePeriod) expiryTimeExp; timePeriodComputeForge = timePeriodExpr.TimePeriodComputeForge; } else if (expr.Forge.ForgeConstantType.IsCompileTimeConstant) { if (count == last) { var value = expr.Forge.ExprEvaluator.Evaluate(null, true, null); if (!value.IsNumber()) { throw new ExprValidationException( "Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)"); } var secondsExpire = expr.Forge.ExprEvaluator.Evaluate(null, true, null); var timeExpire = secondsExpire == null ? (long?) null : (long?) services.ImportServiceCompileTime.TimeAbacus.DeltaForSecondsNumber( secondsExpire); if (timeExpire != null && timeExpire > 0) { timePeriodComputeForge = new TimePeriodComputeConstGivenDeltaForge(timeExpire.Value); expiryTimeExp = expr; } else { Log.Warn( "Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr)); } } else { Log.Warn( "Every-distinct node utilizes an expression returning a constant value, please check expression '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr) + "', not adding expression to distinct-value expression list"); } } else { distinctExpressions.Add(expr); } } if (distinctExpressions.IsEmpty()) { throw new ExprValidationException( "Every-distinct node requires one or more distinct-value expressions that each return non-constant result values"); } distinctNode.SetDistinctExpressions(distinctExpressions, timePeriodComputeForge, expiryTimeExp); } else if (evalNode is EvalMatchUntilForgeNode) { var matchUntilNode = (EvalMatchUntilForgeNode) evalNode; // compile bounds expressions, if any var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes); var streamTypeService = GetStreamTypeService( untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, matchUntilNode, streamNum, statementRawInfo, services); var validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build(); var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext); matchUntilNode.LowerBounds = lower; var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext); matchUntilNode.UpperBounds = upper; var single = ValidateBounds(matchUntilNode.SingleBound, validationContext); matchUntilNode.SingleBound = single; bool tightlyBound; if (matchUntilNode.SingleBound != null) { ValidateMatchUntil(matchUntilNode.SingleBound, matchUntilNode.SingleBound, false); tightlyBound = true; } else { var allowZeroLowerBounds = matchUntilNode.LowerBounds != null && matchUntilNode.UpperBounds != null; tightlyBound = ValidateMatchUntil( matchUntilNode.LowerBounds, matchUntilNode.UpperBounds, allowZeroLowerBounds); } if (matchUntilNode.SingleBound == null && !tightlyBound && matchUntilNode.ChildNodes.Count < 2) { throw new ExprValidationException("Variable bounds repeat operator requires an until-expression"); } var convertor = new MatchedEventConvertorForge( untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered); matchUntilNode.Convertor = convertor; // compile new tag lists ISet<string> arrayTags = null; var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]); foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) { var optionalTag = filterNode.EventAsName; if (optionalTag != null) { if (arrayTags == null) { arrayTags = new HashSet<string>(); } arrayTags.Add(optionalTag); } } if (arrayTags != null) { foreach (var arrayTag in arrayTags) { if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) { tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag)); tags.TaggedEventTypes.Remove(arrayTag); } } } matchUntilNode.TagsArrayedSet = GetIndexesForTags(allTagNamesOrdered, arrayTags); } else if (evalNode is EvalFollowedByForgeNode) { var followedByNode = (EvalFollowedByForgeNode) evalNode; StreamTypeService streamTypeService = new StreamTypeServiceImpl(false); var validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build(); if (followedByNode.OptionalMaxExpressions != null) { IList<ExprNode> validated = new List<ExprNode>(); foreach (var maxExpr in followedByNode.OptionalMaxExpressions) { if (maxExpr == null) { validated.Add(null); } else { var visitor = new ExprNodeSummaryVisitor(); maxExpr.Accept(visitor); if (!visitor.IsPlain) { var errorMessage = "Invalid maximum expression in followed-by, " + visitor.Message + " are not allowed within the expression"; Log.Error(errorMessage); throw new ExprValidationException(errorMessage); } var validatedExpr = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext); validated.Add(validatedExpr); var returnType = validatedExpr.Forge.EvaluationType; if (returnType == null || !returnType.IsNumeric()) { var message = "Invalid maximum expression in followed-by, the expression must return an integer value"; throw new ExprValidationException(message); } } } followedByNode.OptionalMaxExpressions = validated; } } if (newTaggedEventTypes != null) { tags.TaggedEventTypes.PutAll(newTaggedEventTypes); } if (newArrayEventTypes != null) { tags.ArrayEventTypes.PutAll(newArrayEventTypes); } }
private static StreamTypeService BuildDefineStreamTypeServiceDefine( int defineNum, LinkedHashMap<string, Pair<int, bool>> variableStreams, MatchRecognizeDefineItem defineItem, IDictionary<string, ISet<string>> visibilityByIdentifier, EventType parentViewType, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { if (!variableStreams.ContainsKey(defineItem.Identifier)) { throw new ExprValidationException("Variable '" + defineItem.Identifier + "' does not occur in pattern"); } var streamNamesDefine = new string[variableStreams.Count + 1]; var typesDefine = new EventType[variableStreams.Count + 1]; var isIStreamOnly = new bool[variableStreams.Count + 1]; CompatExtensions.Fill(isIStreamOnly, true); var streamNumDefine = variableStreams.Get(defineItem.Identifier).First; streamNamesDefine[streamNumDefine] = defineItem.Identifier; typesDefine[streamNumDefine] = parentViewType; // add visible single-value var visibles = visibilityByIdentifier.Get(defineItem.Identifier); var hasVisibleMultimatch = false; if (visibles != null) { foreach (var visible in visibles) { var def = variableStreams.Get(visible); if (!def.Second) { streamNamesDefine[def.First] = visible; typesDefine[def.First] = parentViewType; } else { hasVisibleMultimatch = true; } } } // compile multi-matching event type (in last position), if any are used if (hasVisibleMultimatch) { IDictionary<string, object> multievent = new LinkedHashMap<string, object>(); foreach (var entry in variableStreams) { var identifier = entry.Key; if (entry.Value.Second) { if (visibles.Contains(identifier)) { multievent.Put(identifier, new[] {parentViewType}); } else { multievent.Put("esper_matchrecog_internal", null); } } } var multimatchTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousRowrecogMultimatchDefineName(defineNum); var multimatchTypeMetadata = new EventTypeMetadata( multimatchTypeName, statementRawInfo.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var multimatchEventType = BaseNestableEventUtil.MakeOATypeCompileTime( multimatchTypeMetadata, multievent, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); typesDefine[typesDefine.Length - 1] = multimatchEventType; streamNamesDefine[streamNamesDefine.Length - 1] = multimatchEventType.Name; } return new StreamTypeServiceImpl(typesDefine, streamNamesDefine, isIStreamOnly, false, true); }
public static OnTriggerSetPlan HandleSetVariable( string className, CodegenNamespaceScope namespaceScope, string classPostfix, OnTriggerActivatorDesc activatorResult, string optionalStreamName, IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation, OnTriggerSetDesc desc, StatementBaseInfo @base, StatementCompileTimeServices services) { StreamTypeService typeService = new StreamTypeServiceImpl( new[] {activatorResult.ActivatorResultEventType}, new[] {optionalStreamName}, new[] {true}, false, false); var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); // handle subselects var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, new[] {optionalStreamName}, new[] {activatorResult.ActivatorResultEventType}, new[] {activatorResult.TriggerEventTypeName}, services); // validate assignments foreach (var assignment in desc.Assignments) { var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext); assignment.Expression = validated; } // create read-write logic var variableReadWritePackageForge = new VariableReadWritePackageForge(desc.Assignments, services); // plan table access var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes); // create output event type var eventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName; var eventTypeMetadata = new EventTypeMetadata( eventTypeName, @base.ModuleName, EventTypeTypeClass.STATEMENTOUT, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var eventType = BaseNestableEventUtil.MakeMapTypeCompileTime( eventTypeMetadata, variableReadWritePackageForge.VariableTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(eventType); // Handle output format var defaultSelectAllSpec = new StatementSpecCompiled(); defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService streamTypeService = new StreamTypeServiceImpl( new EventType[] {eventType}, new[] {"trigger_stream"}, new[] {true}, false, false); var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(defaultSelectAllSpec), streamTypeService, null, new bool[1], false, @base.ContextPropertyRegistry, false, false, @base.StatementRawInfo, services); var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryOnTriggerSetForge( activatorResult.Activator, eventType, subselectForges, tableAccessForges, variableReadWritePackageForge, classNameRSP); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add( new StmtClassForgableRSPFactoryProvider( classNameRSP, resultSetProcessor, namespaceScope, @base.StatementRawInfo)); var onTrigger = new StmtClassForgableAIFactoryProviderOnTrigger(className, namespaceScope, forge); return new OnTriggerSetPlan(onTrigger, forgables, resultSetProcessor.SelectSubscriberDescriptor); }
public static RowRecogPlan ValidateAndPlan( IContainer container, EventType parentEventType, bool unbound, StatementBaseInfo @base, StatementCompileTimeServices services) { var statementRawInfo = @base.StatementRawInfo; var matchRecognizeSpec = @base.StatementSpec.Raw.MatchRecognizeSpec; var annotations = statementRawInfo.Annotations; var iterateOnly = HintEnum.ITERATE_ONLY.GetHint(annotations) != null; var additionalForgeables = new List<StmtClassForgeableFactory>(); // Expanded pattern already there RowRecogExprNode expandedPatternNode = matchRecognizeSpec.Pattern; // Determine single-row and multiple-row variables var variablesSingle = new LinkedHashSet<string>(); var variablesMultiple = new LinkedHashSet<string>(); RowRecogHelper.RecursiveInspectVariables(expandedPatternNode, false, variablesSingle, variablesMultiple); // each variable gets associated with a stream number (multiple-row variables as well to hold the current event for the expression). var streamNum = 0; var variableStreams = new LinkedHashMap<string, Pair<int, bool>>(); foreach (var variableSingle in variablesSingle) { variableStreams.Put(variableSingle, new Pair<int, bool>(streamNum, false)); streamNum++; } foreach (var variableMultiple in variablesMultiple) { variableStreams.Put(variableMultiple, new Pair<int, bool>(streamNum, true)); streamNum++; } // mapping of stream to variable var streamVariables = new OrderedListDictionary<int, string>(); foreach (var entry in variableStreams) { streamVariables.Put(entry.Value.First, entry.Key); } // determine visibility rules var visibility = RowRecogHelper.DetermineVisibility(expandedPatternNode); // assemble all single-row variables for expression validation var allStreamNames = new string[variableStreams.Count]; var allTypes = new EventType[variableStreams.Count]; streamNum = 0; foreach (var variableSingle in variablesSingle) { allStreamNames[streamNum] = variableSingle; allTypes[streamNum] = parentEventType; streamNum++; } foreach (var variableMultiple in variablesMultiple) { allStreamNames[streamNum] = variableMultiple; allTypes[streamNum] = parentEventType; streamNum++; } // determine type service for use with DEFINE // validate each DEFINE clause expression ISet<string> definedVariables = new HashSet<string>(); IList<ExprAggregateNode> aggregateNodes = new List<ExprAggregateNode>(); var isExprRequiresMultimatchState = new bool[variableStreams.Count]; var previousNodes = new OrderedListDictionary<int, IList<ExprPreviousMatchRecognizeNode>>(); for (var defineIndex = 0; defineIndex < matchRecognizeSpec.Defines.Count; defineIndex++) { MatchRecognizeDefineItem defineItem = matchRecognizeSpec.Defines[defineIndex]; if (definedVariables.Contains(defineItem.Identifier)) { throw new ExprValidationException( "Variable '" + defineItem.Identifier + "' has already been defined"); } definedVariables.Add(defineItem.Identifier); // stream-type visibilities handled here var typeServiceDefines = BuildDefineStreamTypeServiceDefine( defineIndex, variableStreams, defineItem, visibility, parentEventType, statementRawInfo, services); var exprNodeResult = HandlePreviousFunctions(defineItem.Expression, previousNodes); var validationContext = new ExprValidationContextBuilder(typeServiceDefines, statementRawInfo, services) .WithAllowBindingConsumption(true) .WithDisablePropertyExpressionEventCollCache(true) .Build(); ExprNode validated; try { // validate validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGDEFINE, exprNodeResult, validationContext); // check aggregates defineItem.Expression = validated; ExprAggregateNodeUtil.GetAggregatesBottomUp(validated, aggregateNodes); if (!aggregateNodes.IsEmpty()) { throw new ExprValidationException("An aggregate function may not appear in a DEFINE clause"); } } catch (ExprValidationException ex) { throw new ExprValidationException( "Failed to validate condition expression for variable '" + defineItem.Identifier + "': " + ex.Message, ex); } // determine access to event properties from multi-matches var visitor = new ExprNodeStreamRequiredVisitor(); validated.Accept(visitor); var streamsRequired = visitor.StreamsRequired; foreach (var streamRequired in streamsRequired) { if (streamRequired >= variableStreams.Count) { var streamNumIdent = variableStreams.Get(defineItem.Identifier).First; isExprRequiresMultimatchState[streamNumIdent] = true; break; } } } var defineAsksMultimatches = CollectionUtil.IsAnySet(isExprRequiresMultimatchState); // determine type service for use with MEASURE IDictionary<string, object> measureTypeDef = new LinkedHashMap<string, object>(); foreach (var variableSingle in variablesSingle) { measureTypeDef.Put(variableSingle, parentEventType); } foreach (var variableMultiple in variablesMultiple) { measureTypeDef.Put(variableMultiple, new[] {parentEventType}); } var compositeTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogCompositeName; var compositeTypeMetadata = new EventTypeMetadata( compositeTypeName, @base.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var compositeEventType = BaseNestableEventUtil.MakeOATypeCompileTime( compositeTypeMetadata, measureTypeDef, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(compositeEventType); StreamTypeService compositeTypeServiceMeasure = new StreamTypeServiceImpl(compositeEventType, "MATCH_RECOGNIZE", true); // find MEASURE clause aggregations var measureReferencesMultivar = false; IList<ExprAggregateNode> measureAggregateExprNodes = new List<ExprAggregateNode>(); foreach (var measureItem in matchRecognizeSpec.Measures) { ExprAggregateNodeUtil.GetAggregatesBottomUp(measureItem.Expr, measureAggregateExprNodes); } AggregationServiceForgeDesc[] aggregationServices = null; if (!measureAggregateExprNodes.IsEmpty()) { aggregationServices = PlanAggregations( measureAggregateExprNodes, compositeTypeServiceMeasure, allStreamNames, allTypes, streamVariables, variablesMultiple, @base, services); foreach (AggregationServiceForgeDesc svc in aggregationServices) { if (svc != null) { additionalForgeables.AddAll(svc.AdditionalForgeables); } } } // validate each MEASURE clause expression IDictionary<string, object> rowTypeDef = new LinkedHashMap<string, object>(); var streamRefVisitor = new ExprNodeStreamUseCollectVisitor(); foreach (var measureItem in matchRecognizeSpec.Measures) { if (measureItem.Name == null) { throw new ExprValidationException( "The measures clause requires that each expression utilizes the AS keyword to assign a column name"); } var validated = ValidateMeasureClause( measureItem.Expr, compositeTypeServiceMeasure, variablesMultiple, variablesSingle, statementRawInfo, services); measureItem.Expr = validated; rowTypeDef.Put(measureItem.Name, validated.Forge.EvaluationType); validated.Accept(streamRefVisitor); } // Determine if any of the multi-var streams are referenced in the measures (non-aggregated only) foreach (var @ref in streamRefVisitor.Referenced) { var rootPropName = @ref.RootPropertyNameIfAny; if (rootPropName != null) { if (variablesMultiple.Contains(rootPropName)) { measureReferencesMultivar = true; break; } } var streamRequired = @ref.StreamReferencedIfAny; if (streamRequired != null) { var streamVariable = streamVariables.Get(streamRequired.Value); if (streamVariable != null) { var def = variableStreams.Get(streamVariable); if (def != null && def.Second) { measureReferencesMultivar = true; break; } } } } var collectMultimatches = measureReferencesMultivar || defineAsksMultimatches; // create rowevent type var rowTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogRowName; var rowTypeMetadata = new EventTypeMetadata( rowTypeName, @base.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var rowEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( rowTypeMetadata, rowTypeDef, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(rowEventType); // validate partition-by expressions, if any ExprNode[] partitionBy; MultiKeyClassRef partitionMultiKey; if (!matchRecognizeSpec.PartitionByExpressions.IsEmpty()) { StreamTypeService typeServicePartition = new StreamTypeServiceImpl( parentEventType, "MATCH_RECOGNIZE_PARTITION", true); IList<ExprNode> validated = new List<ExprNode>(); var validationContext = new ExprValidationContextBuilder(typeServicePartition, statementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); foreach (var partitionExpr in matchRecognizeSpec.PartitionByExpressions) { validated.Add( ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGPARTITION, partitionExpr, validationContext)); } matchRecognizeSpec.PartitionByExpressions = validated; partitionBy = ExprNodeUtilityQuery.ToArray(validated); MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(partitionBy, false, @base.StatementRawInfo, services.SerdeResolver); partitionMultiKey = multiKeyPlan.ClassRef; additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables); } else { partitionBy = null; partitionMultiKey = null; } // validate interval if present if (matchRecognizeSpec.Interval != null) { var validationContext = new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); var validated = (ExprTimePeriod) ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGINTERVAL, matchRecognizeSpec.Interval.TimePeriodExpr, validationContext); matchRecognizeSpec.Interval.TimePeriodExpr = validated; } // compile variable definition expressions IDictionary<string, ExprNode> variableDefinitions = new Dictionary<string, ExprNode>(); foreach (var defineItem in matchRecognizeSpec.Defines) { variableDefinitions.Put(defineItem.Identifier, defineItem.Expression); } // create evaluators var columnNames = new string[matchRecognizeSpec.Measures.Count]; var columnForges = new ExprNode[matchRecognizeSpec.Measures.Count]; var count = 0; foreach (var measureItem in matchRecognizeSpec.Measures) { columnNames[count] = measureItem.Name; columnForges[count] = measureItem.Expr; count++; } // build states var strand = RowRecogHelper.BuildStartStates( expandedPatternNode, variableDefinitions, variableStreams, isExprRequiresMultimatchState); var startStates = strand.StartStates.ToArray(); RowRecogNFAStateForge[] allStates = strand.AllStates.ToArray(); if (Log.IsInfoEnabled) { Log.Info("NFA tree:\n" + RowRecogNFAViewUtil.Print(startStates)); } // determine names of multimatching variables string[] multimatchVariablesArray; int[] multimatchStreamNumToVariable; int[] multimatchVariableToStreamNum; if (variablesSingle.Count == variableStreams.Count) { multimatchVariablesArray = new string[0]; multimatchStreamNumToVariable = new int[0]; multimatchVariableToStreamNum = new int[0]; } else { multimatchVariablesArray = new string[variableStreams.Count - variablesSingle.Count]; multimatchVariableToStreamNum = new int[multimatchVariablesArray.Length]; multimatchStreamNumToVariable = new int[variableStreams.Count]; CompatExtensions.Fill(multimatchStreamNumToVariable, -1); count = 0; foreach (var entry in variableStreams) { if (entry.Value.Second) { var index = count; multimatchVariablesArray[index] = entry.Key; multimatchVariableToStreamNum[index] = entry.Value.First; multimatchStreamNumToVariable[entry.Value.First] = index; count++; } } } var numEventsEventsPerStreamDefine = defineAsksMultimatches ? variableStreams.Count + 1 : variableStreams.Count; // determine interval-or-terminated var orTerminated = matchRecognizeSpec.Interval != null && matchRecognizeSpec.Interval.IsOrTerminated; TimePeriodComputeForge intervalCompute = null; if (matchRecognizeSpec.Interval != null) { intervalCompute = matchRecognizeSpec.Interval.TimePeriodExpr.TimePeriodComputeForge; } EventType multimatchEventType = null; if (defineAsksMultimatches) { multimatchEventType = GetDefineMultimatchEventType(variableStreams, parentEventType, @base, services); } // determine previous-access indexes and assign "prev" node indexes // Since an expression such as "prior(2, price), prior(8, price)" translates into {2, 8} the relative index is {0, 1}. // Map the expression-supplied index to a relative index int[] previousRandomAccessIndexes = null; if (!previousNodes.IsEmpty()) { previousRandomAccessIndexes = new int[previousNodes.Count]; var countPrev = 0; foreach (var entry in previousNodes) { previousRandomAccessIndexes[countPrev] = entry.Key; foreach (var callback in entry.Value) { callback.AssignedIndex = countPrev; } countPrev++; } } RowRecogDescForge forge = new RowRecogDescForge( parentEventType, rowEventType, compositeEventType, multimatchEventType, multimatchStreamNumToVariable, multimatchVariableToStreamNum, partitionBy, partitionMultiKey, variableStreams, matchRecognizeSpec.Interval != null, iterateOnly, unbound, orTerminated, collectMultimatches, defineAsksMultimatches, numEventsEventsPerStreamDefine, multimatchVariablesArray, startStates, allStates, matchRecognizeSpec.IsAllMatches, matchRecognizeSpec.Skip.Skip, columnForges, columnNames, intervalCompute, previousRandomAccessIndexes, aggregationServices); return new RowRecogPlan(forge, additionalForgeables); }
public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = @base.StatementSpec; if (statementSpec.Raw.OptionalContextName != null) { throw new ExprValidationException( "A create-context statement cannot itself be associated to a context, please declare a nested context instead"); } IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>(); IList<ScheduleHandleCallbackProvider> scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>(); IList<FilterSpecParamExprNodeForge> filterBooleanExpressions = new List<FilterSpecParamExprNodeForge>(); var context = statementSpec.Raw.CreateContextDesc; if (services.ContextCompileTimeResolver.GetContextInfo(context.ContextName) != null) { throw new ExprValidationException("Context by name '" + context.ContextName + "' already exists"); } // compile filter specs, if any var validationEnv = new CreateContextValidationEnv( context.ContextName, @base.StatementRawInfo, services, filterSpecCompileds, scheduleHandleCallbackProviders, filterBooleanExpressions); var additionalForgeables = ValidateContextDetail( context.ContextDetail, 0, validationEnv); // get controller factory forges var controllerFactoryForges = GetForges( context.ContextName, context.ContextDetail); // build context properties type information var contextProps = MakeContextProperties( controllerFactoryForges, @base.StatementRawInfo, services); // allocate type for context properties var contextEventTypeName = services.EventTypeNameGeneratorStatement.GetContextPropertyTypeName(context.ContextName); var metadata = new EventTypeMetadata( contextEventTypeName, @base.ModuleName, EventTypeTypeClass.CONTEXTPROPDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var contextPropertiesType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, contextProps, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(contextPropertiesType); // register context var visibilityContext = services.ModuleVisibilityRules.GetAccessModifierContext(@base, context.ContextName); var validationInfo = new ContextControllerPortableInfo[controllerFactoryForges.Length]; for (var i = 0; i < validationInfo.Length; i++) { validationInfo[i] = controllerFactoryForges[i].ValidationInfo; } var detail = new ContextMetaData( context.ContextName, @base.ModuleName, visibilityContext, contextPropertiesType, validationInfo); services.ContextCompileTimeRegistry.NewContext(detail); // define output event type var statementEventTypeName = services.EventTypeNameGeneratorStatement.GetContextStatementTypeName(context.ContextName); var statementTypeMetadata = new EventTypeMetadata( statementEventTypeName, @base.ModuleName, EventTypeTypeClass.STATEMENTOUT, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); EventType statementEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( statementTypeMetadata, EmptyDictionary<string, object>.Instance, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(statementEventType); var statementFieldsClassName = CodeGenerationIDGenerator .GenerateClassNameSimple(typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var forgeables = new List<StmtClassForgeable>(); foreach (var additional in additionalForgeables) { forgeables.Add(additional.Make(namespaceScope, classPostfix)); } var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateContextForge(context.ContextName, statementEventType); forgeables.Add( new StmtClassForgeableAIFactoryProviderCreateContext( statementAIFactoryProviderClassName, namespaceScope, context.ContextName, controllerFactoryForges, contextPropertiesType, forge)); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, filterSpecCompileds, scheduleHandleCallbackProviders, EmptyList<NamedWindowConsumerStreamSpec>.Instance, false, selectSubscriberDescriptor, namespaceScope, services); informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, context.ContextName); forgeables.Add( new StmtClassForgeableStmtProvider( statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope)); forgeables.Add( new StmtClassForgeableStmtFields( statementFieldsClassName, namespaceScope, 0)); return new StmtForgeMethodResult( forgeables, filterSpecCompileds, scheduleHandleCallbackProviders, EmptyList<NamedWindowConsumerStreamSpec>.Instance, FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, filterBooleanExpressions)); }