private static void ValidateBuiltin( CreateIndexItem columnDesc, EventType eventType, IList <IndexedPropDesc> hashProps, IList <IndexedPropDesc> btreeProps, ISet <string> indexedColumns) { if (columnDesc.Expressions.IsEmpty()) { throw new ExprValidationException("Invalid empty list of index expressions"); } if (columnDesc.Expressions.Count > 1) { throw new ExprValidationException("Invalid multiple index expressions for index type '" + columnDesc.IndexType + "'"); } ExprNode expression = columnDesc.Expressions[0]; if (!(expression is ExprIdentNode)) { throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'"); } ExprIdentNode identNode = (ExprIdentNode)expression; if (identNode.FullUnresolvedName.Contains(".")) { throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'"); } string columnName = identNode.FullUnresolvedName; Type type = eventType.GetPropertyType(columnName).GetBoxedType(); if (type == null) { throw new ExprValidationException("Property named '" + columnName + "' not found"); } if (!indexedColumns.Add(columnName)) { throw new ExprValidationException("Property named '" + columnName + "' has been declared more then once"); } var desc = new IndexedPropDesc(columnName, type); string indexType = columnDesc.IndexType; if (string.Equals(indexType, CreateIndexType.HASH.ToString(), StringComparison.InvariantCultureIgnoreCase)) { hashProps.Add(desc); } else { btreeProps.Add(desc); } }
private static void ValidateExpression(ExprNode repeat) { var expression = "pattern quantifier '" + repeat.ToExpressionStringMinPrecedenceSafe() + "'"; ExprNodeUtility.ValidatePlainExpression(ExprNodeOrigin.MATCHRECOGPATTERN, expression, repeat); if (!repeat.IsConstantResult) { throw new ExprValidationException(expression + " must return a constant value"); } if (repeat.ExprEvaluator.ReturnType.GetBoxedType() != typeof(int?)) { throw new ExprValidationException(expression + " must return an integer-type value"); } }
/// <summary> /// Evaluate the bool expression given the event as a stream zero event. /// </summary> /// <param name="theEvent">is the stream zero event (current event)</param> /// <param name="exprEvaluatorContext">The expression evaluator context.</param> /// <returns>bool result of the expression</returns> public bool Evaluate(EventBean theEvent, ExprEvaluatorContext exprEvaluatorContext) { if (_variableService != null) { _variableService.SetLocalVersion(); } EventBean[] eventsPerStream = _arrayPerThread.GetOrCreate(); eventsPerStream[0] = theEvent; try { var result = (bool?)_exprNodeEval.Evaluate(new EvaluateParams(eventsPerStream, true, exprEvaluatorContext)); return(result ?? false); } catch (Exception ex) { Log.Error("Error evaluating expression '" + _exprNode.ToExpressionStringMinPrecedenceSafe() + "': " + ex.Message, ex); return(false); } }
public void TestSPI() { EPAdministratorSPI spi = (EPAdministratorSPI)_epService.EPAdministrator; ExprDotNode funcnode = (ExprDotNode)spi.CompileExpression("func()"); Assert.IsFalse(funcnode.ChainSpec[0].IsProperty); ExprNode node = spi.CompileExpression("value=5 and /* comment */ True"); Assert.AreEqual("value=5 and true", node.ToExpressionStringMinPrecedenceSafe()); Expression expr = spi.CompileExpressionToSODA("value=5 and True"); StringWriter buf = new StringWriter(); expr.ToEPL(buf, ExpressionPrecedenceEnum.MINIMUM); Assert.AreEqual("value=5 and true", buf.ToString()); expr = spi.CompileExpressionToSODA("5 sec"); buf = new StringWriter(); expr.ToEPL(buf, ExpressionPrecedenceEnum.MINIMUM); Assert.AreEqual("5 seconds", buf.ToString()); EvalFactoryNode pattern = spi.CompilePatternToNode("every A -> B"); Assert.That(pattern, Is.InstanceOf <EvalFollowedByFactoryNode>()); PatternExpr patternExpr = spi.CompilePatternToSODA("every A -> B"); Assert.AreEqual(typeof(PatternFollowedByExpr), patternExpr.GetType()); EPStatementObjectModel modelPattern = spi.CompilePatternToSODAModel("@Name('test') every A -> B"); Assert.AreEqual("Name", modelPattern.Annotations[0].Name); Assert.AreEqual(typeof(PatternFollowedByExpr), ((PatternStream)modelPattern.FromClause.Streams[0]).Expression.GetType()); AnnotationPart part = spi.CompileAnnotationToSODA("@somevalue(a='test', b=5)"); Assert.AreEqual("somevalue", part.Name); Assert.AreEqual(2, part.Attributes.Count); Assert.AreEqual("a", part.Attributes[0].Name); Assert.AreEqual("test", part.Attributes[0].Value); Assert.AreEqual("b", part.Attributes[1].Name); Assert.AreEqual(5, part.Attributes[1].Value); MatchRecognizeRegEx regex = spi.CompileMatchRecognizePatternToSODA("a b* c+ d? e?"); Assert.AreEqual(5, regex.Children.Count); // test fail cases string expected = "Incorrect syntax near 'in' (a reserved keyword) at line 1 column 42 [goofy in in]"; String compiled = "goofy in in"; try { spi.CompileExpression(compiled); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual(expected, ex.Message); } try { spi.CompileExpressionToSODA(compiled); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual(expected, ex.Message); } expected = "Incorrect syntax near 'in' (a reserved keyword) at line 1 column 6 [goofy in in]"; try { spi.CompilePatternToNode(compiled); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual(expected, ex.Message); } try { spi.CompilePatternToSODA(compiled); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual(expected, ex.Message); } try { spi.CompileAnnotationToSODA("not an annotation"); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual("Incorrect syntax near 'not' (a reserved keyword) [not an annotation]", ex.Message); } try { spi.CompileMatchRecognizePatternToSODA("a b???"); Assert.Fail(); } catch (EPException ex) { Assert.AreEqual("Incorrect syntax near '?' expecting a closing parenthesis ')' but found a questionmark '?' at line 1 column 76 [a b???]", ex.Message); } StatementSpecRaw raw = spi.CompileEPLToRaw("select * from System.Object"); Assert.NotNull(raw); EPStatementObjectModel model = spi.MapRawToSODA(raw); Assert.NotNull(model); // try control characters TryInvalidControlCharacters(); }
private static EventPropertyGetter ResolveFilterIndexRequiredGetter(string indexName, ExprNode keyExpression) { if (!(keyExpression is ExprIdentNode)) { throw new ExprValidationException("Invalid filter-index lookup expression '" + keyExpression.ToExpressionStringMinPrecedenceSafe() + "' in respect to index '" + indexName + "': expected an event property name"); } return(((ExprIdentNode)keyExpression).ExprEvaluatorIdent.Getter); }
private static FilterSpecParamFilterForEvalDouble ResolveFilterIndexDoubleEval( string indexName, ExprNode indexExpression, IDictionary <string, Pair <EventType, string> > arrayEventTypes, string statementName, ExprEvaluatorContext exprEvaluatorContext) { FilterSpecParamFilterForEvalDouble resolved = null; if (indexExpression is ExprIdentNode) { resolved = GetIdentNodeDoubleEval((ExprIdentNode)indexExpression, arrayEventTypes, statementName); } else if (indexExpression is ExprContextPropertyNode) { var node = (ExprContextPropertyNode)indexExpression; resolved = new FilterForEvalContextPropDouble(node.Getter, node.PropertyName); } else if (ExprNodeUtility.IsConstantValueExpr(indexExpression)) { var constantNode = (ExprConstantNode)indexExpression; var d = constantNode.GetConstantValue(exprEvaluatorContext).AsDouble(); resolved = new FilterForEvalConstantDouble(d); } if (resolved != null) { return(resolved); } throw new ExprValidationException("Invalid filter-indexable expression '" + indexExpression.ToExpressionStringMinPrecedenceSafe() + "' in respect to index '" + indexName + "': expected either a constant, context-builtin or property from a previous pattern match"); }