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