public static void ValidatePlainExpression(
ExprNodeOrigin origin,
ExprNode expression)
{
ExprNodeSummaryVisitor summaryVisitor = new ExprNodeSummaryVisitor();
ValidatePlainExpression(origin, expression, summaryVisitor);
}
public static void ValidatePlainExpression(
ExprNodeOrigin origin,
ExprNode[] expressions)
{
ExprNodeSummaryVisitor summaryVisitor = new ExprNodeSummaryVisitor();
foreach (ExprNode expression in expressions) {
ValidatePlainExpression(origin, expression, summaryVisitor);
}
}
public static void ValidateNoProperties(string viewName, ExprNode expression, int index)
{
var visitor = new ExprNodeSummaryVisitor();
expression.Accept(visitor);
if (!visitor.IsPlain)
{
string message = "Invalid view parameter expression " + index + GetViewDesc(viewName) + ", " +
visitor.GetMessage() + " are not allowed within the expression";
throw new ViewParameterException(message);
}
}
/// <summary>Assert and throws an exception if the expression uses event property values. </summary>
/// <param name="viewName">textual name of view</param>
/// <param name="expression">expression to check</param>
/// <param name="index">number offset of expression in view parameters</param>
/// <param name="exprEvaluatorContext">context for expression evaluation</param>
/// <returns>expression evaluation value</returns>
/// <throws>ViewParameterException if assertion fails</throws>
public static Object EvaluateAssertNoProperties(String viewName, ExprNode expression, int index, ExprEvaluatorContext exprEvaluatorContext)
{
var visitor = new ExprNodeSummaryVisitor();
expression.Accept(visitor);
if (!visitor.IsPlain)
{
var message = "Invalid view parameter expression " + index + GetViewDesc(viewName) + ", " + visitor.Message + " are not allowed within the expression";
throw new ViewParameterException(message);
}
return(expression.ExprEvaluator.Evaluate(new EvaluateParams(null, false, exprEvaluatorContext)));
}
internal static bool DetermineStatelessSelect(
StatementType type,
StatementSpecRaw spec,
bool hasSubselects)
{
if (hasSubselects) {
return false;
}
if (type != StatementType.SELECT) {
return false;
}
if (spec.StreamSpecs == null || spec.StreamSpecs.Count > 1 || spec.StreamSpecs.IsEmpty()) {
return false;
}
StreamSpecRaw singleStream = spec.StreamSpecs[0];
if (!(singleStream is FilterStreamSpecRaw) && !(singleStream is NamedWindowConsumerStreamSpec)) {
return false;
}
if (singleStream.ViewSpecs != null && singleStream.ViewSpecs.Length > 0) {
return false;
}
if (spec.OutputLimitSpec != null) {
return false;
}
if (spec.MatchRecognizeSpec != null) {
return false;
}
IList<ExprNode> expressions = StatementSpecRawWalkerExpr.CollectExpressionsShallow(spec);
if (expressions.IsEmpty()) {
return true;
}
var visitor = new ExprNodeSummaryVisitor();
foreach (var expr in expressions) {
if (expr == null) {
continue;
}
expr.Accept(visitor);
}
return !visitor.HasAggregation && !visitor.HasPreviousPrior && !visitor.HasSubselect;
}
private static void ValidatePlainExpression(
ExprNodeOrigin origin,
ExprNode expression,
ExprNodeSummaryVisitor summaryVisitor)
{
expression.Accept(summaryVisitor);
if (summaryVisitor.HasAggregation ||
summaryVisitor.HasSubselect ||
summaryVisitor.HasStreamSelect ||
summaryVisitor.HasPreviousPrior) {
string text = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expression);
throw new ExprValidationException(
"Invalid " +
origin.GetClauseName() +
" expression '" +
text +
"': Aggregation, sub-select, previous or prior functions are not supported in this context");
}
}
private static void RecursiveCompile(
EvalFactoryNode evalNode,
StatementContext context,
ExprEvaluatorContext evaluatorContext,
ICollection <string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
Deque <int> subexpressionIdStack,
Stack <EvalFactoryNode> parentNodeStack,
ICollection <string> allTagNamesOrdered)
{
var counter = 0;
parentNodeStack.Push(evalNode);
foreach (var child in evalNode.ChildNodes)
{
subexpressionIdStack.AddLast(counter++);
RecursiveCompile(
child, context, evaluatorContext, eventTypeReferences, isInsertInto, tags, subexpressionIdStack,
parentNodeStack, allTagNamesOrdered);
subexpressionIdStack.RemoveLast();
}
parentNodeStack.Pop();
LinkedHashMap <string, Pair <EventType, string> > newTaggedEventTypes = null;
LinkedHashMap <string, Pair <EventType, string> > newArrayEventTypes = null;
if (evalNode is EvalFilterFactoryNode)
{
var filterNode = (EvalFilterFactoryNode)evalNode;
var eventName = filterNode.RawFilterSpec.EventTypeName;
if (context.TableService.GetTableMetadata(eventName) != null)
{
throw new ExprValidationException("Tables cannot be used in pattern filter atoms");
}
var resolvedEventType = FilterStreamSpecRaw.ResolveType(
context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs);
var finalEventType = resolvedEventType;
var optionalTag = filterNode.EventAsName;
var isPropertyEvaluation = false;
var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack);
// obtain property event type, if final event type is properties
if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null)
{
var optionalPropertyEvaluator =
PropertyEvaluatorFactory.MakeEvaluator(
context.Container,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
resolvedEventType,
filterNode.EventAsName,
context.EventAdapterService,
context.EngineImportService,
context.SchedulingService,
context.VariableService,
context.ScriptingService,
context.TableService,
context.EngineURI,
context.StatementId,
context.StatementName,
context.Annotations,
subexpressionIdStack,
context.ConfigSnapshot,
context.NamedWindowMgmtService,
context.StatementExtensionServicesContext);
finalEventType = optionalPropertyEvaluator.FragmentEventType;
isPropertyEvaluation = true;
}
if (finalEventType is EventTypeSPI)
{
eventTypeReferences.Add(((EventTypeSPI)finalEventType).Metadata.PrimaryName);
}
// If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no
if (optionalTag != null)
{
var pair = tags.TaggedEventTypes.Get(optionalTag);
EventType existingType = null;
if (pair != null)
{
existingType = pair.First;
}
if (existingType == null)
{
pair = tags.ArrayEventTypes.Get(optionalTag);
if (pair != null)
{
throw new ExprValidationException(
"Tag '" + optionalTag + "' for event '" + eventName +
"' used in the repeat-until operator cannot also appear in other filter expressions");
}
}
if ((existingType != null) && (existingType != finalEventType))
{
throw new ExprValidationException(
"Tag '" + optionalTag + "' for event '" + eventName +
"' has already been declared for events of type " + existingType.UnderlyingType.FullName);
}
pair = new Pair <EventType, string>(finalEventType, eventName);
// add tagged type
if (isPropertyEvaluation || isParentMatchUntil)
{
newArrayEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
newArrayEventTypes.Put(optionalTag, pair);
}
else
{
newTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
newTaggedEventTypes.Put(optionalTag, pair);
}
}
// For this filter, filter types are all known tags at this time,
// and additionally stream 0 (self) is our event type.
// Stream type service allows resolution by property name event if that name appears in other tags.
// by defaulting to stream zero.
// Stream zero is always the current event type, all others follow the order of the map (stream 1 to N).
var selfStreamName = optionalTag;
if (selfStreamName == null)
{
selfStreamName = "s_" + UuidGenerator.Generate();
}
var filterTypes = new LinkedHashMap <string, Pair <EventType, string> >();
var typePair = new Pair <EventType, string>(finalEventType, eventName);
filterTypes.Put(selfStreamName, typePair);
filterTypes.PutAll(tags.TaggedEventTypes);
// for the filter, specify all tags used
var filterTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(tags.TaggedEventTypes);
filterTaggedEventTypes.Remove(optionalTag);
// handle array tags (match-until clause)
LinkedHashMap <string, Pair <EventType, string> > arrayCompositeEventTypes = null;
if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty())
{
arrayCompositeEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
var patternSubexEventType = GetPatternSubexEventType(
context.StatementId, "pattern", subexpressionIdStack);
foreach (var entry in tags.ArrayEventTypes)
{
var specificArrayType = new LinkedHashMap <string, Pair <EventType, string> >();
specificArrayType.Put(entry.Key, entry.Value);
var arrayTagCompositeEventType =
context.EventAdapterService.CreateSemiAnonymousMapType(
patternSubexEventType, Collections.GetEmptyMap <string, Pair <EventType, string> >(),
specificArrayType, isInsertInto);
context.StatementSemiAnonymousTypeRegistry.Register(arrayTagCompositeEventType);
var tag = entry.Key;
if (!filterTypes.ContainsKey(tag))
{
var pair = new Pair <EventType, string>(arrayTagCompositeEventType, tag);
filterTypes.Put(tag, pair);
arrayCompositeEventTypes.Put(tag, pair);
}
}
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
filterTypes, context.EngineURI, true, false);
var exprNodes = filterNode.RawFilterSpec.FilterExpressions;
var spec = FilterSpecCompiler.MakeFilterSpec(
resolvedEventType, eventName, exprNodes,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
filterTaggedEventTypes,
arrayCompositeEventTypes,
streamTypeService,
null, context, subexpressionIdStack);
filterNode.FilterSpec = spec;
}
else if (evalNode is EvalObserverFactoryNode)
{
var observerNode = (EvalObserverFactoryNode)evalNode;
try
{
var observerFactory = context.PatternResolutionService.Create(observerNode.PatternObserverSpec);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes,
tags.ArrayEventTypes, subexpressionIdStack, "observer", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters,
validationContext);
MatchedEventConvertor convertor = new MatchedEventConvertorImpl(
tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService);
observerNode.ObserverFactory = observerFactory;
observerFactory.SetObserverParameters(validated, convertor, validationContext);
}
catch (ObserverParameterException e)
{
throw new ExprValidationException(
"Invalid parameter for pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " +
e.Message, e);
}
catch (PatternObjectException e)
{
throw new ExprValidationException(
"Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalGuardFactoryNode)
{
var guardNode = (EvalGuardFactoryNode)evalNode;
try
{
var guardFactory = context.PatternResolutionService.Create(guardNode.PatternGuardSpec);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes,
tags.ArrayEventTypes, subexpressionIdStack, "guard", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext);
MatchedEventConvertor convertor = new MatchedEventConvertorImpl(
tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService);
guardNode.GuardFactory = guardFactory;
guardFactory.SetGuardParameters(validated, convertor);
}
catch (GuardParameterException e)
{
throw new ExprValidationException(
"Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e);
}
catch (PatternObjectException e)
{
throw new ExprValidationException(
"Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e);
}
}
else if (evalNode is EvalEveryDistinctFactoryNode)
{
var distinctNode = (EvalEveryDistinctFactoryNode)evalNode;
var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService,
matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes,
subexpressionIdStack, "every-distinct", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
IList <ExprNode> validated;
try
{
validated = ValidateExpressions(
ExprNodeOrigin.PATTERNEVERYDISTINCT, distinctNode.Expressions, validationContext);
}
catch (ExprValidationPropertyException ex)
{
throw new ExprValidationPropertyException(
ex.Message +
", every-distinct requires that all properties resolve from sub-expressions to the every-distinct",
ex.InnerException);
}
MatchedEventConvertor convertor =
new MatchedEventConvertorImpl(
matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes,
allTagNamesOrdered, context.EventAdapterService);
distinctNode.Convertor = convertor;
// Determine whether some expressions are constants or time period
IList <ExprNode> distinctExpressions = new List <ExprNode>();
ExprTimePeriodEvalDeltaConst timeDeltaComputation = null;
ExprNode expiryTimeExp = null;
var count = -1;
var last = validated.Count - 1;
foreach (var expr in validated)
{
count++;
if (count == last && expr is ExprTimePeriod)
{
expiryTimeExp = expr;
var timePeriodExpr = (ExprTimePeriod)expiryTimeExp;
timeDeltaComputation =
timePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(context, false));
}
else if (expr.IsConstantResult)
{
if (count == last)
{
var evaluateParams = new EvaluateParams(null, true, evaluatorContext);
var value = expr.ExprEvaluator.Evaluate(evaluateParams);
if (!(value.IsNumber()))
{
throw new ExprValidationException(
"Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)");
}
var secondsExpire = expr.ExprEvaluator.Evaluate(evaluateParams);
long?timeExpire;
if (secondsExpire == null)
{
timeExpire = null;
}
else
{
timeExpire = context.TimeAbacus.DeltaForSecondsNumber(secondsExpire);
}
if (timeExpire != null && timeExpire > 0)
{
timeDeltaComputation = new ExprTimePeriodEvalDeltaConstGivenDelta(timeExpire.Value);
expiryTimeExp = expr;
}
else
{
Log.Warn("Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr));
}
}
else
{
Log.Warn(
"Every-distinct node utilizes an expression returning a constant value, please check expression '{0}', not adding expression to distinct-value expression list",
expr.ToExpressionStringMinPrecedenceSafe());
}
}
else
{
distinctExpressions.Add(expr);
}
}
if (distinctExpressions.IsEmpty())
{
throw new ExprValidationException(
"Every-distinct node requires one or more distinct-value expressions that each return non-constant result values");
}
distinctNode.SetDistinctExpressions(distinctExpressions, timeDeltaComputation, expiryTimeExp);
}
else if (evalNode is EvalMatchUntilFactoryNode)
{
var matchUntilNode = (EvalMatchUntilFactoryNode)evalNode;
// compile bounds expressions, if any
var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService,
untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, subexpressionIdStack,
"until", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext);
matchUntilNode.LowerBounds = lower;
var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext);
matchUntilNode.UpperBounds = upper;
var single = ValidateBounds(matchUntilNode.SingleBound, validationContext);
matchUntilNode.SingleBound = single;
var convertor = new MatchedEventConvertorImpl(
untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered,
context.EventAdapterService);
matchUntilNode.Convertor = convertor;
// compile new tag lists
ISet <string> arrayTags = null;
var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]);
foreach (var filterNode in matchUntilAnalysisResult.FilterNodes)
{
var optionalTag = filterNode.EventAsName;
if (optionalTag != null)
{
if (arrayTags == null)
{
arrayTags = new HashSet <string>();
}
arrayTags.Add(optionalTag);
}
}
if (arrayTags != null)
{
foreach (var arrayTag in arrayTags)
{
if (!tags.ArrayEventTypes.ContainsKey(arrayTag))
{
tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag));
tags.TaggedEventTypes.Remove(arrayTag);
}
}
}
matchUntilNode.TagsArrayed = GetIndexesForTags(allTagNamesOrdered, arrayTags);
}
else if (evalNode is EvalFollowedByFactoryNode)
{
var followedByNode = (EvalFollowedByFactoryNode)evalNode;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.EngineURI, false);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService,
evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
if (followedByNode.OptionalMaxExpressions != null)
{
IList <ExprNode> validated = new List <ExprNode>();
foreach (var maxExpr in followedByNode.OptionalMaxExpressions)
{
if (maxExpr == null)
{
validated.Add(null);
}
else
{
var visitor = new ExprNodeSummaryVisitor();
maxExpr.Accept(visitor);
if (!visitor.IsPlain)
{
var errorMessage = "Invalid maximum expression in followed-by, " + visitor.GetMessage() +
" are not allowed within the expression";
Log.Error(errorMessage);
throw new ExprValidationException(errorMessage);
}
var validatedExpr = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext);
validated.Add(validatedExpr);
if ((validatedExpr.ExprEvaluator.ReturnType == null) ||
(!validatedExpr.ExprEvaluator.ReturnType.IsNumeric()))
{
var message = "Invalid maximum expression in followed-by, the expression must return an integer value";
throw new ExprValidationException(message);
}
}
}
followedByNode.OptionalMaxExpressions = validated;
}
}
if (newTaggedEventTypes != null)
{
tags.TaggedEventTypes.PutAll(newTaggedEventTypes);
}
if (newArrayEventTypes != null)
{
tags.ArrayEventTypes.PutAll(newArrayEventTypes);
}
}
private static void RecursiveCompile(
EvalForgeNode evalNode,
ISet<string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
Stack<EvalForgeNode> parentNodeStack,
ISet<string> allTagNamesOrdered,
int streamNum,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
parentNodeStack.Push(evalNode);
foreach (var child in evalNode.ChildNodes) {
RecursiveCompile(
child,
eventTypeReferences,
isInsertInto,
tags,
parentNodeStack,
allTagNamesOrdered,
streamNum,
statementRawInfo,
services);
}
parentNodeStack.Pop();
IDictionary<string, Pair<EventType, string>> newTaggedEventTypes = null;
IDictionary<string, Pair<EventType, string>> newArrayEventTypes = null;
if (evalNode is EvalFilterForgeNode) {
var filterNode = (EvalFilterForgeNode) evalNode;
var eventName = filterNode.RawFilterSpec.EventTypeName;
if (services.TableCompileTimeResolver.Resolve(eventName) != null) {
throw new ExprValidationException("Tables cannot be used in pattern filter atoms");
}
var resolvedEventType = ResolveTypeName(eventName, services.EventTypeCompileTimeResolver);
var finalEventType = resolvedEventType;
var optionalTag = filterNode.EventAsName;
var isPropertyEvaluation = false;
var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack);
// obtain property event type, if final event type is properties
if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) {
var optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator(
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
resolvedEventType,
filterNode.EventAsName,
statementRawInfo,
services);
finalEventType = optionalPropertyEvaluator.FragmentEventType;
isPropertyEvaluation = true;
}
// If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no
if (optionalTag != null) {
var pair = tags.TaggedEventTypes.Get(optionalTag);
EventType existingType = null;
if (pair != null) {
existingType = pair.First;
}
if (existingType == null) {
pair = tags.ArrayEventTypes.Get(optionalTag);
if (pair != null) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' used in the repeat-until operator cannot also appear in other filter expressions");
}
}
if (existingType != null && existingType != finalEventType) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' has already been declared for events of type " +
existingType.UnderlyingType.Name);
}
pair = new Pair<EventType, string>(finalEventType, eventName);
// add tagged type
if (isPropertyEvaluation || isParentMatchUntil) {
newArrayEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newArrayEventTypes.Put(optionalTag, pair);
}
else {
newTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newTaggedEventTypes.Put(optionalTag, pair);
}
}
// For this filter, filter types are all known tags at this time,
// and additionally stream 0 (self) is our event type.
// Stream type service allows resolution by property name event if that name appears in other tags.
// by defaulting to stream zero.
// Stream zero is always the current event type, all others follow the order of the map (stream 1 to N).
var selfStreamName = optionalTag;
if (selfStreamName == null) {
selfStreamName = "s_" + UuidGenerator.Generate();
}
var filterTypes = new LinkedHashMap<string, Pair<EventType, string>>();
var typePair = new Pair<EventType, string>(finalEventType, eventName);
filterTypes.Put(selfStreamName, typePair);
filterTypes.PutAll(tags.TaggedEventTypes);
// for the filter, specify all tags used
var filterTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(tags.TaggedEventTypes);
filterTaggedEventTypes.Remove(optionalTag);
// handle array tags (match-until clause)
IDictionary<string, Pair<EventType, string>> arrayCompositeEventTypes = null;
if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) {
arrayCompositeEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
foreach (var entry in tags.ArrayEventTypes) {
var specificArrayType = new LinkedHashMap<string, Pair<EventType, string>>();
specificArrayType.Put(entry.Key, entry.Value);
var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousPatternNameWTag(
streamNum,
evalNode.FactoryNodeId,
entry.Key);
var mapProps = GetMapProperties(
Collections.GetEmptyMap<string, Pair<EventType, string>>(),
specificArrayType);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.PATTERNDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var mapEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
mapProps,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(mapEventType);
var tag = entry.Key;
if (!filterTypes.ContainsKey(tag)) {
var pair = new Pair<EventType, string>(mapEventType, tag);
filterTypes.Put(tag, pair);
arrayCompositeEventTypes.Put(tag, pair);
}
}
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(filterTypes, true, false);
var exprNodes = filterNode.RawFilterSpec.FilterExpressions;
var spec = FilterSpecCompiler.MakeFilterSpec(
resolvedEventType,
eventName,
exprNodes,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
filterTaggedEventTypes,
arrayCompositeEventTypes,
streamTypeService,
null,
statementRawInfo,
services);
filterNode.FilterSpec = spec;
}
else if (evalNode is EvalObserverForgeNode) {
var observerNode = (EvalObserverForgeNode) evalNode;
try {
var observerForge =
services.PatternResolutionService.Create(observerNode.PatternObserverSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
observerNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNOBSERVER,
observerNode.PatternObserverSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
observerNode.ObserverFactory = observerForge;
observerForge.SetObserverParameters(validated, convertor, validationContext);
}
catch (ObserverParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern observer '" +
observerNode.ToPrecedenceFreeEPL() +
"': " +
e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalGuardForgeNode) {
var guardNode = (EvalGuardForgeNode) evalNode;
try {
var guardForge = services.PatternResolutionService.Create(guardNode.PatternGuardSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
guardNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNGUARD,
guardNode.PatternGuardSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
guardNode.GuardForge = guardForge;
guardForge.SetGuardParameters(validated, convertor, services);
}
catch (GuardParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalEveryDistinctForgeNode) {
var distinctNode = (EvalEveryDistinctForgeNode) evalNode;
var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode);
var streamTypeService = GetStreamTypeService(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
distinctNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
IList<ExprNode> validated;
try {
validated = ValidateExpressions(
ExprNodeOrigin.PATTERNEVERYDISTINCT,
distinctNode.Expressions,
validationContext);
}
catch (ExprValidationPropertyException ex) {
throw new ExprValidationPropertyException(
ex.Message +
", every-distinct requires that all properties resolve from sub-expressions to the every-distinct",
ex.InnerException);
}
var convertor = new MatchedEventConvertorForge(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
allTagNamesOrdered);
distinctNode.Convertor = convertor;
// Determine whether some expressions are constants or time period
IList<ExprNode> distinctExpressions = new List<ExprNode>();
TimePeriodComputeForge timePeriodComputeForge = null;
ExprNode expiryTimeExp = null;
var count = -1;
var last = validated.Count - 1;
foreach (var expr in validated) {
count++;
if (count == last && expr is ExprTimePeriod) {
expiryTimeExp = expr;
var timePeriodExpr = (ExprTimePeriod) expiryTimeExp;
timePeriodComputeForge = timePeriodExpr.TimePeriodComputeForge;
}
else if (expr.Forge.ForgeConstantType.IsCompileTimeConstant) {
if (count == last) {
var value = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
if (!value.IsNumber()) {
throw new ExprValidationException(
"Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)");
}
var secondsExpire = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
var timeExpire = secondsExpire == null
? (long?) null
: (long?) services.ImportServiceCompileTime.TimeAbacus.DeltaForSecondsNumber(
secondsExpire);
if (timeExpire != null && timeExpire > 0) {
timePeriodComputeForge = new TimePeriodComputeConstGivenDeltaForge(timeExpire.Value);
expiryTimeExp = expr;
}
else {
Log.Warn(
"Invalid seconds-expire " +
timeExpire +
" for " +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr));
}
}
else {
Log.Warn(
"Every-distinct node utilizes an expression returning a constant value, please check expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr) +
"', not adding expression to distinct-value expression list");
}
}
else {
distinctExpressions.Add(expr);
}
}
if (distinctExpressions.IsEmpty()) {
throw new ExprValidationException(
"Every-distinct node requires one or more distinct-value expressions that each return non-constant result values");
}
distinctNode.SetDistinctExpressions(distinctExpressions, timePeriodComputeForge, expiryTimeExp);
}
else if (evalNode is EvalMatchUntilForgeNode) {
var matchUntilNode = (EvalMatchUntilForgeNode) evalNode;
// compile bounds expressions, if any
var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes);
var streamTypeService = GetStreamTypeService(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
matchUntilNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext);
matchUntilNode.LowerBounds = lower;
var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext);
matchUntilNode.UpperBounds = upper;
var single = ValidateBounds(matchUntilNode.SingleBound, validationContext);
matchUntilNode.SingleBound = single;
bool tightlyBound;
if (matchUntilNode.SingleBound != null) {
ValidateMatchUntil(matchUntilNode.SingleBound, matchUntilNode.SingleBound, false);
tightlyBound = true;
}
else {
var allowZeroLowerBounds = matchUntilNode.LowerBounds != null && matchUntilNode.UpperBounds != null;
tightlyBound = ValidateMatchUntil(
matchUntilNode.LowerBounds,
matchUntilNode.UpperBounds,
allowZeroLowerBounds);
}
if (matchUntilNode.SingleBound == null && !tightlyBound && matchUntilNode.ChildNodes.Count < 2) {
throw new ExprValidationException("Variable bounds repeat operator requires an until-expression");
}
var convertor = new MatchedEventConvertorForge(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
allTagNamesOrdered);
matchUntilNode.Convertor = convertor;
// compile new tag lists
ISet<string> arrayTags = null;
var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]);
foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) {
var optionalTag = filterNode.EventAsName;
if (optionalTag != null) {
if (arrayTags == null) {
arrayTags = new HashSet<string>();
}
arrayTags.Add(optionalTag);
}
}
if (arrayTags != null) {
foreach (var arrayTag in arrayTags) {
if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) {
tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag));
tags.TaggedEventTypes.Remove(arrayTag);
}
}
}
matchUntilNode.TagsArrayedSet = GetIndexesForTags(allTagNamesOrdered, arrayTags);
}
else if (evalNode is EvalFollowedByForgeNode) {
var followedByNode = (EvalFollowedByForgeNode) evalNode;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(false);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
if (followedByNode.OptionalMaxExpressions != null) {
IList<ExprNode> validated = new List<ExprNode>();
foreach (var maxExpr in followedByNode.OptionalMaxExpressions) {
if (maxExpr == null) {
validated.Add(null);
}
else {
var visitor = new ExprNodeSummaryVisitor();
maxExpr.Accept(visitor);
if (!visitor.IsPlain) {
var errorMessage = "Invalid maximum expression in followed-by, " +
visitor.Message +
" are not allowed within the expression";
Log.Error(errorMessage);
throw new ExprValidationException(errorMessage);
}
var validatedExpr = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FOLLOWEDBYMAX,
maxExpr,
validationContext);
validated.Add(validatedExpr);
var returnType = validatedExpr.Forge.EvaluationType;
if (returnType == null || !returnType.IsNumeric()) {
var message =
"Invalid maximum expression in followed-by, the expression must return an integer value";
throw new ExprValidationException(message);
}
}
}
followedByNode.OptionalMaxExpressions = validated;
}
}
if (newTaggedEventTypes != null) {
tags.TaggedEventTypes.PutAll(newTaggedEventTypes);
}
if (newArrayEventTypes != null) {
tags.ArrayEventTypes.PutAll(newArrayEventTypes);
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (_prototype.IsAlias)
{
try
{
_expressionBodyCopy = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.ALIASEXPRBODY, _expressionBodyCopy, validationContext);
}
catch (ExprValidationException ex)
{
var message = "Error validating expression alias '" + _prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
_exprEvaluator = _expressionBodyCopy.ExprEvaluator;
return(null);
}
if (_exprEvaluator != null)
{
return(null); // already evaluated
}
if (ChildNodes.Length > 0)
{
throw new IllegalStateException("Execution node has its own child nodes");
}
// validate chain
var validated = _chainParameters
.Select(expr => ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DECLAREDEXPRPARAM, expr, validationContext))
.ToList();
_chainParameters = validated;
// validate parameter count
CheckParameterCount();
// create context for expression body
var eventTypes = new EventType[_prototype.ParametersNames.Count];
var streamNames = new String[_prototype.ParametersNames.Count];
var isIStreamOnly = new bool[_prototype.ParametersNames.Count];
var streamsIdsPerStream = new int[_prototype.ParametersNames.Count];
var allStreamIdsMatch = true;
for (var i = 0; i < _prototype.ParametersNames.Count; i++)
{
var parameter = _chainParameters[i];
streamNames[i] = _prototype.ParametersNames[i];
if (parameter is ExprStreamUnderlyingNode)
{
var und = (ExprStreamUnderlyingNode)parameter;
eventTypes[i] = validationContext.StreamTypeService.EventTypes[und.StreamId];
isIStreamOnly[i] = validationContext.StreamTypeService.IsIStreamOnly[und.StreamId];
streamsIdsPerStream[i] = und.StreamId;
}
else if (parameter is ExprWildcard)
{
if (validationContext.StreamTypeService.EventTypes.Length != 1)
{
throw new ExprValidationException("Expression '" + _prototype.Name + "' only allows a wildcard parameter if there is a single stream available, please use a stream or tag name instead");
}
eventTypes[i] = validationContext.StreamTypeService.EventTypes[0];
isIStreamOnly[i] = validationContext.StreamTypeService.IsIStreamOnly[0];
streamsIdsPerStream[i] = 0;
}
else
{
throw new ExprValidationException("Expression '" + _prototype.Name + "' requires a stream name as a parameter");
}
if (streamsIdsPerStream[i] != i)
{
allStreamIdsMatch = false;
}
}
var streamTypeService = validationContext.StreamTypeService;
var copyTypes = new StreamTypeServiceImpl(eventTypes, streamNames, isIStreamOnly, streamTypeService.EngineURIQualifier, streamTypeService.IsOnDemandStreams);
copyTypes.RequireStreamNames = true;
// validate expression body in this context
try {
var expressionBodyContext = new ExprValidationContext(copyTypes, validationContext);
_expressionBodyCopy = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DECLAREDEXPRBODY, _expressionBodyCopy, expressionBodyContext);
}
catch (ExprValidationException ex) {
var message = "Error validating expression declaration '" + _prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
// analyze child node
var summaryVisitor = new ExprNodeSummaryVisitor();
_expressionBodyCopy.Accept(summaryVisitor);
var isCache = !(summaryVisitor.HasAggregation || summaryVisitor.HasPreviousPrior);
// determine a suitable evaluation
if (_expressionBodyCopy.IsConstantResult)
{
// pre-evaluated
_exprEvaluator = new ExprDeclaredEvalConstant(
_expressionBodyCopy.ExprEvaluator.ReturnType, _prototype,
_expressionBodyCopy.ExprEvaluator.Evaluate(new EvaluateParams(null, true, null)));
}
else if (_prototype.ParametersNames.IsEmpty() ||
(allStreamIdsMatch && _prototype.ParametersNames.Count == streamTypeService.EventTypes.Length))
{
_exprEvaluator = new ExprDeclaredEvalNoRewrite(_expressionBodyCopy.ExprEvaluator, _prototype, isCache);
}
else
{
_exprEvaluator = new ExprDeclaredEvalRewrite(_expressionBodyCopy.ExprEvaluator, _prototype, isCache, streamsIdsPerStream);
}
var audit = AuditEnum.EXPRDEF.GetAudit(validationContext.Annotations);
if (audit != null)
{
_exprEvaluator = (ExprEvaluator)ExprEvaluatorProxy.NewInstance(validationContext.StreamTypeService.EngineURIQualifier, validationContext.StatementName, _prototype.Name, _exprEvaluator);
}
return(null);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
var prototype = PrototypeWVisibility;
if (prototype.IsAlias) {
try {
ExpressionBodyCopy = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.ALIASEXPRBODY,
ExpressionBodyCopy,
validationContext);
}
catch (ExprValidationException ex) {
var message = "Error validating expression alias '" + prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
forge = ExpressionBodyCopy.Forge;
return null;
}
if (forge != null) {
return null; // already evaluated
}
if (ChildNodes.Length > 0) {
throw new IllegalStateException("Execution node has its own child nodes");
}
// validate chain
IList<ExprNode> validated = new List<ExprNode>();
foreach (var expr in ChainParameters) {
validated.Add(
ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DECLAREDEXPRPARAM,
expr,
validationContext));
}
ChainParameters = validated;
// validate parameter count
CheckParameterCount();
// create context for expression body
var eventTypes = new EventType[prototype.ParametersNames.Length];
var streamNames = new string[prototype.ParametersNames.Length];
var isIStreamOnly = new bool[prototype.ParametersNames.Length];
var streamsIdsPerStream = new int[prototype.ParametersNames.Length];
var allStreamIdsMatch = true;
for (var i = 0; i < prototype.ParametersNames.Length; i++) {
var parameter = ChainParameters[i];
streamNames[i] = prototype.ParametersNames[i];
if (parameter is ExprStreamUnderlyingNode) {
var und = (ExprStreamUnderlyingNode) parameter;
eventTypes[i] = validationContext.StreamTypeService.EventTypes[und.StreamId];
isIStreamOnly[i] = validationContext.StreamTypeService.IStreamOnly[und.StreamId];
streamsIdsPerStream[i] = und.StreamId;
}
else if (parameter is ExprWildcard) {
if (validationContext.StreamTypeService.EventTypes.Length != 1) {
throw new ExprValidationException(
"Expression '" +
prototype.Name +
"' only allows a wildcard parameter if there is a single stream available, please use a stream or tag name instead");
}
eventTypes[i] = validationContext.StreamTypeService.EventTypes[0];
isIStreamOnly[i] = validationContext.StreamTypeService.IStreamOnly[0];
streamsIdsPerStream[i] = 0;
}
else {
throw new ExprValidationException(
"Expression '" + prototype.Name + "' requires a stream name as a parameter");
}
if (streamsIdsPerStream[i] != i) {
allStreamIdsMatch = false;
}
}
var streamTypeService = validationContext.StreamTypeService;
var copyTypes = new StreamTypeServiceImpl(
eventTypes,
streamNames,
isIStreamOnly,
streamTypeService.IsOnDemandStreams,
streamTypeService.IsOptionalStreams);
copyTypes.RequireStreamNames = true;
// validate expression body in this context
try {
var expressionBodyContext = new ExprValidationContext(copyTypes, validationContext);
ExpressionBodyCopy = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DECLAREDEXPRBODY,
ExpressionBodyCopy,
expressionBodyContext);
}
catch (ExprValidationException ex) {
var message = "Error validating expression declaration '" + prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
// analyze child node
var summaryVisitor = new ExprNodeSummaryVisitor();
ExpressionBodyCopy.Accept(summaryVisitor);
var isCache = !(summaryVisitor.HasAggregation || summaryVisitor.HasPreviousPrior);
isCache &= validationContext.StatementCompileTimeService.Configuration.Compiler.Execution
.IsEnabledDeclaredExprValueCache;
// determine a suitable evaluation
var audit = AuditEnum.EXPRDEF.GetAudit(validationContext.Annotations) != null;
var statementName = validationContext.StatementName;
if (ExpressionBodyCopy.Forge.ForgeConstantType.IsConstant) {
// pre-evaluated
forge = new ExprDeclaredForgeConstant(
this,
ExpressionBodyCopy.Forge.EvaluationType,
prototype,
ExpressionBodyCopy.Forge.ExprEvaluator.Evaluate(null, true, null),
audit,
statementName);
}
else if (prototype.ParametersNames.Length == 0 ||
allStreamIdsMatch && prototype.ParametersNames.Length == streamTypeService.EventTypes.Length) {
forge = new ExprDeclaredForgeNoRewrite(this, ExpressionBodyCopy.Forge, isCache, audit, statementName);
}
else {
forge = new ExprDeclaredForgeRewrite(
this,
ExpressionBodyCopy.Forge,
isCache,
streamsIdsPerStream,
audit,
statementName);
}
return null;
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
_eventType = parentEventType;
// define built-in fields
var builtinTypeDef = ExpressionViewOAFieldEnumExtensions.AsMapOfTypes(_eventType);
_builtinMapType = statementContext.EventAdapterService.CreateAnonymousObjectArrayType(
statementContext.StatementId + "_exprview", builtinTypeDef);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(new EventType[] { _eventType, _builtinMapType }, new String[2], new bool[2], statementContext.EngineURI, false);
// validate expression
ExpiryExpression = ViewFactorySupport.ValidateExpr(ViewName, statementContext, ExpiryExpression, streamTypeService, 0);
var summaryVisitor = new ExprNodeSummaryVisitor();
ExpiryExpression.Accept(summaryVisitor);
if (summaryVisitor.HasSubselect || summaryVisitor.HasStreamSelect || summaryVisitor.HasPreviousPrior)
{
throw new ViewParameterException("Invalid expiry expression: Sub-select, previous or prior functions are not supported in this context");
}
var returnType = ExpiryExpression.ExprEvaluator.ReturnType;
if (returnType.GetBoxedType() != typeof(bool?))
{
throw new ViewParameterException("Invalid return value for expiry expression, expected a bool return value but received " + returnType.GetParameterAsString());
}
// determine variables used, if any
var visitor = new ExprNodeVariableVisitor();
ExpiryExpression.Accept(visitor);
VariableNames = visitor.VariableNames;
// determine aggregation nodes, if any
var aggregateNodes = new List <ExprAggregateNode>();
ExprAggregateNodeUtil.GetAggregatesBottomUp(ExpiryExpression, aggregateNodes);
if (aggregateNodes.IsNotEmpty())
{
try {
AggregationServiceFactoryDesc = AggregationServiceFactoryFactory.GetService(
Collections.GetEmptyList <ExprAggregateNode>(),
Collections.GetEmptyMap <ExprNode, String>(),
Collections.GetEmptyList <ExprDeclaredNode>(),
null, aggregateNodes,
Collections.GetEmptyList <ExprAggregateNode>(),
Collections.GetEmptyList <ExprAggregateNodeGroupKey>(), false,
statementContext.Annotations,
statementContext.VariableService, false, false, null, null,
AggregationServiceFactoryServiceImpl.DEFAULT_FACTORY,
streamTypeService.EventTypes,
statementContext.MethodResolutionService, null,
statementContext.ContextName,
null, null);
}
catch (ExprValidationException ex) {
throw new ViewParameterException(ex.Message, ex);
}
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
this.exprValidationContext = validationContext;
var prototype = PrototypeWVisibility;
if (prototype.IsAlias) {
if (!ChainParameters.IsEmpty()) {
throw new ExprValidationException("Expression '" + prototype.Name + " is an expression-alias and does not allow parameters");
}
try {
ExpressionBodyCopy = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.ALIASEXPRBODY,
ExpressionBodyCopy,
validationContext);
}
catch (ExprValidationException ex) {
var message = "Failed to validate expression alias '" + prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
forge = ExpressionBodyCopy.Forge;
return null;
}
if (forge != null) {
return null; // already evaluated
}
if (ChildNodes.Length > 0) {
throw new IllegalStateException("Execution node has its own child nodes");
}
// validate chain
IList<ExprNode> validated = new List<ExprNode>();
foreach (var expr in ChainParameters) {
validated.Add(
ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DECLAREDEXPRPARAM,
expr,
validationContext));
}
ChainParameters = validated;
// validate parameter count
CheckParameterCount();
// collect event and value (non-event) parameters
List<int> valueParameters = new List<int>();
List<int> eventParameters = new List<int>();
for (int i = 0; i < prototype.ParametersNames.Length; i++) {
ExprNode parameter = ChainParameters[i];
if (parameter is ExprWildcard) {
if (validationContext.StreamTypeService.EventTypes.Length != 1) {
throw new ExprValidationException("Expression '" + prototype.Name + "' only allows a wildcard parameter if there is a single stream available, please use a stream or tag name instead");
}
}
if (IsEventProviding(parameter, validationContext)) {
eventParameters.Add(i);
} else {
valueParameters.Add(i);
}
}
// determine value event type for holding non-event parameter values, if any
ObjectArrayEventType valueEventType = null;
List<ExprNode> valueExpressions = new List<ExprNode>(valueParameters.Count);
if (!valueParameters.IsEmpty()) {
var valuePropertyTypes = new LinkedHashMap<string, object>();
foreach (int index in valueParameters) {
String name = prototype.ParametersNames[index];
ExprNode expr = ChainParameters[index];
var result = Boxing.GetBoxedType(expr.Forge.EvaluationType);
valuePropertyTypes.Put(name, result);
valueExpressions.Add(expr);
}
valueEventType = ExprDotNodeUtility.MakeTransientOAType(
PrototypeWVisibility.Name,
valuePropertyTypes,
validationContext.StatementRawInfo,
validationContext.StatementCompileTimeService);
}
// create context for expression body
int numEventTypes = eventParameters.Count + (valueEventType == null ? 0 : 1);
EventType[] eventTypes = new EventType[numEventTypes];
String[] streamNames = new String[numEventTypes];
bool[] isIStreamOnly = new bool[numEventTypes];
ExprEnumerationForge[] eventEnumerationForges = new ExprEnumerationForge[numEventTypes];
allStreamIdsMatch = true;
int offsetEventType = 0;
if (valueEventType != null) {
offsetEventType = 1;
eventTypes[0] = valueEventType;
streamNames[0] = INTERNAL_VALUE_STREAMNAME;
isIStreamOnly[0] = true;
allStreamIdsMatch = false;
}
bool forceOptionalStream = false;
foreach (int index in eventParameters) {
ExprNode parameter = ChainParameters[index];
streamNames[offsetEventType] = prototype.ParametersNames[index];
int streamId;
bool istreamOnlyFlag;
ExprEnumerationForge forge;
if (parameter is ExprEnumerationForgeProvider) {
ExprEnumerationForgeProvider enumerationForgeProvider = (ExprEnumerationForgeProvider) parameter;
ExprEnumerationForgeDesc desc = enumerationForgeProvider.GetEnumerationForge(
validationContext.StreamTypeService, validationContext.ContextDescriptor);
forge = desc.Forge;
streamId = desc.DirectIndexStreamNumber;
istreamOnlyFlag = desc.IsIstreamOnly;
} else {
forge = (ExprEnumerationForge) parameter.Forge;
istreamOnlyFlag = false;
streamId = -1;
forceOptionalStream = true; // since they may return null, i.e. subquery returning no row or multiple rows etc.
}
isIStreamOnly[offsetEventType] = istreamOnlyFlag;
eventEnumerationForges[offsetEventType] = forge;
eventTypes[offsetEventType] = forge.GetEventTypeSingle(validationContext.StatementRawInfo, validationContext.StatementCompileTimeService);
if (streamId != index) {
allStreamIdsMatch = false;
}
offsetEventType++;
}
var streamTypeService = validationContext.StreamTypeService;
var optionalStream = forceOptionalStream || streamTypeService.IsOptionalStreams;
var copyTypes = new StreamTypeServiceImpl(
eventTypes,
streamNames,
isIStreamOnly,
streamTypeService.IsOnDemandStreams,
optionalStream);
copyTypes.RequireStreamNames = true;
// validate expression body in this context
try {
var expressionBodyContext = new ExprValidationContext(copyTypes, validationContext);
ExpressionBodyCopy = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DECLAREDEXPRBODY,
ExpressionBodyCopy,
expressionBodyContext);
}
catch (ExprValidationException ex) {
var message = "Failed to validate expression declaration '" + prototype.Name + "': " + ex.Message;
throw new ExprValidationException(message, ex);
}
// analyze child node
var summaryVisitor = new ExprNodeSummaryVisitor();
ExpressionBodyCopy.Accept(summaryVisitor);
var isCache = !(summaryVisitor.HasAggregation || summaryVisitor.HasPreviousPrior);
isCache &= validationContext.StatementCompileTimeService.Configuration.Compiler.Execution
.IsEnabledDeclaredExprValueCache;
// determine a suitable evaluation
var audit = AuditEnum.EXPRDEF.GetAudit(validationContext.Annotations) != null;
var statementName = validationContext.StatementName;
if (ExpressionBodyCopy.Forge.ForgeConstantType.IsConstant) {
// pre-evaluated
forge = new ExprDeclaredForgeConstant(
this,
ExpressionBodyCopy.Forge.EvaluationType,
prototype,
ExpressionBodyCopy.Forge.ExprEvaluator.Evaluate(null, true, null),
audit,
statementName);
}
else if (valueEventType == null &&
prototype.ParametersNames.Length == 0 ||
allStreamIdsMatch && prototype.ParametersNames.Length == streamTypeService.EventTypes.Length) {
forge = new ExprDeclaredForgeNoRewrite(
this, ExpressionBodyCopy.Forge, isCache, audit, statementName);
}
else if (valueEventType == null) {
forge = new ExprDeclaredForgeRewrite(
this, ExpressionBodyCopy.Forge, isCache, eventEnumerationForges, audit, statementName);
}
else {
// cache is always false
forge = new ExprDeclaredForgeRewriteWValue(
this, ExpressionBodyCopy.Forge, false, audit, statementName, eventEnumerationForges, valueEventType, valueExpressions);
}
return null;
}