public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { const string message = "The nth aggregation function requires two parameters, an expression returning aggregation values and a numeric index constant"; var positionalParams = PositionalParams; if (positionalParams.Length != 2) { throw new ExprValidationException(message); } ExprNode first = positionalParams[0]; ExprNode second = positionalParams[1]; if (!second.IsConstantResult) { throw new ExprValidationException(message); } var num = second.ExprEvaluator.Evaluate(new EvaluateParams(null, true, validationContext.ExprEvaluatorContext)); int size = num.AsInt(); return(new ExprNthAggNodeFactory(this, first.ExprEvaluator.ReturnType, size)); }
private static ExprNodeUtilMethodDesc GetValidateMethodDescriptor( Type methodTarget, string methodName, IList<ExprNode> parameters, ExprValidationContext validationContext) { ExprNodeUtilResolveExceptionHandler exceptionHandler = new ProxyExprNodeUtilResolveExceptionHandler( e => new ExprValidationException("Failed to resolve method '" + methodName + "': " + e.Message, e)); var wildcardType = validationContext.StreamTypeService.EventTypes.Length != 1 ? null : validationContext.StreamTypeService.EventTypes[0]; return ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream( methodTarget.FullName, methodTarget, methodName, parameters, wildcardType != null, wildcardType, exceptionHandler, methodName, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); }
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext) { string message = "The nth aggregation function requires two parameters, an expression returning aggregation values and a numeric index constant"; if (this.positionalParams.Length != 2) { throw new ExprValidationException(message); } ExprNode first = this.positionalParams[0]; ExprNode second = this.positionalParams[1]; if (!second.Forge.ForgeConstantType.IsCompileTimeConstant) { throw new ExprValidationException(message); } var num = second.Forge.ExprEvaluator.Evaluate(null, true, null); int size = num.AsInt32(); if (optionalFilter != null) { this.positionalParams = ExprNodeUtilityMake.AddExpression(positionalParams, optionalFilter); } return new AggregationFactoryMethodNth(this, first.Forge.EvaluationType, size); }
public void SetObserverParameters( IList<ExprNode> parameters, MatchedEventConvertorForge convertor, ExprValidationContext validationContext) { ObserverParameterUtil.ValidateNoNamedParameters("timer:at", parameters); if (Log.IsDebugEnabled) { Log.Debug(".setObserverParameters " + parameters); } if (parameters.Count < 5 || parameters.Count > 9) { throw new ObserverParameterException("Invalid number of parameters for timer:at"); } this.parameters = parameters; this.convertor = convertor; // if all parameters are constants, lets try to evaluate and build a schedule for early validation var allConstantResult = true; foreach (var param in parameters) { if (!(param is ExprWildcard) && !param.Forge.ForgeConstantType.IsCompileTimeConstant) { allConstantResult = false; } } if (allConstantResult) { try { var observerParameters = EvaluateCompileTime(parameters); spec = ScheduleSpecUtil.ComputeValues(observerParameters.ToArray()); } catch (ScheduleParameterException e) { throw new ObserverParameterException( "Error computing crontab schedule specification: " + e.Message, e); } } }
protected override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { if (PositionalParams.Length > 2 || PositionalParams.Length == 0) { throw MakeExceptionExpectedParamNum(1, 2); } Type childType = null; bool ignoreNulls = false; if (PositionalParams.Length == 1 && PositionalParams[0] is ExprWildcard) { ValidateNotDistinct(); // defaults } else if (PositionalParams.Length == 1) { childType = PositionalParams[0].ExprEvaluator.ReturnType; ignoreNulls = true; } else if (PositionalParams.Length == 2) { _hasFilter = true; if (!(PositionalParams[0] is ExprWildcard)) { childType = PositionalParams[0].ExprEvaluator.ReturnType; ignoreNulls = true; } else { ValidateNotDistinct(); } base.ValidateFilter(PositionalParams[1].ExprEvaluator); } return(validationContext.EngineImportService.AggregationFactoryFactory.MakeCount(validationContext.StatementExtensionSvcContext, this, ignoreNulls, childType)); }
private ExprNode ValidateMeasureClause( ExprNode measureNode, StreamTypeService typeServiceMeasure, ISet <string> variablesMultiple, ISet <string> variablesSingle, StatementContext statementContext) { try { var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( typeServiceMeasure, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); return(ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGMEASURE, measureNode, validationContext)); } catch (ExprValidationPropertyException e) { var grouped = CollectionUtil.ToString(variablesMultiple); var single = CollectionUtil.ToString(variablesSingle); var message = e.Message; if (!variablesMultiple.IsEmpty()) { message += ", ensure that grouped variables (variables " + grouped + ") are accessed via index (i.e. variable[0].property) or appear within an aggregation"; } if (!variablesSingle.IsEmpty()) { message += ", ensure that singleton variables (variables " + single + ") are not accessed via index"; } throw new ExprValidationPropertyException(message, e); } }
private LinearAggregationFactoryDesc HandleIntoTable( ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext) { var message = "For into-table use 'window(*)' or ''window(stream.*)' instead"; if (stateType != AggregationStateType.WINDOW) throw new ExprValidationException(message); if (childNodes.Length == 0 || childNodes.Length > 1) throw new ExprValidationException(message); if (validationContext.StreamTypeService.StreamNames.Length == 0) throw new ExprValidationException(GetErrorPrefix(stateType) + " requires that at least one stream is provided"); int streamNum; if (childNodes[0] is ExprWildcard) { if (validationContext.StreamTypeService.StreamNames.Length != 1) throw new ExprValidationException(GetErrorPrefix(stateType) + " with wildcard requires a single stream"); streamNum = 0; } else if (childNodes[0] is ExprStreamUnderlyingNode) { var und = (ExprStreamUnderlyingNode) childNodes[0]; streamNum = und.StreamId; } else { throw new ExprValidationException(message); } var containedType = validationContext.StreamTypeService.EventTypes[streamNum]; var componentType = containedType.UnderlyingType; var accessor = new AggregationAccessorWindowNoEval(componentType); var agent = ExprAggAggregationAgentFactory.Make(streamNum, OptionalFilter); var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, TypeHelper.GetArrayType(componentType), containedType, null, null, agent); return new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null); }
public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { if (PositionalParams.Length > 2 || PositionalParams.Length == 0) { throw MakeExceptionExpectedParamNum(1, 2); } Type childType = null; bool ignoreNulls = false; if (PositionalParams.Length == 1 && PositionalParams[0] is ExprWildcard) { ValidateNotDistinct(); // defaults } else if (PositionalParams.Length == 1) { childType = PositionalParams[0].ExprEvaluator.ReturnType; ignoreNulls = true; } else if (PositionalParams.Length == 2) { _hasFilter = true; if (!(PositionalParams[0] is ExprWildcard)) { childType = PositionalParams[0].ExprEvaluator.ReturnType; ignoreNulls = true; } else { ValidateNotDistinct(); } base.ValidateFilter(PositionalParams[1].ExprEvaluator); } return(new ExprCountNodeFactory(this, ignoreNulls, childType)); }
public override ExprNode Validate(ExprValidationContext validationContext) { if (ChildNodes.Length != 1) { throw new ExprValidationException( "Typeof node must have 1 child expression node supplying the expression to test"); } if (ChildNodes[0] is ExprStreamUnderlyingNode) { var stream = (ExprStreamUnderlyingNode) ChildNodes[0]; forge = new ExprTypeofNodeForgeStreamEvent(this, stream.StreamId); return null; } if (ChildNodes[0] is ExprIdentNode) { var ident = (ExprIdentNode) ChildNodes[0]; var streamNum = validationContext.StreamTypeService.GetStreamNumForStreamName(ident.FullUnresolvedName); if (streamNum != -1) { forge = new ExprTypeofNodeForgeStreamEvent(this, streamNum); return null; } var eventType = validationContext.StreamTypeService.EventTypes[ident.StreamId]; var fragmentEventType = eventType.GetFragmentType(ident.ResolvedPropertyName); if (fragmentEventType != null) { var getter = ((EventTypeSPI) eventType).GetGetterSPI(ident.ResolvedPropertyName); forge = new ExprTypeofNodeForgeFragmentType( this, ident.StreamId, getter, fragmentEventType.FragmentType.Name); return null; } } forge = new ExprTypeofNodeForgeInnerEval(this); return null; }
/// <summary> /// Validates the date format. /// </summary> /// <param name="dateFormatParameter">The date format parameter.</param> /// <param name="validationContext">The validation context.</param> /// <returns></returns> private ExprCastNodeDateDesc ValidateDateFormat( ExprNamedParameterNode dateFormatParameter, ExprValidationContext validationContext) { string staticDateFormat = null; ExprEvaluator dynamicDateFormat = null; var iso8601Format = false; if (!dateFormatParameter.ChildNodes[0].IsConstantResult) { dynamicDateFormat = dateFormatParameter.ChildNodes[0].ExprEvaluator; } else { staticDateFormat = (string)dateFormatParameter.ChildNodes[0].ExprEvaluator.Evaluate( new EvaluateParams(null, true, validationContext.ExprEvaluatorContext)); if (staticDateFormat.ToLowerInvariant().Trim().Equals("iso")) { iso8601Format = true; } else { try { DateTime dateTimeTemp; DateTime.TryParseExact("", staticDateFormat, null, DateTimeStyles.None, out dateTimeTemp); //new SimpleDateFormat(staticDateFormat); } catch (Exception ex) { throw new ExprValidationException( "Invalid date format '" + staticDateFormat + "': " + ex.Message, ex); } } } return(new ExprCastNodeDateDesc(staticDateFormat, dynamicDateFormat, iso8601Format)); }
public override ExprNode Validate(ExprValidationContext validationContext) { if (validationContext.TableService == null || !validationContext.IsAllowBindingConsumption) { throw new ExprValidationException("Invalid use of table access expression, expression '" + _tableName + "' is not allowed here"); } TableMetadata metadata = validationContext.TableService.GetTableMetadata(_tableName); if (metadata == null) { throw new ExprValidationException("A table '" + _tableName + "' could not be found"); } if (metadata.ContextName != null && validationContext.ContextDescriptor != null && !metadata.ContextName.Equals(validationContext.ContextDescriptor.ContextName)) { throw new ExprValidationException("Table by name '" + _tableName + "' has been declared for context '" + metadata.ContextName + "' and can only be used within the same context"); } // additional validations depend on detail ValidateBindingInternal(validationContext, metadata); return(null); }
public void SetObserverParameters( IList <ExprNode> parameters, MatchedEventConvertor convertor, ExprValidationContext validationContext) { ObserverParameterUtil.ValidateNoNamedParameters(NAME, parameters); const string errorMessage = NAME + " requires a single numeric or time period parameter"; if (parameters.Count != 1) { throw new ObserverParameterException(errorMessage); } if (!(parameters[0] is ExprTimePeriod)) { var returnType = parameters[0].ExprEvaluator.ReturnType; if (!returnType.IsNumeric()) { throw new ObserverParameterException(errorMessage); } } _parameter = parameters[0]; _convertor = convertor; }
private LinearAggregationFactoryDesc HandleTableAccessWindow( ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccess) { var original = (ExprAggMultiFunctionLinearAccessNodeFactoryAccess)tableAccess.Factory; if (childNodes.Length == 0 || (childNodes.Length == 1 && childNodes[0] is ExprWildcard)) { var componentType = original.ContainedEventType.UnderlyingType; var accessor = new AggregationAccessorWindowNoEval(componentType); var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess( this, accessor, TypeHelper.GetArrayType(componentType), original.ContainedEventType, null, null, null); return(new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null)); } if (childNodes.Length == 1) { // Expressions apply to events held, thereby validate in terms of event value expressions var paramNode = childNodes[0]; var streams = TableServiceUtil.StreamTypeFromTableColumn( tableAccess, validationContext.StreamTypeService.EngineURIQualifier); var localValidationContext = new ExprValidationContext(streams, validationContext); paramNode = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.AGGPARAM, paramNode, localValidationContext); var paramNodeEval = paramNode.ExprEvaluator; var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess( this, new AggregationAccessorWindowWEval(0, paramNodeEval, paramNodeEval.ReturnType), TypeHelper.GetArrayType(paramNodeEval.ReturnType), original.ContainedEventType, null, null, null); return(new LinearAggregationFactoryDesc(factory, null, paramNodeEval.ReturnType)); } throw new ExprValidationException("Invalid number of parameters"); }
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext) { AggregationForgeFactoryAccessSorted factory; if (validationContext.StatementRawInfo.StatementType == StatementType.CREATE_TABLE) { // handle create-table statements (state creator and default accessor, limited to certain options) factory = HandleCreateTable(validationContext); } else if (validationContext.StatementRawInfo.IntoTableName != null) { // handle into-table (state provided, accessor and agent needed, validation done by factory) factory = HandleIntoTable(validationContext); } else { // handle standalone factory = HandleNonTable(validationContext); } _containedType = factory.ContainedEventType; _aggregationForgeFactory = factory; return(factory); }
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext) { if (positionalParams.Length > 2) { throw MakeExceptionExpectedParamNum(0, 2); } if (positionalParams.Length == 2) { ValidateFilter(positionalParams[1]); optionalFilter = positionalParams[1]; } Type resultType; var isWildcard = positionalParams.Length == 0 || positionalParams.Length > 0 && positionalParams[0] is ExprWildcard; if (isWildcard) { resultType = validationContext.StreamTypeService.EventTypes[0].UnderlyingType; } else { resultType = positionalParams[0].Forge.EvaluationType; } var serde = validationContext.SerdeResolver.SerdeForAggregation(resultType, validationContext.StatementRawInfo); return new AggregationForgeFactoryFirstLastEver(this, resultType, serde); }
public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { if (PositionalParams.Length == 0 || PositionalParams.Length > 2) { throw new ExprValidationException(_minMaxTypeEnum.ToString() + " node must have either 1 or 2 parameters"); } ExprNode child = PositionalParams[0]; bool hasDataWindows; if (_isEver) { hasDataWindows = false; } else { if (validationContext.ExprEvaluatorContext.StatementType == StatementType.CREATE_TABLE) { hasDataWindows = true; } else { hasDataWindows = ExprNodeUtility.HasRemoveStreamForAggregations(child, validationContext.StreamTypeService, validationContext.IsResettingAggregations); } } if (_hasFilter) { if (PositionalParams.Length < 2) { throw new ExprValidationException(_minMaxTypeEnum.ToString() + "-filtered aggregation function must have a filter expression as a second parameter"); } base.ValidateFilter(PositionalParams[1].ExprEvaluator); } return(new ExprMinMaxAggrNodeFactory(this, child.ExprEvaluator.ReturnType, hasDataWindows)); }
public override ExprNode Validate(ExprValidationContext validationContext) { if (this.ChildNodes.Length != 2) { throw new ExprValidationException(NAME + "requires two parameters"); } ExprStreamUnderlyingNode undOne = CheckStreamUnd(this.ChildNodes[0]); ExprStreamUnderlyingNode undTwo = CheckStreamUnd(this.ChildNodes[1]); if (undOne.EventType != undTwo.EventType) { throw new ExprValidationException( NAME + " received two different event types as parameter, type '" + undOne.EventType.Name + "' is not the same as type '" + undTwo.EventType.Name + "'"); } forge = new ExprEventIdentityEqualsNodeForge(this, undOne, undTwo); return(null); }
public void SetObserverParameters(IList<ExprNode> parameters, MatchedEventConvertor convertor, ExprValidationContext validationContext) { Convertor = convertor; // obtains name parameters IDictionary<string, ExprNamedParameterNode> namedExpressions; try { namedExpressions = ExprNodeUtility.GetNamedExpressionsHandleDups(parameters); ExprNodeUtility.ValidateNamed(namedExpressions, NAMED_PARAMETERS); } catch (ExprValidationException e) { throw new ObserverParameterException(e.Message, e); } bool allConstantResult; ExprNamedParameterNode isoStringExpr = namedExpressions.Get(ISO_NAME); if (namedExpressions.Count == 1 && isoStringExpr != null) { try { allConstantResult = ExprNodeUtility.ValidateNamedExpectType( isoStringExpr, new Type[] { typeof (string) }); } catch (ExprValidationException ex) { throw new ObserverParameterException(ex.Message, ex); } ScheduleComputer = new TimerScheduleSpecComputeISOString(isoStringExpr.ChildNodes[0]); } else if (isoStringExpr != null) { throw new ObserverParameterException( "The '" + ISO_NAME + "' parameter is exclusive of other parameters"); } else if (namedExpressions.Count == 0) { throw new ObserverParameterException("No parameters provided"); } else { allConstantResult = true; ExprNamedParameterNode dateNamedNode = namedExpressions.Get(DATE_NAME); ExprNamedParameterNode repetitionsNamedNode = namedExpressions.Get(REPETITIONS_NAME); ExprNamedParameterNode periodNamedNode = namedExpressions.Get(PERIOD_NAME); if (dateNamedNode == null && periodNamedNode == null) { throw new ObserverParameterException("Either the date or period parameter is required"); } try { if (dateNamedNode != null) { allConstantResult = ExprNodeUtility.ValidateNamedExpectType( dateNamedNode, new Type[] { typeof (string), typeof (DateTime), typeof (DateTimeOffset), typeof (long?) }); } if (repetitionsNamedNode != null) { allConstantResult &= ExprNodeUtility.ValidateNamedExpectType( repetitionsNamedNode, new Type[] { typeof (int?), typeof (long?) }); } if (periodNamedNode != null) { allConstantResult &= ExprNodeUtility.ValidateNamedExpectType( periodNamedNode, new Type[] { typeof (TimePeriod) }); } } catch (ExprValidationException ex) { throw new ObserverParameterException(ex.Message, ex); } ExprNode dateNode = dateNamedNode == null ? null : dateNamedNode.ChildNodes[0]; ExprNode repetitionsNode = repetitionsNamedNode == null ? null : repetitionsNamedNode.ChildNodes[0]; ExprTimePeriod periodNode = periodNamedNode == null ? null : (ExprTimePeriod) periodNamedNode.ChildNodes[0]; ScheduleComputer = new TimerScheduleSpecComputeFromExpr(dateNode, repetitionsNode, periodNode); } if (allConstantResult) { try { Spec = ScheduleComputer.Compute( convertor, new MatchedEventMapImpl(convertor.MatchedEventMapMeta), null, validationContext.MethodResolutionService.EngineImportService.TimeZone); } catch (ScheduleParameterException ex) { throw new ObserverParameterException(ex.Message, ex); } } }
public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { var positionalParams = base.PositionalParams; if (positionalParams.Length == 0) { throw new ExprValidationException( "The rate aggregation function minimally requires a numeric constant or expression as a parameter."); } ExprNode first = positionalParams[0]; if (first.IsConstantResult) { const string message = "The rate aggregation function requires a numeric constant or time period as the first parameter in the constant-value notation"; long intervalTime; if (first is ExprTimePeriod) { double secInterval = ((ExprTimePeriod)first).EvaluateAsSeconds( null, true, validationContext.ExprEvaluatorContext); intervalTime = validationContext.EngineImportService.TimeAbacus.DeltaForSecondsDouble(secInterval); } else if (ExprNodeUtility.IsConstantValueExpr(first)) { if (!first.ExprEvaluator.ReturnType.IsNumeric()) { throw new ExprValidationException(message); } var num = first.ExprEvaluator.Evaluate( new EvaluateParams(null, true, validationContext.ExprEvaluatorContext)); intervalTime = validationContext.EngineImportService.TimeAbacus.DeltaForSecondsNumber(num); } else { throw new ExprValidationException(message); } return (validationContext.EngineImportService.AggregationFactoryFactory.MakeRate( validationContext.StatementExtensionSvcContext, this, true, intervalTime, validationContext.TimeProvider, validationContext.EngineImportService.TimeAbacus)); } const string messageX = "The rate aggregation function requires a property or expression returning a non-constant long-type value as the first parameter in the timestamp-property notation"; Type boxedParamOne = first.ExprEvaluator.ReturnType.GetBoxedType(); if (boxedParamOne != typeof(long?)) { throw new ExprValidationException(messageX); } if (first.IsConstantResult) { throw new ExprValidationException(messageX); } if (first is ExprTimestampNode) { throw new ExprValidationException( "The rate aggregation function does not allow the current engine timestamp as a parameter"); } if (positionalParams.Length > 1) { if (!TypeHelper.IsNumeric(positionalParams[1].ExprEvaluator.ReturnType)) { throw new ExprValidationException( "The rate aggregation function accepts an expression returning a numeric value to accumulate as an optional second parameter"); } } bool hasDataWindows = ExprNodeUtility.HasRemoveStreamForAggregations( first, validationContext.StreamTypeService, validationContext.IsResettingAggregations); if (!hasDataWindows) { throw new ExprValidationException( "The rate aggregation function in the timestamp-property notation requires data windows"); } return (validationContext.EngineImportService.AggregationFactoryFactory.MakeRate( validationContext.StatementExtensionSvcContext, this, false, -1, validationContext.TimeProvider, validationContext.EngineImportService.TimeAbacus)); }
public void Init( int?streamOfProviderIfApplicable, EnumMethodEnum enumMethodEnum, String enumMethodUsedName, EPType typeInfo, IList <ExprNode> parameters, ExprValidationContext validationContext) { var eventTypeColl = EPTypeHelper.GetEventTypeMultiValued(typeInfo); var eventTypeBean = EPTypeHelper.GetEventTypeSingleValued(typeInfo); var collectionComponentType = EPTypeHelper.GetClassMultiValued(typeInfo); _enumMethodEnum = enumMethodEnum; _enumMethodUsedName = enumMethodUsedName; _streamCountIncoming = validationContext.StreamTypeService.EventTypes.Length; if (eventTypeColl == null && collectionComponentType == null && eventTypeBean == null) { throw new ExprValidationException( "Invalid input for built-in enumeration method '" + enumMethodUsedName + "', expecting collection of event-type or scalar values as input, received " + EPTypeHelper.ToTypeDescriptive(typeInfo)); } // compile parameter abstract for validation against available footprints var footprintProvided = DotMethodUtil.GetProvidedFootprint(parameters); // validate parameters DotMethodInputTypeMatcher inputTypeMatcher = new ProxyDotMethodInputTypeMatcher { ProcMatches = fp => { if (fp.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeBean == null && eventTypeColl == null) { return(false); } if (fp.Input == DotMethodFPInputEnum.SCALAR_ANY && collectionComponentType == null) { return(false); } return(true); } }; var footprint = DotMethodUtil.ValidateParametersDetermineFootprint( enumMethodEnum.GetFootprints(), DotMethodTypeEnum.ENUM, enumMethodUsedName, footprintProvided, inputTypeMatcher); // validate input criteria met for this footprint if (footprint.Input != DotMethodFPInputEnum.ANY) { var message = "Invalid input for built-in enumeration method '" + enumMethodUsedName + "' and " + footprint.Parameters.Length + "-parameter footprint, expecting collection of "; var received = " as input, received " + EPTypeHelper.ToTypeDescriptive(typeInfo); if (footprint.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeColl == null) { throw new ExprValidationException(message + "events" + received); } if (footprint.Input.IsScalar() && collectionComponentType == null) { throw new ExprValidationException(message + "values (typically scalar values)" + received); } if (footprint.Input == DotMethodFPInputEnum.SCALAR_NUMERIC && !collectionComponentType.IsNumeric()) { throw new ExprValidationException(message + "numeric values" + received); } } // manage context of this lambda-expression in regards to outer lambda-expression that may call this one. ExpressionResultCacheForEnumerationMethod enumerationMethodCache = validationContext.ExprEvaluatorContext.ExpressionResultCacheService.AllocateEnumerationMethod; enumerationMethodCache.PushStack(this); var bodiesAndParameters = new List <ExprDotEvalParam>(); var count = 0; var inputEventType = eventTypeBean ?? eventTypeColl; foreach (var node in parameters) { var bodyAndParameter = GetBodyAndParameter( enumMethodUsedName, count++, node, inputEventType, collectionComponentType, validationContext, bodiesAndParameters, footprint); bodiesAndParameters.Add(bodyAndParameter); } _enumEval = GetEnumEval( validationContext.EngineImportService, validationContext.EventAdapterService, validationContext.StreamTypeService, validationContext.StatementId, enumMethodUsedName, bodiesAndParameters, inputEventType, collectionComponentType, _streamCountIncoming, validationContext.IsDisablePropertyExpressionEventCollCache); _enumEvalNumRequiredEvents = _enumEval.StreamNumSize; // determine the stream ids of event properties asked for in the Evaluator(s) var streamsRequired = new HashSet <int>(); var visitor = new ExprNodeIdentifierCollectVisitor(); foreach (var desc in bodiesAndParameters) { desc.Body.Accept(visitor); foreach (var ident in visitor.ExprProperties) { streamsRequired.Add(ident.StreamId); } } if (streamOfProviderIfApplicable != null) { streamsRequired.Add(streamOfProviderIfApplicable.Value); } // We turn on caching if the stack is not empty (we are an inner lambda) and the dependency does not include the stream. var isInner = !enumerationMethodCache.PopLambda(); if (isInner) { // If none of the properties that the current lambda uses comes from the ultimate Parent(s) or subsequent streams, then cache. var parents = enumerationMethodCache.GetStack(); var found = false; foreach (var req in streamsRequired) { var first = (ExprDotEvalEnumMethodBase)parents.First; var parentIncoming = first._streamCountIncoming - 1; var selfAdded = _streamCountIncoming; // the one we use ourselfs if (req > parentIncoming && req < selfAdded) { found = true; } } _cache = !found; } }
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 override ExprNode Validate(ExprValidationContext validationContext) { if (ChildNodes.Length != 2) { throw new ExprValidationException("Arithmatic node must have 2 parameters"); } foreach (var child in ChildNodes) { var childType = child.Forge.EvaluationType; if (!childType.IsNumeric()) { throw new ExprValidationException( "Implicit conversion from datatype '" + childType.CleanName() + "' to numeric is not allowed"); } } // Determine result type, set up compute function var lhs = ChildNodes[0]; var rhs = ChildNodes[1]; var lhsType = lhs.Forge.EvaluationType; var rhsType = rhs.Forge.EvaluationType; Type resultType; // If both sides are unboxed, then the result is also unboxed if (!lhsType.IsNullable() && !rhsType.IsNullable()) { if ((lhsType == typeof(short)) && (rhsType == typeof(short))) { resultType = typeof(int); } else if (lhsType == typeof(byte) && (rhsType == typeof(byte))) { resultType = typeof(int); } else if (lhsType == rhsType) { resultType = rhsType; } else { resultType = lhsType .GetArithmaticCoercionType(rhsType) .GetUnboxedType(); } } else if ((lhsType == typeof(short) || lhsType == typeof(short?)) && (rhsType == typeof(short) || rhsType == typeof(short?))) { resultType = typeof(int?); } else if ((lhsType == typeof(byte) || lhsType == typeof(byte?)) && (rhsType == typeof(byte) || rhsType == typeof(byte?))) { resultType = typeof(int?); } else if (lhsType == rhsType) { resultType = rhsType.GetBoxedType(); } else { resultType = lhsType.GetArithmaticCoercionType(rhsType); } if (MathArithTypeEnum == MathArithTypeEnum.DIVIDE && !_isIntegerDivision) { if (!resultType.IsDecimal()) { resultType = typeof(double?); } } // If ths isDivisionByZeroReturnsNull is set, it requires promotion to boxed types // to support passing back null. if (_isDivisionByZeroReturnsNull) { resultType = resultType.GetBoxedType(); } var arithTypeEnumComputer = MathArithType.GetComputer( MathArithTypeEnum, resultType, lhsType, rhsType, _isIntegerDivision, _isDivisionByZeroReturnsNull, validationContext.ImportService.DefaultMathContext); _forge = new ExprMathNodeForge(this, arithTypeEnumComputer, resultType); return null; }
private ExprDotEvalParam GetBodyAndParameter( String enumMethodUsedName, int parameterNum, ExprNode parameterNode, EventType inputEventType, Type collectionComponentType, ExprValidationContext validationContext, IList <ExprDotEvalParam> priorParameters, DotMethodFP footprint) { // handle an expression that is a constant or other (not =>) if (!(parameterNode is ExprLambdaGoesNode)) { // no node subtree validation is required here, the chain parameter validation has taken place in ExprDotNode.validate // validation of parameter types has taken place in footprint matching return(new ExprDotEvalParamExpr(parameterNum, parameterNode, parameterNode.ExprEvaluator)); } var goesNode = (ExprLambdaGoesNode)parameterNode; // Get secondary var additionalTypes = GetAddStreamTypes( enumMethodUsedName, goesNode.GoesToNames, inputEventType, collectionComponentType, priorParameters, validationContext.EventAdapterService); var additionalStreamNames = goesNode.GoesToNames.ToArray(); ValidateDuplicateStreamNames(validationContext.StreamTypeService.StreamNames, additionalStreamNames); // add name and type to list of known types var addTypes = (EventType[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.EventTypes, additionalTypes); var addNames = (String[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.StreamNames, additionalStreamNames); var types = new StreamTypeServiceImpl( addTypes, addNames, new bool[addTypes.Length], null, false); // validate expression body var filter = goesNode.ChildNodes[0]; try { var filterValidationContext = new ExprValidationContext(types, validationContext); filter = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DECLAREDEXPRBODY, filter, filterValidationContext); } catch (ExprValidationException ex) { throw new ExprValidationException( "Error validating enumeration method '" + enumMethodUsedName + "' parameter " + parameterNum + ": " + ex.Message, ex); } var filterEvaluator = filter.ExprEvaluator; var expectedType = footprint.Parameters[parameterNum].ParamType; // Lambda-methods don't use a specific expected return-type, so passing null for type is fine. DotMethodUtil.ValidateSpecificType( enumMethodUsedName, DotMethodTypeEnum.ENUM, expectedType, null, filterEvaluator.ReturnType, parameterNum, filter); var numStreamsIncoming = validationContext.StreamTypeService.EventTypes.Length; return(new ExprDotEvalParamLambda( parameterNum, filter, filterEvaluator, numStreamsIncoming, goesNode.GoesToNames, additionalTypes)); }
private ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleNonTable(ExprValidationContext validationContext) { if (PositionalParams.Length == 0) { throw new ExprValidationException("Missing the sort criteria expression"); } // validate that the streams referenced in the criteria are a single stream's var streams = ExprNodeUtility.GetIdentStreamNumbers(PositionalParams[0]); if (streams.Count > 1 || streams.IsEmpty()) { throw new ExprValidationException(ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream"); } int streamNum = streams.First(); // validate that there is a remove stream, use "ever" if not var forceEver = false; if (!_ever && ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(validationContext.StreamTypeService, streamNum)) { if (_sortedwin) { throw new ExprValidationException(ErrorPrefix + " requires that a data window is declared for the stream"); } forceEver = true; } // determine typing and evaluation _containedType = validationContext.StreamTypeService.EventTypes[streamNum]; var componentType = _containedType.UnderlyingType; var accessorResultType = componentType; AggregationAccessor accessor; TableMetadata tableMetadata = validationContext.TableService.GetTableMetadataFromEventType(_containedType); if (!_sortedwin) { if (tableMetadata != null) { accessor = new AggregationAccessorMinMaxByTable(_max, tableMetadata); } else { accessor = new AggregationAccessorMinMaxByNonTable(_max); } } else { if (tableMetadata != null) { accessor = new AggregationAccessorSortedTable(_max, componentType, tableMetadata); } else { accessor = new AggregationAccessorSortedNonTable(_max, componentType); } accessorResultType = TypeHelper.GetArrayType(accessorResultType); } Pair <ExprNode[], bool[]> criteriaExpressions = CriteriaExpressions; AggregationStateTypeWStream type; if (_ever) { type = _max ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER; } else { type = AggregationStateTypeWStream.SORTED; } var stateKey = new AggregationStateKeyWStream(streamNum, _containedType, type, criteriaExpressions.First); var stateFactoryFactory = new SortedAggregationStateFactoryFactory(validationContext.MethodResolutionService, ExprNodeUtility.GetEvaluators(criteriaExpressions.First), criteriaExpressions.Second, _ever, streamNum, this); return(new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, _containedType, stateKey, stateFactoryFactory, AggregationAgentDefault.INSTANCE)); }
public override EPStatementStartResult StartInternal( EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { var createDesc = _statementSpec.CreateVariableDesc; VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService); // Get assignment value object value = null; if (createDesc.Assignment != null) { // Evaluate assignment expression StreamTypeService typeService = new StreamTypeServiceImpl( new EventType[0], new string[0], new bool[0], services.EngineURI, false); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( typeService, statementContext.MethodResolutionService, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); var validated = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext); value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, evaluatorContextStmt)); } // Create variable try { services.VariableService.CreateNewVariable( _statementSpec.OptionalContextName, createDesc.VariableName, createDesc.VariableType, createDesc.IsConstant, createDesc.IsArray, createDesc.IsArrayOfPrimitive, value, services.EngineImportService); } catch (VariableExistsException ex) { // for new statement we don't allow creating the same variable if (isNewStatement) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } } catch (VariableDeclarationException ex) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } var destroyMethod = new EPStatementDestroyCallbackList(); destroyMethod.AddCallback(new ProxyDestroyCallback(() => { try { services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName); } catch (Exception ex) { Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message); } })); var stopMethod = new ProxyEPStatementStopMethod(() => { }); var variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName); Viewable outputView; var eventType = CreateVariableView.GetEventType( statementContext.StatementId, services.EventAdapterService, variableMetaData); var contextFactory = new StatementAgentInstanceFactoryCreateVariable( createDesc, _statementSpec, statementContext, services, variableMetaData, eventType); statementContext.StatementAgentInstanceFactory = contextFactory; if (_statementSpec.OptionalContextName != null) { var mergeView = new ContextMergeView(eventType); outputView = mergeView; var statement = new ContextManagedStatementCreateVariableDesc(_statementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement( _statementSpec.OptionalContextName, statement, isRecoveringResilient); var contextManagementService = services.ContextManagementService; destroyMethod.AddCallback(new ProxyDestroyCallback(() => contextManagementService.DestroyedStatement( _statementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId))); } else { var resultOfStart = (StatementAgentInstanceFactoryCreateVariableResult) contextFactory.NewContext(GetDefaultAgentInstanceContext(statementContext), isRecoveringResilient); outputView = resultOfStart.FinalView; if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null) { var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart); statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder; statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient); } } services.StatementVariableRefService.AddReferences( statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null); return(new EPStatementStartResult(outputView, stopMethod, destroyMethod)); }
public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext) { return(ValidateAggregationInternal(validationContext, null)); }
public AggregationMethodFactory ValidateAggregationParamsWBinding(ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccessColumn) { return(ValidateAggregationInternal(validationContext, tableAccessColumn)); }
public override ExprNode Validate(ExprValidationContext validationContext) { if (Script.ParameterNames.Length != Parameters.Count) { throw new ExprValidationException( string.Format( "Invalid number of parameters for script '{0}', expected {1} parameters but received {2} parameters", Script.Name, Script.ParameterNames.Length, Parameters.Count)); } if (!validationContext.StatementCompileTimeService.Configuration.Compiler.Scripts.IsEnabled) { throw new ExprValidationException("Script compilation has been disabled by configuration"); } // validate all expression parameters var validatedParameters = Parameters .Select( expr => ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.SCRIPTPARAMS, expr, validationContext)) .ToList(); // set up map of input parameter names and evaluators var forges = new ExprForge[Script.ParameterNames.Length]; for (var i = 0; i < Script.ParameterNames.Length; i++) { forges[i] = validatedParameters[i].Forge; } Parameters = validatedParameters; // Compile script var parameterTypes = ExprNodeUtilityQuery.GetExprResultTypes(forges); var dialect = Script.OptionalDialect ?? _defaultDialect; var compiled = CompileScript( dialect, Script.Name, Script.Expression, Script.ParameterNames, parameterTypes, Script.CompiledBuf, validationContext.ImportService, validationContext.ScriptCompiler); // Determine declared return type var declaredReturnType = GetDeclaredReturnType(Script.OptionalReturnTypeName, validationContext); if (Script.IsOptionalReturnTypeIsArray && declaredReturnType != null) { declaredReturnType = TypeHelper.GetArrayType(declaredReturnType); } Type returnType; if (compiled.KnownReturnType == null && Script.OptionalReturnTypeName == null) { returnType = typeof(object); } else if (compiled.KnownReturnType != null) { if (declaredReturnType == null) { returnType = compiled.KnownReturnType; } else { var knownReturnType = compiled.KnownReturnType; if (declaredReturnType.IsArray && knownReturnType.IsArray) { // we are fine } else if (!knownReturnType.IsAssignmentCompatible(declaredReturnType)) { throw new ExprValidationException( "Return type and declared type not compatible for script '" + Script.Name + "', known return type is " + knownReturnType.Name + " versus declared return type " + declaredReturnType.Name); } returnType = declaredReturnType; } } else { returnType = declaredReturnType; } if (returnType == null) { returnType = typeof(object); } _eventTypeCollection = null; if (Script.OptionalEventTypeName != null) { if (returnType.IsArray && returnType.GetElementType() == typeof(EventBean)) { _eventTypeCollection = EventTypeUtility.RequireEventType( "Script", Script.Name, Script.OptionalEventTypeName, validationContext.StatementCompileTimeService.EventTypeCompileTimeResolver); } else { throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage()); } } _scriptDescriptor = new ScriptDescriptorCompileTime( Script.OptionalDialect, Script.Name, Script.Expression, Script.ParameterNames, Parameters.ToArray(), returnType, _defaultDialect); return null; }
public override ExprNode Validate(ExprValidationContext validationContext) { _length = ChildNodes.Count; _evaluators = ExprNodeUtility.GetEvaluators(ChildNodes); // Can be an empty array with no content if (ChildNodes.Count == 0) { _arrayReturnType = typeof(Object); _constantResult = new Object[0]; return(null); } var comparedTypes = new List <Type>(); for (int i = 0; i < _length; i++) { comparedTypes.Add(_evaluators[i].ReturnType); } // Determine common denominator type try { _arrayReturnType = TypeHelper.GetCommonCoercionType(comparedTypes.ToArray()); // Determine if we need to coerce numbers when one type doesn't match any other type if (_arrayReturnType.IsNumeric()) { _mustCoerce = false; foreach (var comparedType in comparedTypes) { if (comparedType != _arrayReturnType) { _mustCoerce = true; } } if (_mustCoerce) { _coercer = CoercerFactory.GetCoercer(null, _arrayReturnType); } } } catch (CoercionException) { // expected, such as mixing String and int values, or classes (not boxed) and primitives // use Object[] in such cases } if (_arrayReturnType == null) { _arrayReturnType = typeof(Object); } // Determine if we are dealing with constants only var results = new Object[_length]; int index = 0; foreach (ExprNode child in ChildNodes) { if (!child.IsConstantResult) { results = null; // not using a constant result break; } results[index] = _evaluators[index].Evaluate(new EvaluateParams(null, false, validationContext.ExprEvaluatorContext)); index++; } // Copy constants into array and coerce, if required if (results != null) { var asArray = Array.CreateInstance(_arrayReturnType, _length); _constantResult = asArray; for (int i = 0; i < _length; i++) { if (_mustCoerce) { var boxed = results[i]; if (boxed != null) { Object coercedResult = _coercer.Invoke(boxed); asArray.SetValue(coercedResult, i); } } else { asArray.SetValue(results[i], i); } } } return(null); }
private CountMinSketchSpecForge ValidateSpecification(ExprValidationContext exprValidationContext) { // default specification CountMinSketchSpecHashes hashes = new CountMinSketchSpecHashes(DEFAULT_EPS_OF_TOTAL_COUNT, DEFAULT_CONFIDENCE, DEFAULT_SEED); CountMinSketchSpecForge spec = new CountMinSketchSpecForge(hashes, null, DEFAULT_AGENT); // no parameters if (this.ChildNodes.Length == 0) { return(spec); } // check expected parameter type: a json object if (this.ChildNodes.Length > 1 || !(this.ChildNodes[0] is ExprConstantNode)) { throw GetDeclaredWrongParameterExpr(); } ExprConstantNode constantNode = (ExprConstantNode)this.ChildNodes[0]; object value = constantNode.ConstantValue; if (!(value is IDictionary <string, object>)) { throw GetDeclaredWrongParameterExpr(); } // define what to populate PopulateFieldWValueDescriptor[] descriptors = new PopulateFieldWValueDescriptor[] { new PopulateFieldWValueDescriptor( NAME_EPS_OF_TOTAL_COUNT, typeof(double?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.EpsOfTotalCount = value.AsDouble(); } }, true), new PopulateFieldWValueDescriptor( NAME_CONFIDENCE, typeof(double?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.Confidence = value.AsDouble(); } }, true), new PopulateFieldWValueDescriptor( NAME_SEED, typeof(int?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.Seed = value.AsInt32(); } }, true), new PopulateFieldWValueDescriptor( NAME_TOPK, typeof(int?), spec.GetType(), value => { if (value != null) { spec.TopkSpec = (int?)value; } }, true), new PopulateFieldWValueDescriptor( NAME_AGENT, typeof(string), spec.GetType(), value => { if (value != null) { CountMinSketchAgentForge transform; try { var transformClass = exprValidationContext.ImportService.ResolveClass( (string)value, false, ExtensionClassEmpty.INSTANCE); transform = TypeHelper.Instantiate <CountMinSketchAgentForge>(transformClass); } catch (Exception e) { throw new ExprValidationException("Failed to instantiate agent provider: " + e.Message, e); } spec.Agent = transform; } }, true), }; // populate from json, validates incorrect names, coerces types, instantiates transform PopulateUtil.PopulateSpecCheckParameters(descriptors, (IDictionary <string, object>)value, spec, ExprNodeOrigin.AGGPARAM, exprValidationContext); return(spec); }