Пример #1
0
 public static void WalkStreamSpecs(StatementSpecRaw spec, ExprNodeSubselectDeclaredDotVisitor visitor)
 {
     // Determine filter streams
     foreach (StreamSpecRaw rawSpec in spec.StreamSpecs)
     {
         if (rawSpec is FilterStreamSpecRaw)
         {
             FilterStreamSpecRaw raw = (FilterStreamSpecRaw)rawSpec;
             foreach (ExprNode filterExpr in raw.RawFilterSpec.FilterExpressions)
             {
                 filterExpr.Accept(visitor);
             }
         }
         if (rawSpec is PatternStreamSpecRaw)
         {
             PatternStreamSpecRaw   patternStreamSpecRaw = (PatternStreamSpecRaw)rawSpec;
             EvalNodeAnalysisResult analysisResult       = EvalNodeUtil.RecursiveAnalyzeChildNodes(patternStreamSpecRaw.EvalFactoryNode);
             foreach (EvalFactoryNode evalNode in analysisResult.ActiveNodes)
             {
                 if (evalNode is EvalFilterFactoryNode)
                 {
                     EvalFilterFactoryNode filterNode = (EvalFilterFactoryNode)evalNode;
                     foreach (ExprNode filterExpr in filterNode.RawFilterSpec.FilterExpressions)
                     {
                         filterExpr.Accept(visitor);
                     }
                 }
             }
         }
     }
 }
Пример #2
0
 private static void AddFilters(StreamSpecCompiled[] streams, IList <FilterSpecCompiled> filters, IList <NamedWindowConsumerStreamSpec> namedWindows)
 {
     foreach (StreamSpecCompiled compiled in streams)
     {
         if (compiled is FilterStreamSpecCompiled)
         {
             FilterStreamSpecCompiled c = (FilterStreamSpecCompiled)compiled;
             filters.Add(c.FilterSpec);
         }
         if (compiled is PatternStreamSpecCompiled)
         {
             PatternStreamSpecCompiled     r = (PatternStreamSpecCompiled)compiled;
             EvalNodeAnalysisResult        evalNodeAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes((r.EvalFactoryNode));
             IList <EvalFilterFactoryNode> filterNodes            = evalNodeAnalysisResult.FilterNodes;
             foreach (EvalFilterFactoryNode filterNode in filterNodes)
             {
                 filters.Add(filterNode.FilterSpec);
             }
         }
         if (compiled is NamedWindowConsumerStreamSpec)
         {
             namedWindows.Add((NamedWindowConsumerStreamSpec)compiled);
         }
     }
 }
        public static void WalkStreamSpecs(
            StatementSpecRaw spec,
            ExprNodeSubselectDeclaredDotVisitor visitor)
        {
            // determine pattern-filter subqueries
            foreach (StreamSpecRaw streamSpecRaw in spec.StreamSpecs) {
                if (streamSpecRaw is PatternStreamSpecRaw) {
                    PatternStreamSpecRaw patternStreamSpecRaw = (PatternStreamSpecRaw) streamSpecRaw;
                    EvalNodeAnalysisResult analysisResult =
                        EvalNodeUtil.RecursiveAnalyzeChildNodes(patternStreamSpecRaw.EvalForgeNode);
                    foreach (EvalForgeNode evalNode in analysisResult.ActiveNodes) {
                        if (evalNode is EvalFilterForgeNode) {
                            EvalFilterForgeNode filterNode = (EvalFilterForgeNode) evalNode;
                            foreach (ExprNode filterExpr in filterNode.RawFilterSpec.FilterExpressions) {
                                filterExpr.Accept(visitor);
                            }
                        }
                        else if (evalNode is EvalObserverForgeNode) {
                            int beforeCount = visitor.Subselects.Count;
                            EvalObserverForgeNode observerNode = (EvalObserverForgeNode) evalNode;
                            foreach (ExprNode param in observerNode.PatternObserverSpec.ObjectParameters) {
                                param.Accept(visitor);
                            }

                            if (visitor.Subselects.Count != beforeCount) {
                                throw new ExprValidationException(
                                    "Subselects are not allowed within pattern observer parameters, please consider using a variable instead");
                            }
                        }
                    }
                }
            }

            // determine filter streams
            foreach (StreamSpecRaw rawSpec in spec.StreamSpecs) {
                if (rawSpec is FilterStreamSpecRaw) {
                    FilterStreamSpecRaw raw = (FilterStreamSpecRaw) rawSpec;
                    foreach (ExprNode filterExpr in raw.RawFilterSpec.FilterExpressions) {
                        filterExpr.Accept(visitor);
                    }
                }
            }
        }
Пример #4
0
        public static void WalkStatement(StatementSpecRaw spec, ExprNodeSubselectDeclaredDotVisitor visitor)
        {
            // Look for expressions with sub-selects in select expression list and filter expression
            // Recursively compile the statement within the statement.
            foreach (SelectClauseElementRaw raw in spec.SelectClauseSpec.SelectExprList)
            {
                if (raw is SelectClauseExprRawSpec)
                {
                    SelectClauseExprRawSpec rawExpr = (SelectClauseExprRawSpec)raw;
                    rawExpr.SelectExpression.Accept(visitor);
                }
                else
                {
                    continue;
                }
            }
            if (spec.FilterRootNode != null)
            {
                spec.FilterRootNode.Accept(visitor);
            }
            if (spec.HavingExprRootNode != null)
            {
                spec.HavingExprRootNode.Accept(visitor);
            }
            if (spec.UpdateDesc != null)
            {
                if (spec.UpdateDesc.OptionalWhereClause != null)
                {
                    spec.UpdateDesc.OptionalWhereClause.Accept(visitor);
                }
                foreach (OnTriggerSetAssignment assignment in spec.UpdateDesc.Assignments)
                {
                    assignment.Expression.Accept(visitor);
                }
            }
            if (spec.OnTriggerDesc != null)
            {
                VisitSubselectOnTrigger(spec.OnTriggerDesc, visitor);
            }
            // Determine pattern-filter subqueries
            foreach (StreamSpecRaw streamSpecRaw in spec.StreamSpecs)
            {
                if (streamSpecRaw is PatternStreamSpecRaw)
                {
                    PatternStreamSpecRaw   patternStreamSpecRaw = (PatternStreamSpecRaw)streamSpecRaw;
                    EvalNodeAnalysisResult analysisResult       = EvalNodeUtil.RecursiveAnalyzeChildNodes(patternStreamSpecRaw.EvalFactoryNode);
                    foreach (EvalFactoryNode evalNode in analysisResult.ActiveNodes)
                    {
                        if (evalNode is EvalFilterFactoryNode)
                        {
                            EvalFilterFactoryNode filterNode = (EvalFilterFactoryNode)evalNode;
                            foreach (ExprNode filterExpr in filterNode.RawFilterSpec.FilterExpressions)
                            {
                                filterExpr.Accept(visitor);
                            }
                        }
                        else if (evalNode is EvalObserverFactoryNode)
                        {
                            int beforeCount = visitor.Subselects.Count;
                            EvalObserverFactoryNode observerNode = (EvalObserverFactoryNode)evalNode;
                            foreach (ExprNode param in observerNode.PatternObserverSpec.ObjectParameters)
                            {
                                param.Accept(visitor);
                            }
                            if (visitor.Subselects.Count != beforeCount)
                            {
                                throw new ExprValidationException("Subselects are not allowed within pattern observer parameters, please consider using a variable instead");
                            }
                        }
                    }
                }
            }

            // walk streams
            WalkStreamSpecs(spec, visitor);
        }