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");
}
