예제 #1
0
        public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement)
        {
            StatementSpecCompiledAnalyzerResult streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec);

            ContextControllerPartitionedUtil.ValidateStatementForContext(FactoryContext.ContextName, statement, streamAnalysis, GetItemEventTypes(_segmentedSpec), FactoryContext.ServicesContext.NamedWindowMgmtService);
            return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters));
        }
        public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement)
        {
            var streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec);

            ValidateStatementForContext(statement, streamAnalysis);
            return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters));
        }
예제 #3
0
        public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement)
        {
            var streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec);

            ContextControllerPartitionedUtil.ValidateStatementForContext(
                _factoryContext.ContextName, statement, streamAnalysis, GetItemEventTypes(_hashedSpec),
                _factoryContext.ServicesContext.NamedWindowMgmtService);
            // register non-property expression to be able to recreated indexes
            foreach (var entry in _nonPropertyExpressions)
            {
                _factoryContext.ServicesContext.FilterNonPropertyRegisteryService.RegisterNonPropertyExpression(statement.StatementContext.StatementName, entry.Key, entry.Value);
            }
            return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters));
        }
        public void ValidateStatement(
            string contextName,
            StatementSpecCompiled spec,
            StatementCompileTimeServices compileTimeServices)
        {
            var streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(spec);
            var filters = streamAnalysis.Filters;

            // Category validation
            var isCreateWindow = spec.Raw.CreateWindowDesc != null;
            var message = "Category context '" +
                          contextName +
                          "' requires that any of the events types that are listed in the category context also appear in any of the filter expressions of the statement";

            // if no create-window: at least one of the filters must match one of the filters specified by the context
            if (!isCreateWindow) {
                foreach (var filter in filters) {
                    var stmtFilterType = filter.FilterForEventType;
                    if (stmtFilterType == CategoryEventType) {
                        return;
                    }

                    if (EventTypeUtility.IsTypeOrSubTypeOf(stmtFilterType, CategoryEventType)) {
                        return;
                    }
                }

                if (!filters.IsEmpty()) {
                    throw new ExprValidationException(message);
                }

                return;
            }

            // validate create-window
            var declaredAsName = spec.Raw.CreateWindowDesc.AsEventTypeName;
            if (declaredAsName != null) {
                if (CategoryEventType.Name.Equals(declaredAsName)) {
                    return;
                }

                throw new ExprValidationException(message);
            }
        }
예제 #5
0
        public static void ValidateStatementKeyAndHash(
            IEnumerable<Supplier<EventType>> typeProvider,
            string contextName,
            StatementSpecCompiled spec,
            StatementCompileTimeServices compileTimeServices)
        {
            StatementSpecCompiledAnalyzerResult streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(spec);
            IList<FilterSpecCompiled> filters = streamAnalysis.Filters;

            var isCreateWindow = spec.Raw.CreateWindowDesc != null;

            // if no create-window: at least one of the filters must match one of the filters specified by the context
            if (!isCreateWindow) {
                foreach (var filter in filters) {
                    foreach (var item in typeProvider) {
                        EventType itemEventType = item.Invoke();
                        var stmtFilterType = filter.FilterForEventType;
                        if (ReferenceEquals(stmtFilterType, itemEventType)) {
                            return;
                        }

                        if (EventTypeUtility.IsTypeOrSubTypeOf(stmtFilterType, itemEventType)) {
                            return;
                        }

                        NamedWindowMetaData namedWindow =
                            compileTimeServices.NamedWindowCompileTimeResolver.Resolve(stmtFilterType.Name);
                        string namedWindowContextName = namedWindow?.ContextName;
                        if (namedWindowContextName != null && namedWindowContextName.Equals(contextName)) {
                            return;
                        }
                    }
                }

                if (!filters.IsEmpty()) {
                    throw new ExprValidationException(
                        GetTypeValidationMessage(contextName, filters[0].FilterForEventType.Name));
                }

                return;
            }

            // validate create-window with column definition: not allowed, requires typed
            if (spec.Raw.CreateWindowDesc.Columns != null &&
                spec.Raw.CreateWindowDesc.Columns.Count > 0) {
                throw new ExprValidationException(
                    "Segmented context '" +
                    contextName +
                    "' requires that named windows are associated to an existing event type and that the event type is listed among the partitions defined by the create-context statement");
            }

            // validate create-window declared type
            var declaredAsName = spec.Raw.CreateWindowDesc.AsEventTypeName;
            if (declaredAsName != null) {
                foreach (var item in typeProvider) {
                    EventType itemEventType = item.Invoke();
                    if (itemEventType.Name.Equals(declaredAsName)) {
                        return;
                    }
                }

                throw new ExprValidationException(GetTypeValidationMessage(contextName, declaredAsName));
            }
        }