public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { ExprEvaluator sizeEval = bodiesAndParameters[0].BodyEvaluator; if (inputEventType != null) { base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); } if (EnumMethodEnum == EnumMethodEnum.TAKE) { return(new EnumEvalTake(sizeEval, numStreamsIncoming)); } else { return(new EnumEvalTakeLast(sizeEval, numStreamsIncoming)); } }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); if (first.GoesToNames.Count == 1) { return(new EnumEvalWhereEvents(first.BodyEvaluator, first.StreamCountIncoming)); } return(new EnumEvalWhereIndexEvents( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1])); } TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); if (first.GoesToNames.Count == 1) { return(new EnumEvalWhereScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalWhereScalarIndex( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0], (ObjectArrayEventType)first.GoesToTypes[1])); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var isDescending = EnumMethodEnum == EnumMethodEnum.ORDERBYDESC; if (bodiesAndParameters.IsEmpty()) { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); return new EnumOrderByAscDescScalarForge(numStreamsIncoming, isDescending); } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; if (inputEventType == null) { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); return new EnumOrderByAscDescScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, isDescending, (ObjectArrayEventType) first.GoesToTypes[0]); } TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); return new EnumOrderByAscDescEventsForge(first.BodyForge, first.StreamCountIncoming, isDescending); }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { bool isDescending = EnumMethodEnum == EnumMethodEnum.ORDERBYDESC; if (bodiesAndParameters.IsEmpty()) { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); return(new EnumEvalOrderByAscDescScalar(numStreamsIncoming, isDescending)); } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType == null) { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); return(new EnumEvalOrderByAscDescScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, isDescending, (ObjectArrayEventType)first.GoesToTypes[0])); } base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); return(new EnumEvalOrderByAscDescEvents(first.BodyEvaluator, first.StreamCountIncoming, isDescending)); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var sizeEval = bodiesAndParameters[0].BodyForge; if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); } if (EnumMethodEnum == EnumMethodEnum.TAKE) { return new EnumTakeForge(sizeEval, numStreamsIncoming, inputEventType == null); } else { return new EnumTakeLastForge(sizeEval, numStreamsIncoming, inputEventType == null); } }
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType( EventType inputEventType, Type collectionComponentType) { return(lambda => inputEventType == null ? EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null) : EPTypeHelper.CollectionOfEvents(inputEventType)); }
public ExprDotForgeUnpackCollEventBeanTable( EventType type, TableMetaData table) { this.typeInfo = EPTypeHelper.CollectionOfSingleValue( table.PublicEventType.UnderlyingType, null); this.table = table; }
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType( EventType inputEventType, Type collectionComponentType) { return(lambda => { var returnType = lambda.BodyForge.EvaluationType; return EPTypeHelper.CollectionOfSingleValue(returnType, typeof(EventBean)); }); }
public static ExprDotEnumerationSourceForProps GetPropertyEnumerationSource(string propertyName, int streamId, EventType streamType, bool allowEnumType, bool disablePropertyExpressionEventCollCache) { var propertyType = streamType.GetPropertyType(propertyName); var typeInfo = EPTypeHelper.SingleValue(propertyType); // assume scalar for now // no enumeration methods, no need to expose as an enumeration if (!allowEnumType) { return(new ExprDotEnumerationSourceForProps(null, typeInfo, streamId, null)); } var fragmentEventType = streamType.GetFragmentType(propertyName); var getter = streamType.GetGetter(propertyName); ExprEvaluatorEnumeration enumEvaluator = null; if (getter != null && fragmentEventType != null) { if (fragmentEventType.IsIndexed) { enumEvaluator = new PropertyExprEvaluatorEventCollection(propertyName, streamId, fragmentEventType.FragmentType, getter, disablePropertyExpressionEventCollCache); typeInfo = EPTypeHelper.CollectionOfEvents(fragmentEventType.FragmentType); } else { // we don't want native to require an eventbean instance enumEvaluator = new PropertyExprEvaluatorEventSingle(streamId, fragmentEventType.FragmentType, getter); typeInfo = EPTypeHelper.SingleEvent(fragmentEventType.FragmentType); } } else { var desc = EventTypeUtility.GetNestablePropertyDescriptor(streamType, propertyName); if (desc != null && desc.IsIndexed && !desc.RequiresIndex && desc.PropertyComponentType != null) { if (propertyType.IsGenericCollection()) { enumEvaluator = new PropertyExprEvaluatorScalarCollection(propertyName, streamId, getter, desc.PropertyComponentType); } else if (propertyType.IsImplementsInterface(typeof(System.Collections.IEnumerable))) { enumEvaluator = new PropertyExprEvaluatorScalarIterable(propertyName, streamId, getter, desc.PropertyComponentType); } else if (propertyType.IsArray) { enumEvaluator = new PropertyExprEvaluatorScalarArray(propertyName, streamId, getter, desc.PropertyComponentType); } else { throw new IllegalStateException("Property indicated indexed-type but failed to find proper collection adapter for use with enumeration methods"); } typeInfo = EPTypeHelper.CollectionOfSingleValue(desc.PropertyComponentType); } } var enumEvaluatorGivenEvent = (ExprEvaluatorEnumerationGivenEvent)enumEvaluator; return(new ExprDotEnumerationSourceForProps(enumEvaluator, typeInfo, streamId, enumEvaluatorGivenEvent)); }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { ExprDotEvalParam first = bodiesAndParameters[0]; ExprDotEnumerationSource enumSrc = ExprDotNodeUtility.GetEnumerationSource( first.Body, streamTypeService, eventAdapterService, statementId, true, disablePropertyExpressionEventCollCache); if (inputEventType != null) { base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); } if (enumSrc.Enumeration == null) { String message = "Enumeration method '" + enumMethodUsedName + "' requires an expression yielding an event-collection as input paramater"; throw new ExprValidationException(message); } var setType = enumSrc.Enumeration.GetEventTypeCollection(eventAdapterService, statementId); if (!Equals(setType, inputEventType)) { bool isSubtype = EventTypeUtility.IsTypeOrSubTypeOf(setType, inputEventType); if (!isSubtype) { String message = "Enumeration method '" + enumMethodUsedName + "' expects event type '" + inputEventType.Name + "' but receives event type '" + enumSrc.Enumeration.GetEventTypeCollection(eventAdapterService, statementId).Name + "'"; throw new ExprValidationException(message); } } if (EnumMethodEnum == EnumMethodEnum.UNION) { return(new EnumEvalUnion(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null)); } else if (EnumMethodEnum == EnumMethodEnum.INTERSECT) { return(new EnumEvalIntersect(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null)); } else if (EnumMethodEnum == EnumMethodEnum.EXCEPT) { return(new EnumEvalExcept(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null)); } else { throw new ArgumentException("Invalid enumeration method for this factory: " + EnumMethodEnum); } }
public static ExprDotEnumerationSourceForge GetEnumerationSource( ExprNode inputExpression, StreamTypeService streamTypeService, bool hasEnumerationMethod, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices compileTimeServices) { var rootNodeForge = inputExpression.Forge; ExprEnumerationForge rootLambdaForge = null; EPType info = null; if (rootNodeForge is ExprEnumerationForge) { rootLambdaForge = (ExprEnumerationForge) rootNodeForge; var eventTypeCollection = rootLambdaForge.GetEventTypeCollection(statementRawInfo, compileTimeServices); if (eventTypeCollection != null) { info = EPTypeHelper.CollectionOfEvents(eventTypeCollection); } if (info == null) { var eventTypeSingle = rootLambdaForge.GetEventTypeSingle(statementRawInfo, compileTimeServices); if (eventTypeSingle != null) { info = EPTypeHelper.SingleEvent(eventTypeSingle); } } if (info == null) { var componentType = rootLambdaForge.ComponentTypeCollection; if (componentType != null) { info = EPTypeHelper.CollectionOfSingleValue( rootLambdaForge.ComponentTypeCollection, typeof(ICollection<>).MakeGenericType(componentType)); } } if (info == null) { rootLambdaForge = null; // not a lambda evaluator } } else if (inputExpression is ExprIdentNode) { var identNode = (ExprIdentNode) inputExpression; var streamId = identNode.StreamId; var streamType = streamTypeService.EventTypes[streamId]; return GetPropertyEnumerationSource( identNode.ResolvedPropertyName, streamId, streamType, hasEnumerationMethod, disablePropertyExpressionEventCollCache); } return new ExprDotEnumerationSourceForge(info, null, rootLambdaForge); }
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { if (inputEventType != null) { base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); } return(new EnumEvalReverse(numStreamsIncoming)); }
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; var returnType = first.BodyEvaluator.ReturnType; base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(returnType); if (inputEventType == null) { return(new EnumEvalSelectFromScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalSelectFromEvents(first.BodyEvaluator, first.StreamCountIncoming)); }
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType != null) { base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); if (first.GoesToNames.Count == 1) { if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST) { return(new EnumEvalTakeWhileLastEvents(first.BodyEvaluator, first.StreamCountIncoming)); } return(new EnumEvalTakeWhileEvents(first.BodyEvaluator, first.StreamCountIncoming)); } if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST) { return(new EnumEvalTakeWhileLastIndexEvents( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1])); } return(new EnumEvalTakeWhileIndexEvents( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1])); } base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); if (first.GoesToNames.Count == 1) { if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST) { return(new EnumEvalTakeWhileLastScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalTakeWhileScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST) { return(new EnumEvalTakeWhileLastIndexScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0], (ObjectArrayEventType)first.GoesToTypes[1])); } return(new EnumEvalTakeWhileIndexScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0], (ObjectArrayEventType)first.GoesToTypes[1])); }
public override EnumForgeDescFactory GetForgeFactory( DotMethodFP footprint, IList<ExprNode> parameters, EnumMethodEnum enumMethod, String enumMethodUsedName, EventType inputEventType, Type collectionComponentType, ExprValidationContext validationContext) { EPType type; if (inputEventType != null) { type = EPTypeHelper.CollectionOfEvents(inputEventType); } else { type = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); } return new EnumForgeDescFactoryTake(enumMethod, type, inputEventType == null); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; var returnType = first.BodyForge.EvaluationType; TypeInfo = EPTypeHelper.CollectionOfSingleValue(returnType, typeof(EventBean)); if (inputEventType == null) { return new EnumSelectFromScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumSelectFromEventsForge(first.BodyForge, first.StreamCountIncoming); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); if (first.GoesToNames.Count == 1) { return new EnumWhereEventsForge(first.BodyForge, first.StreamCountIncoming); } return new EnumWhereIndexEventsForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[1]); } TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); if (first.GoesToNames.Count == 1) { return new EnumWhereScalarForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumWhereScalarIndexForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0], (ObjectArrayEventType) first.GoesToTypes[1]); }
public static ExprDotEnumerationSource GetEnumerationSource(ExprNode inputExpression, StreamTypeService streamTypeService, EventAdapterService eventAdapterService, int statementId, bool hasEnumerationMethod, bool disablePropertyExpressionEventCollCache) { var rootNodeEvaluator = inputExpression.ExprEvaluator; ExprEvaluatorEnumeration rootLambdaEvaluator = null; EPType info = null; if (rootNodeEvaluator is ExprEvaluatorEnumeration) { rootLambdaEvaluator = (ExprEvaluatorEnumeration)rootNodeEvaluator; if (rootLambdaEvaluator.GetEventTypeCollection(eventAdapterService, statementId) != null) { info = EPTypeHelper.CollectionOfEvents(rootLambdaEvaluator.GetEventTypeCollection(eventAdapterService, statementId)); } else if (rootLambdaEvaluator.GetEventTypeSingle(eventAdapterService, statementId) != null) { info = EPTypeHelper.SingleEvent(rootLambdaEvaluator.GetEventTypeSingle(eventAdapterService, statementId)); } else if (rootLambdaEvaluator.ComponentTypeCollection != null) { info = EPTypeHelper.CollectionOfSingleValue(rootLambdaEvaluator.ComponentTypeCollection); } else { rootLambdaEvaluator = null; // not a lambda evaluator } } else if (inputExpression is ExprIdentNode) { var identNode = (ExprIdentNode)inputExpression; var streamId = identNode.StreamId; var streamType = streamTypeService.EventTypes[streamId]; return(GetPropertyEnumerationSource(identNode.ResolvedPropertyName, streamId, streamType, hasEnumerationMethod, disablePropertyExpressionEventCollCache)); } return(new ExprDotEnumerationSource(info, null, rootLambdaEvaluator)); }
public static EPType GetReturnType(this SupportAggMFFunc value, EventType eventType, ExprNode[] parameters) { if (value == SupportAggMFFunc.SCALAR) { return(EPTypeHelper.SingleValue(parameters[0].ExprEvaluator.ReturnType)); } if (value == SupportAggMFFunc.ENUM_EVENT) { return(EPTypeHelper.CollectionOfEvents(eventType)); } if (value == SupportAggMFFunc.COLL_SCALAR) { return(EPTypeHelper.CollectionOfSingleValue(parameters[0].ExprEvaluator.ReturnType)); } if (value == SupportAggMFFunc.ARR_SCALAR) { return(EPTypeHelper.Array(parameters[0].ExprEvaluator.ReturnType)); } if (value == SupportAggMFFunc.SINGLE_EVENT_1 || value == SupportAggMFFunc.SINGLE_EVENT_2) { return(EPTypeHelper.SingleEvent(eventType)); } throw new ArgumentException("Return type not supported for " + value); }
public ExprDotEvalUnpackCollEventBeanTable(EventType type, TableMetadata tableMetadata) { this._typeInfo = EPTypeHelper.CollectionOfSingleValue(tableMetadata.PublicEventType.UnderlyingType); this._tableMetadata = tableMetadata; }
public ExprDotEvalUnpackCollEventBean(EventType type) { _typeInfo = EPTypeHelper.CollectionOfSingleValue(type.UnderlyingType); }
public ExprDotForgeUnpackCollEventBean(EventType type) { TypeInfo = EPTypeHelper.CollectionOfSingleValue( type.UnderlyingType, typeof(EventBean)); }
public override ExprNode Validate(ExprValidationContext validationContext) { // validate all parameters ExprNodeUtility.Validate(ExprNodeOrigin.DOTNODEPARAMETER, _chainSpec, validationContext); // determine if there are enumeration method expressions in the chain bool hasEnumerationMethod = false; foreach (ExprChainedSpec chain in _chainSpec) { if (chain.Name.IsEnumerationMethod()) { hasEnumerationMethod = true; break; } } // determine if there is an implied binding, replace first chain element with evaluation node if there is if (validationContext.StreamTypeService.HasTableTypes && validationContext.TableService != null && _chainSpec.Count > 1 && _chainSpec[0].IsProperty) { Pair <ExprNode, IList <ExprChainedSpec> > tableNode = validationContext.TableService.GetTableNodeChainable( validationContext.StreamTypeService, _chainSpec, validationContext.EngineImportService); if (tableNode != null) { ExprNode node = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DOTNODE, tableNode.First, validationContext); if (tableNode.Second.IsEmpty()) { return(node); } _chainSpec.Clear(); _chainSpec.AddAll(tableNode.Second); AddChildNode(node); } } // The root node expression may provide the input value: // Such as "window(*).doIt(...)" or "(select * from Window).doIt()" or "prevwindow(sb).doIt(...)", in which case the expression to act on is a child expression // StreamTypeService streamTypeService = validationContext.StreamTypeService; if (ChildNodes.Length != 0) { // the root expression is the first child node ExprNode rootNode = ChildNodes[0]; ExprEvaluator rootNodeEvaluator = rootNode.ExprEvaluator; // the root expression may also provide a lambda-function input (GetEnumerator<EventBean>) // Determine collection-type and evaluator if any for root node ExprDotEnumerationSource enumSrc = ExprDotNodeUtility.GetEnumerationSource(rootNode, validationContext.StreamTypeService, validationContext.EventAdapterService, validationContext.StatementId, hasEnumerationMethod, validationContext.IsDisablePropertyExpressionEventCollCache); EPType typeInfo; if (enumSrc.ReturnType == null) { typeInfo = EPTypeHelper.SingleValue(rootNodeEvaluator.ReturnType); // not a collection type, treat as scalar } else { typeInfo = enumSrc.ReturnType; } ExprDotNodeRealizedChain evals = ExprDotNodeUtility.GetChainEvaluators(enumSrc.StreamOfProviderIfApplicable, typeInfo, _chainSpec, validationContext, _isDuckTyping, new ExprDotNodeFilterAnalyzerInputExpr()); _exprEvaluator = new ExprDotEvalRootChild(hasEnumerationMethod, this, rootNodeEvaluator, enumSrc.Enumeration, typeInfo, evals.Chain, evals.ChainWithUnpack, false); return(null); } // No root node, and this is a 1-element chain i.e. "something(param,...)". // Plug-in single-row methods are not handled here. // Plug-in aggregation methods are not handled here. if (_chainSpec.Count == 1) { ExprChainedSpec spec = _chainSpec[0]; if (spec.Parameters.IsEmpty()) { throw HandleNotFound(spec.Name); } // single-parameter can resolve to a property Pair <PropertyResolutionDescriptor, string> propertyInfoPair = null; try { propertyInfoPair = ExprIdentNodeUtil.GetTypeFromStream(streamTypeService, spec.Name, streamTypeService.HasPropertyAgnosticType, false); } catch (ExprValidationPropertyException) { // fine } // if not a property then try built-in single-row non-grammar functions if (propertyInfoPair == null && string.Equals(spec.Name, EngineImportServiceConstants.EXT_SINGLEROW_FUNCTION_TRANSPOSE, StringComparison.OrdinalIgnoreCase)) { if (spec.Parameters.Count != 1) { throw new ExprValidationException("The " + EngineImportServiceConstants.EXT_SINGLEROW_FUNCTION_TRANSPOSE + " function requires a single parameter expression"); } _exprEvaluator = new ExprDotEvalTransposeAsStream(_chainSpec[0].Parameters[0].ExprEvaluator); } else if (spec.Parameters.Count != 1) { throw HandleNotFound(spec.Name); } else { if (propertyInfoPair == null) { throw new ExprValidationException("Unknown single-row function, aggregation function or mapped or indexed property named '" + spec.Name + "' could not be resolved"); } _exprEvaluator = GetPropertyPairEvaluator(spec.Parameters[0].ExprEvaluator, propertyInfoPair, validationContext); _streamNumReferenced = propertyInfoPair.First.StreamNum; } return(null); } // handle the case where the first chain spec element is a stream name. ExprValidationException prefixedStreamNumException = null; int prefixedStreamNumber = PrefixedStreamName(_chainSpec, validationContext.StreamTypeService); if (prefixedStreamNumber != -1) { ExprChainedSpec specAfterStreamName = _chainSpec[1]; // Attempt to resolve as property Pair <PropertyResolutionDescriptor, string> propertyInfoPair = null; try { string propName = _chainSpec[0].Name + "." + specAfterStreamName.Name; propertyInfoPair = ExprIdentNodeUtil.GetTypeFromStream(streamTypeService, propName, streamTypeService.HasPropertyAgnosticType, false); } catch (ExprValidationPropertyException) { // fine } if (propertyInfoPair != null) { if (specAfterStreamName.Parameters.Count != 1) { throw HandleNotFound(specAfterStreamName.Name); } _exprEvaluator = GetPropertyPairEvaluator(specAfterStreamName.Parameters[0].ExprEvaluator, propertyInfoPair, validationContext); _streamNumReferenced = propertyInfoPair.First.StreamNum; return(null); } // Attempt to resolve as event-underlying object instance method EventType eventType = validationContext.StreamTypeService.EventTypes[prefixedStreamNumber]; Type type = eventType.UnderlyingType; IList <ExprChainedSpec> remainderChain = new List <ExprChainedSpec>(_chainSpec); remainderChain.RemoveAt(0); ExprValidationException methodEx = null; ExprDotEval[] underlyingMethodChain = null; try { EPType typeInfo = EPTypeHelper.SingleValue(type); underlyingMethodChain = ExprDotNodeUtility.GetChainEvaluators(prefixedStreamNumber, typeInfo, remainderChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStream(prefixedStreamNumber)).ChainWithUnpack; } catch (ExprValidationException ex) { methodEx = ex; // expected - may not be able to find the methods on the underlying } ExprDotEval[] eventTypeMethodChain = null; ExprValidationException enumDatetimeEx = null; try { EPType typeInfo = EPTypeHelper.SingleEvent(eventType); ExprDotNodeRealizedChain chain = ExprDotNodeUtility.GetChainEvaluators(prefixedStreamNumber, typeInfo, remainderChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStream(prefixedStreamNumber)); eventTypeMethodChain = chain.ChainWithUnpack; _exprDotNodeFilterAnalyzerDesc = chain.FilterAnalyzerDesc; } catch (ExprValidationException ex) { enumDatetimeEx = ex; // expected - may not be able to find the methods on the underlying } if (underlyingMethodChain != null) { _exprEvaluator = new ExprDotEvalStreamMethod(this, prefixedStreamNumber, underlyingMethodChain); _streamNumReferenced = prefixedStreamNumber; } else if (eventTypeMethodChain != null) { _exprEvaluator = new ExprDotEvalStreamEventBean(this, prefixedStreamNumber, eventTypeMethodChain); _streamNumReferenced = prefixedStreamNumber; } if (_exprEvaluator != null) { return(null); } else { if (ExprDotNodeUtility.IsDatetimeOrEnumMethod(remainderChain[0].Name)) { prefixedStreamNumException = enumDatetimeEx; } else { prefixedStreamNumException = new ExprValidationException("Failed to solve '" + remainderChain[0].Name + "' to either a date-time or enumeration method, an event property or a method on the event underlying object: " + methodEx.Message, methodEx); } } } // There no root node, in this case the classname or property name is provided as part of the chain. // Such as "MyClass.myStaticLib(...)" or "mycollectionproperty.doIt(...)" // IList <ExprChainedSpec> modifiedChain = new List <ExprChainedSpec>(_chainSpec); ExprChainedSpec firstItem = modifiedChain.Delete(0); Pair <PropertyResolutionDescriptor, string> propertyInfoPairX = null; try { propertyInfoPairX = ExprIdentNodeUtil.GetTypeFromStream(streamTypeService, firstItem.Name, streamTypeService.HasPropertyAgnosticType, true); } catch (ExprValidationPropertyException) { // not a property } // If property then treat it as such if (propertyInfoPairX != null) { string propertyName = propertyInfoPairX.First.PropertyName; int streamId = propertyInfoPairX.First.StreamNum; EventType streamType = streamTypeService.EventTypes[streamId]; EPType typeInfo; ExprEvaluatorEnumeration enumerationEval = null; EPType inputType; ExprEvaluator rootNodeEvaluator = null; EventPropertyGetter getter; if (firstItem.Parameters.IsEmpty()) { getter = streamType.GetGetter(propertyInfoPairX.First.PropertyName); ExprDotEnumerationSourceForProps propertyEval = ExprDotNodeUtility.GetPropertyEnumerationSource( propertyInfoPairX.First.PropertyName, streamId, streamType, hasEnumerationMethod, validationContext.IsDisablePropertyExpressionEventCollCache); typeInfo = propertyEval.ReturnType; enumerationEval = propertyEval.Enumeration; inputType = propertyEval.ReturnType; rootNodeEvaluator = new PropertyExprEvaluatorNonLambda(streamId, getter, propertyInfoPairX.First.PropertyType); } else { // property with parameter - mapped or indexed property EventPropertyDescriptor desc = EventTypeUtility.GetNestablePropertyDescriptor(streamTypeService.EventTypes[propertyInfoPairX.First.StreamNum], firstItem.Name); if (firstItem.Parameters.Count > 1) { throw new ExprValidationException("Property '" + firstItem.Name + "' may not be accessed passing 2 or more parameters"); } ExprEvaluator paramEval = firstItem.Parameters[0].ExprEvaluator; typeInfo = EPTypeHelper.SingleValue(desc.PropertyComponentType); inputType = typeInfo; getter = null; if (desc.IsMapped) { if (paramEval.ReturnType != typeof(string)) { throw new ExprValidationException("Parameter expression to mapped property '" + propertyName + "' is expected to return a string-type value but returns " + paramEval.ReturnType.GetTypeNameFullyQualPretty()); } EventPropertyGetterMapped mappedGetter = propertyInfoPairX.First.StreamEventType.GetGetterMapped(propertyInfoPairX.First.PropertyName); if (mappedGetter == null) { throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object"); } rootNodeEvaluator = new PropertyExprEvaluatorNonLambdaMapped(streamId, mappedGetter, paramEval, desc.PropertyComponentType); } if (desc.IsIndexed) { if (paramEval.ReturnType.GetBoxedType() != typeof(int?)) { throw new ExprValidationException("Parameter expression to mapped property '" + propertyName + "' is expected to return a Integer-type value but returns " + paramEval.ReturnType.GetTypeNameFullyQualPretty()); } EventPropertyGetterIndexed indexedGetter = propertyInfoPairX.First.StreamEventType.GetGetterIndexed(propertyInfoPairX.First.PropertyName); if (indexedGetter == null) { throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object"); } rootNodeEvaluator = new PropertyExprEvaluatorNonLambdaIndexed(streamId, indexedGetter, paramEval, desc.PropertyComponentType); } } if (typeInfo == null) { throw new ExprValidationException("Property '" + propertyName + "' is not a mapped or indexed property"); } // try to build chain based on the input (non-fragment) ExprDotNodeRealizedChain evals; ExprDotNodeFilterAnalyzerInputProp filterAnalyzerInputProp = new ExprDotNodeFilterAnalyzerInputProp(propertyInfoPairX.First.StreamNum, propertyInfoPairX.First.PropertyName); bool rootIsEventBean = false; try { evals = ExprDotNodeUtility.GetChainEvaluators(streamId, inputType, modifiedChain, validationContext, _isDuckTyping, filterAnalyzerInputProp); } catch (ExprValidationException ex) { // try building the chain based on the fragment event type (i.e. A.after(B) based on A-configured start time where A is a fragment) FragmentEventType fragment = propertyInfoPairX.First.FragmentEventType; if (fragment == null) { throw; } EPType fragmentTypeInfo; if (fragment.IsIndexed) { fragmentTypeInfo = EPTypeHelper.CollectionOfEvents(fragment.FragmentType); } else { fragmentTypeInfo = EPTypeHelper.SingleEvent(fragment.FragmentType); } rootIsEventBean = true; evals = ExprDotNodeUtility.GetChainEvaluators(propertyInfoPairX.First.StreamNum, fragmentTypeInfo, modifiedChain, validationContext, _isDuckTyping, filterAnalyzerInputProp); rootNodeEvaluator = new PropertyExprEvaluatorNonLambdaFragment(streamId, getter, fragment.FragmentType.UnderlyingType); } _exprEvaluator = new ExprDotEvalRootChild(hasEnumerationMethod, this, rootNodeEvaluator, enumerationEval, inputType, evals.Chain, evals.ChainWithUnpack, !rootIsEventBean); _exprDotNodeFilterAnalyzerDesc = evals.FilterAnalyzerDesc; _streamNumReferenced = propertyInfoPairX.First.StreamNum; _rootPropertyName = propertyInfoPairX.First.PropertyName; return(null); } // If variable then resolve as such string contextNameVariable = validationContext.VariableService.IsContextVariable(firstItem.Name); if (contextNameVariable != null) { throw new ExprValidationException("Method invocation on context-specific variable is not supported"); } VariableReader variableReader = validationContext.VariableService.GetReader(firstItem.Name, EPStatementStartMethodConst.DEFAULT_AGENT_INSTANCE_ID); if (variableReader != null) { EPType typeInfo; ExprDotStaticMethodWrap wrap; if (variableReader.VariableMetaData.VariableType.IsArray) { typeInfo = EPTypeHelper.CollectionOfSingleValue(variableReader.VariableMetaData.VariableType.GetElementType()); wrap = new ExprDotStaticMethodWrapArrayScalar(variableReader.VariableMetaData.VariableName, variableReader.VariableMetaData.VariableType.GetElementType()); } else if (variableReader.VariableMetaData.EventType != null) { typeInfo = EPTypeHelper.SingleEvent(variableReader.VariableMetaData.EventType); wrap = null; } else { typeInfo = EPTypeHelper.SingleValue(variableReader.VariableMetaData.VariableType); wrap = null; } ExprDotNodeRealizedChain evals = ExprDotNodeUtility.GetChainEvaluators(null, typeInfo, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); _exprEvaluator = new ExprDotEvalVariable(this, variableReader, wrap, evals.ChainWithUnpack); return(null); } // try resolve as enumeration class with value object enumconstant = TypeHelper.ResolveIdentAsEnumConst(firstItem.Name, validationContext.EngineImportService, false); if (enumconstant != null) { // try resolve method ExprChainedSpec methodSpec = modifiedChain[0]; string enumvalue = firstItem.Name; ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler { ProcHandle = ex => new ExprValidationException("Failed to resolve method '" + methodSpec.Name + "' on enumeration value '" + enumvalue + "': " + ex.Message), }; EventType wildcardType = validationContext.StreamTypeService.EventTypes.Length != 1 ? null : validationContext.StreamTypeService.EventTypes[0]; ExprNodeUtilMethodDesc methodDesc = ExprNodeUtility.ResolveMethodAllowWildcardAndStream( enumconstant.GetType().Name, enumconstant.GetType(), methodSpec.Name, methodSpec.Parameters, validationContext.EngineImportService, validationContext.EventAdapterService, validationContext.StatementId, wildcardType != null, wildcardType, handler, methodSpec.Name, validationContext.TableService); // method resolved, hook up modifiedChain.RemoveAt(0); // we identified this piece ExprDotStaticMethodWrap optionalLambdaWrap = ExprDotStaticMethodWrapFactory.Make(methodDesc.ReflectionMethod, validationContext.EventAdapterService, modifiedChain); EPType typeInfo = optionalLambdaWrap != null ? optionalLambdaWrap.TypeInfo : EPTypeHelper.SingleValue(methodDesc.FastMethod.ReturnType); ExprDotNodeRealizedChain evals = ExprDotNodeUtility.GetChainEvaluators(null, typeInfo, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); _exprEvaluator = new ExprDotEvalStaticMethod(validationContext.StatementName, firstItem.Name, methodDesc.FastMethod, methodDesc.ChildEvals, false, optionalLambdaWrap, evals.ChainWithUnpack, false, enumconstant); return(null); } // if prefixed by a stream name, we are giving up if (prefixedStreamNumException != null) { throw prefixedStreamNumException; } // If class then resolve as class ExprChainedSpec secondItem = modifiedChain.Delete(0); bool allowWildcard = validationContext.StreamTypeService.EventTypes.Length == 1; EventType streamZeroType = null; if (validationContext.StreamTypeService.EventTypes.Length > 0) { streamZeroType = validationContext.StreamTypeService.EventTypes[0]; } ExprNodeUtilMethodDesc method = ExprNodeUtility.ResolveMethodAllowWildcardAndStream( firstItem.Name, null, secondItem.Name, secondItem.Parameters, validationContext.EngineImportService, validationContext.EventAdapterService, validationContext.StatementId, allowWildcard, streamZeroType, new ExprNodeUtilResolveExceptionHandlerDefault(firstItem.Name + "." + secondItem.Name, false), secondItem.Name, validationContext.TableService); bool isConstantParameters = method.IsAllConstants && _isUDFCache; _isReturnsConstantResult = isConstantParameters && modifiedChain.IsEmpty(); // this may return a pair of null if there is no lambda or the result cannot be wrapped for lambda-function use ExprDotStaticMethodWrap optionalLambdaWrapX = ExprDotStaticMethodWrapFactory.Make(method.ReflectionMethod, validationContext.EventAdapterService, modifiedChain); EPType typeInfoX = optionalLambdaWrapX != null ? optionalLambdaWrapX.TypeInfo : EPTypeHelper.SingleValue(method.ReflectionMethod.ReturnType); ExprDotNodeRealizedChain evalsX = ExprDotNodeUtility.GetChainEvaluators(null, typeInfoX, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); _exprEvaluator = new ExprDotEvalStaticMethod(validationContext.StatementName, firstItem.Name, method.FastMethod, method.ChildEvals, isConstantParameters, optionalLambdaWrapX, evalsX.ChainWithUnpack, false, null); return(null); }
public static ExprDotNodeRealizedChain GetChainEvaluators( int?streamOfProviderIfApplicable, EPType inputType, IList <Chainable> chainSpec, ExprValidationContext validationContext, bool isDuckTyping, ExprDotNodeFilterAnalyzerInput inputDesc) { var methodForges = new List <ExprDotForge>(); var currentInputType = inputType; EnumMethodDesc lastLambdaFunc = null; var lastElement = chainSpec.IsEmpty() ? null : chainSpec[chainSpec.Count - 1]; FilterExprAnalyzerAffector filterAnalyzerDesc = null; Deque <Chainable> chainSpecStack = new ArrayDeque <Chainable>(chainSpec); while (!chainSpecStack.IsEmpty()) { var chainElement = chainSpecStack.RemoveFirst(); var parameters = chainElement.GetParametersOrEmpty(); var chainElementName = chainElement.GetRootNameOrEmptyString(); var last = chainSpecStack.IsEmpty(); lastLambdaFunc = null; // reset // compile parameters for chain element var paramForges = new ExprForge[parameters.Count]; var paramTypes = new Type[parameters.Count]; for (var i = 0; i < parameters.Count; i++) { paramForges[i] = parameters[i].Forge; paramTypes[i] = paramForges[i].EvaluationType; } // check if special 'size' method if (currentInputType is ClassMultiValuedEPType) { var type = (ClassMultiValuedEPType)currentInputType; if (string.Equals(chainElementName, "size", StringComparison.InvariantCultureIgnoreCase) && paramTypes.Length == 0 && lastElement == chainElement) { ExprDotForge size; var containerType = ((ClassMultiValuedEPType)currentInputType).Container; if (containerType.IsArray) { size = new ExprDotForgeSizeArray(); } else { size = new ExprDotForgeSizeCollection(); } methodForges.Add(size); currentInputType = size.TypeInfo; continue; } if (string.Equals(chainElementName, "get", StringComparison.InvariantCultureIgnoreCase) && paramTypes.Length == 1 && paramTypes[0].GetBoxedType() == typeof(int?)) { ExprDotForge get; var componentType = type.Component.GetBoxedType(); if (type.Container.IsArray) { get = new ExprDotForgeGetArray(paramForges[0], componentType); } else { get = new ExprDotForgeGetCollection(paramForges[0], componentType); } methodForges.Add(get); currentInputType = get.TypeInfo; continue; } if (chainElement is ChainableArray && type.Container.IsArray) { var array = (ChainableArray)chainElement; var typeInfo = currentInputType; var indexExpr = ChainableArray.ValidateSingleIndexExpr( array.Indexes, () => "operation on type " + typeInfo.ToTypeDescriptive()); var componentType = type.Component.GetBoxedType(); var get = new ExprDotForgeGetArray(indexExpr.Forge, componentType); methodForges.Add(get); currentInputType = get.TypeInfo; continue; } } // determine if there is a matching method or property var methodTarget = GetMethodTarget(currentInputType); var matchingMethod = false; if (methodTarget != null && (!(chainElement is ChainableArray))) { try { GetValidateMethodDescriptor(methodTarget, chainElementName, parameters, validationContext); matchingMethod = true; } catch (ExprValidationException) { // expected } } if (EnumMethodResolver.IsEnumerationMethod(chainElementName, validationContext.ImportService) && (!matchingMethod || methodTarget.IsArray || methodTarget.IsGenericCollection())) { var enumerationMethod = EnumMethodResolver.FromName(chainElementName, validationContext.ImportService); if (enumerationMethod == null) { throw new EPException("unable to determine enumeration method from name"); } var eval = enumerationMethod.Factory.Invoke(chainElement.GetParametersOrEmpty().Count); if (currentInputType is ClassEPType classEpType && classEpType.Clazz.IsGenericCollection() && !classEpType.Clazz.IsArray) { currentInputType = EPTypeHelper.CollectionOfSingleValue(typeof(object), null); } eval.Init(streamOfProviderIfApplicable, enumerationMethod, chainElementName, currentInputType, parameters, validationContext); currentInputType = eval.TypeInfo; if (currentInputType == null) { throw new IllegalStateException("Enumeration method '" + chainElementName + "' has not returned type information"); } methodForges.Add(eval); lastLambdaFunc = enumerationMethod; continue; } // resolve datetime if (DatetimeMethodResolver.IsDateTimeMethod(chainElementName, validationContext.ImportService) && (!matchingMethod || methodTarget == typeof(DateTimeEx) || methodTarget == typeof(DateTimeOffset) || methodTarget == typeof(DateTime))) { var datetimeMethod = DatetimeMethodResolver.FromName(chainElementName, validationContext.ImportService); var datetimeImpl = ExprDotDTFactory.ValidateMake( validationContext.StreamTypeService, chainSpecStack, datetimeMethod, chainElementName, currentInputType, parameters, inputDesc, validationContext.ImportService.TimeAbacus, validationContext.TableCompileTimeResolver, validationContext.ImportService, validationContext.StatementRawInfo); currentInputType = datetimeImpl.ReturnType; if (currentInputType == null) { throw new IllegalStateException( "Date-time method '" + chainElementName + "' has not returned type information"); } methodForges.Add(datetimeImpl.Forge); filterAnalyzerDesc = datetimeImpl.IntervalFilterDesc; continue; } // try to resolve as property if the last method returned a type if (currentInputType is EventEPType) { if (chainElement is ChainableArray) { throw new ExprValidationException("Could not perform array operation on type " + currentInputType.ToTypeDescriptive()); } var inputEventType = (EventTypeSPI)((EventEPType)currentInputType).EventType; var type = inputEventType.GetPropertyType(chainElementName); var getter = inputEventType.GetGetterSPI(chainElementName); var fragmentType = inputEventType.GetFragmentType(chainElementName); ExprDotForge forge; if (type != null && getter != null) { if (fragmentType == null || last) { forge = new ExprDotForgeProperty(getter, EPTypeHelper.SingleValue(type.GetBoxedType())); currentInputType = forge.TypeInfo; } else { if (!fragmentType.IsIndexed) { currentInputType = EPTypeHelper.SingleEvent(fragmentType.FragmentType); } else { currentInputType = EPTypeHelper.ArrayOfEvents(fragmentType.FragmentType); } forge = new ExprDotForgePropertyFragment(getter, currentInputType); } methodForges.Add(forge); continue; } } if (currentInputType is EventMultiValuedEPType eventMultiValuedEpType && chainElement is ChainableArray chainableArray) { var inputEventType = (EventTypeSPI)eventMultiValuedEpType.Component; var typeInfo = currentInputType; var indexExpr = ChainableArray.ValidateSingleIndexExpr( chainableArray.Indexes, () => "operation on type " + typeInfo.ToTypeDescriptive()); currentInputType = EPTypeHelper.SingleEvent(inputEventType); var forge = new ExprDotForgeEventArrayAtIndex(currentInputType, indexExpr); methodForges.Add(forge); continue; } // Finally try to resolve the method if (methodTarget != null && !(chainElement is ChainableArray)) { try { // find descriptor again, allow for duck typing var desc = GetValidateMethodDescriptor(methodTarget, chainElementName, parameters, validationContext); paramForges = desc.ChildForges; ExprDotForge forge; if (currentInputType is ClassEPType) { // if followed by an enumeration method, convert array to collection if (desc.ReflectionMethod.ReturnType.IsArray && !chainSpecStack.IsEmpty() && EnumMethodResolver.IsEnumerationMethod(chainSpecStack.First.GetRootNameOrEmptyString(), validationContext.ImportService)) { forge = new ExprDotMethodForgeNoDuck( validationContext.StatementName, desc.ReflectionMethod, paramForges, ExprDotMethodForgeNoDuck.DuckType.WRAPARRAY); } else { forge = new ExprDotMethodForgeNoDuck( validationContext.StatementName, desc.ReflectionMethod, paramForges, ExprDotMethodForgeNoDuck.DuckType.PLAIN); } } else { forge = new ExprDotMethodForgeNoDuck( validationContext.StatementName, desc.ReflectionMethod, paramForges, ExprDotMethodForgeNoDuck.DuckType.UNDERLYING); } methodForges.Add(forge); currentInputType = forge.TypeInfo; } catch (Exception e) { if (!isDuckTyping) { throw new ExprValidationException(e.Message, e); } var duck = new ExprDotMethodForgeDuck( validationContext.StatementName, validationContext.ImportService, chainElementName, paramTypes, paramForges); methodForges.Add(duck); currentInputType = duck.TypeInfo; } continue; } string message; if (!(chainElement is ChainableArray)) { message = "Could not find event property or method named '" + chainElementName + "' in " + currentInputType.ToTypeDescriptive(); } else { message = "Could not perform array operation on type " + currentInputType.ToTypeDescriptive(); } throw new ExprValidationException(message); } var intermediateEvals = methodForges.ToArray(); if (lastLambdaFunc != null) { ExprDotForge finalEval = null; if (currentInputType is EventMultiValuedEPType mvType) { var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(mvType.Component); if (tableMetadata != null) { finalEval = new ExprDotForgeUnpackCollEventBeanTable(mvType.Component, tableMetadata); } else { finalEval = new ExprDotForgeUnpackCollEventBean(mvType.Component); } } else if (currentInputType is EventEPType epType) { var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(epType.EventType); if (tableMetadata != null) { finalEval = new ExprDotForgeUnpackBeanTable(epType.EventType, tableMetadata); } else { finalEval = new ExprDotForgeUnpackBean(epType.EventType); } } if (finalEval != null) { methodForges.Add(finalEval); } } var unpackingForges = methodForges.ToArray(); return(new ExprDotNodeRealizedChain(intermediateEvals, unpackingForges, filterAnalyzerDesc)); }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { return(EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null)); }
public override EnumForgeDescFactory GetForgeFactory( DotMethodFP footprint, IList<ExprNode> parameters, EnumMethodEnum enumMethod, String enumMethodUsedName, EventType inputEventType, Type collectionComponentType, ExprValidationContext validationContext) { var first = parameters[0]; var enumSrc = ExprDotNodeUtility.GetEnumerationSource( first, validationContext.StreamTypeService, true, validationContext.IsDisablePropertyExpressionEventCollCache, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); EPType type; if (inputEventType != null) { type = EPTypeHelper.CollectionOfEvents(inputEventType); } else { type = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); } if (inputEventType != null) { var setType = enumSrc.Enumeration?.GetEventTypeCollection( validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); if (setType == null) { var message = "Enumeration method '" + enumMethodUsedName + "' requires an expression yielding a " + "collection of events of type '" + inputEventType.Name + "' as input parameter"; throw new ExprValidationException(message); } if (setType != inputEventType) { var isSubtype = EventTypeUtility.IsTypeOrSubTypeOf(setType, inputEventType); if (!isSubtype) { var message = "Enumeration method '" + enumMethodUsedName + "' expects event type '" + inputEventType.Name + "' but receives event type '" + setType.Name + "'"; throw new ExprValidationException(message); } } } else { var setType = enumSrc.Enumeration?.ComponentTypeCollection; if (setType == null) { var message = "Enumeration method '" + enumMethodUsedName + "' requires an expression yielding a " + "collection of values of type '" + collectionComponentType.Name + "' as input parameter"; throw new ExprValidationException(message); } if (!setType.IsAssignmentCompatible(collectionComponentType)) { var message = "Enumeration method '" + enumMethodUsedName + "' expects scalar type '" + collectionComponentType.Name + "' but receives event type '" + setType.Name + "'"; throw new ExprValidationException(message); } } return new EnumForgeDescFactoryEIU(enumMethod, type, enumSrc); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var first = bodiesAndParameters[0]; var enumSrc = ExprDotNodeUtility.GetEnumerationSource( first.Body, streamTypeService, true, disablePropertyExpressionEventCollCache, statementRawInfo, services); if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); } if (inputEventType != null) { var setType = enumSrc.Enumeration == null ? null : enumSrc.Enumeration.GetEventTypeCollection(statementRawInfo, services); if (setType == null) { var message = "Enumeration method '" + enumMethodUsedName + "' requires an expression yielding a " + "collection of events of type '" + inputEventType.Name + "' as input parameter"; throw new ExprValidationException(message); } if (setType != inputEventType) { var isSubtype = EventTypeUtility.IsTypeOrSubTypeOf(setType, inputEventType); if (!isSubtype) { var message = "Enumeration method '" + enumMethodUsedName + "' expects event type '" + inputEventType.Name + "' but receives event type '" + setType.Name + "'"; throw new ExprValidationException(message); } } } else { var setType = enumSrc.Enumeration?.ComponentTypeCollection; if (setType == null) { var message = "Enumeration method '" + enumMethodUsedName + "' requires an expression yielding a " + "collection of values of type '" + collectionComponentType.CleanName() + "' as input parameter"; throw new ExprValidationException(message); } if (!TypeHelper.IsAssignmentCompatible(setType, collectionComponentType)) { var message = "Enumeration method '" + enumMethodUsedName + "' expects scalar type '" + collectionComponentType.Name + "' but receives event type '" + setType.Name + "'"; throw new ExprValidationException(message); } } if (EnumMethodEnum == EnumMethodEnum.UNION) { return new EnumUnionForge(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null); } else if (EnumMethodEnum == EnumMethodEnum.INTERSECT) { return new EnumIntersectForge(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null); } else if (EnumMethodEnum == EnumMethodEnum.EXCEPT) { return new EnumExceptForge(numStreamsIncoming, enumSrc.Enumeration, inputEventType == null); } else { throw new ArgumentException("Invalid enumeration method for this factory: " + EnumMethodEnum); } }
public override ExprNode Validate(ExprValidationContext validationContext) { // check for plannable methods: these are validated according to different rules var appDotMethod = GetAppDotMethod(validationContext.IsFilterExpression); if (appDotMethod != null) { return appDotMethod; } // validate all parameters ExprNodeUtilityValidate.Validate(ExprNodeOrigin.DOTNODEPARAMETER, ChainSpec, validationContext); // determine if there are enumeration method expressions in the chain var hasEnumerationMethod = false; foreach (var chain in ChainSpec) { if (EnumMethodEnumExtensions.IsEnumerationMethod(chain.Name)) { hasEnumerationMethod = true; break; } } // determine if there is an implied binding, replace first chain element with evaluation node if there is if (validationContext.StreamTypeService.HasTableTypes && validationContext.TableCompileTimeResolver != null && ChainSpec.Count > 1 && ChainSpec[0].IsProperty) { var tableNode = TableCompileTimeUtil.GetTableNodeChainable( validationContext.StreamTypeService, ChainSpec, validationContext.ImportService, validationContext.TableCompileTimeResolver); if (tableNode != null) { var node = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.DOTNODE, tableNode.First, validationContext); if (tableNode.Second.IsEmpty()) { return node; } ChainSpec.Clear(); ChainSpec.AddAll(tableNode.Second); AddChildNode(node); } } // The root node expression may provide the input value: // Such as "window(*).doIt(...)" or "(select * from Window).doIt()" or "prevwindow(sb).doIt(...)", in which case the expression to act on is a child expression // var streamTypeService = validationContext.StreamTypeService; if (ChildNodes.Length != 0) { // the root expression is the first child node var rootNode = ChildNodes[0]; // the root expression may also provide a lambda-function input (Iterator<EventBean>) // Determine collection-type and evaluator if any for root node var enumSrc = ExprDotNodeUtility.GetEnumerationSource( rootNode, validationContext.StreamTypeService, hasEnumerationMethod, validationContext.IsDisablePropertyExpressionEventCollCache, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); EPType typeInfoX; if (enumSrc.ReturnType == null) { typeInfoX = EPTypeHelper.SingleValue( rootNode.Forge.EvaluationType); // not a collection type, treat as scalar } else { typeInfoX = enumSrc.ReturnType; } var evalsX = ExprDotNodeUtility.GetChainEvaluators( enumSrc.StreamOfProviderIfApplicable, typeInfoX, ChainSpec, validationContext, isDuckTyping, new ExprDotNodeFilterAnalyzerInputExpr()); forge = new ExprDotNodeForgeRootChild( this, null, null, null, hasEnumerationMethod, rootNode.Forge, enumSrc.Enumeration, typeInfoX, evalsX.Chain, evalsX.ChainWithUnpack, false); return null; } // No root node, and this is a 1-element chain i.e. "something(param,...)". // Plug-in single-row methods are not handled here. // Plug-in aggregation methods are not handled here. if (ChainSpec.Count == 1) { var spec = ChainSpec[0]; if (spec.Parameters.IsEmpty()) { throw HandleNotFound(spec.Name); } // single-parameter can resolve to a property Pair<PropertyResolutionDescriptor, string> propertyInfoPairX = null; try { propertyInfoPairX = ExprIdentNodeUtil.GetTypeFromStream( streamTypeService, spec.Name, streamTypeService.HasPropertyAgnosticType, false, validationContext.TableCompileTimeResolver); } catch (ExprValidationPropertyException) { // fine } // if not a property then try built-in single-row non-grammar functions if (propertyInfoPairX == null && spec.Name.ToLowerInvariant() .Equals(ImportServiceCompileTime.EXT_SINGLEROW_FUNCTION_TRANSPOSE)) { if (spec.Parameters.Count != 1) { throw new ExprValidationException( "The " + ImportServiceCompileTime.EXT_SINGLEROW_FUNCTION_TRANSPOSE + " function requires a single parameter expression"); } forge = new ExprDotNodeForgeTransposeAsStream(this, ChainSpec[0].Parameters[0].Forge); } else if (spec.Parameters.Count != 1) { throw HandleNotFound(spec.Name); } else { if (propertyInfoPairX == null) { throw new ExprValidationException( "Unknown single-row function, aggregation function or mapped or indexed property named '" + spec.Name + "' could not be resolved"); } forge = GetPropertyPairEvaluator(spec.Parameters[0].Forge, propertyInfoPairX, validationContext); } return null; } // handle the case where the first chain spec element is a stream name. ExprValidationException prefixedStreamNumException = null; var prefixedStreamNumber = PrefixedStreamName(ChainSpec, validationContext.StreamTypeService); if (prefixedStreamNumber != -1) { var specAfterStreamName = ChainSpec[1]; // Attempt to resolve as property Pair<PropertyResolutionDescriptor, string> propertyInfoPairX = null; try { var propName = ChainSpec[0].Name + "." + specAfterStreamName.Name; propertyInfoPairX = ExprIdentNodeUtil.GetTypeFromStream( streamTypeService, propName, streamTypeService.HasPropertyAgnosticType, false, validationContext.TableCompileTimeResolver); } catch (ExprValidationPropertyException) { // fine } if (propertyInfoPairX != null) { if (specAfterStreamName.Parameters.Count != 1) { throw HandleNotFound(specAfterStreamName.Name); } forge = GetPropertyPairEvaluator( specAfterStreamName.Parameters[0].Forge, propertyInfoPairX, validationContext); return null; } // Attempt to resolve as event-underlying object instance method var eventType = validationContext.StreamTypeService.EventTypes[prefixedStreamNumber]; var type = eventType.UnderlyingType; IList<ExprChainedSpec> remainderChain = new List<ExprChainedSpec>(ChainSpec); remainderChain.RemoveAt(0); ExprValidationException methodEx = null; ExprDotForge[] underlyingMethodChain = null; try { var typeInfoX = EPTypeHelper.SingleValue(type); if (validationContext.TableCompileTimeResolver.ResolveTableFromEventType(eventType) != null) { typeInfoX = new ClassEPType(typeof(object[])); } underlyingMethodChain = ExprDotNodeUtility.GetChainEvaluators( prefixedStreamNumber, typeInfoX, remainderChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStream(prefixedStreamNumber)) .ChainWithUnpack; } catch (ExprValidationException ex) { methodEx = ex; // expected - may not be able to find the methods on the underlying } ExprDotForge[] eventTypeMethodChain = null; ExprValidationException enumDatetimeEx = null; FilterExprAnalyzerAffector filterExprAnalyzerAffector = null; try { var typeInfoX = EPTypeHelper.SingleEvent(eventType); var chain = ExprDotNodeUtility.GetChainEvaluators( prefixedStreamNumber, typeInfoX, remainderChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStream(prefixedStreamNumber)); eventTypeMethodChain = chain.ChainWithUnpack; filterExprAnalyzerAffector = chain.FilterAnalyzerDesc; } catch (ExprValidationException ex) { enumDatetimeEx = ex; // expected - may not be able to find the methods on the underlying } if (underlyingMethodChain != null) { forge = new ExprDotNodeForgeStream( this, filterExprAnalyzerAffector, prefixedStreamNumber, eventType, underlyingMethodChain, true); } else if (eventTypeMethodChain != null) { forge = new ExprDotNodeForgeStream( this, filterExprAnalyzerAffector, prefixedStreamNumber, eventType, eventTypeMethodChain, false); } if (forge != null) { return null; } if (ExprDotNodeUtility.IsDatetimeOrEnumMethod(remainderChain[0].Name)) { prefixedStreamNumException = enumDatetimeEx; } else { prefixedStreamNumException = new ExprValidationException( "Failed to solve '" + remainderChain[0].Name + "' to either an date-time or enumeration method, an event property or a method on the event underlying object: " + methodEx.Message, methodEx); } } // There no root node, in this case the classname or property name is provided as part of the chain. // Such as "MyClass.myStaticLib(...)" or "mycollectionproperty.doIt(...)" // IList<ExprChainedSpec> modifiedChain = new List<ExprChainedSpec>(ChainSpec); var firstItem = modifiedChain.DeleteAt(0); Pair<PropertyResolutionDescriptor, string> propertyInfoPair = null; try { propertyInfoPair = ExprIdentNodeUtil.GetTypeFromStream( streamTypeService, firstItem.Name, streamTypeService.HasPropertyAgnosticType, true, validationContext.TableCompileTimeResolver); } catch (ExprValidationPropertyException) { // not a property } // If property then treat it as such if (propertyInfoPair != null) { var propertyName = propertyInfoPair.First.PropertyName; var streamId = propertyInfoPair.First.StreamNum; var streamType = streamTypeService.EventTypes[streamId]; EPType typeInfoX; ExprEnumerationForge enumerationForge = null; EPType inputType; ExprForge rootNodeForge = null; EventPropertyGetterSPI getter; if (firstItem.Parameters.IsEmpty()) { getter = ((EventTypeSPI) streamType).GetGetterSPI(propertyInfoPair.First.PropertyName); var propertyEval = ExprDotNodeUtility.GetPropertyEnumerationSource( propertyInfoPair.First.PropertyName, streamId, streamType, hasEnumerationMethod, validationContext.IsDisablePropertyExpressionEventCollCache); typeInfoX = propertyEval.ReturnType; enumerationForge = propertyEval.Enumeration; inputType = propertyEval.ReturnType; rootNodeForge = new PropertyDotNonLambdaForge( streamId, getter, propertyInfoPair.First.PropertyType.GetBoxedType()); } else { // property with parameter - mapped or indexed property var desc = EventTypeUtility.GetNestablePropertyDescriptor( streamTypeService.EventTypes[propertyInfoPair.First.StreamNum], firstItem.Name); if (firstItem.Parameters.Count > 1) { throw new ExprValidationException( "Property '" + firstItem.Name + "' may not be accessed passing 2 or more parameters"); } var paramEval = firstItem.Parameters[0].Forge; typeInfoX = EPTypeHelper.SingleValue(desc.PropertyComponentType); inputType = typeInfoX; getter = null; if (desc.IsMapped) { if (paramEval.EvaluationType != typeof(string)) { throw new ExprValidationException( "Parameter expression to mapped property '" + propertyName + "' is expected to return a string-type value but returns " + paramEval.EvaluationType.CleanName()); } var mappedGetter = ((EventTypeSPI) propertyInfoPair.First.StreamEventType).GetGetterMappedSPI( propertyInfoPair.First.PropertyName); if (mappedGetter == null) { throw new ExprValidationException( "Mapped property named '" + propertyName + "' failed to obtain getter-object"); } rootNodeForge = new PropertyDotNonLambdaMappedForge( streamId, mappedGetter, paramEval, desc.PropertyComponentType); } if (desc.IsIndexed) { if (paramEval.EvaluationType.GetBoxedType() != typeof(int?)) { throw new ExprValidationException( "Parameter expression to mapped property '" + propertyName + "' is expected to return a Integer-type value but returns " + paramEval.EvaluationType.CleanName()); } var indexedGetter = ((EventTypeSPI) propertyInfoPair.First.StreamEventType).GetGetterIndexedSPI( propertyInfoPair.First.PropertyName); if (indexedGetter == null) { throw new ExprValidationException( "Mapped property named '" + propertyName + "' failed to obtain getter-object"); } rootNodeForge = new PropertyDotNonLambdaIndexedForge( streamId, indexedGetter, paramEval, desc.PropertyComponentType); } } if (typeInfoX == null) { throw new ExprValidationException( "Property '" + propertyName + "' is not a mapped or indexed property"); } // try to build chain based on the input (non-fragment) ExprDotNodeRealizedChain evalsX; var filterAnalyzerInputProp = new ExprDotNodeFilterAnalyzerInputProp( propertyInfoPair.First.StreamNum, propertyInfoPair.First.PropertyName); var rootIsEventBean = false; try { evalsX = ExprDotNodeUtility.GetChainEvaluators( streamId, inputType, modifiedChain, validationContext, isDuckTyping, filterAnalyzerInputProp); } catch (ExprValidationException) { // try building the chain based on the fragment event type (i.e. A.after(B) based on A-configured start time where A is a fragment) var fragment = propertyInfoPair.First.FragmentEventType; if (fragment == null) { throw; } EPType fragmentTypeInfo; if (fragment.IsIndexed) { fragmentTypeInfo = EPTypeHelper.CollectionOfEvents(fragment.FragmentType); } else { fragmentTypeInfo = EPTypeHelper.SingleEvent(fragment.FragmentType); } rootIsEventBean = true; evalsX = ExprDotNodeUtility.GetChainEvaluators( propertyInfoPair.First.StreamNum, fragmentTypeInfo, modifiedChain, validationContext, isDuckTyping, filterAnalyzerInputProp); rootNodeForge = new PropertyDotNonLambdaFragmentForge(streamId, getter); } var filterExprAnalyzerAffector = evalsX.FilterAnalyzerDesc; var streamNumReferenced = propertyInfoPair.First.StreamNum; var rootPropertyName = propertyInfoPair.First.PropertyName; forge = new ExprDotNodeForgeRootChild( this, filterExprAnalyzerAffector, streamNumReferenced, rootPropertyName, hasEnumerationMethod, rootNodeForge, enumerationForge, inputType, evalsX.Chain, evalsX.ChainWithUnpack, !rootIsEventBean); return null; } // If variable then resolve as such var variable = validationContext.VariableCompileTimeResolver.Resolve(firstItem.Name); if (variable != null) { if (variable.OptionalContextName != null) { throw new ExprValidationException( "Method invocation on context-specific variable is not supported"); } EPType typeInfoX; ExprDotStaticMethodWrap wrap; if (variable.Type.IsArray) { typeInfoX = EPTypeHelper.CollectionOfSingleValue( variable.Type.GetElementType(), variable.Type); wrap = new ExprDotStaticMethodWrapArrayScalar(variable.VariableName, variable.Type); } else if (variable.EventType != null) { typeInfoX = EPTypeHelper.SingleEvent(variable.EventType); wrap = null; } else { typeInfoX = EPTypeHelper.SingleValue(variable.Type); wrap = null; } var evalsX = ExprDotNodeUtility.GetChainEvaluators( null, typeInfoX, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); forge = new ExprDotNodeForgeVariable(this, variable, wrap, evalsX.ChainWithUnpack); return null; } // try resolve as enumeration class with value var enumconstant = ImportCompileTimeUtil.ResolveIdentAsEnumConst( firstItem.Name, validationContext.ImportService, false); if (enumconstant != null) { // try resolve method var methodSpec = modifiedChain[0]; var enumvalue = firstItem.Name; ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler { ProcHandle = ex => { return new ExprValidationException( "Failed to resolve method '" + methodSpec.Name + "' on enumeration value '" + enumvalue + "': " + ex.Message); } }; var wildcardType = validationContext.StreamTypeService.EventTypes.Length != 1 ? null : validationContext.StreamTypeService.EventTypes[0]; var methodDesc = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream( enumconstant.GetType().Name, enumconstant.GetType(), methodSpec.Name, methodSpec.Parameters, wildcardType != null, wildcardType, handler, methodSpec.Name, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); // method resolved, hook up modifiedChain.RemoveAt(0); // we identified this piece var optionalLambdaWrapX = ExprDotStaticMethodWrapFactory.Make( methodDesc.ReflectionMethod, modifiedChain, null, validationContext); var typeInfoX = optionalLambdaWrapX != null ? optionalLambdaWrapX.TypeInfo : EPTypeHelper.SingleValue(methodDesc.ReflectionMethod.ReturnType); var evalsX = ExprDotNodeUtility.GetChainEvaluators( null, typeInfoX, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); forge = new ExprDotNodeForgeStaticMethod( this, false, firstItem.Name, methodDesc.ReflectionMethod, methodDesc.ChildForges, false, evalsX.ChainWithUnpack, optionalLambdaWrapX, false, enumconstant, validationContext.StatementName); return null; } // if prefixed by a stream name, we are giving up if (prefixedStreamNumException != null) { throw prefixedStreamNumException; } // If class then resolve as class var secondItem = modifiedChain.DeleteAt(0); var allowWildcard = validationContext.StreamTypeService.EventTypes.Length == 1; EventType streamZeroType = null; if (validationContext.StreamTypeService.EventTypes.Length > 0) { streamZeroType = validationContext.StreamTypeService.EventTypes[0]; } var method = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream( firstItem.Name, null, secondItem.Name, secondItem.Parameters, allowWildcard, streamZeroType, new ExprNodeUtilResolveExceptionHandlerDefault(firstItem.Name + "." + secondItem.Name, false), secondItem.Name, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); var isConstantParameters = method.IsAllConstants && isUDFCache; var isReturnsConstantResult = isConstantParameters && modifiedChain.IsEmpty(); // this may return a pair of null if there is no lambda or the result cannot be wrapped for lambda-function use var optionalLambdaWrap = ExprDotStaticMethodWrapFactory.Make( method.ReflectionMethod, modifiedChain, null, validationContext); var typeInfo = optionalLambdaWrap != null ? optionalLambdaWrap.TypeInfo : EPTypeHelper.SingleValue(method.ReflectionMethod.ReturnType); var evals = ExprDotNodeUtility.GetChainEvaluators( null, typeInfo, modifiedChain, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()); forge = new ExprDotNodeForgeStaticMethod( this, isReturnsConstantResult, firstItem.Name, method.ReflectionMethod, method.ChildForges, isConstantParameters, evals.ChainWithUnpack, optionalLambdaWrap, false, null, validationContext.StatementName); return null; }