private static ExprChainedSpec GetLibFunctionChainSpec(ASTLibModelChainElement element, IDictionary <ITree, ExprNode> astExprNodeMap)
{
var methodName = ASTConstantHelper.RemoveTicks(element.FuncName);
var parameters = ASTLibFunctionHelper.GetExprNodesLibFunc(element.Args, astExprNodeMap);
return(new ExprChainedSpec(methodName, parameters, !element.HasLeftParen));
}
public static IList <ExprChainedSpec> GetLibFuncChain(IList <EsperEPL2GrammarParser.LibFunctionNoClassContext> ctxs, IDictionary <ITree, ExprNode> astExprNodeMap)
{
var chained = new List <ExprChainedSpec>(ctxs.Count);
foreach (var ctx in ctxs)
{
var chainSpec = ASTLibFunctionHelper.GetLibFunctionChainSpec(ctx, astExprNodeMap);
chained.Add(chainSpec);
}
return(chained);
}
public static Pair <ExpressionDeclItem, ExpressionScriptProvided> WalkExpressionDecl(
EsperEPL2GrammarParser.ExpressionDeclContext ctx,
IList <String> scriptBodies,
IDictionary <ITree, ExprNode> astExprNodeMap,
CommonTokenStream tokenStream)
{
var name = ctx.name.Text;
if (ctx.alias != null)
{
if (ctx.alias.Text.ToLower().Trim() != "alias")
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting 'alias' keyword but received '" + ctx.alias.Text + "'");
}
if (ctx.columnList() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting no parameters but received '" + tokenStream.GetText(ctx.columnList()) + "'");
}
if (ctx.expressionDef() != null && ctx.expressionDef().expressionLambdaDecl() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression without parameters but received '" + tokenStream.GetText(ctx.expressionDef().expressionLambdaDecl()) + "'");
}
if (ctx.expressionDef().stringconstant() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression but received a script");
}
var exprNode = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap)[0];
var alias = ctx.name.Text;
var decl = new ExpressionDeclItem(alias, Collections.GetEmptyList <String>(), exprNode, true);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(decl, null));
}
if (ctx.expressionDef().stringconstant() != null)
{
var expressionText = scriptBodies[0];
scriptBodies.RemoveAt(0);
var parameters = ASTUtil.GetIdentList(ctx.columnList());
var optionalReturnType = ctx.classIdentifier() == null
? null
: ASTUtil.UnescapeClassIdent(ctx.classIdentifier());
var optionalReturnTypeArray = ctx.array != null;
var optionalDialect = ctx.expressionDialect() == null ? null : ctx.expressionDialect().d.Text;
var script = new ExpressionScriptProvided(
name, expressionText, parameters,
optionalReturnType, optionalReturnTypeArray, optionalDialect);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(null, script));
}
var ctxexpr = ctx.expressionDef();
var inner = ASTExprHelper.ExprCollectSubNodes(ctxexpr.expression(), 0, astExprNodeMap)[0];
var parametersNames = Collections.GetEmptyList <string>();
var lambdactx = ctxexpr.expressionLambdaDecl();
if (ctxexpr.expressionLambdaDecl() != null)
{
parametersNames = ASTLibFunctionHelper.GetLambdaGoesParams(lambdactx);
}
var expr = new ExpressionDeclItem(name, parametersNames, inner, false);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(expr, null));
}
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.ExpressionConfig.IsDuckTyping;
var udfCache = configurationInformation.EngineDefaults.ExpressionConfig.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)
{
ExprNode exprNode = new ExprDotNode(Collections.SingletonList(chainSpec), duckType, udfCache);
exprNode.AddChildNode(declaredNodeX);
ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap);
return;
}
IList <ExprChainedSpec> chainX = new List <ExprChainedSpec>(2);
chainX.Add(new ExprChainedSpec(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), true));
chainX.Add(chainSpec);
var dotNodeX = new ExprDotNode(chainX, configurationInformation.EngineDefaults.ExpressionConfig.IsDuckTyping, configurationInformation.EngineDefaults.ExpressionConfig.IsUdfCache);
if (dotNodeX.IsVariableOp(variableService))
{
statementSpec.HasVariables = true;
}
ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNodeX, ctx, astExprNodeMap);
return;
}
// try additional built-in single-row function
ExprNode 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>();
EsperEPL2GrammarParser.LibFunctionArgsContext firstArgs = model.ChainElements[0].Args;
var childExpressions = ASTLibFunctionHelper.GetExprNodesLibFunc(firstArgs, astExprNodeMap);
singleRowExtNode.AddChildNodes(childExpressions);
AddChainRemainderFromOffset(model.ChainElements, 1, spec, astExprNodeMap);
var dotNodeX = new ExprDotNode(spec, configurationInformation.EngineDefaults.ExpressionConfig.IsDuckTyping, configurationInformation.EngineDefaults.ExpressionConfig.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);
IList <ExprChainedSpec> spec = new List <ExprChainedSpec>();
var firstArgs = model.ChainElements[0].Args;
var childExpressions = ASTLibFunctionHelper.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 e) {
// 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.ToLower().Equals("max")) || (firstFunction.ToLower().Equals("min")) ||
(firstFunction.ToLower().Equals("fmax")) || (firstFunction.ToLower().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.Pluck(0);
aggregationNode.AddChildNodes(firstSpec.Parameters);
ExprNode exprNode;
if (chain.IsEmpty())
{
exprNode = aggregationNode;
}
else
{
exprNode = new ExprDotNode(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 ExprDotNode(chain, duckType, udfCache);
exprNode.AddChildNode(declaredNode);
}
ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap);
return;
}
// try script
var scriptNode = ExprDeclaredHelper.GetExistsScript(configurationInformation.EngineDefaults.ScriptsConfig.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 ExprDotNode(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 ExprDotNode(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 ExprDotNode(chain, false, false);
}
else
{
dotNode = new ExprDotNode(chain, duckType, udfCache);
}
ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNode, ctx, astExprNodeMap);
}
private static ContextDetail WalkChoice(EsperEPL2GrammarParser.CreateContextChoiceContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap, IDictionary <ITree, EvalFactoryNode> astPatternNodeMap, PropertyEvalSpec propertyEvalSpec, FilterSpecRaw filterSpec)
{
// temporal fixed (start+end) and overlapping (initiated/terminated)
if (ctx.START() != null || ctx.INITIATED() != null)
{
ExprNode[] distinctExpressions = null;
if (ctx.createContextDistinct() != null)
{
if (ctx.createContextDistinct().expressionList() == null)
{
distinctExpressions = new ExprNode[0];
}
else
{
distinctExpressions = ASTExprHelper.ExprCollectSubNodesPerNode(ctx.createContextDistinct().expressionList().expression(), astExprNodeMap);
}
}
ContextDetailCondition startEndpoint;
if (ctx.START() != null)
{
bool immediate = CheckNow(ctx.i);
if (immediate)
{
startEndpoint = new ContextDetailConditionImmediate();
}
else
{
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
}
}
else
{
bool immediate = CheckNow(ctx.i);
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, immediate);
}
bool overlapping = ctx.INITIATED() != null;
ContextDetailCondition endEndpoint = GetContextCondition(ctx.r2, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
return(new ContextDetailInitiatedTerminated(startEndpoint, endEndpoint, overlapping, distinctExpressions));
}
// partitioned
if (ctx.PARTITION() != null)
{
IList <EsperEPL2GrammarParser.CreateContextPartitionItemContext> partitions = ctx.createContextPartitionItem();
IList <ContextDetailPartitionItem> rawSpecs = new List <ContextDetailPartitionItem>();
foreach (EsperEPL2GrammarParser.CreateContextPartitionItemContext partition in partitions)
{
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(partition.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
IList <String> propertyNames = new List <String>();
IList <EsperEPL2GrammarParser.EventPropertyContext> properties = partition.eventProperty();
foreach (EsperEPL2GrammarParser.EventPropertyContext property in properties)
{
String propertyName = ASTUtil.GetPropertyName(property, 0);
propertyNames.Add(propertyName);
}
ASTExprHelper.ExprCollectSubNodes(partition, 0, astExprNodeMap); // remove expressions
rawSpecs.Add(new ContextDetailPartitionItem(filterSpec, propertyNames));
}
return(new ContextDetailPartitioned(rawSpecs));
}
// hash
else if (ctx.COALESCE() != null)
{
IList <EsperEPL2GrammarParser.CreateContextCoalesceItemContext> coalesces = ctx.createContextCoalesceItem();
IList <ContextDetailHashItem> rawSpecs = new List <ContextDetailHashItem>(coalesces.Count);
foreach (EsperEPL2GrammarParser.CreateContextCoalesceItemContext coalesce in coalesces)
{
ExprChainedSpec func = ASTLibFunctionHelper.GetLibFunctionChainSpec(coalesce.libFunctionNoClass(), astExprNodeMap);
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(coalesce.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
rawSpecs.Add(new ContextDetailHashItem(func, filterSpec));
}
String granularity = ctx.g.Text;
if (!granularity.ToLower().Equals("granularity"))
{
throw ASTWalkException.From("Expected 'granularity' keyword after list of coalesce items, found '" + granularity + "' instead");
}
var num = ASTConstantHelper.Parse(ctx.number());
String preallocateStr = ctx.p != null ? ctx.p.Text : null;
if (preallocateStr != null && !preallocateStr.ToLower().Equals("preallocate"))
{
throw ASTWalkException.From("Expected 'preallocate' keyword after list of coalesce items, found '" + preallocateStr + "' instead");
}
if (!num.GetType().IsNumericNonFP() || num.GetType().GetBoxedType() == typeof(long?))
{
throw ASTWalkException.From("Granularity provided must be an int-type number, received " + num.GetType() + " instead");
}
return(new ContextDetailHash(rawSpecs, num.AsInt(), preallocateStr != null));
}
// categorized
if (ctx.createContextGroupItem() != null)
{
IList <EsperEPL2GrammarParser.CreateContextGroupItemContext> grps = ctx.createContextGroupItem();
IList <ContextDetailCategoryItem> items = new List <ContextDetailCategoryItem>();
foreach (EsperEPL2GrammarParser.CreateContextGroupItemContext grp in grps)
{
ExprNode exprNode = ASTExprHelper.ExprCollectSubNodes(grp, 0, astExprNodeMap)[0];
String name = grp.i.Text;
items.Add(new ContextDetailCategoryItem(exprNode, name));
}
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(ctx.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
return(new ContextDetailCategory(items, filterSpec));
}
throw new IllegalStateException("Unrecognized context detail type");
}
