public EventAdvancedIndexProvisionCompileTime ToCompileTime( EventType eventTypeIndexed, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { ExprNode[] indexedExpr; if (IndexExpressionsOpt != null) { indexedExpr = IndexExpressionsOpt; } else { if (IsIndexExpressionsAllProps) { indexedExpr = new ExprNode[IndexProperties.Length]; for (var i = 0; i < IndexProperties.Length; i++) { indexedExpr[i] = new ExprIdentNodeImpl(eventTypeIndexed, IndexProperties[i], 0); } } else { indexedExpr = new ExprNode[IndexProperties.Length]; for (var i = 0; i < IndexProperties.Length; i++) { indexedExpr[i] = services.CompilerServices.CompileExpression(IndexExpressionTexts[i], services); indexedExpr[i] = EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.CREATEINDEXCOLUMN, indexedExpr[i], eventTypeIndexed, false, statementRawInfo, services); } } } var desc = new AdvancedIndexDescWExpr(IndexTypeName, indexedExpr); ExprNode[] parameters; if (ParameterExpressionsOpt != null) { parameters = ParameterExpressionsOpt; } else { parameters = new ExprNode[ParameterExpressionTexts.Length]; for (var i = 0; i < ParameterExpressionTexts.Length; i++) { parameters[i] = services.CompilerServices.CompileExpression(ParameterExpressionTexts[i], services); } } return new EventAdvancedIndexProvisionCompileTime( desc, parameters, Factory.Forge, Factory.ToConfigStatement(indexedExpr)); }
public static ExprForge ToExpression( string hint, StatementRawInfo rawInfo, StatementCompileTimeServices services) { ExprNode expr = services.CompilerServices.CompileExpression(hint, services); ExprNode validated = EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.HINT, expr, OAEXPRESSIONTYPE, false, rawInfo, services); return validated.Forge; }
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)}); }
/// <summary> /// Validate the provided expression. /// </summary> /// <param name="name">parameter name</param> /// <param name="eventType">event type</param> /// <param name="expr">expression</param> /// <param name="expectedReturnType">expected result type</param> /// <param name="context">forge initialization context</param> /// <returns>validated expression node</returns> /// <throws>ExprValidationException when validation failed</throws> public static ExprNode Validate( string name, ExprNode expr, EventType eventType, Type expectedReturnType, DataFlowOpForgeInitializeContext context) { if (expr == null) { return null; } ExprNode validated = EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.DATAFLOWFILTER, expr, eventType, false, context.StatementRawInfo, context.Services); ValidateReturnType(name, validated, expectedReturnType); return validated; }
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 DataFlowOpForgeInitializeResult InitializeTypeDeclared( DataFlowOpOutputPort port, DataFlowOpForgeInitializeContext context) { produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying; // compile properties to populate outputEventType = port.OptionalDeclaredType.EventType; var props = allProperties.Keys; props.RemoveAll(PARAMETER_PROPERTIES); var writables = SetupProperties(props.ToArray(), outputEventType); try { eventBeanManufacturer = EventTypeUtility.GetManufacturer( outputEventType, writables, context.Services.ImportServiceCompileTime, false, context.Services.EventTypeAvroHandler); } catch (EventBeanManufactureException e) { throw new ExprValidationException( "Cannot manufacture event for the provided type '" + outputEventType.Name + "': " + e.Message, e); } var index = 0; evaluatorForges = new ExprForge[writables.Length]; var typeWidenerCustomizer = context.Services.EventTypeAvroHandler.GetTypeWidenerCustomizer(outputEventType); foreach (var writable in writables) { object providedProperty = allProperties.Get(writable.PropertyName); var exprNode = (ExprNode) providedProperty; var validated = EPLValidationUtil.ValidateSimpleGetSubtree( ExprNodeOrigin.DATAFLOWBEACON, exprNode, null, false, context.Base.StatementRawInfo, context.Services); TypeWidenerSPI widener; try { widener = TypeWidenerFactory.GetCheckPropertyAssignType( ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validated), validated.Forge.EvaluationType, writable.PropertyType, writable.PropertyName, false, typeWidenerCustomizer, context.Base.StatementName); } catch (TypeWidenerException e) { throw new ExprValidationException("Failed for property '" + writable.PropertyName + "'", e); } if (widener != null) { evaluatorForges[index] = new ExprEvalWithTypeWidener(widener, validated, writable.PropertyType); } else { evaluatorForges[index] = validated.Forge; } index++; } return null; }