public static StatementSpecRaw CompileEPL(
string eplStatement,
string eplStatementForErrorMsg,
bool addPleaseCheck,
string statementName,
SelectClauseStreamSelectorEnum defaultStreamSelector,
EngineImportService engineImportService,
VariableService variableService,
SchedulingService schedulingService,
string engineURI,
ConfigurationInformation configSnapshot,
PatternNodeFactory patternNodeFactory,
ContextManagementService contextManagementService,
ExprDeclaredService exprDeclaredService,
TableService tableService)
{
if (Log.IsDebugEnabled)
{
Log.Debug(".createEPLStmt statementName=" + statementName + " eplStatement=" + eplStatement);
}
ParseResult parseResult = ParseHelper.Parse(
eplStatement, eplStatementForErrorMsg, addPleaseCheck, EPLParseRule, true);
ITree ast = parseResult.Tree;
var walker = new EPLTreeWalkerListener(
parseResult.TokenStream, engineImportService, variableService, schedulingService, defaultStreamSelector,
engineURI, configSnapshot, patternNodeFactory, contextManagementService, parseResult.Scripts,
exprDeclaredService, tableService);
try
{
ParseHelper.Walk(ast, walker, eplStatement, eplStatementForErrorMsg);
}
catch (ASTWalkException ex)
{
Log.Error(".createEPL Error validating expression", ex);
throw new EPStatementException(ex.Message, ex, eplStatementForErrorMsg);
}
catch (EPStatementSyntaxException ex)
{
throw;
}
catch (Exception ex)
{
string message = "Error in expression";
Log.Debug(message, ex);
throw new EPStatementException(GetNullableErrortext(message, ex.Message), ex, eplStatementForErrorMsg);
}
if (Log.IsDebugEnabled)
{
ASTUtil.DumpAST(ast);
}
StatementSpecRaw raw = walker.StatementSpec;
raw.ExpressionNoAnnotations = parseResult.ExpressionWithoutAnnotations;
return(raw);
}
public static ExprNodeScript GetExistsScript(
String defaultDialect,
String expressionName,
IList <ExprNode> parameters,
ICollection <ExpressionScriptProvided> scriptExpressions,
ExprDeclaredService exprDeclaredService)
{
if (scriptExpressions.IsNotEmpty())
{
var scriptProvided = FindScript(expressionName, parameters.Count, scriptExpressions);
if (scriptProvided != null)
{
return(new ExprNodeScript(defaultDialect, scriptProvided, parameters));
}
}
var globalScripts = exprDeclaredService.GetScriptsByName(expressionName);
var script = FindScript(expressionName, parameters.Count, globalScripts);
if (script != null)
{
return(new ExprNodeScript(defaultDialect, script, parameters));
}
return(null);
}
public static ExprDeclaredNodeImpl GetExistsDeclaredExpr(
IContainer container,
String name,
IList <ExprNode> parameters,
ICollection <ExpressionDeclItem> expressionDeclarations,
ExprDeclaredService exprDeclaredService,
ContextDescriptor contextDescriptor)
{
// Find among local expressions
if (expressionDeclarations.IsNotEmpty())
{
foreach (ExpressionDeclItem declNode in expressionDeclarations)
{
if (declNode.Name.Equals(name))
{
return(new ExprDeclaredNodeImpl(
container, declNode, parameters, contextDescriptor));
}
}
}
// find among global expressions
ExpressionDeclItem found = exprDeclaredService.GetExpression(name);
if (found != null)
{
return(new ExprDeclaredNodeImpl(
container, found, parameters, contextDescriptor));
}
return(null);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="engineImportService">engine imports</param>
/// <param name="variableService">variable names</param>
/// <param name="configuration">the configuration</param>
/// <param name="schedulingService">The scheduling service.</param>
/// <param name="engineURI">The engine URI.</param>
/// <param name="patternNodeFactory">The pattern node factory.</param>
/// <param name="namedWindowMgmtService">The named window service.</param>
/// <param name="contextManagementService">The context management service.</param>
/// <param name="exprDeclaredService">The expr declared service.</param>
/// <param name="contextDescriptor">optional context description</param>
/// <param name="tableService">The table service.</param>
public StatementSpecMapContext(
IContainer container,
EngineImportService engineImportService,
VariableService variableService,
ConfigurationInformation configuration,
SchedulingService schedulingService,
string engineURI,
PatternNodeFactory patternNodeFactory,
NamedWindowMgmtService namedWindowMgmtService,
ContextManagementService contextManagementService,
ExprDeclaredService exprDeclaredService,
ContextDescriptor contextDescriptor,
TableService tableService)
{
Container = container;
PlugInAggregations = new LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory>();
TableExpressions = new HashSet <ExprTableAccessNode>();
EngineImportService = engineImportService;
VariableService = variableService;
Configuration = configuration;
VariableNames = new HashSet <string>();
SchedulingService = schedulingService;
EngineURI = engineURI;
PatternNodeFactory = patternNodeFactory;
NamedWindowMgmtService = namedWindowMgmtService;
ContextManagementService = contextManagementService;
ExprDeclaredService = exprDeclaredService;
ContextDescriptor = contextDescriptor;
TableService = tableService;
}
public StatementContextEngineServices(
IContainer container,
String engineURI,
EventAdapterService eventAdapterService,
NamedWindowMgmtService namedWindowMgmtService,
VariableService variableService,
TableService tableService,
EngineSettingsService engineSettingsService,
ValueAddEventService valueAddEventService,
ConfigurationInformation configSnapshot,
MetricReportingServiceSPI metricReportingService,
ViewService viewService,
ExceptionHandlingService exceptionHandlingService,
ExpressionResultCacheService expressionResultCacheService,
StatementEventTypeRef statementEventTypeRef,
TableExprEvaluatorContext tableExprEvaluatorContext,
EngineLevelExtensionServicesContext engineLevelExtensionServicesContext,
RegexHandlerFactory regexHandlerFactory,
StatementLockFactory statementLockFactory,
ContextManagementService contextManagementService,
ViewServicePreviousFactory viewServicePreviousFactory,
EventTableIndexService eventTableIndexService,
PatternNodeFactory patternNodeFactory,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
TimeSourceService timeSourceService,
EngineImportService engineImportService,
AggregationFactoryFactory aggregationFactoryFactory,
SchedulingService schedulingService,
ExprDeclaredService exprDeclaredService)
{
Container = container;
EngineURI = engineURI;
EventAdapterService = eventAdapterService;
NamedWindowMgmtService = namedWindowMgmtService;
VariableService = variableService;
TableService = tableService;
EngineSettingsService = engineSettingsService;
ValueAddEventService = valueAddEventService;
ConfigSnapshot = configSnapshot;
MetricReportingService = metricReportingService;
ViewService = viewService;
ExceptionHandlingService = exceptionHandlingService;
ExpressionResultCacheService = expressionResultCacheService;
StatementEventTypeRef = statementEventTypeRef;
TableExprEvaluatorContext = tableExprEvaluatorContext;
EngineLevelExtensionServicesContext = engineLevelExtensionServicesContext;
RegexHandlerFactory = regexHandlerFactory;
StatementLockFactory = statementLockFactory;
ContextManagementService = contextManagementService;
ViewServicePreviousFactory = viewServicePreviousFactory;
EventTableIndexService = eventTableIndexService;
PatternNodeFactory = patternNodeFactory;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
TimeSourceService = timeSourceService;
EngineImportService = engineImportService;
AggregationFactoryFactory = aggregationFactoryFactory;
SchedulingService = schedulingService;
ExprDeclaredService = exprDeclaredService;
}
/// <summary>Dispose services. </summary>
public void Dispose()
{
if (ScriptingService != null)
{
ScriptingService.Dispose();
}
if (ExprDeclaredService != null)
{
ExprDeclaredService.Dispose();
}
if (DataFlowService != null)
{
DataFlowService.Dispose();
}
if (VariableService != null)
{
VariableService.Dispose();
}
if (MetricsReportingService != null)
{
MetricsReportingService.Dispose();
}
if (ThreadingService != null)
{
ThreadingService.Dispose();
}
if (StatementLifecycleSvc != null)
{
StatementLifecycleSvc.Dispose();
}
if (FilterService != null)
{
FilterService.Dispose();
}
if (SchedulingService != null)
{
SchedulingService.Dispose();
}
if (SchedulingMgmtService != null)
{
SchedulingMgmtService.Dispose();
}
if (StreamService != null)
{
StreamService.Destroy();
}
if (NamedWindowMgmtService != null)
{
NamedWindowMgmtService.Dispose();
}
if (NamedWindowDispatchService != null)
{
NamedWindowDispatchService.Dispose();
}
if (EngineLevelExtensionServicesContext != null)
{
EngineLevelExtensionServicesContext.Dispose();
}
if (StatementIsolationService != null)
{
StatementIsolationService.Dispose();
}
if (DeploymentStateService != null)
{
DeploymentStateService.Dispose();
}
}
// Supplied after construction to avoid circular dependency
/// <summary>
/// Constructor - sets up new set of services.
/// </summary>
/// <param name="engineURI">is the engine URI</param>
/// <param name="schedulingService">service to get time and schedule callbacks</param>
/// <param name="eventAdapterService">service to resolve event types</param>
/// <param name="engineImportService">is engine imported static func packages and aggregation functions</param>
/// <param name="engineSettingsService">provides engine settings</param>
/// <param name="databaseConfigService">service to resolve a database name to database connection factory and configs</param>
/// <param name="plugInViews">resolves view namespace and name to view factory class</param>
/// <param name="statementLockFactory">creates statement-level locks</param>
/// <param name="eventProcessingRWLock">is the engine lock for statement management</param>
/// <param name="extensionServicesContext">marker interface allows adding additional services</param>
/// <param name="engineEnvContext">is engine environment/directory information for use with adapters and external env</param>
/// <param name="statementContextFactory">is the factory to use to create statement context objects</param>
/// <param name="plugInPatternObjects">resolves plug-in pattern objects</param>
/// <param name="timerService">is the timer service</param>
/// <param name="filterService">the filter service</param>
/// <param name="streamFactoryService">is hooking up filters to streams</param>
/// <param name="namedWindowMgmtService">The named window MGMT service.</param>
/// <param name="namedWindowDispatchService">The named window dispatch service.</param>
/// <param name="variableService">provides access to variable values</param>
/// <param name="tableService">The table service.</param>
/// <param name="timeSourceService">time source provider class</param>
/// <param name="valueAddEventService">handles Update events</param>
/// <param name="metricsReportingService">for metric reporting</param>
/// <param name="statementEventTypeRef">statement to event type reference holding</param>
/// <param name="statementVariableRef">statement to variabke reference holding</param>
/// <param name="configSnapshot">configuration snapshot</param>
/// <param name="threadingServiceImpl">engine-level threading services</param>
/// <param name="internalEventRouter">routing of events</param>
/// <param name="statementIsolationService">maintains isolation information per statement</param>
/// <param name="schedulingMgmtService">schedule management for statements</param>
/// <param name="deploymentStateService">The deployment state service.</param>
/// <param name="exceptionHandlingService">The exception handling service.</param>
/// <param name="patternNodeFactory">The pattern node factory.</param>
/// <param name="eventTypeIdGenerator">The event type id generator.</param>
/// <param name="statementMetadataFactory">The statement metadata factory.</param>
/// <param name="contextManagementService">The context management service.</param>
/// <param name="patternSubexpressionPoolSvc">The pattern subexpression pool SVC.</param>
/// <param name="matchRecognizeStatePoolEngineSvc">The match recognize state pool engine SVC.</param>
/// <param name="dataFlowService">The data flow service.</param>
/// <param name="exprDeclaredService">The expr declared service.</param>
/// <param name="contextControllerFactoryFactorySvc">The context controller factory factory SVC.</param>
/// <param name="contextManagerFactoryService">The context manager factory service.</param>
/// <param name="epStatementFactory">The ep statement factory.</param>
/// <param name="regexHandlerFactory">The regex handler factory.</param>
/// <param name="viewableActivatorFactory">The viewable activator factory.</param>
/// <param name="filterNonPropertyRegisteryService">The filter non property registery service.</param>
/// <param name="resultSetProcessorHelperFactory">The result set processor helper factory.</param>
/// <param name="viewServicePreviousFactory">The view service previous factory.</param>
/// <param name="eventTableIndexService">The event table index service.</param>
/// <param name="epRuntimeIsolatedFactory">The ep runtime isolated factory.</param>
/// <param name="filterBooleanExpressionFactory">The filter boolean expression factory.</param>
/// <param name="dataCacheFactory">The data cache factory.</param>
/// <param name="multiMatchHandlerFactory">The multi match handler factory.</param>
/// <param name="namedWindowConsumerMgmtService">The named window consumer MGMT service.</param>
/// <param name="aggregationFactoryFactory"></param>
/// <param name="scriptingService">The scripting service.</param>
public EPServicesContext(
string engineURI,
SchedulingServiceSPI schedulingService,
EventAdapterService eventAdapterService,
EngineImportService engineImportService,
EngineSettingsService engineSettingsService,
DatabaseConfigService databaseConfigService,
PluggableObjectCollection plugInViews,
StatementLockFactory statementLockFactory,
IReaderWriterLock eventProcessingRWLock,
EngineLevelExtensionServicesContext extensionServicesContext,
Directory engineEnvContext,
StatementContextFactory statementContextFactory,
PluggableObjectCollection plugInPatternObjects,
TimerService timerService,
FilterServiceSPI filterService,
StreamFactoryService streamFactoryService,
NamedWindowMgmtService namedWindowMgmtService,
NamedWindowDispatchService namedWindowDispatchService,
VariableService variableService,
TableService tableService,
TimeSourceService timeSourceService,
ValueAddEventService valueAddEventService,
MetricReportingServiceSPI metricsReportingService,
StatementEventTypeRef statementEventTypeRef,
StatementVariableRef statementVariableRef,
ConfigurationInformation configSnapshot,
ThreadingService threadingServiceImpl,
InternalEventRouterImpl internalEventRouter,
StatementIsolationService statementIsolationService,
SchedulingMgmtService schedulingMgmtService,
DeploymentStateService deploymentStateService,
ExceptionHandlingService exceptionHandlingService,
PatternNodeFactory patternNodeFactory,
EventTypeIdGenerator eventTypeIdGenerator,
StatementMetadataFactory statementMetadataFactory,
ContextManagementService contextManagementService,
PatternSubexpressionPoolEngineSvc patternSubexpressionPoolSvc,
MatchRecognizeStatePoolEngineSvc matchRecognizeStatePoolEngineSvc,
DataFlowService dataFlowService,
ExprDeclaredService exprDeclaredService,
ContextControllerFactoryFactorySvc contextControllerFactoryFactorySvc,
ContextManagerFactoryService contextManagerFactoryService,
EPStatementFactory epStatementFactory,
RegexHandlerFactory regexHandlerFactory,
ViewableActivatorFactory viewableActivatorFactory,
FilterNonPropertyRegisteryService filterNonPropertyRegisteryService,
ResultSetProcessorHelperFactory resultSetProcessorHelperFactory,
ViewServicePreviousFactory viewServicePreviousFactory,
EventTableIndexService eventTableIndexService,
EPRuntimeIsolatedFactory epRuntimeIsolatedFactory,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
DataCacheFactory dataCacheFactory,
MultiMatchHandlerFactory multiMatchHandlerFactory,
NamedWindowConsumerMgmtService namedWindowConsumerMgmtService,
AggregationFactoryFactory aggregationFactoryFactory,
ScriptingService scriptingService)
{
EngineURI = engineURI;
SchedulingService = schedulingService;
EventAdapterService = eventAdapterService;
EngineImportService = engineImportService;
EngineSettingsService = engineSettingsService;
DatabaseRefService = databaseConfigService;
FilterService = filterService;
TimerService = timerService;
DispatchService = DispatchServiceProvider.NewService();
ViewService = ViewServiceProvider.NewService();
StreamService = streamFactoryService;
PlugInViews = plugInViews;
StatementLockFactory = statementLockFactory;
EventProcessingRWLock = eventProcessingRWLock;
EngineLevelExtensionServicesContext = extensionServicesContext;
EngineEnvContext = engineEnvContext;
StatementContextFactory = statementContextFactory;
PlugInPatternObjects = plugInPatternObjects;
NamedWindowMgmtService = namedWindowMgmtService;
NamedWindowDispatchService = namedWindowDispatchService;
VariableService = variableService;
TableService = tableService;
TimeSource = timeSourceService;
ValueAddEventService = valueAddEventService;
MetricsReportingService = metricsReportingService;
StatementEventTypeRefService = statementEventTypeRef;
ConfigSnapshot = configSnapshot;
ThreadingService = threadingServiceImpl;
InternalEventRouter = internalEventRouter;
StatementIsolationService = statementIsolationService;
SchedulingMgmtService = schedulingMgmtService;
StatementVariableRefService = statementVariableRef;
DeploymentStateService = deploymentStateService;
ExceptionHandlingService = exceptionHandlingService;
PatternNodeFactory = patternNodeFactory;
EventTypeIdGenerator = eventTypeIdGenerator;
StatementMetadataFactory = statementMetadataFactory;
ContextManagementService = contextManagementService;
PatternSubexpressionPoolSvc = patternSubexpressionPoolSvc;
MatchRecognizeStatePoolEngineSvc = matchRecognizeStatePoolEngineSvc;
DataFlowService = dataFlowService;
ExprDeclaredService = exprDeclaredService;
ExpressionResultCacheSharable = new ExpressionResultCacheService(
configSnapshot.EngineDefaults.ExecutionConfig.DeclaredExprValueCacheSize);
ContextControllerFactoryFactorySvc = contextControllerFactoryFactorySvc;
ContextManagerFactoryService = contextManagerFactoryService;
EpStatementFactory = epStatementFactory;
RegexHandlerFactory = regexHandlerFactory;
ViewableActivatorFactory = viewableActivatorFactory;
FilterNonPropertyRegisteryService = filterNonPropertyRegisteryService;
ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory;
ViewServicePreviousFactory = viewServicePreviousFactory;
EventTableIndexService = eventTableIndexService;
EpRuntimeIsolatedFactory = epRuntimeIsolatedFactory;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
DataCacheFactory = dataCacheFactory;
MultiMatchHandlerFactory = multiMatchHandlerFactory;
NamedWindowConsumerMgmtService = namedWindowConsumerMgmtService;
AggregationFactoryFactory = aggregationFactoryFactory;
ScriptingService = scriptingService;
}
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);
}
