protected internal static ExprNode ValidateJoinNamedWindow( ExprNodeOrigin exprNodeOrigin, ExprNode deleteJoinExpr, EventType namedWindowType, string namedWindowStreamName, string namedWindowName, EventType filteredType, string filterStreamName, string filteredTypeName, string optionalTableName, StatementRawInfo statementRawInfo, StatementCompileTimeServices compileTimeServices ) { if (deleteJoinExpr == null) { return null; } var namesAndTypes = new LinkedHashMap<string, Pair<EventType, string>>(); namesAndTypes.Put(namedWindowStreamName, new Pair<EventType, string>(namedWindowType, namedWindowName)); namesAndTypes.Put(filterStreamName, new Pair<EventType, string>(filteredType, filteredTypeName)); StreamTypeService typeService = new StreamTypeServiceImpl(namesAndTypes, false, false); var validationContext = new ExprValidationContextBuilder(typeService, statementRawInfo, compileTimeServices) .WithAllowBindingConsumption(true) .Build(); return ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, deleteJoinExpr, validationContext); }
public static IList<ExprNode> ValidateAllowSubquery( ExprNodeOrigin exprNodeOrigin, IList<ExprNode> exprNodes, StreamTypeService streamTypeService, IDictionary<string, Pair<EventType, string>> taggedEventTypes, IDictionary<string, Pair<EventType, string>> arrayEventTypes, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { IList<ExprNode> validatedNodes = new List<ExprNode>(); ExprValidationContext validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services) .WithAllowBindingConsumption(true) .WithIsFilterExpression(true) .Build(); foreach (var node in exprNodes) { // Determine subselects var visitor = new ExprNodeSubselectDeclaredDotVisitor(); node.Accept(visitor); // Compile subselects if (!visitor.Subselects.IsEmpty()) { // The outer event type is the filtered-type itself foreach (var subselect in visitor.Subselects) { try { SubSelectHelperFilters.HandleSubselectSelectClauses( subselect, streamTypeService.EventTypes[0], streamTypeService.StreamNames[0], streamTypeService.StreamNames[0], taggedEventTypes, arrayEventTypes, statementRawInfo, services); } catch (ExprValidationException ex) { throw new ExprValidationException( "Failed to validate " + ExprNodeUtilityMake.GetSubqueryInfoText(subselect) + ": " + ex.Message, ex); } } } var validated = ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, node, validationContext); validatedNodes.Add(validated); if (validated.Forge.EvaluationType != typeof(bool?) && validated.Forge.EvaluationType != typeof(bool)) { throw new ExprValidationException( "Filter expression not returning a boolean value: '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validated) + "'"); } } return validatedNodes; }
internal static ExprNode ValidateExprNoAgg( ExprNodeOrigin exprNodeOrigin, ExprNode exprNode, StreamTypeService streamTypeService, StatementContext statementContext, ExprEvaluatorContext exprEvaluatorContext, String errorMsg, bool allowTableConsumption) { var validationContext = new ExprValidationContext( streamTypeService, statementContext.MethodResolutionService, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, allowTableConsumption, false, null, false); var validated = ExprNodeUtility.GetValidatedSubtree(exprNodeOrigin, exprNode, validationContext); ValidateNoAggregations(validated, errorMsg); return(validated); }
public static void ValidatePlainExpression( ExprNodeOrigin origin, ExprNode expression) { ExprNodeSummaryVisitor summaryVisitor = new ExprNodeSummaryVisitor(); ValidatePlainExpression(origin, expression, summaryVisitor); }
public static object InstantiatePopulateObject( IDictionary<string, object> objectProperties, Type topClass, ExprNodeOrigin exprNodeOrigin, ExprValidationContext exprValidationContext) { var applicableClass = topClass; if (topClass.IsInterface) { applicableClass = FindInterfaceImplementation( objectProperties, topClass, exprValidationContext.ImportService); } object top; try { top = TypeHelper.Instantiate(applicableClass); } catch (EPException) { throw; } catch (Exception ex) { throw new ExprValidationException( "Exception instantiating class " + applicableClass.Name + ": " + ex.Message, ex); } PopulateObject(objectProperties, top, exprNodeOrigin, exprValidationContext); return top; }
public static void PopulateSpecCheckParameters( PopulateFieldWValueDescriptor[] descriptors, IDictionary<string, object> jsonRaw, object spec, ExprNodeOrigin exprNodeOrigin, ExprValidationContext exprValidationContext) { // lowercase keys IDictionary<string, object> lowerCaseJsonRaw = new LinkedHashMap<string, object>(); foreach (var entry in jsonRaw) { lowerCaseJsonRaw.Put(entry.Key.ToLowerInvariant(), entry.Value); } jsonRaw = lowerCaseJsonRaw; // apply values foreach (var desc in descriptors) { object value = jsonRaw.Delete(desc.PropertyName.ToLowerInvariant()); var coerced = CoerceProperty( desc.PropertyName, desc.ContainerType, value, desc.FieldType, exprNodeOrigin, exprValidationContext, desc.IsForceNumeric, false); desc.Setter.Invoke(coerced); } // should not have remaining parameters if (!jsonRaw.IsEmpty()) { throw new ExprValidationException("Unrecognized parameter '" + jsonRaw.Keys.First() + "'"); } }
public override void Validate( ExprNodeOrigin origin, ExprValidationContext validationContext) { Expression = GetValidatedSubtree(origin, Expression, validationContext); EPStatementStartMethodHelperValidate.ValidateNoAggregations(Expression, ValidationAggMsg); }
public static ExprForge[] CrontabScheduleValidate( ExprNodeOrigin origin, IList<ExprNode> scheduleSpecExpressionList, bool allowBindingConsumption, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // Validate the expressions ExprForge[] expressions = new ExprForge[scheduleSpecExpressionList.Count]; int count = 0; ExprValidationContext validationContext = new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services) .WithAllowBindingConsumption(allowBindingConsumption) .Build(); foreach (ExprNode parameters in scheduleSpecExpressionList) { ExprNode node = ExprNodeUtilityValidate.GetValidatedSubtree(origin, parameters, validationContext); expressions[count++] = node.Forge; } if (expressions.Length <= 4 || expressions.Length >= 8) { throw new ExprValidationException( "Invalid schedule specification: " + ScheduleSpecUtil.GetExpressionCountException(expressions.Length)); } return expressions; }
public static ExprValidationException MakeValidationExWExpression( ExprNodeOrigin origin, String text, ExprValidationException ex) { return new ExprValidationException( $"Failed to validate {origin.GetClauseName()} expression {text}: {ex.Message}", ex); }
public static void ValidatePlainExpression( ExprNodeOrigin origin, ExprNode[] expressions) { ExprNodeSummaryVisitor summaryVisitor = new ExprNodeSummaryVisitor(); foreach (ExprNode expression in expressions) { ValidatePlainExpression(origin, expression, summaryVisitor); } }
public override void Validate( ExprNodeOrigin origin, ExprValidationContext validationContext) { var index = _indexExpressions[0]; index = ExprNodeUtilityValidate.GetValidatedSubtree(origin, index, validationContext); _indexExpressions = Collections.SingletonList(index); ChainableArray.ValidateSingleIndexExpr(_indexExpressions, () => "expression '" + Ident + "'"); EPStatementStartMethodHelperValidate.ValidateNoAggregations(index, ExprAssignment.ValidationAggMsg); }
public static void Validate( ExprNodeOrigin origin, IList<Chainable> chainSpec, ExprValidationContext validationContext) { // validate all parameters foreach (var chainElement in chainSpec) { chainElement.Validate(origin, validationContext); } }
public void Validate( ExprNodeOrigin origin, ExprValidationContext validationContext) { foreach (var node in GetParametersOrEmpty()) { if (node is ExprNamedParameterNode) { throw new ExprValidationException("Named parameters are not allowed"); } } ValidateExpressions(origin, validationContext); }
public static void GetValidatedSubtree( ExprNodeOrigin origin, ExprNode[][] exprNode, ExprValidationContext validationContext) { if (exprNode == null) { return; } foreach (ExprNode[] anExprNode in exprNode) { GetValidatedSubtree(origin, anExprNode, validationContext); } }
public static void GetValidatedSubtree( ExprNodeOrigin origin, ExprNode[] exprNode, ExprValidationContext validationContext) { if (exprNode == null) { return; } for (int i = 0; i < exprNode.Length; i++) { exprNode[i] = GetValidatedSubtree(origin, exprNode[i], validationContext); } }
internal static void ValidateExpressions( IList<ExprNode> expressions, ExprNodeOrigin origin, ExprValidationContext validationContext) { for (var i = 0; i < expressions.Count; i++) { var node = expressions[i]; var validated = GetValidatedSubtree(origin, node, validationContext); if (node != validated) { expressions[i] = validated; } } }
/// <summary> /// Validates the expression node subtree that has this /// node as root. Some of the nodes of the tree, including the /// root, might be replaced in the process. /// </summary> /// <param name="origin">validate origin</param> /// <param name="exprNode">node</param> /// <param name="validationContext">context</param> /// <returns>the root node of the validated subtree, possibly different than the root node of the unvalidated subtree /// </returns> /// <throws>ExprValidationException when the validation fails</throws> public static ExprNode GetValidatedSubtree( ExprNodeOrigin origin, ExprNode exprNode, ExprValidationContext validationContext) { if (exprNode is ExprLambdaGoesNode) { return exprNode; } try { return GetValidatedSubtreeInternal(exprNode, validationContext, true); } catch (ExprValidationException ex) { try { string text; if (exprNode is ExprSubselectNode subselect) { text = ExprNodeUtilityMake.GetSubqueryInfoText(subselect); } else { text = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode); if (text.Length > 40) { string shortened = text.Substring(0, 35); text = shortened + "...(" + text.Length + " chars)"; } text = "'" + text + "'"; } var errorText = string.Format( "Failed to validate {0} expression {1}: {2}", origin.GetClauseName(), text, ex.Message); throw new ExprValidationException(errorText, ex); } catch (ExprValidationException) { throw; } catch (EPException) { throw; } catch (Exception rtex) { Log.Debug("Failed to render nice validation message text: " + rtex.Message, rtex); // fall through } throw; } }
private static IList<ExprNode> ValidateExpressions( ExprNodeOrigin exprNodeOrigin, IList<ExprNode> objectParameters, ExprValidationContext validationContext) { if (objectParameters == null) { return objectParameters; } IList<ExprNode> validated = new List<ExprNode>(); foreach (var node in objectParameters) { validated.Add(ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, node, validationContext)); } return validated; }
public static void ValidateAssignment( bool allowLHSVariables, ExprNodeOrigin origin, OnTriggerSetAssignment spec, ExprValidationContext validationContext) { // equals-assignments are "a=1" and "a[1]=2" and such // they are not "a.reset()" var assignment = CheckGetStraightAssignment(spec.Expression, allowLHSVariables); if (assignment == null) { assignment = new ExprAssignmentCurly(spec.Expression); } assignment.Validate(origin, validationContext); spec.Validated = assignment; }
public static Object ParsePopulate(String json, Type topClass, ExprNodeOrigin exprNodeOrigin, ExprValidationContext exprValidationContext) { var startRuleSelector = new ParseRuleSelector(parser => parser.startJsonValueRule()); var parseResult = ParseHelper.Parse(json, json, true, startRuleSelector, false); var tree = (EsperEPL2GrammarParser.StartJsonValueRuleContext)parseResult.Tree; var parsed = ASTJsonHelper.Walk(parseResult.TokenStream, tree.jsonvalue()); if (!(parsed is IDictionary <String, Object>)) { throw new ExprValidationException( "Failed to map value to object of type " + topClass.FullName + ", expected Json Map/Object format, received " + (parsed != null ? parsed.GetType().Name : "null")); } var objectProperties = (IDictionary <String, Object>)parsed; return(PopulateUtil.InstantiatePopulateObject(objectProperties, topClass, exprNodeOrigin, exprValidationContext)); }
public static ExprNode ValidateExprNoAgg( ExprNodeOrigin exprNodeOrigin, ExprNode exprNode, StreamTypeService streamTypeService, string errorMsg, bool allowTableConsumption, bool allowTableAggReset, StatementRawInfo raw, StatementCompileTimeServices compileTimeServices) { var validationContext = new ExprValidationContextBuilder(streamTypeService, raw, compileTimeServices) .WithAllowBindingConsumption(allowTableConsumption) .WithAllowTableAggReset(allowTableAggReset) .Build(); var validated = ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, exprNode, validationContext); ValidateNoAggregations(validated, errorMsg); return validated; }
public static void Validate( ExprNodeOrigin origin, IList<ExprChainedSpec> chainSpec, ExprValidationContext validationContext) { // validate all parameters foreach (ExprChainedSpec chainElement in chainSpec) { IList<ExprNode> validated = new List<ExprNode>(); foreach (ExprNode expr in chainElement.Parameters) { validated.Add(GetValidatedSubtree(origin, expr, validationContext)); if (expr is ExprNamedParameterNode) { throw new ExprValidationException("Named parameters are not allowed"); } } chainElement.Parameters = validated; } }
private static void ValidatePlainExpression( ExprNodeOrigin origin, ExprNode expression, ExprNodeSummaryVisitor summaryVisitor) { expression.Accept(summaryVisitor); if (summaryVisitor.HasAggregation || summaryVisitor.HasSubselect || summaryVisitor.HasStreamSelect || summaryVisitor.HasPreviousPrior) { string text = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expression); throw new ExprValidationException( "Invalid " + origin.GetClauseName() + " expression '" + text + "': Aggregation, sub-select, previous or prior functions are not supported in this context"); } }
public static ExprNode ValidateSimpleGetSubtree( ExprNodeOrigin origin, ExprNode expression, EventType optionalEventType, bool allowBindingConsumption, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { ExprNodeUtilityValidate.ValidatePlainExpression(origin, expression); StreamTypeServiceImpl streamTypes; if (optionalEventType != null) { streamTypes = new StreamTypeServiceImpl(optionalEventType, null, true); } else { streamTypes = new StreamTypeServiceImpl(false); } var validationContext = new ExprValidationContextBuilder(streamTypes, statementRawInfo, services) .WithAllowBindingConsumption(allowBindingConsumption) .Build(); return ExprNodeUtilityValidate.GetValidatedSubtree(origin, expression, validationContext); }
public override void Validate( ExprNodeOrigin origin, ExprValidationContext validationContext) { // specific validation by assignor }
public static void PopulateObject( IDictionary<string, object> objectProperties, object top, ExprNodeOrigin exprNodeOrigin, ExprValidationContext exprValidationContext) { var applicableClass = top.GetType(); var writables = PropertyHelper.GetWritableProperties(applicableClass); var annotatedFields = TypeHelper.FindAnnotatedFields(top.GetType(), typeof(DataFlowOpParameterAttribute)); var annotatedMethods = TypeHelper.FindAnnotatedMethods(top.GetType(), typeof(DataFlowOpParameterAttribute)); // find catch-all methods ISet<MethodInfo> catchAllMethods = new LinkedHashSet<MethodInfo>(); if (annotatedMethods != null) { foreach (var method in annotatedMethods) { var anno = (DataFlowOpParameterAttribute) TypeHelper .GetAnnotations<DataFlowOpParameterAttribute>(method.UnwrapAttributes())[0]; if (anno.IsAll) { var parameters = method.GetParameters(); if (parameters.Length == 2 && (parameters[0].ParameterType == typeof(string)) && (parameters[1].ParameterType == typeof(object))) { catchAllMethods.Add(method); continue; } throw new ExprValidationException("Invalid annotation for catch-call"); } } } // map provided values foreach (var property in objectProperties) { var found = false; var propertyName = property.Key; // invoke catch-all setters foreach (var method in catchAllMethods) { try { method.Invoke(top, new[] {propertyName, property.Value}); } catch (MemberAccessException e) { throw new ExprValidationException( "Illegal access invoking method for property '" + propertyName + "' for class " + applicableClass.Name + " method " + method.Name, e); } catch (TargetException e) { throw new ExprValidationException( "Exception invoking method for property '" + propertyName + "' for class " + applicableClass.Name + " method " + method.Name + ": " + e.InnerException.Message, e); } found = true; } if (propertyName.ToLowerInvariant().Equals(CLASS_PROPERTY_NAME)) { continue; } // use the writeable property descriptor (appropriate setter method) from writing the property var descriptor = FindDescriptor(applicableClass, propertyName, writables); if (descriptor != null) { var coerceProperty = CoerceProperty( propertyName, applicableClass, property.Value, descriptor.PropertyType, exprNodeOrigin, exprValidationContext, false, true); try { var writeMember = descriptor.WriteMember; if (writeMember is MethodInfo writeMethod) { writeMethod.Invoke(top, new[] {coerceProperty}); } else if (writeMember is PropertyInfo writeProperty) { writeProperty.SetValue(top, coerceProperty); } else { throw new IllegalStateException("writeMember of invalid type"); } } catch (ArgumentException e) { throw new ExprValidationException( "Illegal argument invoking setter method for property '" + propertyName + "' for class " + applicableClass.Name + " method " + descriptor.WriteMember.Name + " provided value " + coerceProperty, e); } catch (MemberAccessException e) { throw new ExprValidationException( "Illegal access invoking setter method for property '" + propertyName + "' for class " + applicableClass.Name + " method " + descriptor.WriteMember.Name, e); } catch (TargetException e) { throw new ExprValidationException( "Exception invoking setter method for property '" + propertyName + "' for class " + applicableClass.Name + " method " + descriptor.WriteMember.Name + ": " + e.InnerException.Message, e); } continue; } // find the field annotated with {@link @GraphOpProperty} foreach (var annotatedField in annotatedFields) { var anno = (DataFlowOpParameterAttribute) TypeHelper.GetAnnotations( typeof(DataFlowOpParameterAttribute), annotatedField.UnwrapAttributes())[0]; if (anno.Name.Equals(propertyName) || annotatedField.Name.Equals(propertyName)) { var coerceProperty = CoerceProperty( propertyName, applicableClass, property.Value, annotatedField.FieldType, exprNodeOrigin, exprValidationContext, true, true); try { annotatedField.SetValue(top, coerceProperty); } catch (Exception e) { throw new ExprValidationException( "Failed to set field '" + annotatedField.Name + "': " + e.Message, e); } found = true; break; } } if (found) { continue; } throw new ExprValidationException( "Failed to find writable property '" + propertyName + "' for class " + applicableClass.Name); } }
public static object CoerceProperty( string propertyName, Type containingType, object value, Type type, ExprNodeOrigin exprNodeOrigin, ExprValidationContext exprValidationContext, bool forceNumeric, bool includeClassNameInEx) { // handle system-property exception if (value is ExprNode) { if (value is ExprIdentNode) { var identNode = (ExprIdentNode) value; Property prop; try { prop = PropertyParser.ParseAndWalkLaxToSimple(identNode.FullUnresolvedName); } catch (Exception) { throw new ExprValidationException( "Failed to parse property '" + identNode.FullUnresolvedName + "'"); } if (!(prop is MappedProperty)) { throw new ExprValidationException( "Unrecognized property '" + identNode.FullUnresolvedName + "'"); } var mappedProperty = (MappedProperty) prop; if (string.Equals( mappedProperty.PropertyNameAtomic, ExprEvalSystemProperty.SYSTEM_PROPETIES_NAME, StringComparison.InvariantCultureIgnoreCase)) { if (type == typeof(ExprNode)) { return new ExprEvalSystemProperty(mappedProperty.Key); } return Environment.GetEnvironmentVariable(mappedProperty.Key); } } else { var exprNode = (ExprNode) value; if (type == typeof(ExprNode)) { return exprNode; } if (!exprNode.Forge.ForgeConstantType.IsCompileTimeConstant) { throw new ExprValidationException( "Failed to determine parameter for property '" + propertyName + "' as the parameter is not a compile-time constant expression"); } value = exprNode.Forge.ExprEvaluator.Evaluate(null, true, null); } } if (value == null) { return null; } var valueType = value.GetType(); if (valueType == type) { return value; } var typeUnboxed = type.GetUnboxedType(); if (valueType.GetUnboxedType().IsAssignmentCompatible(typeUnboxed)) { if (forceNumeric && value.GetType().GetBoxedType() != type.GetBoxedType() && type.IsNumeric() && value.GetType().IsNumeric()) { value = TypeHelper.CoerceBoxed(value, type.GetBoxedType()); } return value; } if (TypeHelper.IsSubclassOrImplementsInterface(value.GetType(), type)) { return value; } if (type.IsArray) { if (!value.GetType().IsGenericCollection()) { var detail = "expects an array but receives a value of type " + value.GetType().Name; throw new ExprValidationException( GetExceptionText(propertyName, containingType, includeClassNameInEx, detail)); } var items = value.UnwrapIntoArray<object>(); var coercedArray = Arrays.CreateInstanceChecked(type.GetElementType(), items.Length); for (var i = 0; i < items.Length; i++) { var coercedValue = CoerceProperty( propertyName + " (array element)", type, items[i], type.GetElementType(), exprNodeOrigin, exprValidationContext, false, includeClassNameInEx); coercedArray.SetValue(coercedValue, i); } return coercedArray; } if (!(value is IDictionary<string, object>)) { var detail = "expects an " + type.CleanName() + " but receives a value of type " + value.GetType().CleanName(); throw new ExprValidationException( GetExceptionText(propertyName, containingType, includeClassNameInEx, detail)); } var props = (IDictionary<string, object>) value; return InstantiatePopulateObject(props, type, exprNodeOrigin, exprValidationContext); }
/// <summary> /// Validates expression nodes and returns a list of validated nodes. /// </summary> /// <param name="exprNodeOrigin">The expr node origin.</param> /// <param name="exprNodes">is the nodes to validate</param> /// <param name="streamTypeService">is provding type information for each stream</param> /// <param name="statementContext">context</param> /// <param name="taggedEventTypes">pattern tagged types</param> /// <param name="arrayEventTypes">@return list of validated expression nodes</param> /// <returns> /// expr nodes /// </returns> /// <exception cref="ExprValidationException"> /// Failed to validate + EPStatementStartMethodHelperSubselect.GetSubqueryInfoText(count, subselect) + : + ex.Message /// or /// Filter expression not returning a boolean value: ' + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated) + ' /// </exception> /// <throws>ExprValidationException for validation errors</throws> public static IList <ExprNode> ValidateAllowSubquery( ExprNodeOrigin exprNodeOrigin, IList <ExprNode> exprNodes, StreamTypeService streamTypeService, StatementContext statementContext, IDictionary <string, Pair <EventType, string> > taggedEventTypes, IDictionary <string, Pair <EventType, string> > arrayEventTypes) { IList <ExprNode> validatedNodes = new List <ExprNode>(); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( streamTypeService, statementContext.MethodResolutionService, null, statementContext.TimeProvider, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, true); foreach (var node in exprNodes) { // Determine subselects var visitor = new ExprNodeSubselectDeclaredDotVisitor(); node.Accept(visitor); // Compile subselects if (!visitor.Subselects.IsEmpty()) { // The outer event type is the filtered-type itself var subselectStreamNumber = 2048; var count = -1; foreach (var subselect in visitor.Subselects) { count++; subselectStreamNumber++; try { HandleSubselectSelectClauses(subselectStreamNumber, statementContext, subselect, streamTypeService.EventTypes[0], streamTypeService.StreamNames[0], streamTypeService.StreamNames[0], taggedEventTypes, arrayEventTypes); } catch (ExprValidationException ex) { throw new ExprValidationException("Failed to validate " + EPStatementStartMethodHelperSubselect.GetSubqueryInfoText(count, subselect) + ": " + ex.Message, ex); } } } var validated = ExprNodeUtility.GetValidatedSubtree(exprNodeOrigin, node, validationContext); validatedNodes.Add(validated); if ((validated.ExprEvaluator.ReturnType != typeof(bool?)) && ((validated.ExprEvaluator.ReturnType != typeof(bool)))) { throw new ExprValidationException("Filter expression not returning a boolean value: '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated) + "'"); } } return(validatedNodes); }
public static string GetClauseName(this ExprNodeOrigin enumValue) { switch (enumValue) { case ExprNodeOrigin.SELECT: return("select-clause"); case ExprNodeOrigin.WHERE: return("where-clause"); case ExprNodeOrigin.GROUPBY: return("group-by-clause"); case ExprNodeOrigin.HAVING: return("having-clause"); case ExprNodeOrigin.METHODINVJOIN: return("from-clause method-invocation"); case ExprNodeOrigin.DATABASEPOLL: return("from-clause database-access parameter"); case ExprNodeOrigin.CONTEXT: return("context declaration"); case ExprNodeOrigin.CONTEXTDISTINCT: return("context distinct-clause"); case ExprNodeOrigin.CONTEXTCONDITION: return("context condition"); case ExprNodeOrigin.VARIABLEASSIGN: return("variable-assignment"); case ExprNodeOrigin.DATAFLOW: return("dataflow operator"); case ExprNodeOrigin.DATAFLOWBEACON: return("beacon dataflow operator"); case ExprNodeOrigin.DATAFLOWFILTER: return("filter dataflow operator"); case ExprNodeOrigin.UPDATEASSIGN: return("update assignment"); case ExprNodeOrigin.PLUGINSINGLEROWPARAM: return("single-row function parameter"); case ExprNodeOrigin.AGGPARAM: return("aggregation function parameter"); case ExprNodeOrigin.OUTPUTLIMIT: return("output limit"); case ExprNodeOrigin.DECLAREDEXPRPARAM: return("declared expression parameter"); case ExprNodeOrigin.DECLAREDEXPRBODY: return("declared expression body"); case ExprNodeOrigin.ALIASEXPRBODY: return("alias expression body"); case ExprNodeOrigin.ORDERBY: return("order-by-clause"); case ExprNodeOrigin.SCRIPTPARAMS: return("script parameter"); case ExprNodeOrigin.FOLLOWEDBYMAX: return("pattern followed-by max"); case ExprNodeOrigin.PATTERNMATCHUNTILBOUNDS: return("pattern match-until bounds"); case ExprNodeOrigin.PATTERNGUARD: return("pattern guard"); case ExprNodeOrigin.PATTERNEVERYDISTINCT: return("pattern every-distinct"); case ExprNodeOrigin.PATTERNOBSERVER: return("pattern observer"); case ExprNodeOrigin.DOTNODEPARAMETER: return("method-chain parameter"); case ExprNodeOrigin.DOTNODE: return("method-chain"); case ExprNodeOrigin.CONTAINEDEVENT: return("contained-event"); case ExprNodeOrigin.CREATEWINDOWFILTER: return("create-window filter"); case ExprNodeOrigin.CREATETABLECOLUMN: return("table-column"); case ExprNodeOrigin.CREATEINDEXCOLUMN: return("create-index index-column"); case ExprNodeOrigin.CREATEINDEXPARAMETER: return("create-index index-parameter"); case ExprNodeOrigin.SUBQUERYSELECT: return("subquery select-clause"); case ExprNodeOrigin.FILTER: return("filter"); case ExprNodeOrigin.FORCLAUSE: return("for-clause"); case ExprNodeOrigin.VIEWPARAMETER: return("view parameter"); case ExprNodeOrigin.MATCHRECOGDEFINE: return("match-recognize define"); case ExprNodeOrigin.MATCHRECOGMEASURE: return("match-recognize measure"); case ExprNodeOrigin.MATCHRECOGPARTITION: return("match-recognize partition"); case ExprNodeOrigin.MATCHRECOGINTERVAL: return("match-recognize interval"); case ExprNodeOrigin.MATCHRECOGPATTERN: return("match-recognize pattern"); case ExprNodeOrigin.JOINON: return("on-clause join"); case ExprNodeOrigin.MERGEMATCHCOND: return("match condition"); case ExprNodeOrigin.MERGEMATCHWHERE: return("match where-clause"); case ExprNodeOrigin.HINT: return("hint"); } throw new ArgumentException("invalid value for enumValue", "enumValue"); }
public override void ValidateExpressions( ExprNodeOrigin origin, ExprValidationContext validationContext) { ValidateExpressions(Parameters, origin, validationContext); }