public override EPPreparedExecuteIUDSingleStreamExec GetExecutor(FilterSpecCompiled filter, string aliasName)
{
var services = base.Services;
var processor = base.Processor;
var statementContext = base.StatementContext;
var statementSpec = base.StatementSpec;
var updateSpec = (FireAndForgetSpecUpdate)statementSpec.FireAndForgetSpec;
var assignmentTypeService = new StreamTypeServiceImpl(
new EventType[] { processor.EventTypeResultSetProcessor, null, processor.EventTypeResultSetProcessor },
new string[] { aliasName, "", EPStatementStartMethodOnTrigger.INITIAL_VALUE_STREAM_NAME },
new bool[] { true, true, true }, services.EngineURI, true);
assignmentTypeService.IsStreamZeroUnambigous = true;
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, true);
var validationContext = new ExprValidationContext(
assignmentTypeService, statementContext.EngineImportService,
statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService,
statementContext.VariableService, statementContext.TableService, evaluatorContextStmt,
statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId,
statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService,
false, false, true, false, null, false);
// validate update expressions
try {
foreach (OnTriggerSetAssignment assignment in updateSpec.Assignments)
{
ExprNode validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.UPDATEASSIGN, assignment.Expression, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause");
}
} catch (ExprValidationException e) {
throw new EPException(e.Message, e);
}
// make updater
EventBeanUpdateHelper updateHelper;
TableUpdateStrategy tableUpdateStrategy = null;
try {
bool copyOnWrite = !(processor is FireAndForgetProcessorTable);
updateHelper = EventBeanUpdateHelperFactory.Make(processor.NamedWindowOrTableName,
(EventTypeSPI)processor.EventTypeResultSetProcessor, updateSpec.Assignments, aliasName, null, copyOnWrite, statementContext.StatementName, services.EngineURI, services.EventAdapterService);
if (processor is FireAndForgetProcessorTable)
{
FireAndForgetProcessorTable tableProcessor = (FireAndForgetProcessorTable)processor;
tableUpdateStrategy = services.TableService.GetTableUpdateStrategy(tableProcessor.TableMetadata, updateHelper, false);
copyOnWrite = false;
}
} catch (ExprValidationException e) {
throw new EPException(e.Message, e);
}
return(new EPPreparedExecuteIUDSingleStreamExecUpdate(filter, statementSpec.FilterRootNode, statementSpec.Annotations, updateHelper, tableUpdateStrategy, statementSpec.TableNodes, services));
}
private static void ValidateThenSetAssignments(
IList <OnTriggerSetAssignment> assignments,
ExprValidationContext validationContext)
{
if (assignments == null || assignments.IsEmpty())
{
return;
}
foreach (var assign in assignments)
{
var node = ExprNodeUtility.GetValidatedAssignment(assign, validationContext);
assign.Expression = node;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(node, "An aggregate function may not appear in a OUTPUT LIMIT clause");
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteMethodQuery(StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
_hasTableAccess = (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
foreach (var streamSpec in statementSpec.StreamSpecs)
{
_hasTableAccess |= streamSpec is TableQueryStreamSpec;
}
_statementSpec = statementSpec;
_services = services;
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
var numStreams = statementSpec.StreamSpecs.Length;
var typesPerStream = new EventType[numStreams];
var namesPerStream = new string[numStreams];
_processors = new FireAndForgetProcessor[numStreams];
_agentInstanceContext = new AgentInstanceContext(statementContext, null, -1, null, null, statementContext.DefaultAgentInstanceScriptContext);
// resolve types and processors
for (var i = 0; i < numStreams; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
_processors[i] = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
string streamName = _processors[i].NamedWindowOrTableName;
if (streamSpec.OptionalStreamName != null)
{
streamName = streamSpec.OptionalStreamName;
}
namesPerStream[i] = streamName;
typesPerStream[i] = _processors[i].EventTypeResultSetProcessor;
}
// compile filter to optimize access to named window
_filters = new FilterSpecCompiled[numStreams];
if (statementSpec.FilterRootNode != null)
{
var tagged = new LinkedHashMap <string, Pair <EventType, string> >();
for (var i = 0; i < numStreams; i++)
{
try {
var types = new StreamTypeServiceImpl(typesPerStream, namesPerStream, new bool[numStreams], services.EngineURI, false);
_filters[i] = FilterSpecCompiler.MakeFilterSpec(typesPerStream[i], namesPerStream[i],
Collections.SingletonList(statementSpec.FilterRootNode), null,
tagged, tagged, types,
null, statementContext, Collections.SingletonList(i));
}
catch (Exception ex) {
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
}
}
}
// obtain result set processor
var isIStreamOnly = new bool[namesPerStream.Length];
CompatExtensions.Fill(isIStreamOnly, true);
StreamTypeService typeService = new StreamTypeServiceImpl(typesPerStream, namesPerStream, isIStreamOnly, services.EngineURI, true);
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(statementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot);
_resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(_agentInstanceContext, resultSetProcessorPrototype);
if (statementSpec.SelectClauseSpec.IsDistinct)
{
if (_resultSetProcessor.ResultEventType is EventTypeSPI)
{
_eventBeanReader = ((EventTypeSPI)_resultSetProcessor.ResultEventType).GetReader();
}
if (_eventBeanReader == null)
{
_eventBeanReader = new EventBeanReaderDefaultImpl(_resultSetProcessor.ResultEventType);
}
}
// plan joins or simple queries
if (numStreams > 1)
{
var streamJoinAnalysisResult = new StreamJoinAnalysisResult(numStreams);
CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindow, true);
for (var i = 0; i < numStreams; i++)
{
var processorInstance = _processors[i].GetProcessorInstance(_agentInstanceContext);
if (_processors[i].IsVirtualDataWindow)
{
streamJoinAnalysisResult.ViewExternal[i] = agentInstanceContext => processorInstance.VirtualDataWindow;
}
var uniqueIndexes = _processors[i].GetUniqueIndexes(processorInstance);
streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes;
}
var hasAggregations = !resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions.IsEmpty();
_joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(
null, null,
statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typesPerStream, namesPerStream,
streamJoinAnalysisResult, queryPlanLogging, statementContext, new HistoricalViewableDesc(numStreams),
_agentInstanceContext, false, hasAggregations, services.TableService, true);
}
// check context partition use
if (statementSpec.OptionalContextName != null)
{
if (numStreams > 1)
{
throw new ExprValidationException("Joins in runtime queries for context partitions are not supported");
}
}
}
/// <summary>
/// Validate filter and join expression nodes.
/// </summary>
/// <param name="statementSpec">the compiled statement</param>
/// <param name="statementContext">the statement services</param>
/// <param name="typeService">the event types for streams</param>
/// <param name="viewResourceDelegate">the delegate to verify expressions that use view resources</param>
internal static void ValidateNodes(
StatementSpecCompiled statementSpec,
StatementContext statementContext,
StreamTypeService typeService,
ViewResourceDelegateUnverified viewResourceDelegate)
{
var methodResolutionService = statementContext.MethodResolutionService;
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
var intoTableName = statementSpec.IntoTableSpec == null ? null : statementSpec.IntoTableSpec.Name;
if (statementSpec.FilterRootNode != null)
{
var optionalFilterNode = statementSpec.FilterRootNode;
// Validate where clause, initializing nodes to the stream ids used
try
{
var validationContext = new ExprValidationContext(
typeService,
methodResolutionService,
viewResourceDelegate,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false,
intoTableName, false);
optionalFilterNode = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.FILTER, optionalFilterNode, validationContext);
if (optionalFilterNode.ExprEvaluator.ReturnType != typeof(bool) && optionalFilterNode.ExprEvaluator.ReturnType != typeof(bool?))
{
throw new ExprValidationException("The where-clause filter expression must return a boolean value");
}
statementSpec.FilterExprRootNode = optionalFilterNode;
// Make sure there is no aggregation in the where clause
var aggregateNodes = new List <ExprAggregateNode>();
ExprAggregateNodeUtil.GetAggregatesBottomUp(optionalFilterNode, aggregateNodes);
if (!aggregateNodes.IsEmpty())
{
throw new ExprValidationException("An aggregate function may not appear in a WHERE clause (use the HAVING clause)");
}
}
catch (ExprValidationException ex)
{
Log.Debug(".validateNodes Validation exception for filter=" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(optionalFilterNode), ex);
throw new EPStatementException("Error validating expression: " + ex.Message, ex, statementContext.Expression);
}
}
if ((statementSpec.OutputLimitSpec != null) && ((statementSpec.OutputLimitSpec.WhenExpressionNode != null) || (statementSpec.OutputLimitSpec.AndAfterTerminateExpr != null)))
{
// Validate where clause, initializing nodes to the stream ids used
try
{
var outputLimitType = OutputConditionExpressionFactory.GetBuiltInEventType(statementContext.EventAdapterService);
StreamTypeService typeServiceOutputWhen = new StreamTypeServiceImpl(new EventType[] { outputLimitType }, new String[] { null }, new bool[] { true }, statementContext.EngineURI, false);
var validationContext = new ExprValidationContext(
typeServiceOutputWhen,
methodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, false, false,
intoTableName, false);
var outputLimitWhenNode = statementSpec.OutputLimitSpec.WhenExpressionNode;
if (outputLimitWhenNode != null)
{
outputLimitWhenNode = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.OUTPUTLIMIT, outputLimitWhenNode, validationContext);
statementSpec.OutputLimitSpec.WhenExpressionNode = outputLimitWhenNode;
if (TypeHelper.GetBoxedType(outputLimitWhenNode.ExprEvaluator.ReturnType) != typeof(bool?))
{
throw new ExprValidationException("The when-trigger expression in the OUTPUT WHEN clause must return a boolean-type value");
}
EPStatementStartMethodHelperValidate.ValidateNoAggregations(outputLimitWhenNode, "An aggregate function may not appear in a OUTPUT LIMIT clause");
}
// validate and-terminate expression if provided
if (statementSpec.OutputLimitSpec.AndAfterTerminateExpr != null)
{
if (statementSpec.OutputLimitSpec.RateType != OutputLimitRateType.WHEN_EXPRESSION && statementSpec.OutputLimitSpec.RateType != OutputLimitRateType.TERM)
{
throw new ExprValidationException("A terminated-and expression must be used with the OUTPUT WHEN clause");
}
var validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.OUTPUTLIMIT, statementSpec.OutputLimitSpec.AndAfterTerminateExpr, validationContext);
statementSpec.OutputLimitSpec.AndAfterTerminateExpr = validated;
if (validated.ExprEvaluator.ReturnType.GetBoxedType() != typeof(bool?))
{
throw new ExprValidationException("The terminated-and expression must return a boolean-type value");
}
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "An aggregate function may not appear in a terminated-and clause");
}
// validate then-expression
ValidateThenSetAssignments(statementSpec.OutputLimitSpec.ThenExpressions, validationContext);
// validate after-terminated then-expression
ValidateThenSetAssignments(statementSpec.OutputLimitSpec.AndAfterTerminateThenExpressions, validationContext);
}
catch (ExprValidationException ex)
{
throw new EPStatementException("Error validating expression: " + ex.Message, statementContext.Expression);
}
}
for (var outerJoinCount = 0; outerJoinCount < statementSpec.OuterJoinDescList.Length; outerJoinCount++)
{
var outerJoinDesc = statementSpec.OuterJoinDescList[outerJoinCount];
// validate on-expression nodes, if provided
if (outerJoinDesc.OptLeftNode != null)
{
var streamIdPair = ValidateOuterJoinPropertyPair(statementContext, outerJoinDesc.OptLeftNode, outerJoinDesc.OptRightNode, outerJoinCount,
typeService, viewResourceDelegate);
if (outerJoinDesc.AdditionalLeftNodes != null)
{
ISet <int?> streamSet = new HashSet <int?>();
streamSet.Add(streamIdPair.First);
streamSet.Add(streamIdPair.Second);
for (var i = 0; i < outerJoinDesc.AdditionalLeftNodes.Length; i++)
{
var streamIdPairAdd = ValidateOuterJoinPropertyPair(statementContext, outerJoinDesc.AdditionalLeftNodes[i], outerJoinDesc.AdditionalRightNodes[i], outerJoinCount,
typeService, viewResourceDelegate);
// make sure all additional properties point to the same two streams
if ((!streamSet.Contains(streamIdPairAdd.First) || (!streamSet.Contains(streamIdPairAdd.Second))))
{
const string message = "Outer join ON-clause columns must refer to properties of the same joined streams" +
" when using multiple columns in the on-clause";
throw new EPStatementException("Error validating expression: " + message, statementContext.Expression);
}
}
}
}
}
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
// define stop and destroy
var stopCallbacks = new List <StopCallback>();
var destroyCallbacks = new EPStatementDestroyCallbackList();
// determine context
var contextName = StatementSpec.OptionalContextName;
if (contextName != null)
{
throw new ExprValidationException("Update IStream is not supported in conjunction with a context");
}
// First we create streams for subselects, if there are any
var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(
services, StatementSpec, statementContext, destroyCallbacks);
var streamSpec = StatementSpec.StreamSpecs[0];
var updateSpec = StatementSpec.UpdateSpec;
String triggereventTypeName;
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec;
triggereventTypeName = filterStreamSpec.FilterSpec.FilterForEventTypeName;
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
triggereventTypeName = namedSpec.WindowName;
}
else if (streamSpec is TableQueryStreamSpec)
{
throw new ExprValidationException("Tables cannot be used in an update-istream statement");
}
else
{
throw new ExprValidationException("Unknown stream specification streamEventType: " + streamSpec);
}
// determine a stream name
var streamName = triggereventTypeName;
if (updateSpec.OptionalStreamName != null)
{
streamName = updateSpec.OptionalStreamName;
}
var streamEventType = services.EventAdapterService.GetEventTypeByName(triggereventTypeName);
StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { streamEventType }, new String[] { streamName }, new bool[] { true }, services.EngineURI, false);
// determine subscriber result types
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
statementContext.StatementResultService.SetSelectClause(new Type[] { streamEventType.UnderlyingType }, new String[] { "*" }, false, null, evaluatorContextStmt);
// Materialize sub-select views
var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, IsQueryPlanLogging(services), subSelectStreamDesc, new String[] { streamName }, new EventType[] { streamEventType }, new String[] { triggereventTypeName }, StatementSpec.DeclaredExpressions, null);
var validationContext = new ExprValidationContext(
typeService,
statementContext.MethodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, false, false,
null, false);
foreach (var assignment in updateSpec.Assignments)
{
var validated = ExprNodeUtility.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause");
}
if (updateSpec.OptionalWhereClause != null)
{
var validated = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.WHERE, updateSpec.OptionalWhereClause, validationContext);
updateSpec.OptionalWhereClause = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause");
}
// preprocessing view
var onExprView = new InternalRoutePreprocessView(streamEventType, statementContext.StatementResultService);
// validation
var routerDesc = services.InternalEventRouter.GetValidatePreprocessing(onExprView.EventType, updateSpec, statementContext.Annotations);
// create context factory
var contextFactory = new StatementAgentInstanceFactoryUpdate(statementContext, services, streamEventType, updateSpec, onExprView, routerDesc, subSelectStrategyCollection);
// perform start of hook-up to start
Viewable finalViewable;
EPStatementStopMethod stopStatementMethod;
IDictionary <ExprSubselectNode, SubSelectStrategyHolder> subselectStrategyInstances;
// With context - delegate instantiation to context
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks).Stop;
if (StatementSpec.OptionalContextName != null)
{
// use statement-wide agent-instance-specific subselects
var aiRegistryExpr = statementContext.StatementAgentInstanceRegistry.AgentInstanceExprService;
subselectStrategyInstances = new Dictionary <ExprSubselectNode, SubSelectStrategyHolder>();
foreach (var node in subSelectStrategyCollection.Subqueries.Keys)
{
var specificService = aiRegistryExpr.AllocateSubselect(node);
node.Strategy = specificService;
subselectStrategyInstances.Put(node, new SubSelectStrategyHolder(null, null, null, null, null, null));
}
var mergeView = new ContextMergeView(onExprView.EventType);
finalViewable = mergeView;
var statement = new ContextManagedStatementOnTriggerDesc(StatementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient);
stopStatementMethod = () =>
{
services.ContextManagementService.StoppedStatement(contextName, statementContext.StatementName, statementContext.StatementId);
stopMethod.Invoke();
};
destroyCallbacks.AddCallback(EPStatementDestroyCallbackContext.New(
services.ContextManagementService,
StatementSpec.OptionalContextName,
statementContext.StatementName,
statementContext.StatementId));
}
// Without context - start here
else
{
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var resultOfStart = (StatementAgentInstanceFactoryUpdateResult)
contextFactory.NewContext(agentInstanceContext, isRecoveringResilient);
finalViewable = resultOfStart.FinalView;
stopStatementMethod = new EPStatementStopMethod(() =>
{
resultOfStart.StopCallback.Invoke();
stopMethod.Invoke();
});
subselectStrategyInstances = resultOfStart.SubselectStrategies;
}
// assign subquery nodes
EPStatementStartMethodHelperAssignExpr.AssignSubqueryStrategies(subSelectStrategyCollection, subselectStrategyInstances);
return(new EPStatementStartResult(finalViewable, stopStatementMethod, destroyCallbacks.Destroy));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteIUDSingleStream(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
HasTableAccess = statementSpec.IntoTableSpec != null ||
(statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
if (statementSpec.InsertIntoDesc != null && services.TableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName) != null)
{
HasTableAccess = true;
}
if (statementSpec.FireAndForgetSpec is FireAndForgetSpecUpdate ||
statementSpec.FireAndForgetSpec is FireAndForgetSpecDelete)
{
HasTableAccess |= statementSpec.StreamSpecs[0] is TableQueryStreamSpec;
}
StatementSpec = statementSpec;
Services = services;
StatementContext = statementContext;
// validate general FAF criteria
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
// obtain processor
var streamSpec = statementSpec.StreamSpecs[0];
Processor = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
// obtain name and type
var processorName = Processor.NamedWindowOrTableName;
var eventType = Processor.EventTypeResultSetProcessor;
// determine alias
var aliasName = processorName;
if (streamSpec.OptionalStreamName != null)
{
aliasName = streamSpec.OptionalStreamName;
}
// compile filter to optimize access to named window
var typeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new string[] { aliasName }, new bool[] { true }, services.EngineURI, true);
FilterSpecCompiled filter;
if (statementSpec.FilterRootNode != null)
{
var tagged = new LinkedHashMap <string, Pair <EventType, string> >();
FilterSpecCompiled filterCompiled;
try {
filterCompiled = FilterSpecCompiler.MakeFilterSpec(eventType, aliasName,
Collections.SingletonList(statementSpec.FilterRootNode), null,
tagged, tagged, typeService,
null, statementContext,
Collections.SingletonList(0));
}
catch (Exception ex) {
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
filterCompiled = null;
}
filter = filterCompiled;
}
else
{
filter = null;
}
// validate expressions
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
// get executor
Executor = GetExecutor(filter, aliasName);
}
public static EPStatementStartMethodSelectDesc Prepare(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext,
bool recoveringResilient,
AgentInstanceContext defaultAgentInstanceContext,
bool queryPlanLogging,
ViewableActivatorFactory optionalViewableActivatorFactory,
OutputProcessViewCallback optionalOutputProcessViewCallback,
SelectExprProcessorDeliveryCallback selectExprProcessorDeliveryCallback)
{
// define stop and destroy
var stopCallbacks = new List <StopCallback>();
var destroyCallbacks = new EPStatementDestroyCallbackList();
// determine context
var contextName = statementSpec.OptionalContextName;
var contextPropertyRegistry = (contextName != null) ? services.ContextManagementService.GetContextDescriptor(contextName).ContextPropertyRegistry : null;
// Determine stream names for each stream - some streams may not have a name given
var streamNames = EPStatementStartMethodHelperUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0)
{
throw new ExprValidationException("The from-clause is required but has not been specified");
}
var isJoin = statementSpec.StreamSpecs.Length > 1;
var hasContext = statementSpec.OptionalContextName != null;
// First we create streams for subselects, if there are any
var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(services, statementSpec, statementContext, destroyCallbacks);
// Create streams and views
var eventStreamParentViewableActivators = new ViewableActivator[numStreams];
var unmaterializedViewChain = new ViewFactoryChain[numStreams];
var eventTypeNames = new string[numStreams];
var isNamedWindow = new bool[numStreams];
var historicalEventViewables = new HistoricalEventViewable[numStreams];
// verify for joins that required views are present
var joinAnalysisResult = VerifyJoinViews(statementSpec, statementContext.NamedWindowMgmtService, defaultAgentInstanceContext);
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
for (var i = 0; i < statementSpec.StreamSpecs.Length; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.ConfigSnapshot.EngineDefaults.ViewResourcesConfig.IsIterableUnbound ||
AnnotationUtil.FindAttribute(statementSpec.Annotations, typeof(IterableUnboundAttribute)) != null);
// Create view factories and parent view based on a filter specification
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec;
eventTypeNames[i] = filterStreamSpec.FilterSpec.FilterForEventTypeName;
// Since only for non-joins we get the existing stream's lock and try to reuse it's views
var filterSubselectSameStream = EPStatementStartMethodHelperUtil.DetermineSubquerySameStream(statementSpec, filterStreamSpec);
// create activator
ViewableActivator activatorDeactivator;
if (optionalViewableActivatorFactory != null)
{
activatorDeactivator = optionalViewableActivatorFactory.CreateActivatorSimple(filterStreamSpec);
if (activatorDeactivator == null)
{
throw new IllegalStateException("Viewable activate is null for " + filterStreamSpec.FilterSpec.FilterForEventType.Name);
}
}
else
{
if (!hasContext)
{
activatorDeactivator = services.ViewableActivatorFactory.CreateStreamReuseView(services, statementContext, statementSpec, filterStreamSpec, isJoin, evaluatorContextStmt, filterSubselectSameStream, i, isCanIterateUnbound);
}
else
{
InstrumentationAgent instrumentationAgentFilter = null;
if (InstrumentationHelper.ENABLED)
{
var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name;
var streamNumber = i;
instrumentationAgentFilter = new ProxyInstrumentationAgent()
{
ProcIndicateQ = () => {
InstrumentationHelper.Get().QFilterActivationStream(eventTypeName, streamNumber);
},
ProcIndicateA = () => {
InstrumentationHelper.Get().AFilterActivationStream();
},
};
}
activatorDeactivator = services.ViewableActivatorFactory.CreateFilterProxy(services, filterStreamSpec.FilterSpec, statementSpec.Annotations, false, instrumentationAgentFilter, isCanIterateUnbound, i);
}
}
eventStreamParentViewableActivators[i] = activatorDeactivator;
var resultEventType = filterStreamSpec.FilterSpec.ResultEventType;
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1);
}
// Create view factories and parent view based on a pattern expression
else if (streamSpec is PatternStreamSpecCompiled)
{
var patternStreamSpec = (PatternStreamSpecCompiled)streamSpec;
var usedByChildViews = streamSpec.ViewSpecs.Length > 0 || (statementSpec.InsertIntoDesc != null);
var patternTypeName = statementContext.StatementId + "_pattern_" + i;
var eventType = services.EventAdapterService.CreateSemiAnonymousMapType(patternTypeName, patternStreamSpec.TaggedEventTypes, patternStreamSpec.ArrayEventTypes, usedByChildViews);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, eventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1);
var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode);
var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true);
// create activator
var patternActivator = services.ViewableActivatorFactory.CreatePattern(patternContext, rootFactoryNode, eventType, EPStatementStartMethodHelperUtil.IsConsumingFilters(patternStreamSpec.EvalFactoryNode), patternStreamSpec.IsSuppressSameEventMatches, patternStreamSpec.IsDiscardPartialsOnMatch, isCanIterateUnbound);
eventStreamParentViewableActivators[i] = patternActivator;
}
// Create view factories and parent view based on a database SQL statement
else if (streamSpec is DBStatementStreamSpec)
{
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec)streamSpec;
var typeConversionHook = (SQLColumnTypeConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), statementContext.MethodResolutionService);
var outputRowConversionHook = (SQLOutputRowConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), statementContext.MethodResolutionService);
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = DatabasePollingViewableFactory.CreateDBStatementView(
statementContext.StatementId, i, sqlStreamSpec,
services.DatabaseRefService,
services.EventAdapterService,
epStatementAgentInstanceHandle,
statementContext.Annotations,
typeConversionHook,
outputRowConversionHook,
statementContext.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableADO,
services.DataCacheFactory,
statementContext);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable);
stopCallbacks.Add(historicalEventViewable);
}
else if (streamSpec is MethodStreamSpec)
{
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec)streamSpec;
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = MethodPollingViewableFactory.CreatePollMethodView(
i, methodStreamSpec, services.EventAdapterService, epStatementAgentInstanceHandle,
statementContext.MethodResolutionService, services.EngineImportService,
statementContext.SchedulingService, statementContext.ScheduleBucket, evaluatorContextStmt,
statementContext.VariableService, statementContext.ContextName, services.DataCacheFactory,
statementContext);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable);
stopCallbacks.Add(historicalEventViewable);
}
else if (streamSpec is TableQueryStreamSpec)
{
ValidateNoViews(streamSpec, "Table data");
var tableStreamSpec = (TableQueryStreamSpec)streamSpec;
if (isJoin && tableStreamSpec.FilterExpressions.Count > 0)
{
throw new ExprValidationException("Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead");
}
var metadata = services.TableService.GetTableMetadata(tableStreamSpec.TableName);
ExprEvaluator[] tableFilterEvals = null;
if (tableStreamSpec.FilterExpressions.Count > 0)
{
tableFilterEvals = ExprNodeUtility.GetEvaluators(tableStreamSpec.FilterExpressions);
}
EPLValidationUtil.ValidateContextName(true, metadata.TableName, metadata.ContextName, statementSpec.OptionalContextName, false);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateTable(metadata, tableFilterEvals);
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(metadata.InternalEventType);
eventTypeNames[i] = tableStreamSpec.TableName;
joinAnalysisResult.SetTablesForStream(i, metadata);
if (tableStreamSpec.Options.IsUnidirectional)
{
throw new ExprValidationException("Tables cannot be marked as unidirectional");
}
if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion)
{
throw new ExprValidationException("Tables cannot be marked with retain");
}
if (isJoin)
{
destroyCallbacks.AddCallback(new EPStatementDestroyCallbackTableIdxRef(services.TableService, metadata, statementContext.StatementName));
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, metadata.TableName);
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
var processor = services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName);
var namedWindowType = processor.TailView.EventType;
if (namedSpec.OptPropertyEvaluator != null)
{
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec, statementContext);
services.NamedWindowConsumerMgmtService.AddConsumer(statementContext, namedSpec);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext, false, -1);
joinAnalysisResult.SetNamedWindow(i);
eventTypeNames[i] = namedSpec.WindowName;
isNamedWindow[i] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(unmaterializedViewChain[i].FactoryChain);
}
else
{
throw new ExprValidationException("Unknown stream specification type: " + streamSpec);
}
}
// handle match-recognize pattern
if (statementSpec.MatchRecognizeSpec != null)
{
if (isJoin)
{
throw new ExprValidationException("Joins are not allowed when using match-recognize");
}
if (joinAnalysisResult.TablesPerStream[0] != null)
{
throw new ExprValidationException("Tables cannot be used with match-recognize");
}
var isUnbound = (unmaterializedViewChain[0].FactoryChain.IsEmpty()) && (!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec));
var factoryX = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig);
unmaterializedViewChain[0].FactoryChain.Add(factoryX);
EPStatementStartMethodHelperAssignExpr.AssignAggregations(factoryX.AggregationService, factoryX.AggregationExpressions);
}
// Obtain event types from view factory chains
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
for (var i = 0; i < unmaterializedViewChain.Length; i++)
{
streamEventTypes[i] = unmaterializedViewChain[i].EventType;
}
// Add uniqueness information useful for joins
joinAnalysisResult.AddUniquenessInfo(unmaterializedViewChain, statementSpec.Annotations);
// Validate sub-select views
var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, queryPlanLogging, subSelectStreamDesc, streamNames, streamEventTypes, eventTypeNames, statementSpec.DeclaredExpressions, contextPropertyRegistry);
// Construct type information per stream
StreamTypeService typeService = new StreamTypeServiceImpl(streamEventTypes, streamNames, EPStatementStartMethodHelperUtil.GetHasIStreamOnly(isNamedWindow, unmaterializedViewChain), services.EngineURI, false);
var viewResourceDelegateUnverified = new ViewResourceDelegateUnverified();
// Validate views that require validation, specifically streams that don't have
// sub-views such as DB SQL joins
var historicalViewableDesc = new HistoricalViewableDesc(numStreams);
for (var stream = 0; stream < historicalEventViewables.Length; stream++)
{
var historicalEventViewable = historicalEventViewables[stream];
if (historicalEventViewable == null)
{
continue;
}
historicalEventViewable.Validate(
services.EngineImportService,
typeService,
statementContext.MethodResolutionService,
statementContext.TimeProvider,
statementContext.VariableService, statementContext.TableService,
statementContext.ScriptingService, evaluatorContextStmt,
services.ConfigSnapshot, services.SchedulingService, services.EngineURI,
statementSpec.SqlParameters,
statementContext.EventAdapterService, statementContext);
historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams);
if (historicalEventViewable.RequiredStreams.Contains(stream))
{
throw new ExprValidationException("Parameters for historical stream " + stream + " indicate that the stream is subordinate to itself as stream parameters originate in the same stream");
}
}
// unidirectional is not supported with into-table
if (joinAnalysisResult.IsUnidirectional && statementSpec.IntoTableSpec != null)
{
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
// Construct a processor for results posted by views and joins, which takes care of aggregation if required.
// May return null if we don't need to post-process results posted by views or joins.
var resultSetProcessorPrototypeDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
statementSpec, statementContext, typeService, viewResourceDelegateUnverified, joinAnalysisResult.UnidirectionalInd, true, contextPropertyRegistry, selectExprProcessorDeliveryCallback, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, false, false);
// Validate where-clause filter tree, outer join clause and output limit expression
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, viewResourceDelegateUnverified);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateVerified = EPStatementStartMethodHelperViewResources.VerifyPreviousAndPriorRequirements(unmaterializedViewChain, viewResourceDelegateUnverified);
// handle join
JoinSetComposerPrototype joinSetComposerPrototype = null;
if (numStreams > 1)
{
var selectsRemoveStream =
statementSpec.SelectStreamSelectorEnum.IsSelectsRStream() ||
statementSpec.OutputLimitSpec != null;
var hasAggregations = !resultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions.IsEmpty();
joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(
statementContext.StatementName, statementContext.StatementId,
statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typeService.EventTypes, streamNames,
joinAnalysisResult, queryPlanLogging, statementContext, historicalViewableDesc, defaultAgentInstanceContext,
selectsRemoveStream, hasAggregations, services.TableService, false, services.EventTableIndexService.AllowInitIndex(recoveringResilient));
}
// obtain factory for output limiting
var outputViewFactory = OutputProcessViewFactoryFactory.Make(statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType, optionalOutputProcessViewCallback, services.TableService, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType, services.ResultSetProcessorHelperFactory, services.StatementVariableRefService);
// Factory for statement-context instances
var factory = new StatementAgentInstanceFactorySelect(
numStreams, eventStreamParentViewableActivators,
statementContext, statementSpec, services,
typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient,
joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory);
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks);
return(new EPStatementStartMethodSelectDesc(factory, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteIUDSingleStream(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.Logging.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
HasTableAccess = statementSpec.IntoTableSpec != null ||
(statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
if (statementSpec.InsertIntoDesc != null && services.TableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName) != null)
{
HasTableAccess = true;
}
if (statementSpec.FireAndForgetSpec is FireAndForgetSpecUpdate ||
statementSpec.FireAndForgetSpec is FireAndForgetSpecDelete)
{
HasTableAccess |= statementSpec.StreamSpecs[0] is TableQueryStreamSpec;
}
StatementSpec = statementSpec;
Services = services;
StatementContext = statementContext;
// validate general FAF criteria
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
// obtain processor
var streamSpec = statementSpec.StreamSpecs[0];
Processor = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
// obtain name and type
var processorName = Processor.NamedWindowOrTableName;
var eventType = Processor.EventTypeResultSetProcessor;
// determine alias
var aliasName = processorName;
if (streamSpec.OptionalStreamName != null)
{
aliasName = streamSpec.OptionalStreamName;
}
// compile filter to optimize access to named window
var typeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new string[] { aliasName }, new bool[] { true }, services.EngineURI, true);
var excludePlanHint = ExcludePlanHint.GetHint(typeService.StreamNames, statementContext);
var queryGraph = new QueryGraph(1, excludePlanHint, false);
if (statementSpec.FilterRootNode != null)
{
ExprNodeUtility.ValidateFilterWQueryGraphSafe(
queryGraph, statementSpec.FilterRootNode,
statementContext, typeService);
}
// validate expressions
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
// get executor
Executor = GetExecutor(queryGraph, aliasName);
}
