public EventBean GetEventBean(int column, EvaluateParams evaluateParams)
{
// acquire table-level write lock
ExprTableEvalLockUtil.ObtainLockUnless(_tableStateInstance.TableLevelRWLock.WriteLock, evaluateParams.ExprEvaluatorContext);
var @event = _tableStateInstance.EventUngrouped;
if (@event == null)
{
return null;
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
var aggregators = row.Methods;
if (column < aggregators.Length)
{
return null;
}
else
{
var pair = _accessors[column - aggregators.Length];
return pair.Accessor.GetEnumerableEvent(row.States[pair.Slot], evaluateParams);
}
}
// Filter and Select
public ICollection <object> EvaluateGetCollScalar(
EventBean[] eventsPerStream,
bool isNewData,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext context,
ExprSubselectRowNode parent)
{
IList <object> result = new List <object>();
var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream);
var evaluateParamsA = new EvaluateParams(events, true, context);
var evaluateParamsB = new EvaluateParams(events, isNewData, context);
foreach (var subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = parent.FilterExpr.Evaluate(evaluateParamsA);
if ((pass != null) && (true.Equals(pass)))
{
result.Add(parent.SelectClauseEvaluator[0].Evaluate(evaluateParamsB));
}
}
return(result);
}
private static Object[] Evaluate(ExprEvaluator[] parameters, ExprEvaluatorContext exprEvaluatorContext)
{
var results = new Object[parameters.Length];
var count = 0;
var evaluateParams = new EvaluateParams(null, true, exprEvaluatorContext);
foreach (ExprEvaluator expr in parameters)
{
try
{
results[count] = expr.Evaluate(evaluateParams);
count++;
}
catch (Exception ex)
{
string message = "Failed expression evaluation in crontab timer-at for parameter " + count + ": " +
ex.Message;
Log.Error(message, ex);
throw new ArgumentException(message);
}
}
return(results);
}
public object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprDot(_dotNode);
}
Object result = _variableReader.Value;
result = ExprDotNodeUtility.EvaluateChainWithWrap(
_resultWrapLambda, result,
_variableReader.VariableMetaData.EventType,
_variableReader.VariableMetaData.VariableType, _chainEval,
evaluateParams.EventsPerStream,
evaluateParams.IsNewData,
evaluateParams.ExprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprDot(result);
}
return(result);
}
public override EventBean Process(EventBean[] eventsPerStream, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext)
{
// Evaluate all expressions and build a map of name-value pairs
IDictionary <String, Object> props = new Dictionary <String, Object>();
int count = 0;
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
foreach (ExprEvaluator expressionNode in SelectExprContext.ExpressionNodes)
{
Object evalResult = expressionNode.Evaluate(evaluateParams);
props.Put(SelectExprContext.ColumnNames[count], evalResult);
count++;
}
foreach (SelectClauseStreamCompiledSpec element in NamedStreams)
{
EventBean theEvent = eventsPerStream[element.StreamNumber];
if (element.TableMetadata != null)
{
if (theEvent != null)
{
theEvent = element.TableMetadata.EventToPublic.Convert(theEvent, evaluateParams);
}
}
props.Put(SelectExprContext.ColumnNames[count], theEvent);
count++;
}
if (IsUsingWildcard && eventsPerStream.Length > 1)
{
foreach (EventBean anEventsPerStream in eventsPerStream)
{
props.Put(SelectExprContext.ColumnNames[count], anEventsPerStream);
count++;
}
}
return(ProcessSpecific(props, eventsPerStream, isNewData, exprEvaluatorContext));
}
public object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprRelOp(this, _relationalOpEnum.GetExpressionText());
}
Object valueLeft = _evaluators[0].Evaluate(evaluateParams);
if (valueLeft == null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprRelOp(null);
}
return(null);
}
Object valueRight = _evaluators[1].Evaluate(evaluateParams);
if (valueRight == null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprRelOp(null);
}
return(null);
}
if (InstrumentationHelper.ENABLED)
{
var result = _computer.Invoke(valueLeft, valueRight);
InstrumentationHelper.Get().AExprRelOp(result);
return(result);
}
return(_computer.Invoke(valueLeft, valueRight));
}
public override Object Evaluate(EventBean[] eventsPerStream, bool isNewData, ICollection <EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext)
{
if (matchingEvents == null)
{
return(false);
}
if (matchingEvents.Count == 0)
{
return(false);
}
if (FilterExpr == null)
{
return(true);
}
// Evaluate filter
var events = new EventBean[eventsPerStream.Length + 1];
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
Array.Copy(eventsPerStream, 0, events, 1, eventsPerStream.Length);
foreach (var subselectEvent in matchingEvents)
{
// Prepare filter expression event list
events[0] = subselectEvent;
var pass = (bool?)FilterExpr.Evaluate(evaluateParams);
if ((pass != null) && (pass.Value))
{
return(true);
}
}
return(false);
}
public object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprStreamUndMethod(_dotNode);
}
// get underlying event
EventBean theEvent = evaluateParams.EventsPerStream[_streamNumber];
if (theEvent == null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprStreamUndMethod(null);
}
return(null);
}
Object inner = theEvent.Underlying;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprDotChain(EPTypeHelper.SingleValue(theEvent.EventType.UnderlyingType), inner, _evaluators);
}
inner = ExprDotNodeUtility.EvaluateChain(_evaluators, inner, evaluateParams.EventsPerStream, evaluateParams.IsNewData, evaluateParams.ExprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprDotChain();
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprStreamUndMethod(inner);
}
return(inner);
}
internal static void PopulateSelectEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ICollection <Object> optSortKeys, ExprEvaluatorContext exprEvaluatorContext)
{
if (events == null)
{
return;
}
var eventsPerStream = new EventBean[1];
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
foreach (var theEvent in events)
{
eventsPerStream[0] = theEvent;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QHavingClauseNonJoin(theEvent);
}
var passesHaving = havingNode.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AHavingClauseNonJoin(passesHaving.AsBoxedBoolean());
}
if ((passesHaving == null) || (false.Equals(passesHaving)))
{
continue;
}
var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
if (resultEvent != null)
{
result.Add(resultEvent);
optSortKeys.Add(orderByProcessor.GetSortKey(eventsPerStream, isNewData, exprEvaluatorContext));
}
}
}
public object Evaluate(object target, EvaluateParams evalParams)
{
if (target == null)
{
return(null);
}
ICollection <EventBean> baseCollection;
if (target is ICollection <EventBean> )
{
return(((ICollection <EventBean>)target).Select(e => e.Underlying).ToList());
}
else if (target is ICollection <Object> )
{
return(((ICollection <Object>)target).OfType <EventBean>().Select(e => e.Underlying).ToList());
}
else if (target is ICollection)
{
return(((ICollection)target).Cast <EventBean>().Select(e => e.Underlying).ToList());
}
throw new ArgumentException("invalid value for target");
}
private static IList <RowRegexExprNode> ExpandRepeat(RowRegexExprNode node,
RowRegexExprRepeatDesc repeat,
RegexNFATypeEnum type,
RowRegexExprNodeCopier copier)
{
var evaluateParams = new EvaluateParams(null, true, null);
// handle single-bounds (no ranges)
IList <RowRegexExprNode> repeated = new List <RowRegexExprNode>();
if (repeat.Single != null)
{
ValidateExpression(repeat.Single);
int numRepeated = repeat.Single.ExprEvaluator.Evaluate(evaluateParams).AsInt();
ValidateRange(numRepeated, 1, int.MaxValue);
for (var i = 0; i < numRepeated; i++)
{
var copy = copier.Copy(node, type);
repeated.Add(copy);
}
return(repeated);
}
// evaluate bounds
int?lower = null;
int?upper = null;
if (repeat.Lower != null)
{
ValidateExpression(repeat.Lower);
lower = (int?)repeat.Lower.ExprEvaluator.Evaluate(evaluateParams);
}
if (repeat.Upper != null)
{
ValidateExpression(repeat.Upper);
upper = (int?)repeat.Upper.ExprEvaluator.Evaluate(evaluateParams);
}
// handle range
if (lower != null && upper != null)
{
ValidateRange(lower.Value, 1, int.MaxValue);
ValidateRange(upper.Value, 1, int.MaxValue);
ValidateRange(lower.Value, 1, upper.Value);
for (var i = 0; i < lower; i++)
{
var copy = copier.Copy(node, type);
repeated.Add(copy);
}
for (int i = lower.Value; i < upper; i++)
{
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ONE_OPTIONAL;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
}
return(repeated);
}
// handle lower-bounds only
if (upper == null)
{
ValidateRange(lower.Value, 1, int.MaxValue);
for (var i = 0; i < lower; i++)
{
var copyInner = copier.Copy(node, type);
repeated.Add(copyInner);
}
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_OPTIONAL)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_OPTIONAL_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
return(repeated);
}
// handle upper-bounds only
ValidateRange(upper.Value, 1, int.MaxValue);
for (var i = 0; i < upper; i++)
{
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ONE_OPTIONAL;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
}
return(repeated);
}
public ICollection <EventBean> EvaluateGetROCollectionEvents(EvaluateParams evaluateParams)
{
return(null);
}
public object Evaluate(EvaluateParams evaluateParams)
{
var result = new Mutable <bool?>(null);
using (Instrument.With(
i => i.QExprRegexp(this),
i => i.AExprRegexp(result.Value)))
{
if (_pattern == null)
{
var patternText = (String)_evaluators[1].Evaluate(evaluateParams);
if (patternText == null)
{
return(null);
}
try
{
_pattern = new Regex(String.Format("^{0}$", patternText));
}
catch (ArgumentException ex)
{
throw new EPException("Error compiling regex pattern '" + patternText + '\'', ex);
}
}
else
{
if (!_isConstantPattern)
{
var patternText = (String)_evaluators[1].Evaluate(evaluateParams);
if (patternText == null)
{
return(null);
}
try
{
_pattern = new Regex(String.Format("^{0}$", patternText));
}
catch (ArgumentException ex)
{
throw new EPException("Error compiling regex pattern '" + patternText + '\'', ex);
}
}
}
var evalValue = _evaluators[0].Evaluate(evaluateParams);
if (evalValue == null)
{
return(null);
}
if (_isNumericValue)
{
if (evalValue is double)
{
var tempValue = (double)evalValue;
evalValue = tempValue.ToString("F");
}
else if (evalValue is float)
{
var tempValue = (float)evalValue;
evalValue = tempValue.ToString("F");
}
else if (evalValue is decimal)
{
var tempValue = (decimal)evalValue;
evalValue = tempValue.ToString("F");
}
else
{
evalValue = evalValue.ToString();
}
}
result.Value = _pattern.IsMatch((String)evalValue);
if (_isNot)
{
result.Value = !result.Value;
}
return(result.Value);
}
}
public object Evaluate(EvaluateParams evaluateParams)
{
throw new IllegalStateException("Time-Period expression must be evaluated via any of " + typeof(ExprTimePeriod).Name + " interface methods");
}
public ICollection <EventBean> GetCollectionOfEvents(int column, EvaluateParams evaluateParams)
{
return(_services.Array[evaluateParams.ExprEvaluatorContext.AgentInstanceId].GetCollectionOfEvents(column, evaluateParams));
}
public EventBean GetEventBean(int column, EvaluateParams evaluateParams)
{
return(_services.Array[evaluateParams.ExprEvaluatorContext.AgentInstanceId].GetEventBean(column, evaluateParams));
}
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 EventBean EvaluateGetEventBean(EvaluateParams evaluateParams)
{
return(null);
}
public ICollection <object> EvaluateGetROCollectionScalar(EvaluateParams evaluateParams)
{
return(null);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (ChildNodes.Count == 0 || ChildNodes.Count > 2)
{
throw new ExprValidationException("Cast function node must have one or two child expressions");
}
var valueEvaluator = ChildNodes[0].ExprEvaluator;
var fromType = valueEvaluator.ReturnType;
// determine date format parameter
var namedParams =
ExprNodeUtility.GetNamedExpressionsHandleDups(ChildNodes);
ExprNodeUtility.ValidateNamed(namedParams, new string[] { "dateformat" });
var dateFormatParameter = namedParams.Get("dateformat");
if (dateFormatParameter != null)
{
ExprNodeUtility.ValidateNamedExpectType(
dateFormatParameter, new Type[] { typeof(string) });
}
// identify target type
// try the primitive names including "string"
_targetType = TypeHelper.GetPrimitiveTypeForName(_classIdentifier.Trim()).GetBoxedType();
SimpleTypeCaster caster;
bool numeric;
CasterParserComputer casterParserComputer = null;
var classIdentifierInvariant = _classIdentifier.Trim().ToLowerInvariant();
if (dateFormatParameter != null)
{
if (fromType != typeof(string))
{
throw new ExprValidationException(
string.Format("Use of the '{0}' named parameter requires a string-type input", dateFormatParameter.ParameterName));
}
if (_targetType == null)
{
try
{
_targetType = TypeHelper.GetClassForName(
_classIdentifier.Trim(), validationContext.EngineImportService.GetClassForNameProvider());
}
catch (TypeLoadException)
{
// expected
}
}
// dynamic or static date format
numeric = false;
caster = null;
StringToDateTimeBaseComputer dateTimeComputer;
if (_targetType == typeof(DateTime) ||
_targetType == typeof(DateTime?) ||
classIdentifierInvariant.Equals("date"))
{
_targetType = typeof(DateTime);
var desc = ValidateDateFormat(dateFormatParameter, validationContext);
if (desc.StaticDateFormat != null)
{
if (desc.Iso8601Format)
{
dateTimeComputer = new StringToDateTimeWStaticISOFormatComputer(validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseISOException;
}
else
{
dateTimeComputer = new StringToDateTimeWStaticFormatComputer(desc.StaticDateFormat);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else
{
dateTimeComputer = new StringToDateTimeWDynamicFormatComputer(desc.DynamicDateFormat);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else if (_targetType == typeof(DateTimeOffset) ||
_targetType == typeof(DateTimeOffset?) ||
classIdentifierInvariant.Equals("dto") ||
classIdentifierInvariant.Equals("datetimeoffset"))
{
_targetType = typeof(DateTimeOffset);
var desc = ValidateDateFormat(dateFormatParameter, validationContext);
if (desc.StaticDateFormat != null)
{
if (desc.Iso8601Format)
{
dateTimeComputer = new StringToDtoWStaticISOFormatComputer(validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseISOException;
}
else
{
dateTimeComputer = new StringToDtoWStaticFormatComputer(desc.StaticDateFormat, validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else
{
dateTimeComputer = new StringToDtoWDynamicFormatComputer(desc.DynamicDateFormat, validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else if (_targetType == typeof(DateTimeEx) ||
classIdentifierInvariant.Equals("dtx") ||
classIdentifierInvariant.Equals("datetimeex") ||
classIdentifierInvariant.Equals("calendar"))
{
_targetType = typeof(DateTimeEx);
var desc = ValidateDateFormat(dateFormatParameter, validationContext);
if (desc.StaticDateFormat != null)
{
if (desc.Iso8601Format)
{
dateTimeComputer = new StringToDtxWStaticISOFormatComputer(validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseISOException;
}
else
{
dateTimeComputer = new StringToDtxWStaticFormatComputer(desc.StaticDateFormat, validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else
{
dateTimeComputer = new StringToDtxWDynamicFormatComputer(desc.DynamicDateFormat, validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else if (_targetType == typeof(long) || _targetType == typeof(long?))
{
_targetType = typeof(long);
var desc = ValidateDateFormat(dateFormatParameter, validationContext);
if (desc.StaticDateFormat != null)
{
if (desc.Iso8601Format)
{
dateTimeComputer = new StringToDateTimeLongWStaticISOFormatComputer(validationContext.EngineImportService.TimeZone);
dateTimeComputer.HandleParseException += HandleParseISOException;
}
else
{
dateTimeComputer = new StringToDateTimeLongWStaticFormatComputer(desc.StaticDateFormat);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else
{
dateTimeComputer = new StringToDateTimeLongWDynamicFormatComputer(desc.DynamicDateFormat);
dateTimeComputer.HandleParseException += HandleParseException;
}
}
else
{
throw new ExprValidationException(
"Use of the '" + dateFormatParameter.ParameterName +
"' named parameter requires a target type of long or datetime");
}
casterParserComputer = dateTimeComputer;
}
else if (_targetType != null)
{
_targetType = _targetType.GetBoxedType();
caster = SimpleTypeCasterFactory.GetCaster(fromType, _targetType);
numeric = _targetType.IsNumeric();
}
else if (String.Equals(classIdentifierInvariant, "bigint", StringComparison.InvariantCultureIgnoreCase) ||
String.Equals(classIdentifierInvariant, "biginteger", StringComparison.InvariantCultureIgnoreCase))
{
_targetType = typeof(BigInteger);
caster = SimpleTypeCasterFactory.GetCaster(fromType, _targetType);
numeric = true;
}
else if (classIdentifierInvariant.Equals("decimal".ToLowerInvariant()))
{
_targetType = typeof(decimal);
caster = SimpleTypeCasterFactory.GetCaster(fromType, _targetType);
numeric = true;
}
else
{
try
{
_targetType = TypeHelper.GetClassForName(
_classIdentifier.Trim(), validationContext.EngineImportService.GetClassForNameProvider());
}
catch (TypeLoadException e)
{
throw new ExprValidationException(
"Type as listed in cast function by name '" + _classIdentifier + "' cannot be loaded", e);
}
numeric = _targetType.IsNumeric();
caster = numeric
? SimpleTypeCasterFactory.GetCaster(fromType, _targetType)
: SimpleTypeCasterFactory.GetCaster(_targetType);
}
// assign a computer unless already assigned
if (casterParserComputer == null)
{
// to-string
if (_targetType == typeof(string))
{
casterParserComputer = new StringXFormComputer();
}
else if (fromType == typeof(string))
{
// parse
var parser = SimpleTypeParserFactory.GetParser(_targetType.GetBoxedType());
casterParserComputer = new StringParserComputer(parser);
}
else if (numeric)
{
// numeric cast with check
casterParserComputer = new NumericCasterComputer(caster);
}
else
{
// non-numeric cast
casterParserComputer = new NonnumericCasterComputer(caster);
}
}
// determine constant or not
Object theConstant = null;
if (ChildNodes[0].IsConstantResult)
{
_isConstant = casterParserComputer.IsConstantForConstInput;
if (_isConstant)
{
var evaluateParams = new EvaluateParams(null, true, validationContext.ExprEvaluatorContext);
var @in = valueEvaluator.Evaluate(evaluateParams);
theConstant = @in == null ? null : casterParserComputer.Compute(@in, evaluateParams);
}
}
// determine evaluator
if (_isConstant)
{
_exprEvaluator = new ExprCastNodeConstEval(this, theConstant);
}
else
{
_exprEvaluator = new ExprCastNodeNonConstEval(this, valueEvaluator, casterParserComputer);
}
return(null);
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
using (Instrument.With(
i => i.QViewProcessIRStream(this, NAME, newData, oldData),
i => i.AViewProcessIRStream()))
{
// If we have child views, keep a reference to the old values, so we can fireStatementStopped them as old data event.
EventBean oldValues = null;
if (_lastNewEvent == null)
{
if (HasViews)
{
oldValues = PopulateMap(_statisticsBean, AgentInstanceContext.StatementContext.EventAdapterService, _eventType, _additionalProps, _lastValuesEventNew);
}
}
var evaluateParams = new EvaluateParams(_eventsPerStream, true, AgentInstanceContext);
// add data points to the bean
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
_eventsPerStream[0] = newData[i];
var xnum = _expressionXEval.Evaluate(evaluateParams);
var ynum = _expressionYEval.Evaluate(evaluateParams);
if (xnum != null && ynum != null)
{
var x = xnum.AsDouble();
var y = ynum.AsDouble();
_statisticsBean.AddPoint(x, y);
}
}
if ((_additionalProps != null) && (newData.Length != 0))
{
if (_lastValuesEventNew == null)
{
_lastValuesEventNew = new Object[_additionalProps.AdditionalExpr.Length];
}
for (var val = 0; val < _additionalProps.AdditionalExpr.Length; val++)
{
_lastValuesEventNew[val] = _additionalProps.AdditionalExpr[val].Evaluate(evaluateParams);
}
}
}
// remove data points from the bean
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
_eventsPerStream[0] = oldData[i];
var xnum = _expressionXEval.Evaluate(evaluateParams);
var ynum = _expressionYEval.Evaluate(evaluateParams);
if (xnum != null && ynum != null)
{
var x = xnum.AsDouble();
var y = ynum.AsDouble();
_statisticsBean.RemovePoint(x, y);
}
}
}
// If there are child view, fireStatementStopped Update method
if (HasViews)
{
var newDataMap = PopulateMap(_statisticsBean, AgentInstanceContext.StatementContext.EventAdapterService, _eventType, _additionalProps, _lastValuesEventNew);
var newEvents = new EventBean[] { newDataMap };
EventBean[] oldEvents;
if (_lastNewEvent == null)
{
oldEvents = new EventBean[] { oldValues };
}
else
{
oldEvents = new EventBean[] { _lastNewEvent };
}
Instrument.With(
i => i.QViewIndicate(this, NAME, newEvents, oldEvents),
i => i.AViewIndicate(),
() => UpdateChildren(newEvents, oldEvents));
_lastNewEvent = newDataMap;
}
}
}
public static object EvaluateChainWithWrap(ExprDotStaticMethodWrap resultWrapLambda,
object result,
EventType optionalResultSingleEventType,
Type resultType,
ExprDotEval[] chainEval,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext exprEvaluatorContext)
{
if (result == null)
{
return(null);
}
if (resultWrapLambda != null)
{
result = resultWrapLambda.Convert(result);
}
var evaluateParams = new EvaluateParams(eventsPerStream, newData, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
EPType typeInfo;
if (resultWrapLambda != null)
{
typeInfo = resultWrapLambda.TypeInfo;
}
else
{
if (optionalResultSingleEventType != null)
{
typeInfo = EPTypeHelper.SingleEvent(optionalResultSingleEventType);
}
else
{
typeInfo = EPTypeHelper.SingleValue(resultType);
}
}
InstrumentationHelper.Get().QExprDotChain(typeInfo, result, chainEval);
var i = -1;
foreach (var aChainEval in chainEval)
{
i++;
InstrumentationHelper.Get().QExprDotChainElement(i, aChainEval);
result = aChainEval.Evaluate(result, evaluateParams);
InstrumentationHelper.Get().AExprDotChainElement(aChainEval.TypeInfo, result);
if (result == null)
{
break;
}
}
InstrumentationHelper.Get().AExprDotChain();
return(result);
}
foreach (var aChainEval in chainEval)
{
result = aChainEval.Evaluate(result, evaluateParams);
if (result == null)
{
return(result);
}
}
return(result);
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, WeightedAverageViewFactory.NAME, newData, oldData);
}
double oldValue = CurrentValue;
// If we have child views, keep a reference to the old values, so we can update them as old data event.
EventBean oldDataMap = null;
if (_lastNewEvent == null)
{
if (HasViews)
{
IDictionary <string, object> oldDataValues = new Dictionary <string, object>();
oldDataValues.Put(ViewFieldEnum.WEIGHTED_AVERAGE__AVERAGE.GetName(), oldValue);
AddProperties(oldDataValues);
oldDataMap = _agentInstanceContext.StatementContext.EventAdapterService.AdapterForTypedMap(oldDataValues, ViewFactory.EventType);
}
}
// add data points to the bean
if (newData != null)
{
var evaluateParams = new EvaluateParams(_eventsPerStream, true, _agentInstanceContext);
for (int i = 0; i < newData.Length; i++)
{
_eventsPerStream[0] = newData[i];
var pointnum = _fieldNameXEvaluator.Evaluate(evaluateParams);
var weightnum = _fieldNameWeightEvaluator.Evaluate(evaluateParams);
if (pointnum != null && weightnum != null)
{
double point = pointnum.AsDouble();
double weight = weightnum.AsDouble();
if (double.IsNaN(SumXtimesW))
{
SumXtimesW = point * weight;
SumW = weight;
}
else
{
SumXtimesW += point * weight;
SumW += weight;
}
}
}
if ((_viewFactory.AdditionalProps != null) && (newData.Length != 0))
{
if (LastValuesEventNew == null)
{
LastValuesEventNew = new object[_viewFactory.AdditionalProps.AdditionalExpr.Length];
}
for (int val = 0; val < _viewFactory.AdditionalProps.AdditionalExpr.Length; val++)
{
LastValuesEventNew[val] = _viewFactory.AdditionalProps.AdditionalExpr[val].Evaluate(
new EvaluateParams(_eventsPerStream, true, _agentInstanceContext));
}
}
}
// remove data points from the bean
if (oldData != null)
{
var evaluateParams = new EvaluateParams(_eventsPerStream, true, _agentInstanceContext);
for (int i = 0; i < oldData.Length; i++)
{
_eventsPerStream[0] = oldData[i];
var pointnum = _fieldNameXEvaluator.Evaluate(evaluateParams);
var weightnum = _fieldNameWeightEvaluator.Evaluate(evaluateParams);
if (pointnum != null && weightnum != null)
{
double point = pointnum.AsDouble();
double weight = weightnum.AsDouble();
SumXtimesW -= point * weight;
SumW -= weight;
}
}
}
if (SumW != 0)
{
CurrentValue = SumXtimesW / SumW;
}
else
{
CurrentValue = Double.NaN;
}
// If there are child view, fireStatementStopped update method
if (HasViews)
{
IDictionary <string, object> newDataMap = new Dictionary <string, object>();
newDataMap.Put(ViewFieldEnum.WEIGHTED_AVERAGE__AVERAGE.GetName(), CurrentValue);
AddProperties(newDataMap);
EventBean newDataEvent = _agentInstanceContext.StatementContext.EventAdapterService.AdapterForTypedMap(newDataMap, ViewFactory.EventType);
EventBean[] newEvents = new EventBean[] { newDataEvent };
EventBean[] oldEvents;
if (_lastNewEvent == null)
{
oldEvents = new EventBean[] { oldDataMap };
}
else
{
oldEvents = new EventBean[] { _lastNewEvent };
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, WeightedAverageViewFactory.NAME, newEvents, oldEvents);
}
UpdateChildren(newEvents, oldEvents);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
_lastNewEvent = newDataEvent;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public void Next()
{
if (_iterationNumber == 0 && _initialDelayMSec > 0)
{
try
{
Thread.Sleep((int)_initialDelayMSec);
}
catch (ThreadInterruptedException)
{
graphContext.SubmitSignal(
new DataFlowSignalFinalMarker());
}
}
if (_iterationNumber > 0 && _periodDelayMSec > 0)
{
var nsecDelta = _lastSendTime - PerformanceObserver.NanoTime;
var sleepTime = _periodDelayMSec - nsecDelta / 1000000;
if (sleepTime > 0)
{
try
{
Thread.Sleep((int)sleepTime);
}
catch (ThreadInterruptedException)
{
graphContext.SubmitSignal(
new DataFlowSignalFinalMarker());
}
}
}
if (iterations > 0 && _iterationNumber >= iterations)
{
graphContext.SubmitSignal(
new DataFlowSignalFinalMarker());
}
else
{
_iterationNumber++;
if (_evaluators != null)
{
var evaluateParams = new EvaluateParams(null, true, null);
var row = new Object[_evaluators.Length];
for (var i = 0; i < row.Length; i++)
{
if (_evaluators[i] != null)
{
row[i] = _evaluators[i].Evaluate(evaluateParams);
}
}
if (Log.IsDebugEnabled)
{
Log.Debug("BeaconSource submitting row " + CompatExtensions.Render(row));
}
Object outputEvent = row;
if (_manufacturer != null)
{
if (!_produceEventBean)
{
outputEvent = _manufacturer.MakeUnderlying(row);
}
else
{
outputEvent = _manufacturer.Make(row);
}
}
graphContext.Submit(outputEvent);
}
else
{
if (Log.IsDebugEnabled)
{
Log.Debug("BeaconSource submitting empty row");
}
graphContext.Submit(new Object[0]);
}
if (interval > 0)
{
_lastSendTime = PerformanceObserver.NanoTime;
}
}
}
public object GetValue(int column, int agentInstanceId, EvaluateParams evaluateParams)
{
return(_services.Array[agentInstanceId].GetValue(
column, agentInstanceId, evaluateParams));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
_initialDelayMSec = (long)(initialDelay * 1000);
_periodDelayMSec = (long)(interval * 1000);
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException(
"BeaconSource operator requires one output stream but produces " + context.OutputPorts.Count +
" streams");
}
// Check if a type is declared
var port = context.OutputPorts[0];
ICollection <string> props;
if (port.OptionalDeclaredType != null && port.OptionalDeclaredType.EventType != null)
{
var outputEventType = port.OptionalDeclaredType.EventType;
_produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var writables = SetupProperties(props.ToArray(), outputEventType, context.StatementContext);
_manufacturer = context.ServicesContext.EventAdapterService.GetManufacturer(
outputEventType, writables, context.ServicesContext.EngineImportService, false);
var index = 0;
_evaluators = new ExprEvaluator[writables.Length];
TypeWidenerCustomizer typeWidenerCustomizer =
context.ServicesContext.EventAdapterService.GetTypeWidenerCustomizer(outputEventType);
foreach (var writeable in writables)
{
var providedProperty = _allProperties.Get(writeable.PropertyName);
if (providedProperty is ExprNode)
{
var exprNode = (ExprNode)providedProperty;
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var exprEvaluator = validated.ExprEvaluator;
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated), exprEvaluator.ReturnType,
writeable.PropertyType, writeable.PropertyName, false, typeWidenerCustomizer,
context.StatementContext.StatementName, context.Engine.URI);
if (widener != null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var value = exprEvaluator.Evaluate(evaluateParams);
return(widener.Invoke(value));
},
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = exprEvaluator;
}
}
else if (providedProperty == null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => null,
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => providedProperty,
ProcReturnType = () => providedProperty.GetType()
};
}
index++;
}
return(null); // no changing types
}
// No type has been declared, we can create one
var anonymousTypeName = context.DataflowName + "-beacon";
var types = new LinkedHashMap <string, Object>();
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var count = 0;
_evaluators = new ExprEvaluator[props.Count];
foreach (var propertyName in props)
{
var exprNode = (ExprNode)_allProperties.Get(propertyName);
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var evaluateParamsX = new EvaluateParams(null, true, context.AgentInstanceContext);
var value = validated.ExprEvaluator.Evaluate(evaluateParamsX);
if (value == null)
{
types.Put(propertyName, null);
}
else
{
types.Put(propertyName, value.GetType());
}
_evaluators[count] = new ProxyExprEvaluator()
{
ProcEvaluate = (evaluateParams) => value,
ProcReturnType = () => null
};
count++;
}
EventType type =
context.ServicesContext.EventAdapterService.CreateAnonymousObjectArrayType(anonymousTypeName, types);
return(new DataFlowOpInitializeResult(
new GraphTypeDesc[]
{
new GraphTypeDesc(false, true, type)
}));
}
public ICollection <object> GetCollectionScalar(int column, EvaluateParams evaluateParams)
{
return(_services.Array[evaluateParams.ExprEvaluatorContext.AgentInstanceId].GetCollectionScalar(column, evaluateParams));
}
public override void ApplyEnter(EventBean[] eventsPerStream, Object groupByKey, ExprEvaluatorContext exprEvaluatorContext)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggregationGroupedApplyEnterLeave(true, Aggregators.Length, AccessAggregations.Length, groupByKey);
}
HandleRemovedKeys();
var row = AggregatorsPerGroup.Get(groupByKey);
// The aggregators for this group do not exist, need to create them from the prototypes
AggregationMethod[] groupAggregators;
AggregationState[] groupStates;
if (row == null)
{
groupAggregators = AggSvcGroupByUtil.NewAggregators(Aggregators);
groupStates = AggSvcGroupByUtil.NewAccesses(exprEvaluatorContext.AgentInstanceId, IsJoin, AccessAggregations, groupByKey, null);
row = new AggregationMethodPairRow(1, groupAggregators, groupStates);
AggregatorsPerGroup.Put(groupByKey, row);
}
else
{
groupAggregators = row.Methods;
groupStates = row.States;
row.IncreaseRefcount();
}
var evaluateParams = new EvaluateParams(eventsPerStream, true, exprEvaluatorContext);
// For this row, evaluate sub-expressions, enter result
_currentAggregatorMethods = groupAggregators;
_currentAggregatorStates = groupStates;
for (var j = 0; j < Evaluators.Length; j++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggNoAccessEnterLeave(true, j, groupAggregators[j], Aggregators[j].AggregationExpression);
}
var columnResult = Evaluators[j].Evaluate(evaluateParams);
groupAggregators[j].Enter(columnResult);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggNoAccessEnterLeave(true, j, groupAggregators[j]);
}
}
for (var i = 0; i < _currentAggregatorStates.Length; i++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggAccessEnterLeave(true, i, _currentAggregatorStates[i], AccessAggregations[i].AggregationExpression);
}
_currentAggregatorStates[i].ApplyEnter(eventsPerStream, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggAccessEnterLeave(true, i, _currentAggregatorStates[i]);
}
}
InternalHandleGroupUpdate(groupByKey, row);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggregationGroupedApplyEnterLeave(true);
}
}
public TimePeriod EvaluateGetTimePeriod(EvaluateParams evaluateParams)
{
int exprCtr = 0;
int?year = null;
if (_hasYear)
{
year = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?month = null;
if (_hasMonth)
{
month = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?week = null;
if (_hasWeek)
{
week = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?day = null;
if (_hasDay)
{
day = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?hours = null;
if (_hasHour)
{
hours = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?minutes = null;
if (_hasMinute)
{
minutes = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?seconds = null;
if (_hasSecond)
{
seconds = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?milliseconds = null;
if (_hasMillisecond)
{
milliseconds = GetInt(_evaluators[exprCtr++].Evaluate(evaluateParams));
}
int?microseconds = null;
if (_hasMicrosecond)
{
microseconds = GetInt(_evaluators[exprCtr].Evaluate(evaluateParams));
}
return(new TimePeriod(year, month, week, day, hours, minutes, seconds, milliseconds, microseconds));
}
public object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprPlugInSingleRow(_staticMethod.Target);
}
if ((_isConstantParameters) && (_isCachedResult))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprPlugInSingleRow(_cachedResult);
}
return(_cachedResult);
}
var args = new Object[_childEvals.Length];
for (var i = 0; i < args.Length; i++)
{
args[i] = _childEvals[i].Evaluate(evaluateParams);
}
// The method is static so the object it is invoked on
// can be null
try
{
var result = _staticMethod.Invoke(_targetObject, args);
result = ExprDotNodeUtility.EvaluateChainWithWrap(
_resultWrapLambda, result, null, _staticMethod.ReturnType, _chainEval,
evaluateParams.EventsPerStream,
evaluateParams.IsNewData,
evaluateParams.ExprEvaluatorContext);
if (_isConstantParameters)
{
_cachedResult = result;
_isCachedResult = true;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprPlugInSingleRow(result);
}
return(result);
}
catch (EPException)
{
throw;
}
catch (TargetInvocationException e)
{
var message = TypeHelper.GetMessageInvocationTarget(
_statementName, _staticMethod.Target, _classOrPropertyName, args, e);
Log.Error(message, e.InnerException);
if (_rethrowExceptions)
{
throw new EPException(message, e.InnerException);
}
}
catch (Exception e)
{
var message = TypeHelper.GetMessageInvocationTarget(
_statementName, _staticMethod.Target, _classOrPropertyName, args, e);
Log.Error(message, e);
if (_rethrowExceptions)
{
throw new EPException(message, e);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprPlugInSingleRow(null);
}
return(null);
}
