private OnTriggerActivatorDesc ActivatorNamedWindow( NamedWindowConsumerStreamSpec namedSpec, StatementCompileTimeServices services) { var namedWindow = namedSpec.NamedWindow; var triggerEventTypeName = namedSpec.NamedWindow.EventType.Name; var typesFilterValidation = new StreamTypeServiceImpl( namedWindow.EventType, namedSpec.OptionalStreamName, false); var filterSingle = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions); var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe( filterSingle, typesFilterValidation, @base.StatementRawInfo, services); var activator = new ViewableActivatorNamedWindowForge( namedSpec, namedWindow, filterSingle, filterQueryGraph, false, namedSpec.OptPropertyEvaluator); var activatorResultEventType = namedWindow.EventType; if (namedSpec.OptPropertyEvaluator != null) { activatorResultEventType = namedSpec.OptPropertyEvaluator.FragmentEventType; } return new OnTriggerActivatorDesc(activator, triggerEventTypeName, activatorResultEventType); }
/// <summary> /// Validate the view parameter expressions and return the validated expression for later execution. /// <para> /// Does not evaluate the expression. /// </para> /// </summary> /// <param name="viewName">textual name of view</param> /// <param name="eventType">is the event type of the parent view or stream attached.</param> /// <param name="statementContext">context with statement services</param> /// <param name="expressions">view expression parameter to validate</param> /// <param name="allowConstantResult"> /// true to indicate whether expressions that return a constant /// result should be allowed; false to indicate that if an expression is known to return a constant result /// the expression is considered invalid /// </param> /// <exception cref="ViewParameterException">if the expressions fail to validate</exception> /// <returns>object result value of parameter expressions</returns> public static ExprNode[] Validate( string viewName, EventType eventType, StatementContext statementContext, IList <ExprNode> expressions, bool allowConstantResult) { var results = new List <ExprNode>(); int expressionNumber = 0; var streamTypeService = new StreamTypeServiceImpl(eventType, null, false, statementContext.EngineURI); foreach (ExprNode expr in expressions) { ExprNode validated = ValidateExpr(viewName, statementContext, expr, streamTypeService, expressionNumber); results.Add(validated); if ((!allowConstantResult) && (validated.IsConstantResult)) { string message = "Invalid view parameter expression " + expressionNumber + GetViewDesc(viewName) + ", the expression returns a constant result value, are you sure?"; Log.Error(message); throw new ViewParameterException(message); } expressionNumber++; } return(results.ToArray()); }
public static Pair <ExprNode, string> CompileValidateStatementFilterExpr( EPServiceProviderSPI engine, string filterExpression) { ExprNode exprNode; try { var spi = (EPAdministratorSPI)engine.EPAdministrator; exprNode = spi.CompileExpression(filterExpression); } catch (Exception ex) { return(new Pair <ExprNode, string>(null, "Error compiling expression: " + ex.Message)); } try { var streamTypeService = new StreamTypeServiceImpl(STATEMENT_META_EVENT_TYPE, null, true, engine.URI); exprNode = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.SCRIPTPARAMS, exprNode, new ExprValidationContext( streamTypeService, engine.EngineImportService, null, null, engine.TimeProvider, null, null, null, engine.EventAdapterService, "no-name-assigned", -1, null, null, null, true, false, false, false, null, true)); } catch (Exception ex) { return(new Pair <ExprNode, string>(null, "Error validating expression: " + ex.Message)); } return(new Pair <ExprNode, string>(exprNode, null)); }
/// <summary> /// Validate the view parameter expressions and return the validated expression for later execution. /// <para /> /// Does not evaluate the expression. /// </summary> /// <param name="viewName">textual name of view</param> /// <param name="eventType">is the event type of the parent view or stream attached.</param> /// <param name="expressions">view expression parameter to validate</param> /// <param name="allowConstantResult"> /// true to indicate whether expressions that return a constantresult should be allowed; false to indicate that if an /// expression is known to return a constant result /// the expression is considered invalid /// </param> /// <param name="streamNumber">stream number</param> /// <param name="viewForgeEnv">view forge env</param> /// <returns>object result value of parameter expressions</returns> /// <throws>ViewParameterException if the expressions fail to validate</throws> public static ExprNode[] Validate( string viewName, EventType eventType, IList<ExprNode> expressions, bool allowConstantResult, ViewForgeEnv viewForgeEnv, int streamNumber) { IList<ExprNode> results = new List<ExprNode>(); var expressionNumber = 0; StreamTypeService streamTypeService = new StreamTypeServiceImpl(eventType, null, false); foreach (var expr in expressions) { var validated = ValidateExpr( viewName, expr, streamTypeService, viewForgeEnv, expressionNumber, streamNumber); results.Add(validated); if (!allowConstantResult && validated.Forge.ForgeConstantType.IsCompileTimeConstant) { var message = "Invalid view parameter expression " + expressionNumber + GetViewDesc(viewName) + ", the expression returns a constant result value, are you sure?"; throw new ViewParameterException(message); } expressionNumber++; } return results.ToArray(); }
public static void Validate1StreamMD(ExprNode topNode) { var eventType = SupportEventTypeFactory.CreateBeanType(typeof(SupportMarketDataBean)); StreamTypeService streamTypeService = new StreamTypeServiceImpl(eventType, "s0", false, "uri"); ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SELECT, topNode, ExprValidationContextFactory.Make(streamTypeService)); }
public static void ValidateFilterWQueryGraphSafe( QueryGraphForge queryGraph, ExprNode filterExpression, StreamTypeServiceImpl typeService, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { try { var validationContext = new ExprValidationContextBuilder(typeService, statementRawInfo, services) .WithAllowBindingConsumption(true) .WithIsFilterExpression(true) .Build(); var validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.FILTER, filterExpression, validationContext); FilterExprAnalyzer.Analyze(validated, queryGraph, false); } catch (Exception ex) { Log.Warn( "Unexpected exception analyzing filterable expression '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(filterExpression) + "': " + ex.Message, ex); } }
protected internal static ExprNode ValidateJoinNamedWindow( ExprNodeOrigin exprNodeOrigin, ExprNode deleteJoinExpr, EventType namedWindowType, string namedWindowStreamName, string namedWindowName, EventType filteredType, string filterStreamName, string filteredTypeName, string optionalTableName, StatementRawInfo statementRawInfo, StatementCompileTimeServices compileTimeServices ) { if (deleteJoinExpr == null) { return null; } var namesAndTypes = new LinkedHashMap<string, Pair<EventType, string>>(); namesAndTypes.Put(namedWindowStreamName, new Pair<EventType, string>(namedWindowType, namedWindowName)); namesAndTypes.Put(filterStreamName, new Pair<EventType, string>(filteredType, filteredTypeName)); StreamTypeService typeService = new StreamTypeServiceImpl(namesAndTypes, false, false); var validationContext = new ExprValidationContextBuilder(typeService, statementRawInfo, compileTimeServices) .WithAllowBindingConsumption(true) .Build(); return ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, deleteJoinExpr, validationContext); }
private NamedWindowOnMergeActionIns SetupInsert(string namedWindowName, InternalEventRouter internalEventRouter, EventTypeSPI eventTypeNamedWindow, int selectClauseNumber, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementContext statementContext) { // Compile insert-into INFO string streamName = desc.OptionalStreamName ?? eventTypeNamedWindow.Name; var 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 row which is not present for insert var dummyTypeNoProperties = new MapEventType(EventTypeMetadata.CreateAnonymous("merge_named_window_insert", ApplicationType.MAP), "merge_named_window_insert", 0, null, Collections.EmptyDataMap, null, null, null); var eventTypes = new EventType[] { dummyTypeNoProperties, triggeringEventType }; var streamNames = new string[] { UuidGenerator.Generate(), triggeringStreamName }; var streamTypeService = new StreamTypeServiceImpl(eventTypes, streamNames, new bool[1], statementContext.EngineURI, false); // Get select expr processor var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(statementContext.StatementName, statementContext.StatementEventTypeRef); var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false); var insertHelper = SelectExprProcessorFactory.GetProcessor( statementContext.Container, Collections.SingletonList(selectClauseNumber), selectNoWildcard.ToArray(), false, insertIntoDesc, null, null, streamTypeService, statementContext.EventAdapterService, statementContext.StatementResultService, statementContext.ValueAddEventService, selectExprEventTypeRegistry, statementContext.EngineImportService, exprEvaluatorContext, statementContext.VariableService, statementContext.ScriptingService, statementContext.TableService, statementContext.TimeProvider, statementContext.EngineURI, statementContext.StatementId, statementContext.StatementName, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ConfigSnapshot, null, statementContext.NamedWindowMgmtService, null, null, statementContext.StatementExtensionServicesContext); var filterEval = desc.OptionalWhereClause == null ? null : desc.OptionalWhereClause.ExprEvaluator; var routerToUser = streamName.Equals(namedWindowName) ? null : internalEventRouter; var audit = AuditEnum.INSERT.GetAudit(statementContext.Annotations) != null; string insertIntoTableName = null; if (statementContext.TableService.GetTableMetadata(insertIntoDesc.EventTypeName) != null) { insertIntoTableName = insertIntoDesc.EventTypeName; } return(new NamedWindowOnMergeActionIns(filterEval, insertHelper, routerToUser, insertIntoTableName, statementContext.TableService, statementContext.EpStatementHandle, statementContext.InternalEventEngineRouteDest, audit)); }
public static void Validate1StreamBean(ExprNode topNode) { var supportContainer = SupportContainer.Instance; var eventType = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean)); StreamTypeService streamTypeService = new StreamTypeServiceImpl(eventType, "s0", false, "uri"); ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SELECT, topNode, SupportExprValidationContextFactory.Make(supportContainer, streamTypeService)); }
public static TimePeriodComputeForge ValidateAndEvaluateTimeDeltaFactory( string viewName, ExprNode expression, string expectedMessage, int expressionNumber, ViewForgeEnv viewForgeEnv, int streamNumber) { StreamTypeService streamTypeService = new StreamTypeServiceImpl(false); TimePeriodComputeForge forge; if (expression is ExprTimePeriod) { var validated = (ExprTimePeriod) ViewForgeSupport.ValidateExpr( viewName, expression, streamTypeService, viewForgeEnv, expressionNumber, streamNumber); forge = validated.TimePeriodComputeForge; } else { var validated = ViewForgeSupport.ValidateExpr( viewName, expression, streamTypeService, viewForgeEnv, expressionNumber, streamNumber); var returnType = validated.Forge.EvaluationType.GetBoxedType(); if (!returnType.IsNumeric()) { throw new ViewParameterException(expectedMessage); } if (validated.Forge.ForgeConstantType.IsCompileTimeConstant) { var timeAbacus = viewForgeEnv.ImportServiceCompileTime.TimeAbacus; var secondsEvaluator = validated.Forge.ExprEvaluator; var time = ViewForgeSupport.Evaluate(secondsEvaluator, 0, viewName); if (!time.IsNumber()) { throw new IllegalStateException(nameof(time) + " is not a number"); } if (!ExprTimePeriodUtil.ValidateTime(time, timeAbacus)) { throw new ViewParameterException(ExprTimePeriodUtil.GetTimeInvalidMsg(viewName, "view", time)); } var msec = timeAbacus.DeltaForSecondsNumber(time); forge = new TimePeriodComputeConstGivenDeltaForge(msec); } else { forge = new TimePeriodComputeNCGivenExprForge( validated.Forge, viewForgeEnv.ImportServiceCompileTime.TimeAbacus); } } return forge; }
protected override void InitExec( string aliasName, StatementSpecCompiled spec, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { StreamTypeServiceImpl assignmentTypeService = new StreamTypeServiceImpl( new EventType[] { processor.EventTypeRspInputEvents, null, processor.EventTypeRspInputEvents }, new string[] {aliasName, "", INITIAL_VALUE_STREAM_NAME}, new bool[] {true, true, true}, true, false); assignmentTypeService.IsStreamZeroUnambigous = true; ExprValidationContext validationContext = new ExprValidationContextBuilder(assignmentTypeService, statementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); // validate update expressions FireAndForgetSpecUpdate updateSpec = (FireAndForgetSpecUpdate) spec.Raw.FireAndForgetSpec; try { foreach (OnTriggerSetAssignment assignment in updateSpec.Assignments) { ExprNode validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.UPDATEASSIGN, assignment.Expression, validationContext); assignment.Expression = validated; EPStatementStartMethodHelperValidate.ValidateNoAggregations( validated, "Aggregation functions may not be used within an update-clause"); } } catch (ExprValidationException e) { throw new EPException(e.Message, e); } // make updater //TableUpdateStrategy tableUpdateStrategy = null; try { bool copyOnWrite = processor is FireAndForgetProcessorNamedWindowForge; updateHelper = EventBeanUpdateHelperForgeFactory.Make( processor.NamedWindowOrTableName, (EventTypeSPI) processor.EventTypeRspInputEvents, updateSpec.Assignments, aliasName, null, copyOnWrite, statementRawInfo.StatementName, services.EventTypeAvroHandler); } catch (ExprValidationException e) { throw new EPException(e.Message, e); } }
public override EPPreparedExecuteIUDSingleStreamExec GetExecutor(FilterSpecCompiled filter, string aliasName) { var services = base.Services; var processor = base.Processor; var statementContext = base.StatementContext; var statementSpec = base.StatementSpec; var updateSpec = (FireAndForgetSpecUpdate)statementSpec.FireAndForgetSpec; var assignmentTypeService = new StreamTypeServiceImpl( new EventType[] { processor.EventTypeResultSetProcessor, null, processor.EventTypeResultSetProcessor }, new string[] { aliasName, "", EPStatementStartMethodOnTrigger.INITIAL_VALUE_STREAM_NAME }, new bool[] { true, true, true }, services.EngineURI, true); assignmentTypeService.IsStreamZeroUnambigous = true; var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, true); var validationContext = new ExprValidationContext( assignmentTypeService, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); // validate update expressions try { foreach (OnTriggerSetAssignment assignment in updateSpec.Assignments) { ExprNode validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.UPDATEASSIGN, assignment.Expression, validationContext); assignment.Expression = validated; EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause"); } } catch (ExprValidationException e) { throw new EPException(e.Message, e); } // make updater EventBeanUpdateHelper updateHelper; TableUpdateStrategy tableUpdateStrategy = null; try { bool copyOnWrite = !(processor is FireAndForgetProcessorTable); updateHelper = EventBeanUpdateHelperFactory.Make(processor.NamedWindowOrTableName, (EventTypeSPI)processor.EventTypeResultSetProcessor, updateSpec.Assignments, aliasName, null, copyOnWrite, statementContext.StatementName, services.EngineURI, services.EventAdapterService); if (processor is FireAndForgetProcessorTable) { FireAndForgetProcessorTable tableProcessor = (FireAndForgetProcessorTable)processor; tableUpdateStrategy = services.TableService.GetTableUpdateStrategy(tableProcessor.TableMetadata, updateHelper, false); copyOnWrite = false; } } catch (ExprValidationException e) { throw new EPException(e.Message, e); } return(new EPPreparedExecuteIUDSingleStreamExecUpdate(filter, statementSpec.FilterRootNode, statementSpec.Annotations, updateHelper, tableUpdateStrategy, statementSpec.TableNodes, services)); }
private static void PerformanceTestIdentNode() { var bidData = new BidData("IBM", 0L, 0.50); var identNode1 = new ExprIdentNodeImpl("BidPrice"); var bidDataEventType = _espServiceProvider.EventAdapterService.GetEventTypeByName("BidData"); var streamTypeService = new StreamTypeServiceImpl(bidDataEventType, null, false, null); identNode1.Validate( new ExprValidationContext( _container, streamTypeService, null, null, null, null, null, null, null, null, null, -1, null, null, null, false, false, false, false, null, false )); var exprEvaluatorContext = (ExprEvaluatorContext)null; Console.WriteLine("IdentNode"); for (var nn = 0; nn < 10; nn++) { var eventBean = new BeanEventBean(bidData, bidDataEventType); var eventBeans = new EventBean[] { eventBean }; var timeItem = PerformanceObserver.TimeMicro( delegate { for (var ii = 1000000; ii >= 0; ii--) { identNode1.ExprEvaluator.Evaluate( new EvaluateParams(eventBeans, false, exprEvaluatorContext)); } }); Console.WriteLine("time: {0} {1:N3} {2:N3}", timeItem, timeItem / 1000000.0m, 1000000.0m / timeItem); } }
public ExprNode CompileValidate( string expression, EventType[] eventTypes, string[] streamNames) { var services = new StatementCompileTimeServices(0, moduleServices); ExprNode node; try { node = services.CompilerServices.CompileExpression(expression, services); } catch (ExprValidationException e) { throw new EPCompileException( "Failed to compile expression '" + expression + "': " + e.Message, e, new EmptyList<EPCompileExceptionItem>()); } try { ExprNodeUtilityValidate.ValidatePlainExpression(ExprNodeOrigin.API, node); StreamTypeService streamTypeService; if (eventTypes == null || eventTypes.Length == 0) { streamTypeService = new StreamTypeServiceImpl(true); } else { var istreamOnly = new bool[eventTypes.Length]; istreamOnly.Fill(true); streamTypeService = new StreamTypeServiceImpl(eventTypes, streamNames, istreamOnly, true, false); } var statementRawInfo = new StatementRawInfo( 0, "API-provided", null, StatementType.INTERNAL_USE_API_COMPILE_EXPR, null, null, new CompilableEPL(expression), "API-provided"); var validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build(); node = ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.API, node, validationContext); } catch (ExprValidationException e) { throw new EPCompileException( "Failed to validate expression '" + expression + "': " + e.Message, e, new EmptyList<EPCompileExceptionItem>()); } return node; }
private static EventAdvancedIndexProvisionCompileTime ValidateAdvanced( string indexName, string indexType, CreateIndexItem columnDesc, EventType eventType, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // validate index expressions: valid and plain expressions StreamTypeService streamTypeService = new StreamTypeServiceImpl(eventType, null, false); var validationContextColumns = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services) .WithDisablePropertyExpressionEventCollCache(true) .Build(); var columns = columnDesc.Expressions.ToArray(); ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CREATEINDEXCOLUMN, columns, validationContextColumns); ExprNodeUtilityValidate.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXCOLUMN, columns); // validate parameters, may not depend on props ExprNode[] parameters = null; if (columnDesc.Parameters != null && !columnDesc.Parameters.IsEmpty()) { parameters = columnDesc.Parameters.ToArray(); ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CREATEINDEXPARAMETER, parameters, validationContextColumns); ExprNodeUtilityValidate.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXPARAMETER, parameters); // validate no stream dependency of parameters var visitor = new ExprNodeIdentifierAndStreamRefVisitor(false); foreach (var param in columnDesc.Parameters) { param.Accept(visitor); if (!visitor.Refs.IsEmpty()) { throw new ExprValidationException("Index parameters may not refer to event properties"); } } } // obtain provider AdvancedIndexFactoryProvider provider; try { provider = services.ImportServiceCompileTime.ResolveAdvancedIndexProvider(indexType); } catch (ImportException ex) { throw new ExprValidationException(ex.Message, ex); } return provider.ValidateEventIndex(indexName, indexType, columns, parameters); }
private static IList<NamedWindowSelectedProps> CompileLimitedSelect( SelectFromInfo selectFromInfo, StatementBaseInfo @base, StatementCompileTimeServices compileTimeServices) { IList<NamedWindowSelectedProps> selectProps = new List<NamedWindowSelectedProps>(); StreamTypeService streams = new StreamTypeServiceImpl( new[] {selectFromInfo.EventType}, new[] {"stream_0"}, new[] {false}, false, false); var validationContext = new ExprValidationContextBuilder(streams, @base.StatementRawInfo, compileTimeServices).Build(); foreach (var item in @base.StatementSpec.SelectClauseCompiled.SelectExprList) { if (!(item is SelectClauseExprCompiledSpec)) { continue; } var exprSpec = (SelectClauseExprCompiledSpec) item; var validatedExpression = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.SELECT, exprSpec.SelectExpression, validationContext); // determine an element name if none assigned var asName = exprSpec.ProvidedName; if (asName == null) { asName = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validatedExpression); } // check for fragments EventType fragmentType = null; if (validatedExpression is ExprIdentNode && !(selectFromInfo.EventType is NativeEventType)) { var identNode = (ExprIdentNode) validatedExpression; var fragmentEventType = selectFromInfo.EventType.GetFragmentType(identNode.FullUnresolvedName); if (fragmentEventType != null && !fragmentEventType.IsNative) { fragmentType = fragmentEventType.FragmentType; } } var validatedElement = new NamedWindowSelectedProps( validatedExpression.Forge.EvaluationType, asName, fragmentType); selectProps.Add(validatedElement); } return selectProps; }
/// <summary>Validate the view parameter expressions and evaluate the expressions returning the result object. </summary> /// <param name="viewName">textual name of view</param> /// <param name="statementContext">context with statement services</param> /// <param name="expressions">view expression parameter to validate</param> /// <returns>object result value of parameter expressions</returns> /// <throws>ViewParameterException if the expressions fail to validate</throws> public static IList <Object> ValidateAndEvaluate(String viewName, StatementContext statementContext, IList <ExprNode> expressions) { IList <Object> results = new List <Object>(); var expressionNumber = 0; StreamTypeService streamTypeService = new StreamTypeServiceImpl(statementContext.EngineURI, false); foreach (var expr in expressions) { var result = ValidateAndEvaluateExpr(viewName, statementContext, expr, streamTypeService, expressionNumber); results.Add(result); expressionNumber++; } return(results); }
protected override StatementAgentInstanceFactoryResult NewContextInternal(AgentInstanceContext agentInstanceContext, bool isRecoveringResilient) { StopCallback stopCallback = new ProxyStopCallback(() => _services.VariableService.DeallocateVariableState(_variableMetaData.VariableName, agentInstanceContext.AgentInstanceId)); _services.VariableService.AllocateVariableState( _variableMetaData.VariableName, agentInstanceContext.AgentInstanceId, _statementContext.StatementExtensionServicesContext, isRecoveringResilient); CreateVariableView createView = new CreateVariableView( _statementContext.StatementId, _services.EventAdapterService, _services.VariableService, _createDesc.VariableName, _statementContext.StatementResultService, agentInstanceContext.AgentInstanceId); _services.VariableService.RegisterCallback(_createDesc.VariableName, agentInstanceContext.AgentInstanceId, createView.Update); _statementContext.StatementStopService.StatementStopped += () => _services.VariableService.UnregisterCallback(_createDesc.VariableName, 0, createView.Update); // Create result set processor, use wildcard selection _statementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard()); _statementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; var typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new string[] { "create_variable" }, new bool[] { true }, _services.EngineURI, false); OutputProcessViewBase outputViewBase; try { ResultSetProcessorFactoryDesc resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( _statementSpec, _statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot, _services.ResultSetProcessorHelperFactory, false, false); ResultSetProcessor resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype, false, null, false); // Attach output view OutputProcessViewFactory outputViewFactory = OutputProcessViewFactoryFactory.Make( _statementSpec, _services.InternalEventRouter, agentInstanceContext.StatementContext, resultSetProcessor.ResultEventType, null, _services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType, _services.ResultSetProcessorHelperFactory, _services.StatementVariableRefService); outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext); createView.AddView(outputViewBase); } catch (ExprValidationException ex) { throw new EPException("Unexpected exception in create-variable context allocation: " + ex.Message, ex); } return(new StatementAgentInstanceFactoryCreateVariableResult(outputViewBase, stopCallback, agentInstanceContext)); }
public DataFlowOpForgeInitializeResult InitializeForge(DataFlowOpForgeInitializeContext context) { if (context.OutputPorts.Count != 1) { throw new ArgumentException( "EventBusSource operator requires one output stream but produces " + context.OutputPorts.Count + " streams"); } var portZero = context.OutputPorts[0]; if (portZero.OptionalDeclaredType == null || portZero.OptionalDeclaredType.EventType == null) { throw new ArgumentException( "EventBusSource operator requires an event type declated for the output stream"); } var eventType = portZero.OptionalDeclaredType.EventType; if (!portZero.OptionalDeclaredType.IsUnderlying) { submitEventBean = true; } DataFlowParameterValidation.Validate("filter", filter, eventType, typeof(bool), context); try { IList<ExprNode> filters = EmptyList<ExprNode>.Instance; if (filter != null) { filters = Collections.SingletonList(filter); } var streamTypeService = new StreamTypeServiceImpl(eventType, eventType.Name, true); var compiledDesc = FilterSpecCompiler.MakeFilterSpec( eventType, eventType.Name, filters, null, null, null, null, streamTypeService, null, context.StatementRawInfo, context.Services); FilterSpecCompiled = compiledDesc.FilterSpecCompiled; } catch (ExprValidationException ex) { throw new ExprValidationException("Failed to obtain filter parameters: " + ex.Message, ex); } return null; }
private static StreamTypeService GetInsertStreamService( string optionalStreamName, string namedWindowName, StreamTypeService insertOnlyTypeSvc, StreamTypeServiceImpl twoStreamTypeSvc) { if (optionalStreamName == null || optionalStreamName.Equals( namedWindowName, StringComparison.InvariantCultureIgnoreCase)) { // if no name was provided in "insert into NAME" or the name is the named window we use the empty type in the first column return insertOnlyTypeSvc; } return twoStreamTypeSvc; }
public static ExprNode[] Validate( string viewName, StatementContext statementContext, IList <ExprNode> expressions) { var results = new ExprNode[expressions.Count]; int expressionNumber = 0; var streamTypeService = new StreamTypeServiceImpl(statementContext.EngineURI, false); foreach (ExprNode expr in expressions) { results[expressionNumber] = ValidateExpr( viewName, statementContext, expr, streamTypeService, expressionNumber); expressionNumber++; } return(results); }
public static ExprTimePeriodEvalDeltaConstFactory ValidateAndEvaluateTimeDeltaFactory( string viewName, StatementContext statementContext, ExprNode expression, string expectedMessage, int expressionNumber) { var streamTypeService = new StreamTypeServiceImpl(statementContext.EngineURI, false); ExprTimePeriodEvalDeltaConstFactory factory; if (expression is ExprTimePeriod) { var validated = (ExprTimePeriod) ViewFactorySupport.ValidateExpr( viewName, statementContext, expression, streamTypeService, expressionNumber); factory = validated.ConstEvaluator(new ExprEvaluatorContextStatement(statementContext, false)); } else { var validated = ViewFactorySupport.ValidateExpr( viewName, statementContext, expression, streamTypeService, expressionNumber); var secondsEvaluator = validated.ExprEvaluator; var returnType = secondsEvaluator.ReturnType.GetBoxedType(); if (!returnType.IsNumeric()) { throw new ViewParameterException(expectedMessage); } if (validated.IsConstantResult) { var time = ViewFactorySupport.Evaluate(secondsEvaluator, 0, viewName, statementContext); if (!ExprTimePeriodUtil.ValidateTime(time, statementContext.TimeAbacus)) { throw new ViewParameterException(ExprTimePeriodUtil.GetTimeInvalidMsg(viewName, "view", time)); } var msec = statementContext.TimeAbacus.DeltaForSecondsNumber(time); factory = new ExprTimePeriodEvalDeltaConstGivenDelta(msec); } else { factory = new ExprTimePeriodEvalDeltaConstFactoryMsec(secondsEvaluator, statementContext.TimeAbacus); } } return factory; }
private static ExprValidationContext GetValidationContext(EventType eventType, StatementContext statementContext) { var streamTypeService = new StreamTypeServiceImpl(eventType, null, false, statementContext.EngineURI); return(new ExprValidationContext( statementContext.Container, streamTypeService, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.TimeProvider, statementContext.VariableService, statementContext.TableService, new ExprEvaluatorContextStatement(statementContext, false), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, true, false, false, false, null, false)); }
public static QueryGraphForge ValidateFilterGetQueryGraphSafe( ExprNode filterExpression, StreamTypeServiceImpl typeService, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { ExcludePlanHint excludePlanHint = null; try { excludePlanHint = ExcludePlanHint.GetHint(typeService.StreamNames, statementRawInfo, services); } catch (ExprValidationException ex) { Log.Warn("Failed to consider exclude-plan hint: " + ex.Message, ex); } var queryGraph = new QueryGraphForge(1, excludePlanHint, false); if (filterExpression != null) { ValidateFilterWQueryGraphSafe(queryGraph, filterExpression, typeService, statementRawInfo, services); } return queryGraph; }
public ExprValidationContext(StreamTypeServiceImpl types, ExprValidationContext ctx) : this( types, ctx.MethodResolutionService, ctx.ViewResourceDelegate, ctx.TimeProvider, ctx.VariableService, ctx.TableService, ctx.ExprEvaluatorContext, ctx.EventAdapterService, ctx.StatementName, ctx.StatementId, ctx.Annotations, ctx.ContextDescriptor, ctx.ScriptingService, ctx.IsDisablePropertyExpressionEventCollCache, false, ctx.IsAllowBindingConsumption, ctx.IsResettingAggregations, ctx.IntoTableName, false) { }
public static ExprTimePeriodEvalDeltaConst ValidateAndEvaluateTimeDelta(String viewName, StatementContext statementContext, ExprNode expression, String expectedMessage, int expressionNumber) { StreamTypeService streamTypeService = new StreamTypeServiceImpl(statementContext.EngineURI, false); ExprTimePeriodEvalDeltaConst timeDelta; if (expression is ExprTimePeriod) { ExprTimePeriod validated = (ExprTimePeriod)ViewFactorySupport.ValidateExpr(viewName, statementContext, expression, streamTypeService, expressionNumber); timeDelta = validated.ConstEvaluator(new ExprEvaluatorContextStatement(statementContext, false)); } else { var result = ViewFactorySupport.ValidateAndEvaluateExpr(viewName, statementContext, expression, streamTypeService, expressionNumber); if (!result.IsNumber()) { throw new ViewParameterException(expectedMessage); } long millisecondsBeforeExpiry; if (TypeHelper.IsFloatingPointNumber(result)) { millisecondsBeforeExpiry = (long)Math.Round(1000d * result.AsDouble()); } else { millisecondsBeforeExpiry = 1000 * result.AsLong(); } timeDelta = new ExprTimePeriodEvalDeltaConstMsec(millisecondsBeforeExpiry); } if (timeDelta.DeltaMillisecondsAdd(0) < 1) { throw new ViewParameterException(viewName + " view requires a size of at least 1 msec"); } return(timeDelta); }
public static ExprNode[] Validate( string viewName, IList<ExprNode> expressions, ViewForgeEnv viewForgeEnv, int streamNumber) { var results = new ExprNode[expressions.Count]; var expressionNumber = 0; StreamTypeService streamTypeService = new StreamTypeServiceImpl(false); foreach (var expr in expressions) { results[expressionNumber] = ValidateExpr( viewName, expr, streamTypeService, viewForgeEnv, expressionNumber, streamNumber); expressionNumber++; } return results; }
public static ExprNode ValidateSimpleGetSubtree( ExprNodeOrigin origin, ExprNode expression, EventType optionalEventType, bool allowBindingConsumption, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { ExprNodeUtilityValidate.ValidatePlainExpression(origin, expression); StreamTypeServiceImpl streamTypes; if (optionalEventType != null) { streamTypes = new StreamTypeServiceImpl(optionalEventType, null, true); } else { streamTypes = new StreamTypeServiceImpl(false); } var validationContext = new ExprValidationContextBuilder(streamTypes, statementRawInfo, services) .WithAllowBindingConsumption(allowBindingConsumption) .Build(); return ExprNodeUtilityValidate.GetValidatedSubtree(origin, expression, validationContext); }
private static void RecursiveCompile( EvalFactoryNode evalNode, StatementContext context, ExprEvaluatorContext evaluatorContext, ICollection <string> eventTypeReferences, bool isInsertInto, MatchEventSpec tags, Deque <int> subexpressionIdStack, Stack <EvalFactoryNode> parentNodeStack, ICollection <string> allTagNamesOrdered) { var counter = 0; parentNodeStack.Push(evalNode); foreach (var child in evalNode.ChildNodes) { subexpressionIdStack.AddLast(counter++); RecursiveCompile( child, context, evaluatorContext, eventTypeReferences, isInsertInto, tags, subexpressionIdStack, parentNodeStack, allTagNamesOrdered); subexpressionIdStack.RemoveLast(); } parentNodeStack.Pop(); LinkedHashMap <string, Pair <EventType, string> > newTaggedEventTypes = null; LinkedHashMap <string, Pair <EventType, string> > newArrayEventTypes = null; if (evalNode is EvalFilterFactoryNode) { var filterNode = (EvalFilterFactoryNode)evalNode; var eventName = filterNode.RawFilterSpec.EventTypeName; if (context.TableService.GetTableMetadata(eventName) != null) { throw new ExprValidationException("Tables cannot be used in pattern filter atoms"); } var resolvedEventType = FilterStreamSpecRaw.ResolveType( context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs); 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 = PropertyEvaluatorFactory.MakeEvaluator( context.Container, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, resolvedEventType, filterNode.EventAsName, context.EventAdapterService, context.EngineImportService, context.SchedulingService, context.VariableService, context.ScriptingService, context.TableService, context.EngineURI, context.StatementId, context.StatementName, context.Annotations, subexpressionIdStack, context.ConfigSnapshot, context.NamedWindowMgmtService, context.StatementExtensionServicesContext); finalEventType = optionalPropertyEvaluator.FragmentEventType; isPropertyEvaluation = true; } if (finalEventType is EventTypeSPI) { eventTypeReferences.Add(((EventTypeSPI)finalEventType).Metadata.PrimaryName); } // 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.FullName); } 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) LinkedHashMap <string, Pair <EventType, string> > arrayCompositeEventTypes = null; if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) { arrayCompositeEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); var patternSubexEventType = GetPatternSubexEventType( context.StatementId, "pattern", subexpressionIdStack); foreach (var entry in tags.ArrayEventTypes) { var specificArrayType = new LinkedHashMap <string, Pair <EventType, string> >(); specificArrayType.Put(entry.Key, entry.Value); var arrayTagCompositeEventType = context.EventAdapterService.CreateSemiAnonymousMapType( patternSubexEventType, Collections.GetEmptyMap <string, Pair <EventType, string> >(), specificArrayType, isInsertInto); context.StatementSemiAnonymousTypeRegistry.Register(arrayTagCompositeEventType); var tag = entry.Key; if (!filterTypes.ContainsKey(tag)) { var pair = new Pair <EventType, string>(arrayTagCompositeEventType, tag); filterTypes.Put(tag, pair); arrayCompositeEventTypes.Put(tag, pair); } } } StreamTypeService streamTypeService = new StreamTypeServiceImpl( filterTypes, context.EngineURI, true, false); var exprNodes = filterNode.RawFilterSpec.FilterExpressions; var spec = FilterSpecCompiler.MakeFilterSpec( resolvedEventType, eventName, exprNodes, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, filterTaggedEventTypes, arrayCompositeEventTypes, streamTypeService, null, context, subexpressionIdStack); filterNode.FilterSpec = spec; } else if (evalNode is EvalObserverFactoryNode) { var observerNode = (EvalObserverFactoryNode)evalNode; try { var observerFactory = context.PatternResolutionService.Create(observerNode.PatternObserverSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "observer", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); observerNode.ObserverFactory = observerFactory; observerFactory.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 EvalGuardFactoryNode) { var guardNode = (EvalGuardFactoryNode)evalNode; try { var guardFactory = context.PatternResolutionService.Create(guardNode.PatternGuardSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "guard", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); guardNode.GuardFactory = guardFactory; guardFactory.SetGuardParameters(validated, convertor); } 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 EvalEveryDistinctFactoryNode) { var distinctNode = (EvalEveryDistinctFactoryNode)evalNode; var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, subexpressionIdStack, "every-distinct", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); 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); } MatchedEventConvertor convertor = new MatchedEventConvertorImpl( matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); distinctNode.Convertor = convertor; // Determine whether some expressions are constants or time period IList <ExprNode> distinctExpressions = new List <ExprNode>(); ExprTimePeriodEvalDeltaConst timeDeltaComputation = 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; timeDeltaComputation = timePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(context, false)); } else if (expr.IsConstantResult) { if (count == last) { var evaluateParams = new EvaluateParams(null, true, evaluatorContext); var value = expr.ExprEvaluator.Evaluate(evaluateParams); if (!(value.IsNumber())) { throw new ExprValidationException( "Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)"); } var secondsExpire = expr.ExprEvaluator.Evaluate(evaluateParams); long?timeExpire; if (secondsExpire == null) { timeExpire = null; } else { timeExpire = context.TimeAbacus.DeltaForSecondsNumber(secondsExpire); } if (timeExpire != null && timeExpire > 0) { timeDeltaComputation = new ExprTimePeriodEvalDeltaConstGivenDelta(timeExpire.Value); expiryTimeExp = expr; } else { Log.Warn("Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr)); } } else { Log.Warn( "Every-distinct node utilizes an expression returning a constant value, please check expression '{0}', not adding expression to distinct-value expression list", expr.ToExpressionStringMinPrecedenceSafe()); } } 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, timeDeltaComputation, expiryTimeExp); } else if (evalNode is EvalMatchUntilFactoryNode) { var matchUntilNode = (EvalMatchUntilFactoryNode)evalNode; // compile bounds expressions, if any var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, subexpressionIdStack, "until", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); 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; var convertor = new MatchedEventConvertorImpl( untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); 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.TagsArrayed = GetIndexesForTags(allTagNamesOrdered, arrayTags); } else if (evalNode is EvalFollowedByFactoryNode) { var followedByNode = (EvalFollowedByFactoryNode)evalNode; StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.EngineURI, false); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); 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.GetMessage() + " are not allowed within the expression"; Log.Error(errorMessage); throw new ExprValidationException(errorMessage); } var validatedExpr = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext); validated.Add(validatedExpr); if ((validatedExpr.ExprEvaluator.ReturnType == null) || (!validatedExpr.ExprEvaluator.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 ExprDotEvalParam GetBodyAndParameter( String enumMethodUsedName, int parameterNum, ExprNode parameterNode, EventType inputEventType, Type collectionComponentType, ExprValidationContext validationContext, IList <ExprDotEvalParam> priorParameters, DotMethodFP footprint) { // handle an expression that is a constant or other (not =>) if (!(parameterNode is ExprLambdaGoesNode)) { // no node subtree validation is required here, the chain parameter validation has taken place in ExprDotNode.validate // validation of parameter types has taken place in footprint matching return(new ExprDotEvalParamExpr(parameterNum, parameterNode, parameterNode.ExprEvaluator)); } var goesNode = (ExprLambdaGoesNode)parameterNode; // Get secondary var additionalTypes = GetAddStreamTypes( enumMethodUsedName, goesNode.GoesToNames, inputEventType, collectionComponentType, priorParameters, validationContext.EventAdapterService); var additionalStreamNames = goesNode.GoesToNames.ToArray(); ValidateDuplicateStreamNames(validationContext.StreamTypeService.StreamNames, additionalStreamNames); // add name and type to list of known types var addTypes = (EventType[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.EventTypes, additionalTypes); var addNames = (String[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.StreamNames, additionalStreamNames); var types = new StreamTypeServiceImpl( addTypes, addNames, new bool[addTypes.Length], null, false); // validate expression body var filter = goesNode.ChildNodes[0]; try { var filterValidationContext = new ExprValidationContext(types, validationContext); filter = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DECLAREDEXPRBODY, filter, filterValidationContext); } catch (ExprValidationException ex) { throw new ExprValidationException( "Error validating enumeration method '" + enumMethodUsedName + "' parameter " + parameterNum + ": " + ex.Message, ex); } var filterEvaluator = filter.ExprEvaluator; var expectedType = footprint.Parameters[parameterNum].ParamType; // Lambda-methods don't use a specific expected return-type, so passing null for type is fine. DotMethodUtil.ValidateSpecificType( enumMethodUsedName, DotMethodTypeEnum.ENUM, expectedType, null, filterEvaluator.ReturnType, parameterNum, filter); var numStreamsIncoming = validationContext.StreamTypeService.EventTypes.Length; return(new ExprDotEvalParamLambda( parameterNum, filter, filterEvaluator, numStreamsIncoming, goesNode.GoesToNames, additionalTypes)); }