private AggSvcGroupByReclaimAgedEvalFuncFactory GetEvaluationFunction(VariableService variableService, String hintValue, String optionalContextName) { VariableMetaData variableMetaData = variableService.GetVariableMetaData(hintValue); if (variableMetaData != null) { if (!variableMetaData.VariableType.IsNumeric()) { throw new ExprValidationException("Variable type of variable '" + variableMetaData.VariableName + "' is not numeric"); } String message = VariableServiceUtil.CheckVariableContextName(optionalContextName, variableMetaData); if (message != null) { throw new ExprValidationException(message); } return(new ProxyAggSvcGroupByReclaimAgedEvalFuncFactory { ProcMake = agentInstanceContext => { VariableReader reader = variableService.GetReader( variableMetaData.VariableName, agentInstanceContext.AgentInstanceId); return new AggSvcGroupByReclaimAgedEvalFuncVariable(reader); } }); } else { double valueDouble; try { valueDouble = DoubleValue.ParseString(hintValue); } catch (Exception) { throw new ExprValidationException("Failed to parse hint parameter value '" + hintValue + "' as a double-typed seconds value or variable name"); } if (valueDouble <= 0) { throw new ExprValidationException("Hint parameter value '" + hintValue + "' is an invalid value, expecting a double-typed seconds value or variable name"); } return(new ProxyAggSvcGroupByReclaimAgedEvalFuncFactory { ProcMake = agentInstanceContext => new AggSvcGroupByReclaimAgedEvalFuncConstant(valueDouble) }); } }
public static ExprNode ResolvePropertyOrVariableIdentifier(String identifier, VariableService variableService, StatementSpecRaw spec) { var metaData = variableService.GetVariableMetaData(identifier); if (metaData != null) { var exprNode = new ExprVariableNodeImpl(metaData, null); spec.HasVariables = true; AddVariableReference(spec, metaData.VariableName); var message = VariableServiceUtil.CheckVariableContextName(spec.OptionalContextName, metaData); if (message != null) { throw ASTWalkException.From(message); } return(exprNode); } else { return(new ExprIdentNodeImpl(identifier)); } }
public override EPStatementStartResult StartInternal( EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { var createDesc = _statementSpec.CreateVariableDesc; VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService); // Get assignment value object value = null; if (createDesc.Assignment != null) { // Evaluate assignment expression StreamTypeService typeService = new StreamTypeServiceImpl( new EventType[0], new string[0], new bool[0], services.EngineURI, false); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( typeService, statementContext.MethodResolutionService, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); var validated = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext); value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, evaluatorContextStmt)); } // Create variable try { services.VariableService.CreateNewVariable( _statementSpec.OptionalContextName, createDesc.VariableName, createDesc.VariableType, createDesc.IsConstant, createDesc.IsArray, createDesc.IsArrayOfPrimitive, value, services.EngineImportService); } catch (VariableExistsException ex) { // for new statement we don't allow creating the same variable if (isNewStatement) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } } catch (VariableDeclarationException ex) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } var destroyMethod = new EPStatementDestroyCallbackList(); destroyMethod.AddCallback(new ProxyDestroyCallback(() => { try { services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName); } catch (Exception ex) { Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message); } })); var stopMethod = new ProxyEPStatementStopMethod(() => { }); var variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName); Viewable outputView; var eventType = CreateVariableView.GetEventType( statementContext.StatementId, services.EventAdapterService, variableMetaData); var contextFactory = new StatementAgentInstanceFactoryCreateVariable( createDesc, _statementSpec, statementContext, services, variableMetaData, eventType); statementContext.StatementAgentInstanceFactory = contextFactory; if (_statementSpec.OptionalContextName != null) { var mergeView = new ContextMergeView(eventType); outputView = mergeView; var statement = new ContextManagedStatementCreateVariableDesc(_statementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement( _statementSpec.OptionalContextName, statement, isRecoveringResilient); var contextManagementService = services.ContextManagementService; destroyMethod.AddCallback(new ProxyDestroyCallback(() => contextManagementService.DestroyedStatement( _statementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId))); } else { var resultOfStart = (StatementAgentInstanceFactoryCreateVariableResult) contextFactory.NewContext(GetDefaultAgentInstanceContext(statementContext), isRecoveringResilient); outputView = resultOfStart.FinalView; if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null) { var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart); statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder; statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient); } } services.StatementVariableRefService.AddReferences( statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null); return(new EPStatementStartResult(outputView, stopMethod, destroyMethod)); }
/// <summary> /// Ctor. /// </summary> /// <param name="rowLimitSpec">specification for row limit, or null if no row limit is defined</param> /// <param name="variableService">for retrieving variable state for use with row limiting</param> /// <param name="optionalContextName">Name of the optional context.</param> /// <exception cref="ExprValidationException"> /// Limit clause variable by name '" + rowLimitSpec.NumRowsVariable + "' has not been declared /// or /// or /// Limit clause requires a variable of numeric type /// or /// Limit clause variable by name '" + rowLimitSpec.OptionalOffsetVariable + "' has not been declared /// or /// or /// Limit clause requires a variable of numeric type /// or /// Limit clause requires a positive offset /// </exception> /// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if row limit specification validation fails</throws> public RowLimitProcessorFactory(RowLimitSpec rowLimitSpec, VariableService variableService, string optionalContextName) { if (rowLimitSpec.NumRowsVariable != null) { _numRowsVariableMetaData = variableService.GetVariableMetaData(rowLimitSpec.NumRowsVariable); if (_numRowsVariableMetaData == null) { throw new ExprValidationException("Limit clause variable by name '" + rowLimitSpec.NumRowsVariable + "' has not been declared"); } string message = VariableServiceUtil.CheckVariableContextName(optionalContextName, _numRowsVariableMetaData); if (message != null) { throw new ExprValidationException(message); } if (!TypeHelper.IsNumeric(_numRowsVariableMetaData.VariableType)) { throw new ExprValidationException("Limit clause requires a variable of numeric type"); } } else { _numRowsVariableMetaData = null; _currentRowLimit = rowLimitSpec.NumRows.GetValueOrDefault(); if (_currentRowLimit < 0) { _currentRowLimit = int.MaxValue; } } if (rowLimitSpec.OptionalOffsetVariable != null) { _offsetVariableMetaData = variableService.GetVariableMetaData(rowLimitSpec.OptionalOffsetVariable); if (_offsetVariableMetaData == null) { throw new ExprValidationException("Limit clause variable by name '" + rowLimitSpec.OptionalOffsetVariable + "' has not been declared"); } string message = VariableServiceUtil.CheckVariableContextName(optionalContextName, _offsetVariableMetaData); if (message != null) { throw new ExprValidationException(message); } if (!TypeHelper.IsNumeric(_offsetVariableMetaData.VariableType)) { throw new ExprValidationException("Limit clause requires a variable of numeric type"); } } else { _offsetVariableMetaData = null; if (rowLimitSpec.OptionalOffset != null) { _currentOffset = rowLimitSpec.OptionalOffset.GetValueOrDefault(); if (_currentOffset <= 0) { throw new ExprValidationException("Limit clause requires a positive offset"); } } else { _currentOffset = 0; } } }
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { var createDesc = _statementSpec.CreateTableDesc; // determine whether already declared VariableServiceUtil.CheckAlreadyDeclaredVariable(createDesc.TableName, services.VariableService); if (isNewStatement) { VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.TableName, services.TableService); } if (services.EventAdapterService.GetEventTypeByName(createDesc.TableName) != null) { throw new ExprValidationException("An event type or schema by name '" + createDesc.TableName + "' already exists"); } // Determine event type names var internalTypeName = "table_" + createDesc.TableName + "__internal"; var publicTypeName = "table_" + createDesc.TableName + "__public"; TableMetadata metadata; try { // determine key types var keyTypes = GetKeyTypes(createDesc.Columns, services.EngineImportService); // check column naming, interpret annotations var columnDescs = ValidateExpressions(createDesc.Columns, services, statementContext); // analyze and plan the state holders var plan = AnalyzePlanAggregations(createDesc.TableName, statementContext, columnDescs, services, internalTypeName, publicTypeName); var tableStateRowFactory = plan.StateRowFactory; // register new table var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.Logging.IsEnableQueryPlan; metadata = services.TableService.AddTable(createDesc.TableName, statementContext.Expression, statementContext.StatementName, keyTypes, plan.TableColumns, tableStateRowFactory, plan.NumberMethodAggregations, statementContext, plan.InternalEventType, plan.PublicEventType, plan.EventToPublic, queryPlanLogging); } catch (ExprValidationException ex) { services.EventAdapterService.RemoveType(internalTypeName); services.EventAdapterService.RemoveType(publicTypeName); throw ex; } // allocate context factory var contextFactory = new StatementAgentInstanceFactoryCreateTable(metadata); statementContext.StatementAgentInstanceFactory = contextFactory; Viewable outputView; EPStatementStopMethod stopStatementMethod; EPStatementDestroyMethod destroyStatementMethod; if (_statementSpec.OptionalContextName != null) { var contextName = _statementSpec.OptionalContextName; var mergeView = new ContextMergeView(metadata.PublicEventType); outputView = mergeView; var statement = new ContextManagedStatementCreateAggregationVariableDesc(_statementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement(_statementSpec.OptionalContextName, statement, isRecoveringResilient); stopStatementMethod = new ProxyEPStatementStopMethod(() => services.ContextManagementService.StoppedStatement( contextName, statementContext.StatementName, statementContext.StatementId, statementContext.Expression, statementContext.ExceptionHandlingService)); destroyStatementMethod = new ProxyEPStatementDestroyMethod(() => { services.ContextManagementService.DestroyedStatement(contextName, statementContext.StatementName, statementContext.StatementId); services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName); }); } else { var defaultAgentInstanceContext = GetDefaultAgentInstanceContext(statementContext); var result = contextFactory.NewContext(defaultAgentInstanceContext, false); if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null) { var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(result); statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder; } outputView = result.FinalView; stopStatementMethod = new ProxyEPStatementStopMethod(() => { }); destroyStatementMethod = new ProxyEPStatementDestroyMethod(() => services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName)); } services.StatementVariableRefService.AddReferences(statementContext.StatementName, createDesc.TableName); return(new EPStatementStartResult(outputView, stopStatementMethod, destroyStatementMethod)); }
public static OutputConditionFactory CreateCondition( OutputLimitSpec outputLimitSpec, StatementContext statementContext, bool isGrouped, bool isWithHavingClause, bool isStartConditionOnCreation, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory) { if (outputLimitSpec == null) { return new OutputConditionNullFactory(); } // Check if a variable is present VariableMetaData variableMetaData = null; if (outputLimitSpec.VariableName != null) { variableMetaData = statementContext.VariableService.GetVariableMetaData(outputLimitSpec.VariableName); if (variableMetaData == null) { throw new ExprValidationException( "Variable named '" + outputLimitSpec.VariableName + "' has not been declared"); } string message = VariableServiceUtil.CheckVariableContextName( statementContext.ContextDescriptor, variableMetaData); if (message != null) { throw new ExprValidationException(message); } } if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.FIRST && isGrouped) { return new OutputConditionNullFactory(); } if (outputLimitSpec.RateType == OutputLimitRateType.CRONTAB) { return resultSetProcessorHelperFactory.MakeOutputConditionCrontab( outputLimitSpec.CrontabAtSchedule, statementContext, isStartConditionOnCreation); } else if (outputLimitSpec.RateType == OutputLimitRateType.WHEN_EXPRESSION) { return resultSetProcessorHelperFactory.MakeOutputConditionExpression( outputLimitSpec.WhenExpressionNode, outputLimitSpec.ThenExpressions, statementContext, outputLimitSpec.AndAfterTerminateExpr, outputLimitSpec.AndAfterTerminateThenExpressions, isStartConditionOnCreation); } else if (outputLimitSpec.RateType == OutputLimitRateType.EVENTS) { if (Log.IsDebugEnabled) { Log.Debug(".createCondition creating OutputConditionCount with event rate " + outputLimitSpec); } if ((variableMetaData != null) && (!variableMetaData.VariableType.IsNumericNonFP())) { throw new ArgumentException( "Variable named '" + outputLimitSpec.VariableName + "' must be type integer, long or short"); } int rate = -1; if (outputLimitSpec.Rate != null) { rate = outputLimitSpec.Rate.AsInt(); } return resultSetProcessorHelperFactory.MakeOutputConditionCount( rate, variableMetaData, statementContext); } else if (outputLimitSpec.RateType == OutputLimitRateType.TERM) { if (outputLimitSpec.AndAfterTerminateExpr == null && (outputLimitSpec.AndAfterTerminateThenExpressions == null || outputLimitSpec.AndAfterTerminateThenExpressions.IsEmpty())) { return new OutputConditionTermFactory(); } else { return resultSetProcessorHelperFactory.MakeOutputConditionExpression( new ExprConstantNodeImpl(false), Collections.GetEmptyList<OnTriggerSetAssignment>(), statementContext, outputLimitSpec.AndAfterTerminateExpr, outputLimitSpec.AndAfterTerminateThenExpressions, isStartConditionOnCreation); } } else { if (Log.IsDebugEnabled) { Log.Debug( ".createCondition creating OutputConditionTime with interval length " + outputLimitSpec.Rate); } if ((variableMetaData != null) && (!variableMetaData.VariableType.IsNumeric())) { throw new ArgumentException( "Variable named '" + outputLimitSpec.VariableName + "' must be of numeric type"); } return resultSetProcessorHelperFactory.MakeOutputConditionTime( outputLimitSpec.TimePeriodExpr, isStartConditionOnCreation); } }
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { var createDesc = StatementSpec.CreateVariableDesc; VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService); // Get assignment value Object value = null; if (createDesc.Assignment != null) { // Evaluate assignment expression var typeService = new StreamTypeServiceImpl(new EventType[0], new String[0], new bool[0], services.EngineURI, false); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( typeService, statementContext.MethodResolutionService, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); var validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext); value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, evaluatorContextStmt)); } // Create variable try { services.VariableService.CreateNewVariable( StatementSpec.OptionalContextName, createDesc.VariableName, createDesc.VariableType, createDesc.IsConstant, createDesc.IsArray, createDesc.IsArrayOfPrimitive, value, services.EngineImportService); } catch (VariableExistsException ex) { // for new statement we don't allow creating the same variable if (isNewStatement) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } } catch (VariableDeclarationException ex) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } var destroyMethod = new EPStatementDestroyCallbackList(); destroyMethod.AddCallback( () => { try { services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName); } catch (Exception ex) { Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message); } }); var stopMethod = new EPStatementStopMethod(() => { }); VariableMetaData variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName); Viewable outputView; if (StatementSpec.OptionalContextName != null) { EventType eventType = CreateVariableView.GetEventType(statementContext.StatementId, services.EventAdapterService, variableMetaData); var contextFactory = new StatementAgentInstanceFactoryCreateVariable(statementContext, services, variableMetaData, eventType); var mergeView = new ContextMergeView(eventType); outputView = mergeView; var statement = new ContextManagedStatementCreateVariableDesc(StatementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient); ContextManagementService contextManagementService = services.ContextManagementService; destroyMethod.AddCallback(() => contextManagementService.DestroyedStatement(StatementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId)); } else { // allocate services.VariableService.AllocateVariableState(createDesc.VariableName, VariableServiceConstants.NOCONTEXT_AGENTINSTANCEID, statementContext.StatementExtensionServicesContext); var createView = new CreateVariableView(statementContext.StatementId, services.EventAdapterService, services.VariableService, createDesc.VariableName, statementContext.StatementResultService); services.VariableService.RegisterCallback(createDesc.VariableName, 0, 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; StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new String[] { "create_variable" }, new bool[] { true }, services.EngineURI, false); var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext); var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( StatementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, services.ConfigSnapshot); var resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype); // Attach output view var outputViewFactory = OutputProcessViewFactoryFactory.Make(StatementSpec, services.InternalEventRouter, agentInstanceContext.StatementContext, resultSetProcessor.ResultEventType, null, services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType); var outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext); createView.AddView(outputViewBase); outputView = outputViewBase; } services.StatementVariableRefService.AddReferences(statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null); return(new EPStatementStartResult(outputView, stopMethod, destroyMethod.Destroy)); }