public static FilterProviderBase GetFilterProvider(string tableName, string filterMemberName, StatementContext modify) { FilterProviderBase provider = Providers.Cast<FilterProviderBase>().Where( probase => (probase.ObjectType == null || probase.ObjectType.Name == tableName) && probase.FilterMemberName == filterMemberName && (probase.StatementContext == modify || probase.StatementContext == StatementContext.Both)).FirstOrDefault(); if (provider != null && HasFilterValue(provider) && !provider.UseFilterValueWhenNull) return null; return provider; }
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories) { }
private void Login() { //this._loadingControl.Visibility = System.Windows.Visibility.Visible; //this._loadingControl._Refresh(); try { if (string.IsNullOrEmpty(_comboBox用户列表.SelectedValue.ToString().Trim())) { MessageBox.Show("请先选定用户!"); return; } if (string.IsNullOrEmpty(_textBoxPassword.Password.Trim())) { MessageBox.Show("密码不能为空!"); return; } using (StatementContext statement = new StatementContext(typeof(User), typeof(Account))) { string userName = _comboBox用户列表.SelectedValue.ToString().Trim(); var users = statement.Users.Where(o => o.UserName.Trim().Equals(userName)); if (users.Count() == 0) { MessageBox.Show(string.Format("数据库错误:本地数据库中不存在用户“{0}”,请联系管理员!", _comboBox用户列表.Text.Trim())); } else if (users.Count() != 1) { MessageBox.Show(string.Format("数据库错误:用户“{0}”在数据库中出现重复数据,请联系管理员!", _comboBox用户列表.Text.Trim())); } else { var user = users.FirstOrDefault(); var passwordServer = user.UserPassword._RSADecrypt(); var passwordClient = _textBoxPassword.Password.Trim(); if (!passwordServer.Equals(passwordClient)) { MessageBox.Show("您输入的密码不正确,请重新输入!"); _textBoxPassword.Password = ""; _textBoxPassword.Focus(); _textProcessMessage.Visibility = System.Windows.Visibility.Hidden; Storyboard story = Resources["OnLoadedStoryboard"] as Storyboard; story.Begin(); } else { // 设置会话中的UserId _Session.LoginedUserId = user.Id; // if (statement.Accounts.FirstOrDefault(acc => acc.UserId == user.Id) == null) { if (MessageBox.Show(this, "当前用户没有资金账户,是否添加一个资金账户?", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes) { AddAccountWindow aaf = new AddAccountWindow(); aaf.Owner = this; aaf.ShowDialog(); // if (aaf.DialogResult.Value) { _Session.SelectedAccountId = Guid.Parse(_Helper.GetParameter(ParameterName.DefaultAccountId.ToString(), new StatementContext(typeof(Account)).Accounts.FirstOrDefault().Id.ToString())); } else { Show(); return; } } else { Show(); return; } } else { _Session.LoginedUserId = user.Id; _Session.SelectedAccountId = Guid.Parse(_Helper.GetParameter(ParameterName.DefaultAccountId.ToString(), statement.Accounts.FirstOrDefault().Id.ToString())); } MainWindow mw = new MainWindow(this); Hide(); mw.ShowDialog(); Close(); System.Environment.Exit(0); } } } } catch (Exception ex) { MessageBox.Show(ex.Message + "\n" + ex.StackTrace); } finally { //this._loadingControl.Visibility = System.Windows.Visibility.Collapsed; _textProcessMessage.Visibility = System.Windows.Visibility.Hidden; Storyboard story = Resources["OnLoadedStoryboard"] as Storyboard; story.Begin(); } }
public static StreamTypeService BuildDefineStreamTypeServiceDefine( StatementContext statementContext, LinkedHashMap <String, Pair <int, bool> > variableStreams, MatchRecognizeDefineItem defineItem, IDictionary <String, ISet <String> > visibilityByIdentifier, EventType parentViewType) { 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 EventType[] { parentViewType }); } else { multievent.Put("esper_matchrecog_internal", null); } } } var multimatch = statementContext.EventAdapterService.CreateAnonymousObjectArrayType( "esper_matchrecog_internal", multievent); typesDefine[typesDefine.Length - 1] = multimatch; streamNamesDefine[streamNamesDefine.Length - 1] = multimatch.Name; } return(new StreamTypeServiceImpl( typesDefine, streamNamesDefine, isIStreamOnly, statementContext.EngineURI, false)); }
/// <summary> /// Validate the view. /// </summary> /// <param name="engineImportService">The engine import service.</param> /// <param name="streamTypeService">supplies the types of streams against which to validate</param> /// <param name="methodResolutionService">for resolving imports and classes and methods</param> /// <param name="timeProvider">for providing current time</param> /// <param name="variableService">for access to variables</param> /// <param name="tableService"></param> /// <param name="scriptingService">The scripting service.</param> /// <param name="exprEvaluatorContext">The expression evaluator context.</param> /// <param name="configSnapshot">The config snapshot.</param> /// <param name="schedulingService">The scheduling service.</param> /// <param name="engineURI">The engine URI.</param> /// <param name="sqlParameters">The SQL parameters.</param> /// <param name="eventAdapterService">The event adapter service.</param> /// <param name="statementContext">The statement context</param> /// <throws> ExprValidationException is thrown to indicate an exception in validating the view </throws> public void Validate(EngineImportService engineImportService, StreamTypeService streamTypeService, MethodResolutionService methodResolutionService, TimeProvider timeProvider, VariableService variableService, TableService tableService, ScriptingService scriptingService, ExprEvaluatorContext exprEvaluatorContext, ConfigurationInformation configSnapshot, SchedulingService schedulingService, string engineURI, IDictionary <int, IList <ExprNode> > sqlParameters, EventAdapterService eventAdapterService, StatementContext statementContext) { _statementContext = statementContext; _evaluators = new ExprEvaluator[_inputParameters.Count]; _subordinateStreams = new SortedSet <int>(); _exprEvaluatorContext = exprEvaluatorContext; var count = 0; var validationContext = new ExprValidationContext( streamTypeService, methodResolutionService, null, timeProvider, variableService, tableService, exprEvaluatorContext, eventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, null, scriptingService, false, false, true, false, null, false); foreach (var inputParam in _inputParameters) { var raw = FindSQLExpressionNode(_myStreamNumber, count, sqlParameters); if (raw == null) { throw new ExprValidationException( "Internal error find expression for historical stream parameter " + count + " stream " + _myStreamNumber); } var evaluator = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DATABASEPOLL, raw, validationContext); _evaluators[count++] = evaluator.ExprEvaluator; var visitor = new ExprNodeIdentifierCollectVisitor(); visitor.Visit(evaluator); foreach (var identNode in visitor.ExprProperties) { if (identNode.StreamId == _myStreamNumber) { throw new ExprValidationException("Invalid expression '" + inputParam + "' resolves to the historical data itself"); } _subordinateStreams.Add(identNode.StreamId); } } }
/// <summary> /// Ctor. /// </summary> /// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc. /// </param> /// <param name="services">is the service instances for dependency injection</param> /// <param name="statementContext">is statement-level information and statement services</param> /// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the preparation failed</throws> public EPPreparedExecuteIUDSingleStream( StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext) { var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan; if (queryPlanLogging) { QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'"); } HasTableAccess = statementSpec.IntoTableSpec != null || (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0); if (statementSpec.InsertIntoDesc != null && services.TableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName) != null) { HasTableAccess = true; } if (statementSpec.FireAndForgetSpec is FireAndForgetSpecUpdate || statementSpec.FireAndForgetSpec is FireAndForgetSpecDelete) { HasTableAccess |= statementSpec.StreamSpecs[0] is TableQueryStreamSpec; } StatementSpec = statementSpec; Services = services; StatementContext = statementContext; // validate general FAF criteria EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec); // obtain processor var streamSpec = statementSpec.StreamSpecs[0]; Processor = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services); // obtain name and type var processorName = Processor.NamedWindowOrTableName; var eventType = Processor.EventTypeResultSetProcessor; // determine alias var aliasName = processorName; if (streamSpec.OptionalStreamName != null) { aliasName = streamSpec.OptionalStreamName; } // compile filter to optimize access to named window var typeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new string[] { aliasName }, new bool[] { true }, services.EngineURI, true); FilterSpecCompiled filter; if (statementSpec.FilterRootNode != null) { var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); FilterSpecCompiled filterCompiled; try { filterCompiled = FilterSpecCompiler.MakeFilterSpec(eventType, aliasName, Collections.SingletonList(statementSpec.FilterRootNode), null, tagged, tagged, typeService, null, statementContext, Collections.SingletonList(0)); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); filterCompiled = null; } filter = filterCompiled; } else { filter = null; } // validate expressions EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null); // get executor Executor = GetExecutor(filter, aliasName); }
public EventTable[] Index(IList <EventBean> pollResult, bool isActiveCache, StatementContext statementContext) { return(ProcIndex(pollResult, isActiveCache, statementContext)); }
private ContextDetailMatchPair ValidateRewriteContextCondition( EPServicesContext servicesContext, StatementContext statementContext, ContextDetailCondition endpoint, ISet <string> eventTypesReferenced, MatchEventSpec priorMatches, ISet <string> priorAllTags) { if (endpoint is ContextDetailConditionCrontab) { var crontab = (ContextDetailConditionCrontab)endpoint; var scheduleSpecEvaluators = ExprNodeUtility.CrontabScheduleValidate(ExprNodeOrigin.CONTEXTCONDITION, crontab.Crontab, statementContext, false); var schedule = ExprNodeUtility.CrontabScheduleBuild(scheduleSpecEvaluators, new ExprEvaluatorContextStatement(statementContext, false)); crontab.Schedule = schedule; return(new ContextDetailMatchPair(crontab, new MatchEventSpec(), new LinkedHashSet <string>())); } if (endpoint is ContextDetailConditionTimePeriod) { var timePeriod = (ContextDetailConditionTimePeriod)endpoint; var validationContext = new ExprValidationContext( statementContext.Container, new StreamTypeServiceImpl(servicesContext.EngineURI, false), statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, GetDefaultAgentInstanceContext(statementContext), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.CONTEXTCONDITION, timePeriod.TimePeriod, validationContext); if (timePeriod.TimePeriod.IsConstantResult) { if (timePeriod.TimePeriod.EvaluateAsSeconds(null, true, null) < 0) { throw new ExprValidationException("Invalid negative time period expression '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(timePeriod.TimePeriod) + "'"); } } return(new ContextDetailMatchPair(timePeriod, new MatchEventSpec(), new LinkedHashSet <string>())); } if (endpoint is ContextDetailConditionPattern) { var pattern = (ContextDetailConditionPattern)endpoint; var matches = ValidatePatternContextConditionPattern(statementContext, pattern, eventTypesReferenced, priorMatches, priorAllTags); return(new ContextDetailMatchPair(pattern, matches.First, matches.Second)); } if (endpoint is ContextDetailConditionFilter) { var filter = (ContextDetailConditionFilter)endpoint; ValidateNotTable(servicesContext, filter.FilterSpecRaw.EventTypeName); // compile as filter if there are no prior match to consider if (priorMatches == null || (priorMatches.ArrayEventTypes.IsEmpty() && priorMatches.TaggedEventTypes.IsEmpty())) { var rawExpr = new FilterStreamSpecRaw(filter.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiled = (FilterStreamSpecCompiled)rawExpr.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, filter.OptionalFilterAsName); filter.FilterSpecCompiled = compiled.FilterSpec; var matchEventSpec = new MatchEventSpec(); var filterForType = compiled.FilterSpec.FilterForEventType; var allTags = new LinkedHashSet <string>(); if (filter.OptionalFilterAsName != null) { matchEventSpec.TaggedEventTypes.Put(filter.OptionalFilterAsName, new Pair <EventType, string>(filterForType, rawExpr.RawFilterSpec.EventTypeName)); allTags.Add(filter.OptionalFilterAsName); } return(new ContextDetailMatchPair(filter, matchEventSpec, allTags)); } // compile as pattern if there are prior matches to consider, since this is a type of followed-by relationship var factoryNode = servicesContext.PatternNodeFactory.MakeFilterNode(filter.FilterSpecRaw, filter.OptionalFilterAsName, 0); var pattern = new ContextDetailConditionPattern(factoryNode, true, false); var matches = ValidatePatternContextConditionPattern(statementContext, pattern, eventTypesReferenced, priorMatches, priorAllTags); return(new ContextDetailMatchPair(pattern, matches.First, matches.Second)); } else if (endpoint is ContextDetailConditionImmediate || endpoint is ContextDetailConditionNever) { return(new ContextDetailMatchPair(endpoint, new MatchEventSpec(), new LinkedHashSet <string>())); } else { throw new IllegalStateException("Unrecognized endpoint type " + endpoint); } }
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( statementContext.Container, typeService, 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, 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(); 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)); }
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { if (StatementSpec.OptionalContextName != null) { throw new ExprValidationException("A create-context statement cannot itself be associated to a context, please declare a nested context instead"); } var context = StatementSpec.ContextDesc; var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext); // compile filter specs, if any ISet <String> eventTypesReferenced = new HashSet <String>(); ValidateContextDetail(services, statementContext, eventTypesReferenced, context.ContextDetail); services.StatementEventTypeRefService.AddReferences(statementContext.StatementName, CollectionUtil.ToArray(eventTypesReferenced)); // define output event type var typeName = "EventType_Context_" + context.ContextName; var statementResultEventType = services.EventAdapterService.CreateAnonymousMapType(typeName, Collections.GetEmptyMap <String, Object>()); // add context - does not activate that context services.ContextManagementService.AddContextSpec(services, agentInstanceContext, context, isRecoveringResilient, statementResultEventType); var stopMethod = new EPStatementStopMethod(() => { }); var destroyMethod = new EPStatementDestroyMethod( () => services.ContextManagementService.DestroyedContext(context.ContextName)); return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(statementResultEventType), stopMethod, destroyMethod)); }
private Pair <MatchEventSpec, ISet <String> > ValidatePatternContextConditionPattern(StatementContext statementContext, ContextDetailConditionPattern pattern, ISet <String> eventTypesReferenced, MatchEventSpec priorMatches, ISet <String> priorAllTags) { var raw = new PatternStreamSpecRaw(pattern.PatternRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, new StreamSpecOptions(), false, false); var compiled = raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), priorMatches, priorAllTags, false, true, false); pattern.PatternCompiled = compiled; return(new Pair <MatchEventSpec, ISet <String> >(new MatchEventSpec(compiled.TaggedEventTypes, compiled.ArrayEventTypes), compiled.AllTags)); }
public abstract void Ready( StatementContext statementContext, ModuleIncidentals moduleIncidentals, bool recovery);
public static EPStatementStartMethodSelectDesc Prepare( StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext, bool recoveringResilient, AgentInstanceContext defaultAgentInstanceContext, bool queryPlanLogging, ViewableActivatorFactory optionalViewableActivatorFactory, OutputProcessViewCallback optionalOutputProcessViewCallback, SelectExprProcessorDeliveryCallback selectExprProcessorDeliveryCallback) { // define stop and destroy var stopCallbacks = new List <StopCallback>(); var destroyCallbacks = new EPStatementDestroyCallbackList(); // determine context var contextName = statementSpec.OptionalContextName; var contextPropertyRegistry = (contextName != null) ? services.ContextManagementService.GetContextDescriptor(contextName).ContextPropertyRegistry : null; // Determine stream names for each stream - some streams may not have a name given var streamNames = EPStatementStartMethodHelperUtil.DetermineStreamNames(statementSpec.StreamSpecs); var numStreams = streamNames.Length; if (numStreams == 0) { throw new ExprValidationException("The from-clause is required but has not been specified"); } var isJoin = statementSpec.StreamSpecs.Length > 1; var hasContext = statementSpec.OptionalContextName != null; // First we create streams for subselects, if there are any var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(services, statementSpec, statementContext, destroyCallbacks); // Create streams and views var eventStreamParentViewableActivators = new ViewableActivator[numStreams]; var unmaterializedViewChain = new ViewFactoryChain[numStreams]; var eventTypeNames = new string[numStreams]; var isNamedWindow = new bool[numStreams]; var historicalEventViewables = new HistoricalEventViewable[numStreams]; // verify for joins that required views are present var joinAnalysisResult = VerifyJoinViews(statementSpec, statementContext.NamedWindowMgmtService, defaultAgentInstanceContext); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); for (var i = 0; i < statementSpec.StreamSpecs.Length; i++) { var streamSpec = statementSpec.StreamSpecs[i]; var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 && (services.ConfigSnapshot.EngineDefaults.ViewResourcesConfig.IsIterableUnbound || AnnotationUtil.FindAttribute(statementSpec.Annotations, typeof(IterableUnboundAttribute)) != null); // Create view factories and parent view based on a filter specification if (streamSpec is FilterStreamSpecCompiled) { var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec; eventTypeNames[i] = filterStreamSpec.FilterSpec.FilterForEventTypeName; // Since only for non-joins we get the existing stream's lock and try to reuse it's views var filterSubselectSameStream = EPStatementStartMethodHelperUtil.DetermineSubquerySameStream(statementSpec, filterStreamSpec); // create activator ViewableActivator activatorDeactivator; if (optionalViewableActivatorFactory != null) { activatorDeactivator = optionalViewableActivatorFactory.CreateActivatorSimple(filterStreamSpec); if (activatorDeactivator == null) { throw new IllegalStateException("Viewable activate is null for " + filterStreamSpec.FilterSpec.FilterForEventType.Name); } } else { if (!hasContext) { activatorDeactivator = services.ViewableActivatorFactory.CreateStreamReuseView(services, statementContext, statementSpec, filterStreamSpec, isJoin, evaluatorContextStmt, filterSubselectSameStream, i, isCanIterateUnbound); } else { InstrumentationAgent instrumentationAgentFilter = null; if (InstrumentationHelper.ENABLED) { var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name; var streamNumber = i; instrumentationAgentFilter = new ProxyInstrumentationAgent() { ProcIndicateQ = () => { InstrumentationHelper.Get().QFilterActivationStream(eventTypeName, streamNumber); }, ProcIndicateA = () => { InstrumentationHelper.Get().AFilterActivationStream(); }, }; } activatorDeactivator = services.ViewableActivatorFactory.CreateFilterProxy(services, filterStreamSpec.FilterSpec, statementSpec.Annotations, false, instrumentationAgentFilter, isCanIterateUnbound, i); } } eventStreamParentViewableActivators[i] = activatorDeactivator; var resultEventType = filterStreamSpec.FilterSpec.ResultEventType; unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1); } // Create view factories and parent view based on a pattern expression else if (streamSpec is PatternStreamSpecCompiled) { var patternStreamSpec = (PatternStreamSpecCompiled)streamSpec; var usedByChildViews = streamSpec.ViewSpecs.Length > 0 || (statementSpec.InsertIntoDesc != null); var patternTypeName = statementContext.StatementId + "_pattern_" + i; var eventType = services.EventAdapterService.CreateSemiAnonymousMapType(patternTypeName, patternStreamSpec.TaggedEventTypes, patternStreamSpec.ArrayEventTypes, usedByChildViews); unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, eventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1); var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode); var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true); // create activator var patternActivator = services.ViewableActivatorFactory.CreatePattern(patternContext, rootFactoryNode, eventType, EPStatementStartMethodHelperUtil.IsConsumingFilters(patternStreamSpec.EvalFactoryNode), patternStreamSpec.IsSuppressSameEventMatches, patternStreamSpec.IsDiscardPartialsOnMatch, isCanIterateUnbound); eventStreamParentViewableActivators[i] = patternActivator; } // Create view factories and parent view based on a database SQL statement else if (streamSpec is DBStatementStreamSpec) { ValidateNoViews(streamSpec, "Historical data"); var sqlStreamSpec = (DBStatementStreamSpec)streamSpec; var typeConversionHook = (SQLColumnTypeConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), statementContext.MethodResolutionService); var outputRowConversionHook = (SQLOutputRowConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), statementContext.MethodResolutionService); var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle; var historicalEventViewable = DatabasePollingViewableFactory.CreateDBStatementView( statementContext.StatementId, i, sqlStreamSpec, services.DatabaseRefService, services.EventAdapterService, epStatementAgentInstanceHandle, statementContext.Annotations, typeConversionHook, outputRowConversionHook, statementContext.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableADO, services.DataCacheFactory, statementContext); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable); stopCallbacks.Add(historicalEventViewable); } else if (streamSpec is MethodStreamSpec) { ValidateNoViews(streamSpec, "Method data"); var methodStreamSpec = (MethodStreamSpec)streamSpec; var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle; var historicalEventViewable = MethodPollingViewableFactory.CreatePollMethodView( i, methodStreamSpec, services.EventAdapterService, epStatementAgentInstanceHandle, statementContext.MethodResolutionService, services.EngineImportService, statementContext.SchedulingService, statementContext.ScheduleBucket, evaluatorContextStmt, statementContext.VariableService, statementContext.ContextName, services.DataCacheFactory, statementContext); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable); stopCallbacks.Add(historicalEventViewable); } else if (streamSpec is TableQueryStreamSpec) { ValidateNoViews(streamSpec, "Table data"); var tableStreamSpec = (TableQueryStreamSpec)streamSpec; if (isJoin && tableStreamSpec.FilterExpressions.Count > 0) { throw new ExprValidationException("Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead"); } var metadata = services.TableService.GetTableMetadata(tableStreamSpec.TableName); ExprEvaluator[] tableFilterEvals = null; if (tableStreamSpec.FilterExpressions.Count > 0) { tableFilterEvals = ExprNodeUtility.GetEvaluators(tableStreamSpec.FilterExpressions); } EPLValidationUtil.ValidateContextName(true, metadata.TableName, metadata.ContextName, statementSpec.OptionalContextName, false); eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateTable(metadata, tableFilterEvals); unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(metadata.InternalEventType); eventTypeNames[i] = tableStreamSpec.TableName; joinAnalysisResult.SetTablesForStream(i, metadata); if (tableStreamSpec.Options.IsUnidirectional) { throw new ExprValidationException("Tables cannot be marked as unidirectional"); } if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion) { throw new ExprValidationException("Tables cannot be marked with retain"); } if (isJoin) { destroyCallbacks.AddCallback(new EPStatementDestroyCallbackTableIdxRef(services.TableService, metadata, statementContext.StatementName)); } services.StatementVariableRefService.AddReferences(statementContext.StatementName, metadata.TableName); } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; var processor = services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName); var namedWindowType = processor.TailView.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec, statementContext); services.NamedWindowConsumerMgmtService.AddConsumer(statementContext, namedSpec); unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext, false, -1); joinAnalysisResult.SetNamedWindow(i); eventTypeNames[i] = namedSpec.WindowName; isNamedWindow[i] = true; // Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(unmaterializedViewChain[i].FactoryChain); } else { throw new ExprValidationException("Unknown stream specification type: " + streamSpec); } } // handle match-recognize pattern if (statementSpec.MatchRecognizeSpec != null) { if (isJoin) { throw new ExprValidationException("Joins are not allowed when using match-recognize"); } if (joinAnalysisResult.TablesPerStream[0] != null) { throw new ExprValidationException("Tables cannot be used with match-recognize"); } var isUnbound = (unmaterializedViewChain[0].FactoryChain.IsEmpty()) && (!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec)); var factoryX = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig); unmaterializedViewChain[0].FactoryChain.Add(factoryX); EPStatementStartMethodHelperAssignExpr.AssignAggregations(factoryX.AggregationService, factoryX.AggregationExpressions); } // Obtain event types from view factory chains var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length]; for (var i = 0; i < unmaterializedViewChain.Length; i++) { streamEventTypes[i] = unmaterializedViewChain[i].EventType; } // Add uniqueness information useful for joins joinAnalysisResult.AddUniquenessInfo(unmaterializedViewChain, statementSpec.Annotations); // Validate sub-select views var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, queryPlanLogging, subSelectStreamDesc, streamNames, streamEventTypes, eventTypeNames, statementSpec.DeclaredExpressions, contextPropertyRegistry); // Construct type information per stream StreamTypeService typeService = new StreamTypeServiceImpl(streamEventTypes, streamNames, EPStatementStartMethodHelperUtil.GetHasIStreamOnly(isNamedWindow, unmaterializedViewChain), services.EngineURI, false); var viewResourceDelegateUnverified = new ViewResourceDelegateUnverified(); // Validate views that require validation, specifically streams that don't have // sub-views such as DB SQL joins var historicalViewableDesc = new HistoricalViewableDesc(numStreams); for (var stream = 0; stream < historicalEventViewables.Length; stream++) { var historicalEventViewable = historicalEventViewables[stream]; if (historicalEventViewable == null) { continue; } historicalEventViewable.Validate( services.EngineImportService, typeService, statementContext.MethodResolutionService, statementContext.TimeProvider, statementContext.VariableService, statementContext.TableService, statementContext.ScriptingService, evaluatorContextStmt, services.ConfigSnapshot, services.SchedulingService, services.EngineURI, statementSpec.SqlParameters, statementContext.EventAdapterService, statementContext); historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams); if (historicalEventViewable.RequiredStreams.Contains(stream)) { throw new ExprValidationException("Parameters for historical stream " + stream + " indicate that the stream is subordinate to itself as stream parameters originate in the same stream"); } } // unidirectional is not supported with into-table if (joinAnalysisResult.IsUnidirectional && statementSpec.IntoTableSpec != null) { throw new ExprValidationException("Into-table does not allow unidirectional joins"); } // Construct a processor for results posted by views and joins, which takes care of aggregation if required. // May return null if we don't need to post-process results posted by views or joins. var resultSetProcessorPrototypeDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype( statementSpec, statementContext, typeService, viewResourceDelegateUnverified, joinAnalysisResult.UnidirectionalInd, true, contextPropertyRegistry, selectExprProcessorDeliveryCallback, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, false, false); // Validate where-clause filter tree, outer join clause and output limit expression EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, viewResourceDelegateUnverified); // Handle 'prior' function nodes in terms of view requirements var viewResourceDelegateVerified = EPStatementStartMethodHelperViewResources.VerifyPreviousAndPriorRequirements(unmaterializedViewChain, viewResourceDelegateUnverified); // handle join JoinSetComposerPrototype joinSetComposerPrototype = null; if (numStreams > 1) { var selectsRemoveStream = statementSpec.SelectStreamSelectorEnum.IsSelectsRStream() || statementSpec.OutputLimitSpec != null; var hasAggregations = !resultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions.IsEmpty(); joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype( statementContext.StatementName, statementContext.StatementId, statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typeService.EventTypes, streamNames, joinAnalysisResult, queryPlanLogging, statementContext, historicalViewableDesc, defaultAgentInstanceContext, selectsRemoveStream, hasAggregations, services.TableService, false, services.EventTableIndexService.AllowInitIndex(recoveringResilient)); } // obtain factory for output limiting var outputViewFactory = OutputProcessViewFactoryFactory.Make(statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType, optionalOutputProcessViewCallback, services.TableService, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType, services.ResultSetProcessorHelperFactory, services.StatementVariableRefService); // Factory for statement-context instances var factory = new StatementAgentInstanceFactorySelect( numStreams, eventStreamParentViewableActivators, statementContext, statementSpec, services, typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient, joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory); EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks); return(new EPStatementStartMethodSelectDesc(factory, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks)); }
public ViewFactoryChain CreateFactories(int streamNum, EventType parentEventType, ViewSpec[] viewSpecDefinitions, StreamSpecOptions options, StatementContext context, bool isSubquery, int subqueryNumber) { // Clone the view spec list to prevent parameter modification IList <ViewSpec> viewSpecList = new List <ViewSpec>(viewSpecDefinitions); // Inspect views and add merge views if required ViewServiceHelper.AddMergeViews(viewSpecList); // Instantiate factories, not making them aware of each other yet var viewFactories = ViewServiceHelper.InstantiateFactories(streamNum, viewSpecList, context, isSubquery, subqueryNumber); ViewFactory parentViewFactory = null; IList <ViewFactory> attachedViewFactories = new List <ViewFactory>(); for (var i = 0; i < viewFactories.Count; i++) { var factoryToAttach = viewFactories[i]; try { factoryToAttach.Attach(parentEventType, context, parentViewFactory, attachedViewFactories); attachedViewFactories.Add(viewFactories[i]); parentEventType = factoryToAttach.EventType; } catch (ViewParameterException ex) { var text = "Error attaching view to parent view"; if (i == 0) { text = "Error attaching view to event stream"; } throw new ViewProcessingException(text + ": " + ex.Message, ex); } } // obtain count of data windows var dataWindowCount = 0; var firstNonDataWindowIndex = -1; for (var i = 0; i < viewFactories.Count; i++) { var factory = viewFactories[i]; if (factory is DataWindowViewFactory) { dataWindowCount++; continue; } if ((factory is GroupByViewFactoryMarker) || (factory is MergeViewFactory)) { continue; } if (firstNonDataWindowIndex == -1) { firstNonDataWindowIndex = i; } } var isAllowMultipleExpiry = context.ConfigSnapshot.EngineDefaults.ViewResources.IsAllowMultipleExpiryPolicies; var isRetainIntersection = options.IsRetainIntersection; var isRetainUnion = options.IsRetainUnion; // Set the default to retain-intersection unless allow-multiple-expiry is turned on if ((!isAllowMultipleExpiry) && (!isRetainUnion)) { isRetainIntersection = true; } // handle multiple data windows with retain union. // wrap view factories into the union view factory and handle a group-by, if present if ((isRetainUnion || isRetainIntersection) && dataWindowCount > 1) { viewFactories = GetRetainViewFactories(parentEventType, viewFactories, isRetainUnion, context); } return(new ViewFactoryChain(parentEventType, viewFactories)); }
private IList <ViewFactory> GetRetainViewFactories(EventType parentEventType, IList <ViewFactory> viewFactories, bool isUnion, StatementContext context) { ICollection <int> groupByFactory = new HashSet <int>(); ICollection <int> mergeFactory = new HashSet <int>(); IList <ViewFactory> derivedValueViews = new List <ViewFactory>(); IList <ViewFactory> dataWindowViews = new List <ViewFactory>(); for (var i = 0; i < viewFactories.Count; i++) { var factory = viewFactories[i]; if (factory is GroupByViewFactoryMarker) { groupByFactory.Add(i); } else if (factory is MergeViewFactoryMarker) { mergeFactory.Add(i); } else if (factory is DataWindowViewFactory) { dataWindowViews.Add(factory); } else { derivedValueViews.Add(factory); } } if (groupByFactory.Count > 1) { throw new ViewProcessingException("Multiple groupwin views are not allowed in conjuntion with multiple data windows"); } if ((groupByFactory.IsNotEmpty()) && (groupByFactory.First() != 0)) { throw new ViewProcessingException("The groupwin view must occur in the first position in conjuntion with multiple data windows"); } if ((groupByFactory.IsNotEmpty()) && (mergeFactory.First() != (viewFactories.Count - 1))) { throw new ViewProcessingException("The merge view cannot be used in conjuntion with multiple data windows"); } GroupByViewFactoryMarker groupByViewFactory = null; MergeViewFactoryMarker mergeViewFactory = null; if (groupByFactory.IsNotEmpty()) { groupByViewFactory = (GroupByViewFactoryMarker)viewFactories[0]; mergeViewFactory = (MergeViewFactoryMarker)viewFactories[viewFactories.Count - 1]; viewFactories.RemoveAt(0); viewFactories.RemoveAt(viewFactories.Count - 1); } var container = context.Container; ViewFactory retainPolicy; if (isUnion) { var viewFactory = (UnionViewFactory)context.ViewResolutionService.Create(container, "internal", "union"); viewFactory.ParentEventType = parentEventType; viewFactory.ViewFactories = dataWindowViews; retainPolicy = viewFactory; } else { var viewFactory = (IntersectViewFactory)context.ViewResolutionService.Create(container, "internal", "intersect"); viewFactory.ParentEventType = parentEventType; viewFactory.ViewFactories = dataWindowViews; retainPolicy = viewFactory; } IList <ViewFactory> nonRetainViewFactories = new List <ViewFactory>(); nonRetainViewFactories.Add(retainPolicy); if (groupByViewFactory != null) { nonRetainViewFactories.Insert(0, (ViewFactory)groupByViewFactory); nonRetainViewFactories.AddAll(derivedValueViews); nonRetainViewFactories.Add((ViewFactory)mergeViewFactory); } else { nonRetainViewFactories.AddAll(derivedValueViews); } return(nonRetainViewFactories); }
public ViewableActivator CreateNamedWindow(NamedWindowProcessor processor, NamedWindowConsumerStreamSpec streamSpec, StatementContext statementContext) { return(new ViewableActivatorNamedWindow(processor, streamSpec.FilterExpressions, streamSpec.OptPropertyEvaluator)); }
public StatementContextCPPair(int statementId, int agentInstanceId, StatementContext optionalStatementContext) { StatementId = statementId; AgentInstanceId = agentInstanceId; OptionalStatementContext = optionalStatementContext; }
public EPStatementStopMethodImpl(StatementContext statementContext, IList <StopCallback> stopCallbacks) { _statementContext = statementContext; _stopCallbacks = stopCallbacks.ToArray(); }
private void ValidateContextDetail( EPServicesContext servicesContext, StatementContext statementContext, ISet <string> eventTypesReferenced, ContextDetail contextDetail, AgentInstanceContext agentInstanceContext) { if (contextDetail is ContextDetailPartitioned) { var segmented = (ContextDetailPartitioned)contextDetail; foreach (var partition in segmented.Items) { ValidateNotTable(servicesContext, partition.FilterSpecRaw.EventTypeName); var raw = new FilterStreamSpecRaw(partition.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiled = raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); if (!(compiled is FilterStreamSpecCompiled)) { throw new ExprValidationException("Partition criteria may not include named windows"); } var result = (FilterStreamSpecCompiled)compiled; partition.FilterSpecCompiled = result.FilterSpec; } } else if (contextDetail is ContextDetailCategory) { // compile filter var category = (ContextDetailCategory)contextDetail; ValidateNotTable(servicesContext, category.FilterSpecRaw.EventTypeName); var raw = new FilterStreamSpecRaw(category.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var result = (FilterStreamSpecCompiled)raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); category.FilterSpecCompiled = result.FilterSpec; servicesContext.StatementEventTypeRefService.AddReferences(statementContext.StatementName, CollectionUtil.ToArray(eventTypesReferenced)); // compile expressions foreach (var item in category.Items) { ValidateNotTable(servicesContext, category.FilterSpecRaw.EventTypeName); var filterSpecRaw = new FilterSpecRaw(category.FilterSpecRaw.EventTypeName, Collections.SingletonList(item.Expression), null); var rawExpr = new FilterStreamSpecRaw(filterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiled = (FilterStreamSpecCompiled)rawExpr.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); item.SetCompiledFilter(compiled.FilterSpec, agentInstanceContext); } } else if (contextDetail is ContextDetailHash) { var hashed = (ContextDetailHash)contextDetail; foreach (var hashItem in hashed.Items) { var raw = new FilterStreamSpecRaw(hashItem.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); ValidateNotTable(servicesContext, hashItem.FilterSpecRaw.EventTypeName); var result = (FilterStreamSpecCompiled)raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); hashItem.FilterSpecCompiled = result.FilterSpec; // validate parameters var streamTypes = new StreamTypeServiceImpl(result.FilterSpec.FilterForEventType, null, true, statementContext.EngineURI); var validationContext = new ExprValidationContext( statementContext.Container, streamTypes, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, GetDefaultAgentInstanceContext(statementContext), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); ExprNodeUtility.Validate(ExprNodeOrigin.CONTEXT, Collections.SingletonList(hashItem.Function), validationContext); } } else if (contextDetail is ContextDetailInitiatedTerminated) { var def = (ContextDetailInitiatedTerminated)contextDetail; var startCondition = ValidateRewriteContextCondition(servicesContext, statementContext, def.Start, eventTypesReferenced, new MatchEventSpec(), new LinkedHashSet <string>()); var endCondition = ValidateRewriteContextCondition(servicesContext, statementContext, def.End, eventTypesReferenced, startCondition.Matches, startCondition.AllTags); def.Start = startCondition.Condition; def.End = endCondition.Condition; if (def.DistinctExpressions != null) { if (!(startCondition.Condition is ContextDetailConditionFilter)) { throw new ExprValidationException("Distinct-expressions require a stream as the initiated-by condition"); } var distinctExpressions = def.DistinctExpressions; if (distinctExpressions.Length == 0) { throw new ExprValidationException("Distinct-expressions have not been provided"); } var filter = (ContextDetailConditionFilter)startCondition.Condition; if (filter.OptionalFilterAsName == null) { throw new ExprValidationException("Distinct-expressions require that a stream name is assigned to the stream using 'as'"); } var types = new StreamTypeServiceImpl(filter.FilterSpecCompiled.FilterForEventType, filter.OptionalFilterAsName, true, servicesContext.EngineURI); var validationContext = new ExprValidationContext( statementContext.Container, types, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, GetDefaultAgentInstanceContext(statementContext), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false ); for (var i = 0; i < distinctExpressions.Length; i++) { ExprNodeUtility.ValidatePlainExpression(ExprNodeOrigin.CONTEXTDISTINCT, distinctExpressions[i]); distinctExpressions[i] = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.CONTEXTDISTINCT, distinctExpressions[i], validationContext); } } } else if (contextDetail is ContextDetailNested) { var nested = (ContextDetailNested)contextDetail; foreach (var nestedContext in nested.Contexts) { ValidateContextDetail(servicesContext, statementContext, eventTypesReferenced, nestedContext.ContextDetail, agentInstanceContext); } } else { throw new IllegalStateException("Unrecognized context detail " + contextDetail); } }
/// <summary> /// Validates expression nodes and returns a list of validated nodes. /// </summary> /// <param name="exprNodeOrigin">The expr node origin.</param> /// <param name="exprNodes">is the nodes to validate</param> /// <param name="streamTypeService">is provding type information for each stream</param> /// <param name="statementContext">context</param> /// <param name="taggedEventTypes">pattern tagged types</param> /// <param name="arrayEventTypes">@return list of validated expression nodes</param> /// <returns> /// expr nodes /// </returns> /// <exception cref="ExprValidationException"> /// Failed to validate + EPStatementStartMethodHelperSubselect.GetSubqueryInfoText(count, subselect) + : + ex.Message /// or /// Filter expression not returning a boolean value: ' + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated) + ' /// </exception> /// <throws>ExprValidationException for validation errors</throws> public static IList <ExprNode> ValidateAllowSubquery( ExprNodeOrigin exprNodeOrigin, IList <ExprNode> exprNodes, StreamTypeService streamTypeService, StatementContext statementContext, IDictionary <string, Pair <EventType, string> > taggedEventTypes, IDictionary <string, Pair <EventType, string> > arrayEventTypes) { IList <ExprNode> validatedNodes = new List <ExprNode>(); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( streamTypeService, statementContext.MethodResolutionService, null, statementContext.TimeProvider, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, true); foreach (var node in exprNodes) { // Determine subselects var visitor = new ExprNodeSubselectDeclaredDotVisitor(); node.Accept(visitor); // Compile subselects if (!visitor.Subselects.IsEmpty()) { // The outer event type is the filtered-type itself var subselectStreamNumber = 2048; var count = -1; foreach (var subselect in visitor.Subselects) { count++; subselectStreamNumber++; try { HandleSubselectSelectClauses(subselectStreamNumber, statementContext, subselect, streamTypeService.EventTypes[0], streamTypeService.StreamNames[0], streamTypeService.StreamNames[0], taggedEventTypes, arrayEventTypes); } catch (ExprValidationException ex) { throw new ExprValidationException("Failed to validate " + EPStatementStartMethodHelperSubselect.GetSubqueryInfoText(count, subselect) + ": " + ex.Message, ex); } } } var validated = ExprNodeUtility.GetValidatedSubtree(exprNodeOrigin, node, validationContext); validatedNodes.Add(validated); if ((validated.ExprEvaluator.ReturnType != typeof(bool?)) && ((validated.ExprEvaluator.ReturnType != typeof(bool)))) { throw new ExprValidationException("Filter expression not returning a boolean value: '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated) + "'"); } } return(validatedNodes); }
public static ViewFactoryContext MakeViewContext() { StatementContext stmtContext = MakeContext(); return(new ViewFactoryContext(stmtContext, 1, "somenamespacetest", "somenametest", false, -1, false)); }
private static void HandleSubselectSelectClauses( int subselectStreamNumber, StatementContext statementContext, ExprSubselectNode subselect, EventType outerEventType, string outerEventTypeName, string outerStreamName, IDictionary <string, Pair <EventType, string> > taggedEventTypes, IDictionary <string, Pair <EventType, string> > arrayEventTypes) { var statementSpec = subselect.StatementSpecCompiled; var filterStreamSpec = statementSpec.StreamSpecs[0]; ViewFactoryChain viewFactoryChain; string subselecteventTypeName = null; // construct view factory chain try { if (statementSpec.StreamSpecs[0] is FilterStreamSpecCompiled) { var filterStreamSpecCompiled = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0]; subselecteventTypeName = filterStreamSpecCompiled.FilterSpec.FilterForEventTypeName; // A child view is required to limit the stream if (filterStreamSpec.ViewSpecs.Length == 0) { throw new ExprValidationException("Subqueries require one or more views to limit the stream, consider declaring a length or time window"); } // Register filter, create view factories viewFactoryChain = statementContext.ViewService.CreateFactories(subselectStreamNumber, filterStreamSpecCompiled.FilterSpec.ResultEventType, filterStreamSpec.ViewSpecs, filterStreamSpec.Options, statementContext); subselect.RawEventType = viewFactoryChain.EventType; } else { var namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0]; var processor = statementContext.NamedWindowService.GetProcessor(namedSpec.WindowName); viewFactoryChain = statementContext.ViewService.CreateFactories(0, processor.NamedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext); subselecteventTypeName = namedSpec.WindowName; EPLValidationUtil.ValidateContextName(false, processor.NamedWindowName, processor.ContextName, statementContext.ContextName, true); } } catch (ViewProcessingException ex) { throw new ExprValidationException("Error validating subexpression: " + ex.Message, ex); } // the final event type var eventType = viewFactoryChain.EventType; // determine a stream name unless one was supplied var subexpressionStreamName = filterStreamSpec.OptionalStreamName; if (subexpressionStreamName == null) { subexpressionStreamName = "$subselect_" + subselectStreamNumber; } // Named windows don't allow data views if (filterStreamSpec is NamedWindowConsumerStreamSpec) { EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewFactoryChain.FactoryChain); } // Streams event types are the original stream types with the stream zero the subselect stream var namesAndTypes = new LinkedHashMap <string, Pair <EventType, string> >(); namesAndTypes.Put(subexpressionStreamName, new Pair <EventType, string>(eventType, subselecteventTypeName)); namesAndTypes.Put(outerStreamName, new Pair <EventType, string>(outerEventType, outerEventTypeName)); if (taggedEventTypes != null) { foreach (KeyValuePair <string, Pair <EventType, string> > entry in taggedEventTypes) { namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second)); } } if (arrayEventTypes != null) { foreach (KeyValuePair <string, Pair <EventType, string> > entry in arrayEventTypes) { namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second)); } } StreamTypeService subselectTypeService = new StreamTypeServiceImpl(namesAndTypes, statementContext.EngineURI, true, true); var viewResourceDelegateSubselect = new ViewResourceDelegateUnverified(); subselect.FilterSubqueryStreamTypes = subselectTypeService; // Validate select expression var selectClauseSpec = subselect.StatementSpecCompiled.SelectClauseSpec; if (selectClauseSpec.SelectExprList.Length > 0) { if (selectClauseSpec.SelectExprList.Length > 1) { throw new ExprValidationException("Subquery multi-column select is not allowed in this context."); } var element = selectClauseSpec.SelectExprList[0]; if (element is SelectClauseExprCompiledSpec) { // validate var compiled = (SelectClauseExprCompiledSpec)element; var selectExpression = compiled.SelectExpression; var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( subselectTypeService, statementContext.MethodResolutionService, viewResourceDelegateSubselect, 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); selectExpression = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SUBQUERYSELECT, selectExpression, validationContext); subselect.SelectClause = new ExprNode[] { selectExpression }; subselect.SelectAsNames = new string[] { compiled.AssignedName }; // handle aggregation var aggExprNodes = new List <ExprAggregateNode>(); ExprAggregateNodeUtil.GetAggregatesBottomUp(selectExpression, aggExprNodes); if (aggExprNodes.Count > 0) { // Other stream properties, if there is aggregation, cannot be under aggregation. foreach (var aggNode in aggExprNodes) { var propertiesNodesAggregated = ExprNodeUtility.GetExpressionProperties(aggNode, true); foreach (var pair in propertiesNodesAggregated) { if (pair.First != 0) { throw new ExprValidationException("Subselect aggregation function cannot aggregate across correlated properties"); } } } // This stream (stream 0) properties must either all be under aggregation, or all not be. var propertiesNotAggregated = ExprNodeUtility.GetExpressionProperties(selectExpression, false); foreach (var pair in propertiesNotAggregated) { if (pair.First == 0) { throw new ExprValidationException("Subselect properties must all be within aggregation functions"); } } } } } }
/// <summary> /// Ctor. /// </summary> /// <param name="whenExpressionNode">the expression to evaluate, returning true when to output</param> /// <param name="assignments">is the optional then-clause variable assignments, or null or empty if none</param> /// <throws>ExprValidationException when validation fails</throws> public OutputConditionPolledExpressionFactory(ExprNode whenExpressionNode, IList <OnTriggerSetAssignment> assignments, StatementContext statementContext) { _whenExpressionNode = whenExpressionNode.ExprEvaluator; // determine if using properties var containsBuiltinProperties = false; if (ContainsBuiltinProperties(whenExpressionNode)) { containsBuiltinProperties = true; } else { if (assignments != null) { foreach (var assignment in assignments) { if (ContainsBuiltinProperties(assignment.Expression)) { containsBuiltinProperties = true; } } } } if (containsBuiltinProperties) { _oatypeBuiltinProperties = statementContext.EventAdapterService.CreateAnonymousObjectArrayType(typeof(OutputConditionPolledExpressionFactory).Name, OutputConditionExpressionTypeUtil.TYPEINFO); } else { _oatypeBuiltinProperties = null; } if (assignments != null) { _variableReadWritePackage = new VariableReadWritePackage(assignments, statementContext.VariableService, statementContext.EventAdapterService); } else { _variableReadWritePackage = null; } }
public StreamSpecCompiled Compile(StatementContext context, ICollection <String> eventTypeReferences, bool isInsertInto, ICollection <int> assignedTypeNumberStack, bool isJoin, bool isContextDeclaration, bool isOnTrigger, String optionalStreamName) { StreamTypeService streamTypeService; // Determine the event type var eventName = _rawFilterSpec.EventTypeName; if (context.TableService != null && context.TableService.GetTableMetadata(eventName) != null) { if (this.ViewSpecs != null && this.ViewSpecs.Length > 0) { throw new ExprValidationException("Views are not supported with tables"); } if (this.RawFilterSpec.OptionalPropertyEvalSpec != null) { throw new ExprValidationException("Contained-event expressions are not supported with tables"); } var tableMetadata = context.TableService.GetTableMetadata(eventName); var streamTypeServiceX = new StreamTypeServiceImpl(new EventType[] { tableMetadata.InternalEventType }, new String[] { optionalStreamName }, new bool[] { true }, context.EngineURI, false); var validatedNodes = FilterSpecCompiler.ValidateAllowSubquery(ExprNodeOrigin.FILTER, _rawFilterSpec.FilterExpressions, streamTypeServiceX, context, null, null); return(new TableQueryStreamSpec(this.OptionalStreamName, this.ViewSpecs, this.Options, eventName, validatedNodes)); } // Could be a named window if (context.NamedWindowMgmtService.IsNamedWindow(eventName)) { var namedWindowType = context.NamedWindowMgmtService.GetProcessor(eventName).TailView.EventType; streamTypeService = new StreamTypeServiceImpl(new EventType[] { namedWindowType }, new String[] { optionalStreamName }, new bool[] { true }, context.EngineURI, false); var validatedNodes = FilterSpecCompiler.ValidateAllowSubquery( ExprNodeOrigin.FILTER, _rawFilterSpec.FilterExpressions, streamTypeService, context, null, null); PropertyEvaluator optionalPropertyEvaluator = null; if (_rawFilterSpec.OptionalPropertyEvalSpec != null) { optionalPropertyEvaluator = PropertyEvaluatorFactory.MakeEvaluator( _rawFilterSpec.OptionalPropertyEvalSpec, namedWindowType, OptionalStreamName, context.EventAdapterService, context.MethodResolutionService, context.TimeProvider, context.VariableService, context.ScriptingService, context.TableService, context.EngineURI, context.StatementId, context.StatementName, context.Annotations, assignedTypeNumberStack, context.ConfigSnapshot, context.NamedWindowMgmtService); } eventTypeReferences.Add(((EventTypeSPI)namedWindowType).Metadata.PrimaryName); return(new NamedWindowConsumerStreamSpec(eventName, OptionalStreamName, ViewSpecs, validatedNodes, Options, optionalPropertyEvaluator)); } EventType eventType = null; if (context.ValueAddEventService.IsRevisionTypeName(eventName)) { eventType = context.ValueAddEventService.GetValueAddUnderlyingType(eventName); eventTypeReferences.Add(((EventTypeSPI)eventType).Metadata.PrimaryName); } if (eventType == null) { eventType = ResolveType(context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs); if (eventType is EventTypeSPI) { eventTypeReferences.Add(((EventTypeSPI)eventType).Metadata.PrimaryName); } } // Validate all nodes, make sure each returns a bool and types are good; // Also decompose all AND super nodes into individual expressions streamTypeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new String[] { base.OptionalStreamName }, new bool[] { true }, context.EngineURI, false); var spec = FilterSpecCompiler.MakeFilterSpec(eventType, eventName, _rawFilterSpec.FilterExpressions, _rawFilterSpec.OptionalPropertyEvalSpec, null, null, // no tags streamTypeService, OptionalStreamName, context, assignedTypeNumberStack); return(new FilterStreamSpecCompiled(spec, ViewSpecs, OptionalStreamName, Options)); }
public EventTable[] Index(IList <EventBean> pollResult, bool isActiveCache, StatementContext statementContext) { return(new EventTable[] { new UnindexedEventTableList(pollResult, -1) }); }
public static OutputConditionPolledFactory CreateConditionFactory(OutputLimitSpec outputLimitSpec, StatementContext statementContext) { if (outputLimitSpec == null) { throw new ArgumentNullException("Output condition by count requires a non-null callback"); } // check variable use VariableMetaData variableMetaData = null; if (outputLimitSpec.VariableName != null) { variableMetaData = statementContext.VariableService.GetVariableMetaData(outputLimitSpec.VariableName); if (variableMetaData == null) { throw new ArgumentException("Variable named '" + outputLimitSpec.VariableName + "' has not been declared"); } } if (outputLimitSpec.RateType == OutputLimitRateType.CRONTAB) { return(new OutputConditionPolledCrontabFactory(outputLimitSpec.CrontabAtSchedule, statementContext)); } else if (outputLimitSpec.RateType == OutputLimitRateType.WHEN_EXPRESSION) { return(new OutputConditionPolledExpressionFactory(outputLimitSpec.WhenExpressionNode, outputLimitSpec.ThenExpressions, statementContext)); } else if (outputLimitSpec.RateType == OutputLimitRateType.EVENTS) { int rate = -1; if (outputLimitSpec.Rate != null) { rate = outputLimitSpec.Rate.AsInt(); } return(new OutputConditionPolledCountFactory(rate, statementContext, outputLimitSpec.VariableName)); } else { if (variableMetaData != null && (!variableMetaData.VariableType.IsNumeric())) { throw new ArgumentException("Variable named '" + outputLimitSpec.VariableName + "' must be of numeric type"); } return(new OutputConditionPolledTimeFactory(outputLimitSpec.TimePeriodExpr, statementContext)); } }
public ContextManagedStatementCreateVariableDesc(StatementSpecCompiled statementSpec, StatementContext statementContext, ContextMergeView mergeView, StatementAgentInstanceFactory factory) : base(statementSpec, statementContext, mergeView, factory) { }
public NamedWindowOnMergeHelper(StatementContext statementContext, OnTriggerMergeDesc onTriggerDesc, EventType triggeringEventType, string triggeringStreamName, InternalEventRouter internalEventRouter, string namedWindowName, EventTypeSPI namedWindowType) { Matched = new List <NamedWindowOnMergeMatch>(); Unmatched = new List <NamedWindowOnMergeMatch>(); var count = 1; foreach (var matchedItem in onTriggerDesc.Items) { IList <NamedWindowOnMergeAction> actions = new List <NamedWindowOnMergeAction>(); foreach (var item in matchedItem.Actions) { try { if (item is OnTriggerMergeActionInsert) { var insertDesc = (OnTriggerMergeActionInsert)item; actions.Add(SetupInsert(namedWindowName, internalEventRouter, namedWindowType, count, insertDesc, triggeringEventType, triggeringStreamName, statementContext)); } else if (item is OnTriggerMergeActionUpdate) { var updateDesc = (OnTriggerMergeActionUpdate)item; var updateHelper = EventBeanUpdateHelperFactory.Make(namedWindowName, namedWindowType, updateDesc.Assignments, onTriggerDesc.OptionalAsName, triggeringEventType, true); var filterEval = updateDesc.OptionalWhereClause == null ? null : updateDesc.OptionalWhereClause.ExprEvaluator; actions.Add(new NamedWindowOnMergeActionUpd(filterEval, updateHelper)); } else if (item is OnTriggerMergeActionDelete) { var deleteDesc = (OnTriggerMergeActionDelete)item; var filterEval = deleteDesc.OptionalWhereClause == null ? null : deleteDesc.OptionalWhereClause.ExprEvaluator; actions.Add(new NamedWindowOnMergeActionDel(filterEval)); } else { throw new ArgumentException("Invalid type of merge item '" + item.GetType() + "'"); } count++; } catch (ExprValidationException ex) { var isNot = item is OnTriggerMergeActionInsert; var message = "Validation failed in when-" + (isNot?"not-":"") + "matched (clause " + count + "): " + ex.Message; throw new ExprValidationException(message, ex); } } if (matchedItem.IsMatchedUnmatched) { Matched.Add(new NamedWindowOnMergeMatch(matchedItem.OptionalMatchCond, actions)); } else { Unmatched.Add(new NamedWindowOnMergeMatch(matchedItem.OptionalMatchCond, actions)); } } }
private void _linkLabel忘记密码_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { try { using (StatementContext statement = new StatementContext(typeof(User))) { var user = statement.Users.FirstOrDefault(model => model.UserName.Equals(_comboBox用户列表.Text.Trim())); // if (MessageBox.Show(string.Format("是否向用户<{0}>的密保邮箱发送新密码?", user.UserName), "发送新密码确认", MessageBoxButton.YesNo) == MessageBoxResult.Yes) { //确定smtp服务器地址。实例化一个Smtp客户端 SmtpClient client = new SmtpClient("smtp.163.com"); //构造一个发件人地址对象 MailAddress from = new MailAddress("*****@*****.**", "期货助手", Encoding.UTF8); //构造一个收件人地址对象 MailAddress to = new MailAddress(user.Email, _comboBox用户列表.Text.Trim(), Encoding.UTF8); //构造一个Email的Message对 MailMessage message = new MailMessage(from, to); Random random = new Random(); string newPassword = string.Format("{0}{1}{2}{3}{4}{5}", random.Next(10), random.Next(10), random.Next(10), random.Next(10), random.Next(10), random.Next(10)); //添加邮件主题和内容 message.Subject = "期货助手 - 新密码"; message.SubjectEncoding = Encoding.UTF8; message.Body = string.Format("您的新密码是:{0}", newPassword); message.BodyEncoding = Encoding.UTF8; //设置邮件的信息 client.DeliveryMethod = SmtpDeliveryMethod.Network; message.BodyEncoding = System.Text.Encoding.UTF8; message.IsBodyHtml = false; //设置用户名和密码。 client.UseDefaultCredentials = false; string username = "******"; string passwd = "mail351489"; //用户登陆信息 NetworkCredential myCredentials = new NetworkCredential(username, passwd); client.Credentials = myCredentials; //发送邮件 client.Send(message); // user.UserPassword = newPassword._RSAEcrypt(); statement.EditUser(user); statement.SaveChanged(); //提示发送成功 MessageBox.Show("新密码已经发送到您的邮箱中,请及时查收!"); } } } catch (Exception ex) { MessageBox.Show(ex.Message + "\n" + ex.StackTrace); } }
private NamedWindowOnMergeActionIns SetupInsert( string namedWindowName, InternalEventRouter internalEventRouter, EventTypeSPI eventTypeNamedWindow, int selectClauseNumber, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementContext statementContext) { // Compile insert-into info var 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 EventType dummyTypeNoProperties = new MapEventType(EventTypeMetadata.CreateAnonymous("merge_named_window_insert"), "merge_named_window_insert", 0, null, Collections.GetEmptyMap <string, object>(), null, null, null); var eventTypes = new EventType[] { dummyTypeNoProperties, triggeringEventType }; var streamNames = new string[] { UuidGenerator.Generate(), triggeringStreamName }; StreamTypeService 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( Collections.SingletonSet <int>(selectClauseNumber), selectNoWildcard.ToArray(), false, insertIntoDesc, null, null, streamTypeService, statementContext.EventAdapterService, statementContext.StatementResultService, statementContext.ValueAddEventService, selectExprEventTypeRegistry, statementContext.MethodResolutionService, exprEvaluatorContext, statementContext.VariableService, statementContext.ScriptingService, statementContext.TableService, statementContext.TimeProvider, statementContext.EngineURI, statementContext.StatementId, statementContext.StatementName, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ConfigSnapshot, null, statementContext.NamedWindowService, null); 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)); }
/// <summary> /// Creates the viewable for polling via database SQL query. /// </summary> /// <param name="statementId">The statement id.</param> /// <param name="streamNumber">is the stream number of the view</param> /// <param name="databaseStreamSpec">provides the SQL statement, database name and additional info</param> /// <param name="databaseConfigService">for getting database connection and settings</param> /// <param name="eventAdapterService">for generating event beans from database information</param> /// <param name="epStatementAgentInstanceHandle">The ep statement agent instance handle.</param> /// <param name="contextAttributes">The db attributes.</param> /// <param name="columnTypeConversionHook">The column type conversion hook.</param> /// <param name="outputRowConversionHook">The output row conversion hook.</param> /// <param name="enableAdoLogging">if set to <c>true</c> [enable JDBC logging].</param> /// <param name="dataCacheFactory">The data cache factory.</param> /// <param name="statementContext">The statement context.</param> /// <returns> /// viewable providing poll functionality /// </returns> /// <exception cref="ExprValidationException">the validation failed</exception> public static HistoricalEventViewable CreateDBStatementView( int statementId, int streamNumber, DBStatementStreamSpec databaseStreamSpec, DatabaseConfigService databaseConfigService, EventAdapterService eventAdapterService, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle, IEnumerable <Attribute> contextAttributes, SQLColumnTypeConversion columnTypeConversionHook, SQLOutputRowConversion outputRowConversionHook, bool enableAdoLogging, DataCacheFactory dataCacheFactory, StatementContext statementContext) { // Parse the SQL for placeholders and text fragments var sqlFragments = GetSqlFragments(databaseStreamSpec); IList <String> invocationInputParameters = new List <string>(); foreach (var fragment in sqlFragments) { if ((fragment.IsParameter) && (fragment.Value != SAMPLE_WHERECLAUSE_PLACEHOLDER)) { invocationInputParameters.Add(fragment.Value); } } // Get the database information var databaseName = databaseStreamSpec.DatabaseName; var dbDriver = GetDatabaseConnectionFactory(databaseConfigService, databaseName).Driver; var dbCommand = dbDriver.CreateCommand( sqlFragments, GetMetaDataSettings(databaseConfigService, databaseName), contextAttributes); if (Log.IsDebugEnabled) { Log.Debug(".CreateDBStatementView dbCommand=" + dbCommand); } var queryMetaData = GetQueryMetaData( databaseStreamSpec, databaseConfigService, dbCommand, contextAttributes); Func <SQLColumnTypeContext, Type> columnTypeConversionFunc = null; if (columnTypeConversionHook != null) { columnTypeConversionFunc = columnTypeConversionHook.GetColumnType; } Func <SQLOutputRowTypeContext, Type> outputRowConversionFunc = null; if (outputRowConversionHook != null) { outputRowConversionFunc = outputRowConversionHook.GetOutputRowType; } // Construct an event type from SQL query result metadata var eventType = CreateEventType( statementId, streamNumber, queryMetaData, eventAdapterService, databaseStreamSpec, columnTypeConversionFunc, outputRowConversionFunc); // Get a proper connection and data cache ConnectionCache connectionCache; DataCache dataCache; try { connectionCache = databaseConfigService.GetConnectionCache( databaseName, dbCommand.PseudoText, contextAttributes); dataCache = databaseConfigService.GetDataCache( databaseName, statementContext, epStatementAgentInstanceHandle, dataCacheFactory, streamNumber); } catch (DatabaseConfigException e) { const string text = "Error obtaining cache configuration"; Log.Error(text, e); throw new ExprValidationException(text + ", reason: " + e.Message, e); } var dbPollStrategy = new PollExecStrategyDBQuery( eventAdapterService, eventType, connectionCache, dbCommand.CommandText, queryMetaData.OutputParameters, columnTypeConversionHook, outputRowConversionHook); return(new DatabasePollingViewable( streamNumber, invocationInputParameters, dbPollStrategy, dataCache, eventType, statementContext.ThreadLocalManager)); }
public StatementContext statement() { StatementContext _localctx = new StatementContext(_ctx, State); EnterRule(_localctx, 184, RULE_statement); try { State = 1061; switch ( Interpreter.AdaptivePredict(_input,120,_ctx) ) { case 1: EnterOuterAlt(_localctx, 1); { State = 1049; labeled_statement(); } break; case 2: EnterOuterAlt(_localctx, 2); { State = 1050; expression(); State = 1051; Match(SEMI); } break; case 3: EnterOuterAlt(_localctx, 3); { State = 1053; compound_statement(); } break; case 4: EnterOuterAlt(_localctx, 4); { State = 1054; selection_statement(); } break; case 5: EnterOuterAlt(_localctx, 5); { State = 1055; iteration_statement(); } break; case 6: EnterOuterAlt(_localctx, 6); { State = 1056; jump_statement(); } break; case 7: EnterOuterAlt(_localctx, 7); { State = 1057; synchronized_statement(); } break; case 8: EnterOuterAlt(_localctx, 8); { State = 1058; autorelease_statement(); } break; case 9: EnterOuterAlt(_localctx, 9); { State = 1059; try_block(); } break; case 10: EnterOuterAlt(_localctx, 10); { State = 1060; Match(SEMI); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.ReportError(this, re); _errHandler.Recover(this, re); } finally { ExitRule(); } return _localctx; }