public static Pair <ExprTableAccessNode, ExprDotNode> CheckTableNameGetExprForSubproperty( TableService tableService, string tableName, string subproperty) { var metadata = tableService.GetTableMetadata(tableName); if (metadata == null) { return(null); } var index = ASTUtil.UnescapedIndexOfDot(subproperty); if (index == -1) { if (metadata.KeyTypes.Length > 0) { return(null); } var tableNodeX = new ExprTableAccessNodeSubprop(tableName, subproperty); return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNodeX, null)); } // we have a nested subproperty such as "tablename.subproperty.abc" var chainedSpecs = new List <ExprChainedSpec>(1); chainedSpecs.Add(new ExprChainedSpec(subproperty.Substring(index + 1), Collections.GetEmptyList <ExprNode>(), true)); var tableNode = new ExprTableAccessNodeSubprop(tableName, subproperty.Substring(0, index)); var dotNode = new ExprDotNodeImpl(chainedSpecs, false, false); dotNode.AddChildNode(tableNode); return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNode, dotNode)); }
public static Pair <ExprTableAccessNode, ExprDotNode> MapPropertyToTableNested( TableCompileTimeResolver resolver, string stream, string subproperty) { var table = resolver.Resolve(stream); int?indexIfIndexed = null; if (table == null) { // try indexed property var pair = MapPropertyToTable(stream, resolver); if (pair == null) { return(null); } table = pair.Second; indexIfIndexed = pair.First.Index; } if (table.IsKeyed && indexIfIndexed == null) { return(null); } if (!table.IsKeyed && indexIfIndexed != null) { return(null); } var index = StringValue.UnescapedIndexOfDot(subproperty); if (index == -1) { var tableNodeX = new ExprTableAccessNodeSubprop(table.TableName, subproperty); if (indexIfIndexed != null) { tableNodeX.AddChildNode(new ExprConstantNodeImpl(indexIfIndexed)); } return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNodeX, null)); } // we have a nested subproperty such as "tablename.subproperty.abc" IList <Chainable> chainedSpecs = new List <Chainable>(1); chainedSpecs.Add(new ChainableName(subproperty.Substring(index + 1))); var tableNode = new ExprTableAccessNodeSubprop(table.TableName, subproperty.Substring(0, index)); if (indexIfIndexed != null) { tableNode.AddChildNode(new ExprConstantNodeImpl(indexIfIndexed)); } ExprDotNode dotNode = new ExprDotNodeImpl(chainedSpecs, false, false); dotNode.AddChildNode(tableNode); return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNode, dotNode)); }
public SettingsApplicationDotMethodPointInsideRectangle( ExprDotNodeImpl parent, string lhsName, ExprNode[] lhs, string dotMethodName, string rhsName, ExprNode[] rhs, ExprNode[] indexNamedParameter) : base(parent, lhsName, lhs, dotMethodName, rhsName, rhs, indexNamedParameter) { }
public SettingsApplicationDotMethodBase( ExprDotNodeImpl parent, string lhsName, ExprNode[] lhs, string dotMethodName, string rhsName, ExprNode[] rhs, ExprNode[] indexNamedParameter) { this.parent = parent; LhsName = lhsName; Lhs = lhs; DotMethodName = dotMethodName; RhsName = rhsName; Rhs = rhs; this.indexNamedParameter = indexNamedParameter; }
public static ExprNode ProcessDot( bool useChainAsIs, bool resolveObjects, IList <Chainable> chain, StatementSpecMapContext mapContext) { if (chain.IsEmpty()) { throw new ArgumentException("Empty chain"); } Func <IList <Chainable>, ExprDotNodeImpl> dotNodeFunction = chainSpec => { var dotNode = new ExprDotNodeImpl( chainSpec, mapContext.Configuration.Compiler.Expression.IsDuckTyping, mapContext.Configuration.Compiler.Expression.IsUdfCache); // add any variables that are referenced var variable = dotNode.IsVariableOpGetName(mapContext.VariableCompileTimeResolver); if (variable != null) { mapContext.VariableNames.Add(variable.VariableName); } return(dotNode); }; // Resolve objects if required if (resolveObjects) { var resolved = ResolveObject(chain, mapContext, dotNodeFunction); if (resolved != null) { return(resolved); } } // Check if we are dealing with a plain event property expression, i.e. one without any eventstream-dependent expression var plain = DeterminePlainProperty(chain); if (plain) { return(HandlePlain(chain, dotNodeFunction, useChainAsIs)); } return(HandleNonPlain(chain, dotNodeFunction)); }
public PointIntersectsRectangleForge( ExprDotNodeImpl parent, ExprForge pxEval, ExprForge pyEval, ExprForge xEval, ExprForge yEval, ExprForge widthEval, ExprForge heightEval) { this.parent = parent; this.pxEval = pxEval; this.pyEval = pyEval; this.xEval = xEval; this.yEval = yEval; this.widthEval = widthEval; this.heightEval = heightEval; }
public RectangleIntersectsRectangleForge( ExprDotNodeImpl parent, ExprForge meXEval, ExprForge meYEval, ExprForge meWidthEval, ExprForge meHeightEval, ExprForge otherXEval, ExprForge otherYEval, ExprForge otherWidthEval, ExprForge otherHeightEval) { this.parent = parent; this.meXEval = meXEval; this.meYEval = meYEval; this.meWidthEval = meWidthEval; this.meHeightEval = meHeightEval; this.otherXEval = otherXEval; this.otherYEval = otherYEval; this.otherWidthEval = otherWidthEval; this.otherHeightEval = otherHeightEval; }
public static void HandleLibFunc( CommonTokenStream tokenStream, EsperEPL2GrammarParser.LibFunctionContext ctx, ConfigurationInformation configurationInformation, EngineImportService engineImportService, IDictionary <ITree, ExprNode> astExprNodeMap, LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory> plugInAggregations, string engineURI, ExpressionDeclDesc expressionDeclarations, ExprDeclaredService exprDeclaredService, IList <ExpressionScriptProvided> scriptExpressions, ContextDescriptor contextDescriptor, TableService tableService, StatementSpecRaw statementSpec, VariableService variableService) { var model = GetModel(ctx, tokenStream); var duckType = configurationInformation.EngineDefaults.Expression.IsDuckTyping; var udfCache = configurationInformation.EngineDefaults.Expression.IsUdfCache; // handle "some.Xyz(...)" or "some.other.Xyz(...)" if (model.ChainElements.Count == 1 && model.OptionalClassIdent != null && ASTTableExprHelper.CheckTableNameGetExprForProperty(tableService, model.OptionalClassIdent) == null) { var chainSpec = GetLibFunctionChainSpec(model.ChainElements[0], astExprNodeMap); var declaredNodeX = ExprDeclaredHelper.GetExistsDeclaredExpr( model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), expressionDeclarations.Expressions, exprDeclaredService, contextDescriptor); if (declaredNodeX != null) { var exprNode = new ExprDotNodeImpl(Collections.SingletonList(chainSpec), duckType, udfCache); exprNode.AddChildNode(declaredNodeX); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } var chainX = new List <ExprChainedSpec>(2); chainX.Add(new ExprChainedSpec(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), true)); chainX.Add(chainSpec); var dotNodeX = new ExprDotNodeImpl( chainX, configurationInformation.EngineDefaults.Expression.IsDuckTyping, configurationInformation.EngineDefaults.Expression.IsUdfCache); if (dotNodeX.IsVariableOpGetName(variableService) != null) { statementSpec.HasVariables = true; } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNodeX, ctx, astExprNodeMap); return; } // try additional built-in single-row function var singleRowExtNode = engineImportService.ResolveSingleRowExtendedBuiltin(model.ChainElements[0].FuncName); if (singleRowExtNode != null) { if (model.ChainElements.Count == 1) { ASTExprHelper.ExprCollectAddSubNodesAddParentNode(singleRowExtNode, ctx, astExprNodeMap); return; } var spec = new List <ExprChainedSpec>(); var firstArgs = model.ChainElements[0].Args; var childExpressions = GetExprNodesLibFunc(firstArgs, astExprNodeMap); singleRowExtNode.AddChildNodes(childExpressions); AddChainRemainderFromOffset(model.ChainElements, 1, spec, astExprNodeMap); var dotNodeX = new ExprDotNodeImpl( spec, configurationInformation.EngineDefaults.Expression.IsDuckTyping, configurationInformation.EngineDefaults.Expression.IsUdfCache); dotNodeX.AddChildNode(singleRowExtNode); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNodeX, ctx, astExprNodeMap); return; } // try plug-in single-row function try { var firstFunctionX = model.ChainElements[0].FuncName; var firstFunctionIsProperty = !model.ChainElements[0].HasLeftParen; var classMethodPair = engineImportService.ResolveSingleRow(firstFunctionX); var spec = new List <ExprChainedSpec>(); var firstArgs = model.ChainElements[0].Args; var childExpressions = GetExprNodesLibFunc(firstArgs, astExprNodeMap); spec.Add( new ExprChainedSpec(classMethodPair.Second.MethodName, childExpressions, firstFunctionIsProperty)); AddChainRemainderFromOffset(model.ChainElements, 1, spec, astExprNodeMap); var plugin = new ExprPlugInSingleRowNode( firstFunctionX, classMethodPair.First, spec, classMethodPair.Second); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(plugin, ctx, astExprNodeMap); return; } catch (EngineImportUndefinedException) { // Not an single-row function } catch (EngineImportException e) { throw new IllegalStateException("Error resolving single-row function: " + e.Message, e); } // special case for min,max var firstFunction = model.ChainElements[0].FuncName; if ((firstFunction.ToLowerInvariant().Equals("max")) || (firstFunction.ToLowerInvariant().Equals("min")) || (firstFunction.ToLowerInvariant().Equals("fmax")) || (firstFunction.ToLowerInvariant().Equals("fmin"))) { var firstArgs = model.ChainElements[0].Args; HandleMinMax(firstFunction, firstArgs, astExprNodeMap); return; } // obtain chain with actual expressions IList <ExprChainedSpec> chain = new List <ExprChainedSpec>(); AddChainRemainderFromOffset(model.ChainElements, 0, chain, astExprNodeMap); // add chain element for class INFO, if any var distinct = model.ChainElements[0].Args != null && model.ChainElements[0].Args.DISTINCT() != null; if (model.OptionalClassIdent != null) { chain.Insert( 0, new ExprChainedSpec(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), true)); distinct = false; } firstFunction = chain[0].Name; // try plug-in aggregation function var aggregationNode = ASTAggregationHelper.TryResolveAsAggregation( engineImportService, distinct, firstFunction, plugInAggregations, engineURI); if (aggregationNode != null) { var firstSpec = chain.DeleteAt(0); aggregationNode.AddChildNodes(firstSpec.Parameters); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = aggregationNode; } else { exprNode = new ExprDotNodeImpl(chain, duckType, udfCache); exprNode.AddChildNode(aggregationNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try declared or alias expression var declaredNode = ExprDeclaredHelper.GetExistsDeclaredExpr( firstFunction, chain[0].Parameters, expressionDeclarations.Expressions, exprDeclaredService, contextDescriptor); if (declaredNode != null) { chain.RemoveAt(0); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = declaredNode; } else { exprNode = new ExprDotNodeImpl(chain, duckType, udfCache); exprNode.AddChildNode(declaredNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try script var scriptNode = ExprDeclaredHelper.GetExistsScript( configurationInformation.EngineDefaults.Scripts.DefaultDialect, chain[0].Name, chain[0].Parameters, scriptExpressions, exprDeclaredService); if (scriptNode != null) { chain.RemoveAt(0); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = scriptNode; } else { exprNode = new ExprDotNodeImpl(chain, duckType, udfCache); exprNode.AddChildNode(scriptNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try table var tableInfo = ASTTableExprHelper.CheckTableNameGetLibFunc( tableService, engineImportService, plugInAggregations, engineURI, firstFunction, chain); if (tableInfo != null) { ASTTableExprHelper.AddTableExpressionReference(statementSpec, tableInfo.First); chain = tableInfo.Second; ExprNode exprNode; if (chain.IsEmpty()) { exprNode = tableInfo.First; } else { exprNode = new ExprDotNodeImpl(chain, duckType, udfCache); exprNode.AddChildNode(tableInfo.First); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // Could be a mapped property with an expression-parameter "Mapped(expr)" or array property with an expression-parameter "Array(expr)". ExprDotNode dotNode; if (chain.Count == 1) { dotNode = new ExprDotNodeImpl(chain, false, false); } else { dotNode = new ExprDotNodeImpl(chain, duckType, udfCache); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNode, ctx, astExprNodeMap); }
// Since static method calls such as "Class.method('a')" and mapped properties "Stream.property('key')" // look the same, however as the validation could not resolve "Stream.property('key')" before calling this method, // this method tries to resolve the mapped property as a static method. // Assumes that this is an ExprIdentNode. private static ExprNode ResolveStaticMethodOrField( ExprIdentNode identNode, ExprValidationException propertyException, ExprValidationContext validationContext) { // Reconstruct the original string StringBuilder mappedProperty = new StringBuilder(identNode.UnresolvedPropertyName); if (identNode.StreamOrPropertyName != null) { mappedProperty.Insert(0, identNode.StreamOrPropertyName + '.'); } // Parse the mapped property format into a class name, method and single string parameter MappedPropertyParseResult parse = ParseMappedProperty(mappedProperty.ToString()); if (parse == null) { ExprConstantNode constNode = ResolveIdentAsEnumConst( mappedProperty.ToString(), validationContext.ImportService); if (constNode == null) { throw propertyException; } else { return constNode; } } // If there is a class name, assume a static method is possible. if (parse.ClassName != null) { IList<ExprNode> parameters = Collections.SingletonList((ExprNode) new ExprConstantNodeImpl(parse.ArgString)); IList<ExprChainedSpec> chain = new List<ExprChainedSpec>(); chain.Add(new ExprChainedSpec(parse.ClassName, Collections.GetEmptyList<ExprNode>(), false)); chain.Add(new ExprChainedSpec(parse.MethodName, parameters, false)); ConfigurationCompilerExpression exprConfig = validationContext.StatementCompileTimeService.Configuration.Compiler.Expression; ExprNode result = new ExprDotNodeImpl(chain, exprConfig.IsDuckTyping, exprConfig.IsUdfCache); // Validate try { result.Validate(validationContext); } catch (ExprValidationException e) { throw new ExprValidationException( $"Failed to resolve enumeration method, date-time method or mapped property '{mappedProperty}': {e.Message}", e); } return result; } // There is no class name, try a single-row function string functionName = parse.MethodName; try { Pair<Type, ImportSingleRowDesc> classMethodPair = validationContext.ImportService.ResolveSingleRow(functionName); IList<ExprNode> parameters = Collections.SingletonList((ExprNode) new ExprConstantNodeImpl(parse.ArgString)); IList<ExprChainedSpec> chain = Collections.SingletonList( new ExprChainedSpec(classMethodPair.Second.MethodName, parameters, false)); ExprNode result = new ExprPlugInSingleRowNode( functionName, classMethodPair.First, chain, classMethodPair.Second); // Validate try { result.Validate(validationContext); } catch (EPException) { throw; } catch (Exception ex) { throw new ExprValidationException( "Plug-in aggregation function '" + parse.MethodName + "' failed validation: " + ex.Message); } return result; } catch (ImportUndefinedException) { // Not an single-row function } catch (ImportException e) { throw new IllegalStateException("Error resolving single-row function: " + e.Message, e); } // Try an aggregation function factory try { AggregationFunctionForge aggregationForge = validationContext.ImportService.ResolveAggregationFunction(parse.MethodName); ExprNode result = new ExprPlugInAggNode(false, aggregationForge, parse.MethodName); result.AddChildNode(new ExprConstantNodeImpl(parse.ArgString)); // Validate try { result.Validate(validationContext); } catch (EPException) { throw; } catch (Exception e) { throw new ExprValidationException( "Plug-in aggregation function '" + parse.MethodName + "' failed validation: " + e.Message); } return result; } catch (ImportUndefinedException) { // Not an aggregation function } catch (ImportException e) { throw new IllegalStateException("Error resolving aggregation: " + e.Message, e); } // absolutely cannot be resolved throw propertyException; }