/// <summary>
/// Constructor.
/// </summary>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="timeWindowViewFactory">for copying the view in a group-by</param>
/// <param name="timeDeltaComputation">is the computation of number of milliseconds before events gets pushedout of the timeWindow as oldData in the Update method.</param>
/// <param name="viewUpdatedCollection">is a collection the view must Update when receiving events</param>
public TimeWindowView(
AgentInstanceViewFactoryChainContext agentInstanceContext,
TimeWindowViewFactory timeWindowViewFactory,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
ViewUpdatedCollection viewUpdatedCollection)
{
_agentInstanceContext = agentInstanceContext;
_timeWindowViewFactory = timeWindowViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_viewUpdatedCollection = viewUpdatedCollection;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
_timeWindow = new TimeWindow(agentInstanceContext.IsRemoveStream);
ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
{
ProcScheduledTrigger = extensionServicesContext => Instrument.With(
i => i.QViewScheduledEval(this, timeWindowViewFactory.ViewName),
i => i.AViewScheduledEval(),
Expire)
};
_handle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, callback);
if (agentInstanceContext.StatementContext.ScheduleAdjustmentService != null)
{
agentInstanceContext.StatementContext.ScheduleAdjustmentService.AddCallback(this);
}
agentInstanceContext.AddTerminationCallback(Stop);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="timeBatchViewFactory">for copying this view in a group-by</param>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="timeDeltaComputation">computes the number of milliseconds to batch events for</param>
/// <param name="referencePoint">is the reference point onto which to base intervals, or null ifthere is no such reference point supplied</param>
/// <param name="forceOutput">is true if the batch should produce empty output if there is no value to output following time intervals</param>
/// <param name="isStartEager">is true for start-eager</param>
/// <param name="viewUpdatedCollection">is a collection that the view must Update when receiving events</param>
public TimeBatchView(TimeBatchViewFactory timeBatchViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
long?referencePoint,
bool forceOutput,
bool isStartEager,
ViewUpdatedCollection viewUpdatedCollection)
{
_agentInstanceContext = agentInstanceContext;
_timeBatchViewFactory = timeBatchViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_initialReferencePoint = referencePoint;
_isStartEager = isStartEager;
_viewUpdatedCollection = viewUpdatedCollection;
_isForceOutput = forceOutput;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
// schedule the first callback
if (isStartEager)
{
if (_currentReferencePoint == null)
{
_currentReferencePoint = agentInstanceContext.StatementContext.SchedulingService.Time;
}
ScheduleCallback();
_isCallbackScheduled = true;
}
agentInstanceContext.AddTerminationCallback(Stop);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="timeBatchViewFactory">for copying this view in a group-by</param>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="timeDeltaComputation">The time delta computation.</param>
public TimeAccumViewRStream(
TimeAccumViewFactory timeBatchViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
ExprTimePeriodEvalDeltaConst timeDeltaComputation)
{
_agentInstanceContext = agentInstanceContext;
_factory = timeBatchViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
{
ProcScheduledTrigger = extensionServicesContext =>
{
using (Instrument.With(
i => i.QViewScheduledEval(this, _factory.ViewName),
i => i.AViewScheduledEval()))
{
SendRemoveStream();
}
}
};
_handle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, callback);
agentInstanceContext.AddTerminationCallback(Stop);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="timeBatchViewFactory">for copying this view in a group-by</param>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="timeDeltaComputation">is the number of milliseconds to batch events for</param>
/// <param name="numberOfEvents">is the event count before the batch fires off</param>
/// <param name="forceOutput">is true if the batch should produce empty output if there is no value to output following time intervals</param>
/// <param name="isStartEager">is true for start-eager</param>
/// <param name="viewUpdatedCollection">is a collection that the view must Update when receiving events</param>
public TimeLengthBatchView(
TimeLengthBatchViewFactory timeBatchViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
long numberOfEvents,
bool forceOutput,
bool isStartEager,
ViewUpdatedCollection viewUpdatedCollection)
{
_agentInstanceContext = agentInstanceContext;
_timeLengthBatchViewFactory = timeBatchViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_numberOfEvents = numberOfEvents;
_isStartEager = isStartEager;
_viewUpdatedCollection = viewUpdatedCollection;
_isForceOutput = forceOutput;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
// schedule the first callback
if (isStartEager)
{
ScheduleCallback(0);
}
agentInstanceContext.AddTerminationCallback(Stop);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="viewUpdatedCollection">is a collection that the view must update when receiving events</param>
/// <param name="timeBatchViewFactory">fr copying this view in a group-by</param>
/// <param name="agentInstanceContext">is required view services</param>
/// <param name="timeDeltaComputation">delta computation</param>
public TimeAccumView(
TimeAccumViewFactory timeBatchViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
ViewUpdatedCollection viewUpdatedCollection)
{
_agentInstanceContext = agentInstanceContext;
_factory = timeBatchViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_viewUpdatedCollection = viewUpdatedCollection;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
var callback = new ProxyScheduleHandleCallback
{
ProcScheduledTrigger = extensionServicesContext =>
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewScheduledEval(this, _factory.ViewName);
}
SendRemoveStream();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewScheduledEval();
}
}
};
_handle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, callback);
agentInstanceContext.AddTerminationCallback(this);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="viewFactory">for copying this view in a group-by</param>
/// <param name="timestampExpr">the property name of the event supplying timestamp values</param>
/// <param name="timestampEvaluator">The timestamp evaluator.</param>
/// <param name="timeDeltaComputation">The time delta computation.</param>
/// <param name="optionalSortedRandomAccess">is the friend class handling the random access, if required byexpressions</param>
public TimeOrderView(
AgentInstanceViewFactoryChainContext agentInstanceContext,
ViewFactory viewFactory,
ExprNode timestampExpr,
ExprEvaluator timestampEvaluator,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
IStreamSortRankRandomAccess optionalSortedRandomAccess)
{
_agentInstanceContext = agentInstanceContext;
_viewFactory = viewFactory;
_timestampExpression = timestampExpr;
_timestampEvaluator = timestampEvaluator;
_timeDeltaComputation = timeDeltaComputation;
_optionalSortedRandomAccess = optionalSortedRandomAccess;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
_sortedEvents = new OrderedDictionary <Object, Object>();
ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
{
ProcScheduledTrigger = extensionServicesContext => Instrument.With(
i => i.QViewScheduledEval(this, _viewFactory.ViewName),
i => i.AViewScheduledEval(),
Expire)
};
_handle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, callback);
agentInstanceContext.AddTerminationCallback(Stop);
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
String windowName = ViewName;
ExprNode[] validated = ViewFactorySupport.Validate(windowName, parentEventType, statementContext, _viewParameters, true);
if (_viewParameters.Count < 2 || _viewParameters.Count > 3)
{
throw new ViewParameterException(ViewParamMessage);
}
// validate first parameter: timestamp expression
if (!validated[0].ExprEvaluator.ReturnType.IsNumeric())
{
throw new ViewParameterException(ViewParamMessage);
}
TimestampExpression = validated[0];
TimestampExpressionEval = TimestampExpression.ExprEvaluator;
ViewFactorySupport.AssertReturnsNonConstant(windowName, validated[0], 0);
TimeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(ViewName, statementContext, _viewParameters[1], ViewParamMessage, 1);
// validate optional parameters
if (validated.Length == 3)
{
Object constant = ViewFactorySupport.ValidateAndEvaluate(windowName, statementContext, validated[2]);
if ((!constant.IsNumber()) || (TypeHelper.IsFloatingPointNumber(constant)))
{
throw new ViewParameterException("Externally-timed batch view requires a Long-typed reference point in msec as a third parameter");
}
OptionalReferencePoint = constant.AsLong();
}
this._eventType = parentEventType;
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if (expressionParameters.Count != 1)
{
throw new ViewParameterException(ViewParamMessage);
}
_timeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(ViewName, viewFactoryContext.StatementContext, expressionParameters[0], ViewParamMessage, 0);
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
ExprTimePeriodEvalDeltaConst timeDeltaComputation = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceViewFactoryContext.AgentInstanceContext);
ViewUpdatedCollection randomAccess =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRandomAccess(agentInstanceViewFactoryContext);
return new TimeWindowView(agentInstanceViewFactoryContext, this, timeDeltaComputation, randomAccess);
}
public bool EqualsTimePeriod(ExprTimePeriodEvalDeltaConst otherComputation)
{
if (otherComputation is ExprTimePeriodEvalDeltaConstGivenDelta)
{
var other = (ExprTimePeriodEvalDeltaConstGivenDelta)otherComputation;
return(other._timeDelta == _timeDelta);
}
return(false);
}
public void SetDistinctExpressions(
IList<ExprNode> distinctExpressions,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
ExprNode expiryTimeExp)
{
_distinctExpressions = distinctExpressions;
_timeDeltaComputation = timeDeltaComputation;
_expiryTimeExp = expiryTimeExp;
}
public bool EqualsTimePeriod(ExprTimePeriodEvalDeltaConst otherComputation)
{
if (otherComputation is ExprTimePeriodEvalDeltaConstMsec)
{
ExprTimePeriodEvalDeltaConstMsec other = (ExprTimePeriodEvalDeltaConstMsec)otherComputation;
return(other._msec == _msec);
}
return(false);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="timeFirstViewFactory">For copying this view in a group-by</param>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="timeDeltaComputation">The time delta computation.</param>
public FirstTimeView(
FirstTimeViewFactory timeFirstViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
ExprTimePeriodEvalDeltaConst timeDeltaComputation)
{
AgentInstanceContext = agentInstanceContext;
_timeFirstViewFactory = timeFirstViewFactory;
_timeDeltaComputation = timeDeltaComputation;
_scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
ScheduleCallback();
agentInstanceContext.AddTerminationCallback(Stop);
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is FirstTimeView))
{
return false;
}
var myView = (FirstTimeView) view;
ExprTimePeriodEvalDeltaConst delta = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceContext);
if (!delta.EqualsTimePeriod(myView.TimeDeltaComputation))
{
return false;
}
return myView.IsEmpty();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="factory">for copying this view in a group-by</param>
/// <param name="timestampExpression">is the field name containing a long timestamp valuethat should be in ascending order for the natural order of events and is intended to reflect
/// System.currentTimeInMillis but does not necessarily have to.
/// out of the window as oldData in the update method. The view compares
/// each events timestamp against the newest event timestamp and those with a delta
/// greater then secondsBeforeExpiry are pushed out of the window.</param>
/// <param name="timestampExpressionEval">The timestamp expression eval.</param>
/// <param name="timeDeltaComputation">The time delta computation.</param>
/// <param name="optionalReferencePoint">The optional reference point.</param>
/// <param name="viewUpdatedCollection">is a collection that the view must update when receiving events</param>
/// <param name="agentInstanceViewFactoryContext">context for expression evalauation</param>
public ExternallyTimedBatchView(ExternallyTimedBatchViewFactory factory,
ExprNode timestampExpression,
ExprEvaluator timestampExpressionEval,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
long?optionalReferencePoint,
ViewUpdatedCollection viewUpdatedCollection,
AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
_factory = factory;
_timestampExpression = timestampExpression;
_timestampExpressionEval = timestampExpressionEval;
_timeDeltaComputation = timeDeltaComputation;
ViewUpdatedCollection = viewUpdatedCollection;
AgentInstanceViewFactoryContext = agentInstanceViewFactoryContext;
ReferenceTimestamp = optionalReferencePoint;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="externallyTimedWindowViewFactory">for copying this view in a group-by</param>
/// <param name="timestampExpression">is the field name containing a long timestamp valuethat should be in ascending order for the natural order of
/// events and is intended to reflect
/// System.currentTimeInMillis but does not necessarily have to.
/// out of the window as oldData in the update method. The view compares
/// each events timestamp against the newest event timestamp and those with a delta
/// greater then secondsBeforeExpiry are pushed out of the window.</param>
/// <param name="timestampExpressionEval">The timestamp expression eval.</param>
/// <param name="timeDeltaComputation">The time delta computation.</param>
/// <param name="viewUpdatedCollection">is a collection that the view must update when receiving events</param>
/// <param name="agentInstanceViewFactoryContext">context for expression evalauation</param>
public ExternallyTimedWindowView(
ExternallyTimedWindowViewFactory externallyTimedWindowViewFactory,
ExprNode timestampExpression,
ExprEvaluator timestampExpressionEval,
ExprTimePeriodEvalDeltaConst timeDeltaComputation,
ViewUpdatedCollection viewUpdatedCollection,
AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
_externallyTimedWindowViewFactory = externallyTimedWindowViewFactory;
_timestampExpression = timestampExpression;
_timestampExpressionEval = timestampExpressionEval;
_timeDeltaComputation = timeDeltaComputation;
_viewUpdatedCollection = viewUpdatedCollection;
_timeWindow = new TimeWindow(agentInstanceViewFactoryContext.IsRemoveStream);
AgentInstanceViewFactoryContext = agentInstanceViewFactoryContext;
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
ExprTimePeriodEvalDeltaConst timeDeltaComputation = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceViewFactoryContext.AgentInstanceContext);
ViewUpdatedCollection randomAccess =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRandomAccess(agentInstanceViewFactoryContext);
if (agentInstanceViewFactoryContext.IsRemoveStream)
{
return(new TimeAccumViewRStream(this, agentInstanceViewFactoryContext, timeDeltaComputation));
}
else
{
return(new TimeAccumView(this, agentInstanceViewFactoryContext, timeDeltaComputation, randomAccess));
}
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is TimeAccumView))
{
return(false);
}
var myView = (TimeAccumView)view;
ExprTimePeriodEvalDeltaConst timeDeltaComputation = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceContext);
if (!timeDeltaComputation.EqualsTimePeriod(myView.TimeDeltaComputation))
{
return(false);
}
return(myView.IsEmpty);
}
/// <summary>
/// Returns the number of milliseconds.
/// </summary>
/// <returns></returns>
public long GetScheduleBackwardDelta(long fromTime, AgentInstanceContext agentInstanceContext)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QRegIntervalValue(TimePeriodExpr);
}
if (_timeDeltaComputation == null)
{
_timeDeltaComputation = TimePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(agentInstanceContext.StatementContext, false));
}
long result = _timeDeltaComputation.DeltaMillisecondsSubtract(fromTime);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ARegIntervalValue(result);
}
return(result);
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is TimeWindowView))
{
return false;
}
var myView = (TimeWindowView) view;
ExprTimePeriodEvalDeltaConst delta = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceContext);
if (!delta.EqualsTimePeriod(myView.TimeDeltaComputation))
{
return false;
}
// For reuse of the time window it doesn't matter if it provides random access or not
return myView.IsEmpty();
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
ExprNode[] validated = ViewFactorySupport.Validate(ViewName, parentEventType, statementContext, _viewParameters, true);
if (_viewParameters.Count != 2)
{
throw new ViewParameterException(ViewParamMessage);
}
if (!validated[0].ExprEvaluator.ReturnType.IsNumeric())
{
throw new ViewParameterException(ViewParamMessage);
}
TimestampExpression = validated[0];
TimestampExpressionEval = TimestampExpression.ExprEvaluator;
ViewFactorySupport.AssertReturnsNonConstant(ViewName, validated[0], 0);
TimeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(ViewName, statementContext, _viewParameters[1], ViewParamMessage, 1);
_eventType = parentEventType;
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is TimeBatchView))
{
return(false);
}
TimeBatchView myView = (TimeBatchView)view;
ExprTimePeriodEvalDeltaConst timeDeltaComputation = timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceContext);
if (!timeDeltaComputation.EqualsTimePeriod(myView.TimeDeltaComputation))
{
return(false);
}
if ((myView.InitialReferencePoint != null) && (_optionalReferencePoint != null))
{
if (!myView.InitialReferencePoint.Equals(_optionalReferencePoint.Value))
{
return(false);
}
}
if (((myView.InitialReferencePoint == null) && (_optionalReferencePoint != null)) ||
((myView.InitialReferencePoint != null) && (_optionalReferencePoint == null)))
{
return(false);
}
if (myView.IsForceOutput != IsForceUpdate)
{
return(false);
}
if (myView.IsStartEager)
{
// since it's already started
return(false);
}
return(myView.IsEmpty());
}
public bool EqualsTimePeriod(ExprTimePeriodEvalDeltaConst otherComputation)
{
if (otherComputation is ExprTimePeriodEvalDeltaConstGivenDtxAdd)
{
var other = (ExprTimePeriodEvalDeltaConstGivenDtxAdd)otherComputation;
if (other._adders.Length != _adders.Length)
{
return(false);
}
for (int i = 0; i < _adders.Length; i++)
{
if (_added[i] != other._added[i] || _adders[i].GetType() != other._adders[i].GetType())
{
return(false);
}
}
return(true);
}
return(false);
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
ExprTimePeriodEvalDeltaConst timeDeltaComputation = timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceViewFactoryContext.AgentInstanceContext);
ViewUpdatedCollection viewUpdatedCollection =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRelativeAccess(agentInstanceViewFactoryContext);
if (agentInstanceViewFactoryContext.IsRemoveStream)
{
return(new TimeBatchViewRStream(
this, agentInstanceViewFactoryContext, timeDeltaComputation, _optionalReferencePoint, IsForceUpdate,
IsStartEager));
}
else
{
return(new TimeBatchView(
this, agentInstanceViewFactoryContext, timeDeltaComputation, _optionalReferencePoint, IsForceUpdate,
IsStartEager, viewUpdatedCollection));
}
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
ExprTimePeriodEvalDeltaConst timeDeltaComputation = _timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceViewFactoryContext.AgentInstanceContext);
return new FirstTimeView(this, agentInstanceViewFactoryContext, timeDeltaComputation);
}
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);
}
}
public bool EqualsTimePeriod(ExprTimePeriodEvalDeltaConst otherComputation)
{
return otherComputation is ExprTimePeriodEvalDeltaConstZero;
}
private static ExprOptionalConstant GetExprOrConstant(ExprNode exprNode, TimeAbacus timeAbacus)
{
if (exprNode is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod)exprNode;
if (!timePeriod.HasMonth && !timePeriod.HasYear)
{
// no-month and constant
if (exprNode.IsConstantResult)
{
var sec = timePeriod.EvaluateAsSeconds(null, true, null);
var l = timeAbacus.DeltaForSecondsDouble(sec);
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) => l,
};
return(new ExprOptionalConstant(eval, l));
}
// no-month and not constant
else
{
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) =>
{
double sec = timePeriod.EvaluateAsSeconds(eventsPerStream, isNewData, context);
return(timeAbacus.DeltaForSecondsDouble(sec));
},
};
return(new ExprOptionalConstant(eval, null));
}
}
// has-month
else
{
// has-month and constant
if (exprNode.IsConstantResult)
{
ExprTimePeriodEvalDeltaConst timerPeriodConst = timePeriod.ConstEvaluator(null);
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) =>
{
return(timerPeriodConst.DeltaAdd(reference));
},
};
return(new ExprOptionalConstant(eval, null));
}
// has-month and not constant
else
{
ExprTimePeriodEvalDeltaNonConst timerPeriodNonConst = timePeriod.NonconstEvaluator();
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) => timerPeriodNonConst.DeltaAdd(
reference, eventsPerStream, isNewData, context),
};
return(new ExprOptionalConstant(eval, null));
}
}
}
else if (ExprNodeUtility.IsConstantValueExpr(exprNode))
{
var constantNode = (ExprConstantNode)exprNode;
long l = constantNode.GetConstantValue(null).AsLong();
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) => l,
};
return(new ExprOptionalConstant(eval, l));
}
else
{
var evaluator = exprNode.ExprEvaluator;
IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator
{
ProcEvaluate = (reference, eventsPerStream, isNewData, context) => evaluator.Evaluate(
new EvaluateParams(eventsPerStream, isNewData, context)).AsLong(),
};
return(new ExprOptionalConstant(eval, null));
}
}
