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; }
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); }
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 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)}); }
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)); }
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 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 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); }
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); }
public static SelectExprProcessorForgeWForgables Create( SelectProcessorArgs args, InsertIntoDesc insertIntoDesc, Func<String, String> eventTypeNamePostfix) { var streamNames = args.TypeService.StreamNames; var streamTypes = args.TypeService.EventTypes; var moduleName = args.ModuleName; var additionalForgeables = new List<StmtClassForgeableFactory>(); if (streamNames.Length < 2 || streamTypes.Length < 2 || streamNames.Length != streamTypes.Length) { throw new ArgumentException( "Stream names and types parameter length is invalid, expected use of this class is for join statements"); } // Create EventType of result join events var selectProperties = new LinkedHashMap<string, object>(); var streamTypesWTables = new EventType[streamTypes.Length]; var hasTables = false; for (var i = 0; i < streamTypes.Length; i++) { streamTypesWTables[i] = streamTypes[i]; var table = args.TableCompileTimeResolver.ResolveTableFromEventType(streamTypesWTables[i]); if (table != null) { hasTables = true; streamTypesWTables[i] = table.PublicEventType; } selectProperties.Put(streamNames[i], streamTypesWTables[i]); } // If we have a name for this type, add it var representation = EventRepresentationUtil.GetRepresentation( args.Annotations, args.Configuration, AssignedType.NONE); EventType resultEventType; SelectExprProcessorForge processor = null; if (insertIntoDesc != null) { var existingType = args.EventTypeCompileTimeResolver.GetTypeByName(insertIntoDesc.EventTypeName); if (existingType != null) { processor = SelectExprInsertEventBeanFactory.GetInsertUnderlyingJoinWildcard( existingType, streamNames, streamTypesWTables, args.ImportService, args.StatementName, args.EventTypeAvroHandler); } } if (processor == null) { if (insertIntoDesc != null) { var eventTypeName = eventTypeNamePostfix.Invoke(insertIntoDesc.EventTypeName); var visibility = args.CompileTimeServices.ModuleVisibilityRules.GetAccessModifierEventType( args.StatementRawInfo, eventTypeName); var metadata = new Func<EventTypeApplicationType, EventTypeMetadata>( apptype => new EventTypeMetadata( eventTypeName, moduleName, EventTypeTypeClass.STREAM, apptype, visibility, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned())); if (representation == EventUnderlyingType.MAP) { IDictionary<string, object> propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties); resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata.Invoke(EventTypeApplicationType.MAP), propertyTypes, null, null, null, null, args.BeanEventTypeFactoryPrivate, args.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.OBJECTARRAY) { IDictionary<string, object> propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties); resultEventType = BaseNestableEventUtil.MakeOATypeCompileTime( metadata.Invoke(EventTypeApplicationType.OBJECTARR), propertyTypes, null, null, null, null, args.BeanEventTypeFactoryPrivate, args.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.AVRO) { resultEventType = args.EventTypeAvroHandler.NewEventTypeFromNormalized( metadata.Invoke(EventTypeApplicationType.AVRO), args.EventTypeCompileTimeResolver, EventBeanTypedEventFactoryCompileTime.INSTANCE, selectProperties, args.Annotations, null, null, null, args.StatementName); } else if (representation == EventUnderlyingType.JSON) { EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType( metadata.Invoke(EventTypeApplicationType.JSON), selectProperties, null, null, args.StatementRawInfo, args.CompileTimeServices); resultEventType = pair.EventType; additionalForgeables.AddAll(pair.AdditionalForgeables); } else { throw new IllegalStateException("Unrecognized code " + representation); } args.EventTypeCompileTimeRegistry.NewType(resultEventType); } else { var eventTypeName = eventTypeNamePostfix.Invoke( args.CompileTimeServices.EventTypeNameGeneratorStatement.AnonymousTypeName); IDictionary<string, object> propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties); var metadata = new Func<EventTypeApplicationType, EventTypeMetadata>( type => new EventTypeMetadata( eventTypeName, moduleName, EventTypeTypeClass.STATEMENTOUT, type, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned())); if (representation == EventUnderlyingType.MAP) { resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata.Invoke(EventTypeApplicationType.MAP), propertyTypes, null, null, null, null, args.BeanEventTypeFactoryPrivate, args.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.OBJECTARRAY) { resultEventType = BaseNestableEventUtil.MakeOATypeCompileTime( metadata.Invoke(EventTypeApplicationType.OBJECTARR), propertyTypes, null, null, null, null, args.BeanEventTypeFactoryPrivate, args.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.AVRO) { resultEventType = args.EventTypeAvroHandler.NewEventTypeFromNormalized( metadata.Invoke(EventTypeApplicationType.AVRO), args.EventTypeCompileTimeResolver, args.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory, selectProperties, args.Annotations, null, null, null, args.StatementName); } else if (representation == EventUnderlyingType.JSON) { EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType( metadata.Invoke(EventTypeApplicationType.JSON), propertyTypes, null, null, args.StatementRawInfo, args.CompileTimeServices); resultEventType = pair.EventType; additionalForgeables.AddAll(pair.AdditionalForgeables); } else { throw new IllegalStateException("Unrecognized enum " + representation); } args.EventTypeCompileTimeRegistry.NewType(resultEventType); } // NOTE: Processors herein maintain their own result-event-type as they become inner types, // for example "insert into VariantStream select * from A, B" if (resultEventType is ObjectArrayEventType) { processor = new SelectEvalJoinWildcardProcessorObjectArray(streamNames, resultEventType); } else if (resultEventType is MapEventType) { processor = new SelectEvalJoinWildcardProcessorMap(streamNames, resultEventType); } else if (resultEventType is AvroSchemaEventType) { processor = args.EventTypeAvroHandler.OutputFactory.MakeJoinWildcard(streamNames, resultEventType); } else if (resultEventType is JsonEventType) { processor = new SelectEvalJoinWildcardProcessorJson(streamNames, (JsonEventType) resultEventType); } } if (!hasTables) { return new SelectExprProcessorForgeWForgables(processor, additionalForgeables); } processor = new SelectEvalJoinWildcardProcessorTableRows(streamTypes, processor, args.TableCompileTimeResolver); return new SelectExprProcessorForgeWForgables(processor, additionalForgeables); }
// The create window command: // create window windowName[.window_view_list] as [select properties from] type // // This section expected s single FilterStreamSpecCompiled representing the selected type. // It creates a new event type representing the window type and a sets the type selected on the filter stream spec. protected internal static CreateWindowCompileResult HandleCreateWindow( StatementBaseInfo @base, StatementCompileTimeServices services) { var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc; var columns = createWindowDesc.Columns; var typeName = createWindowDesc.WindowName; EventType targetType; // determine that the window name is not already in use as an event type name var existingType = services.EventTypeCompileTimeResolver.GetTypeByName(typeName); if (existingType != null && existingType.Metadata.TypeClass != EventTypeTypeClass.NAMED_WINDOW) { throw new ExprValidationException( "Error starting statement: An event type or schema by name '" + typeName + "' already exists"); } // Determine select-from var optionalSelectFrom = GetOptionalSelectFrom(createWindowDesc, services); // Create Map or Wrapper event type from the select clause of the window. // If no columns selected, simply create a wrapper type // Build a list of properties var newSelectClauseSpecRaw = new SelectClauseSpecRaw(); LinkedHashMap<string, object> properties; var hasProperties = false; if (columns != null && !columns.IsEmpty()) { properties = EventTypeUtility.BuildType( columns, null, services.ImportServiceCompileTime, services.EventTypeCompileTimeResolver); hasProperties = true; } else { if (optionalSelectFrom == null) { throw new IllegalStateException("Missing from-type information for create-window"); } // Validate the select expressions which consists of properties only var select = CompileLimitedSelect(optionalSelectFrom, @base, services); properties = new LinkedHashMap<string, object>(); foreach (var selectElement in select) { if (selectElement.FragmentType != null) { properties.Put(selectElement.AssignedName, selectElement.FragmentType); } else { properties.Put(selectElement.AssignedName, selectElement.SelectExpressionType); } // Add any properties to the new select clause for use by consumers to the statement itself newSelectClauseSpecRaw.Add( new SelectClauseExprRawSpec(new ExprIdentNodeImpl(selectElement.AssignedName), null, false)); hasProperties = true; } } // Create Map or Wrapper event type from the select clause of the window. // If no columns selected, simply create a wrapper type var isOnlyWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsOnlyWildcard; var isWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsUsingWildcard; var namedWindowVisibility = services.ModuleVisibilityRules.GetAccessModifierNamedWindow(@base, typeName); var additionalForgeables = new List<StmtClassForgeableFactory>(); try { if (isWildcard && !isOnlyWildcard) { var metadata = new EventTypeMetadata( typeName, @base.ModuleName, EventTypeTypeClass.NAMED_WINDOW, EventTypeApplicationType.WRAPPER, namedWindowVisibility, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); targetType = WrapperEventTypeUtil.MakeWrapper( metadata, optionalSelectFrom.EventType, properties, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } else { // Some columns selected, use the types of the columns Func<EventTypeApplicationType, EventTypeMetadata> metadata = type => new EventTypeMetadata( typeName, @base.ModuleName, EventTypeTypeClass.NAMED_WINDOW, type, namedWindowVisibility, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); if (hasProperties && !isOnlyWildcard) { var compiledProperties = EventTypeUtility.CompileMapTypeProperties( properties, services.EventTypeCompileTimeResolver); var representation = EventRepresentationUtil.GetRepresentation( @base.StatementSpec.Annotations, services.Configuration, AssignedType.NONE); if (representation == EventUnderlyingType.MAP) { targetType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata.Invoke(EventTypeApplicationType.MAP), compiledProperties, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.OBJECTARRAY) { targetType = BaseNestableEventUtil.MakeOATypeCompileTime( metadata.Invoke(EventTypeApplicationType.OBJECTARR), compiledProperties, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } else if (representation == EventUnderlyingType.AVRO) { targetType = services.EventTypeAvroHandler.NewEventTypeFromNormalized( metadata.Invoke(EventTypeApplicationType.AVRO), services.EventTypeCompileTimeResolver, services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory, compiledProperties, @base.StatementRawInfo.Annotations, null, null, null, @base.StatementName); } else if (representation == EventUnderlyingType.JSON) { EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType( metadata.Invoke(EventTypeApplicationType.JSON), compiledProperties, null, null, @base.StatementRawInfo, services); targetType = pair.EventType; additionalForgeables.AddRange(pair.AdditionalForgeables); } else { throw new IllegalStateException("Unrecognized representation " + representation); } } else { if (optionalSelectFrom == null) { throw new IllegalStateException("Missing from-type information for create-window"); } var selectFromType = optionalSelectFrom.EventType; // No columns selected, no wildcard, use the type as is or as a wrapped type if (selectFromType is ObjectArrayEventType) { var oaType = (ObjectArrayEventType) selectFromType; targetType = BaseNestableEventUtil.MakeOATypeCompileTime( metadata.Invoke(EventTypeApplicationType.OBJECTARR), oaType.Types, null, null, oaType.StartTimestampPropertyName, oaType.EndTimestampPropertyName, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } else if (selectFromType is AvroSchemaEventType) { var avroSchemaEventType = (AvroSchemaEventType) selectFromType; var avro = new ConfigurationCommonEventTypeAvro(); avro.AvroSchema = avroSchemaEventType.Schema; targetType = services.EventTypeAvroHandler.NewEventTypeFromSchema( metadata.Invoke(EventTypeApplicationType.AVRO), services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory, avro, null, null); } else if (selectFromType is JsonEventType) { JsonEventType jsonType = (JsonEventType) selectFromType; targetType = JsonEventTypeUtility.MakeJsonTypeCompileTimeExistingType( metadata.Invoke(EventTypeApplicationType.JSON), jsonType, services); } else if (selectFromType is MapEventType) { var mapType = (MapEventType) selectFromType; targetType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata.Invoke(EventTypeApplicationType.MAP), mapType.Types, null, null, mapType.StartTimestampPropertyName, mapType.EndTimestampPropertyName, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } else if (selectFromType is BeanEventType) { var beanType = (BeanEventType) selectFromType; targetType = new BeanEventType( services.Container, beanType.Stem, metadata.Invoke(EventTypeApplicationType.CLASS), services.BeanEventTypeFactoryPrivate, null, null, beanType.StartTimestampPropertyName, beanType.EndTimestampPropertyName); } else { targetType = WrapperEventTypeUtil.MakeWrapper( metadata.Invoke(EventTypeApplicationType.WRAPPER), selectFromType, new Dictionary<string, object>(), null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); } } } services.EventTypeCompileTimeRegistry.NewType(targetType); } catch (EPException ex) { throw new ExprValidationException(ex.Message, ex); } var filter = new FilterSpecCompiled(targetType, typeName, FilterSpecPlanForge.EMPTY, null); return new CreateWindowCompileResult( filter, newSelectClauseSpecRaw, optionalSelectFrom?.EventType, additionalForgeables); }