/// <summary>
/// Ctor.
/// </summary>
/// <param name="isFirst">true for the first-where clause, false for all where-clauses</param>
/// <param name="eventType">output type</param>
/// <param name="epStatementHandle">handle</param>
/// <param name="internalEventRouter">routining output events</param>
/// <param name="tableStateInstance">The table state instance.</param>
/// <param name="isNamedWindowInsert">The is named window insert.</param>
/// <param name="processors">processors for select clauses</param>
/// <param name="whereClauses">where expressions</param>
/// <param name="agentInstanceContext">agent instance context</param>
/// <exception cref="System.ArgumentException">Number of where-clauses and processors does not match</exception>
public RouteResultView(
bool isFirst,
EventType eventType,
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableStateInstance[] tableStateInstance,
bool[] isNamedWindowInsert,
ResultSetProcessor[] processors,
ExprNode[] whereClauses,
AgentInstanceContext agentInstanceContext)
{
if (whereClauses.Length != processors.Length)
{
throw new ArgumentException("Number of where-clauses and processors does not match");
}
_exprEvaluatorContext = agentInstanceContext;
_eventType = eventType;
if (isFirst)
{
_handler = new RouteResultViewHandlerFirst(epStatementHandle, internalEventRouter, tableStateInstance, isNamedWindowInsert, processors, ExprNodeUtility.GetEvaluators(whereClauses), agentInstanceContext);
}
else
{
_handler = new RouteResultViewHandlerAll(epStatementHandle, internalEventRouter, tableStateInstance, isNamedWindowInsert, processors, ExprNodeUtility.GetEvaluators(whereClauses), agentInstanceContext);
}
}
public RouteResultView(
bool isFirst,
EventType eventType,
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableInstance[] tableInstances,
OnSplitItemEval[] items,
ResultSetProcessor[] processors,
AgentInstanceContext agentInstanceContext)
{
exprEvaluatorContext = agentInstanceContext;
EventType = eventType;
if (isFirst) {
handler = new RouteResultViewHandlerFirst(
epStatementHandle,
internalEventRouter,
tableInstances,
items,
processors,
agentInstanceContext);
}
else {
handler = new RouteResultViewHandlerAll(
epStatementHandle,
internalEventRouter,
tableInstances,
items,
processors,
agentInstanceContext);
}
}
public RouteResultView(
bool isFirst,
EventType eventType,
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableStateInstance[] tableStateInstances,
EPStatementStartMethodOnTriggerItem[] items,
ResultSetProcessor[] processors,
ExprEvaluator[] whereClauses,
AgentInstanceContext agentInstanceContext)
{
if (whereClauses.Length != processors.Length)
{
throw new ArgumentException("Number of where-clauses and processors does not match");
}
_exprEvaluatorContext = agentInstanceContext;
_eventType = eventType;
if (isFirst)
{
_handler = new RouteResultViewHandlerFirst(
epStatementHandle, internalEventRouter, tableStateInstances, items, processors, whereClauses,
agentInstanceContext);
}
else
{
_handler = new RouteResultViewHandlerAll(
epStatementHandle, internalEventRouter, tableStateInstances, items, processors, whereClauses,
agentInstanceContext);
}
}
private NamedWindowOnMergeActionIns SetupInsert(string namedWindowName, InternalEventRouter internalEventRouter, EventTypeSPI eventTypeNamedWindow, int selectClauseNumber, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementContext statementContext)
{
// Compile insert-into INFO
string streamName = desc.OptionalStreamName ?? eventTypeNamedWindow.Name;
var insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns);
// rewrite any wildcards to use "stream.wildcard"
if (triggeringStreamName == null)
{
triggeringStreamName = UuidGenerator.Generate();
}
var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled);
// Set up event types for select-clause evaluation: The first type does not contain anything as its the named window row which is not present for insert
var dummyTypeNoProperties = new MapEventType(EventTypeMetadata.CreateAnonymous("merge_named_window_insert", ApplicationType.MAP), "merge_named_window_insert", 0, null, Collections.EmptyDataMap, null, null, null);
var eventTypes = new EventType[] { dummyTypeNoProperties, triggeringEventType };
var streamNames = new string[] { UuidGenerator.Generate(), triggeringStreamName };
var streamTypeService = new StreamTypeServiceImpl(eventTypes, streamNames, new bool[1], statementContext.EngineURI, false);
// Get select expr processor
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(statementContext.StatementName, statementContext.StatementEventTypeRef);
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
var insertHelper = SelectExprProcessorFactory.GetProcessor(
statementContext.Container,
Collections.SingletonList(selectClauseNumber),
selectNoWildcard.ToArray(), false,
insertIntoDesc, null, null, streamTypeService,
statementContext.EventAdapterService,
statementContext.StatementResultService,
statementContext.ValueAddEventService,
selectExprEventTypeRegistry,
statementContext.EngineImportService,
exprEvaluatorContext,
statementContext.VariableService,
statementContext.ScriptingService,
statementContext.TableService,
statementContext.TimeProvider,
statementContext.EngineURI,
statementContext.StatementId,
statementContext.StatementName,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ConfigSnapshot, null,
statementContext.NamedWindowMgmtService, null, null,
statementContext.StatementExtensionServicesContext);
var filterEval = desc.OptionalWhereClause == null ? null : desc.OptionalWhereClause.ExprEvaluator;
var routerToUser = streamName.Equals(namedWindowName) ? null : internalEventRouter;
var audit = AuditEnum.INSERT.GetAudit(statementContext.Annotations) != null;
string insertIntoTableName = null;
if (statementContext.TableService.GetTableMetadata(insertIntoDesc.EventTypeName) != null)
{
insertIntoTableName = insertIntoDesc.EventTypeName;
}
return(new NamedWindowOnMergeActionIns(filterEval, insertHelper, routerToUser, insertIntoTableName, statementContext.TableService, statementContext.EpStatementHandle, statementContext.InternalEventEngineRouteDest, audit));
}
public static TableOnViewFactory Make(
TableMetadata tableMetadata,
OnTriggerDesc onTriggerDesc,
EventType filterEventType,
string filterStreamName,
StatementContext statementContext,
StatementMetricHandle metricsHandle,
bool isDistinct,
InternalEventRouter internalEventRouter)
{
if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_DELETE)
{
return(new TableOnDeleteViewFactory(statementContext.StatementResultService, tableMetadata));
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_SELECT)
{
EventBeanReader eventBeanReader = null;
if (isDistinct)
{
eventBeanReader = tableMetadata.InternalEventType.GetReader();
}
var windowDesc = (OnTriggerWindowDesc)onTriggerDesc;
return(new TableOnSelectViewFactory(
tableMetadata, internalEventRouter, statementContext.EpStatementHandle,
eventBeanReader, isDistinct, statementContext.StatementResultService,
statementContext.InternalEventEngineRouteDest, windowDesc.IsDeleteAndSelect));
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_UPDATE)
{
var updateDesc = (OnTriggerWindowUpdateDesc)onTriggerDesc;
var updateHelper = EventBeanUpdateHelperFactory.Make(
tableMetadata.TableName, (EventTypeSPI)tableMetadata.InternalEventType, updateDesc.Assignments,
updateDesc.OptionalAsName, filterEventType, false);
TableUpdateStrategy updateStrategy = statementContext.TableService.GetTableUpdateStrategy(
tableMetadata, updateHelper, false);
var onUpdateViewFactory =
new TableOnUpdateViewFactory(
statementContext.StatementResultService, tableMetadata, updateHelper, updateStrategy);
statementContext.TableService.AddTableUpdateStrategyReceiver(
tableMetadata, statementContext.StatementName, onUpdateViewFactory, updateHelper, false);
return(onUpdateViewFactory);
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_MERGE)
{
var onMergeTriggerDesc = (OnTriggerMergeDesc)onTriggerDesc;
var onMergeHelper = new TableOnMergeHelper(
statementContext, onMergeTriggerDesc, filterEventType, filterStreamName, internalEventRouter,
tableMetadata);
return(new TableOnMergeViewFactory(
tableMetadata, onMergeHelper, statementContext.StatementResultService, metricsHandle,
statementContext.MetricReportingService));
}
else
{
throw new IllegalStateException("Unknown trigger type " + onTriggerDesc.OnTriggerType);
}
}
public RouteResultViewHandlerFirst(
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableInstance[] tableInstances,
OnSplitItemEval[] items,
ResultSetProcessor[] processors,
AgentInstanceContext agentInstanceContext)
: base(epStatementHandle, internalEventRouter, tableInstances, items, processors, agentInstanceContext)
{
}
public TableOnSelectViewFactory(TableMetadata tableMetadata, InternalEventRouter internalEventRouter, EPStatementHandle statementHandle, EventBeanReader eventBeanReader, bool distinct, StatementResultService statementResultService, InternalEventRouteDest internalEventRouteDest, bool deleteAndSelect)
{
_tableMetadata = tableMetadata;
InternalEventRouter = internalEventRouter;
StatementHandle = statementHandle;
EventBeanReader = eventBeanReader;
IsDistinct = distinct;
StatementResultService = statementResultService;
InternalEventRouteDest = internalEventRouteDest;
_deleteAndSelect = deleteAndSelect;
}
public AgentInstanceTransferServices(
AgentInstanceContext agentInstanceContext,
FilterService targetFilterService,
SchedulingService targetSchedulingService,
InternalEventRouter targetInternalEventRouter)
{
this.agentInstanceContext = agentInstanceContext;
this.targetFilterService = targetFilterService;
this.targetSchedulingService = targetSchedulingService;
this.targetInternalEventRouter = targetInternalEventRouter;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="epStatementHandle">handle</param>
/// <param name="internalEventRouter">routes generated events</param>
/// <param name="tableStateInstances"></param>
/// <param name="isNamedWindowInsert">The is named window insert.</param>
/// <param name="processors">select clauses</param>
/// <param name="whereClauses">where clauses</param>
/// <param name="agentInstanceContext">agent instance context</param>
public RouteResultViewHandlerFirst(EPStatementHandle epStatementHandle, InternalEventRouter internalEventRouter, TableStateInstance[] tableStateInstances, bool[] isNamedWindowInsert, ResultSetProcessor[] processors, ExprEvaluator[] whereClauses, AgentInstanceContext agentInstanceContext)
{
_internalEventRouter = internalEventRouter;
_tableStateInstances = tableStateInstances;
_isNamedWindowInsert = isNamedWindowInsert;
_epStatementHandle = epStatementHandle;
_processors = processors;
_whereClauses = whereClauses;
_agentInstanceContext = agentInstanceContext;
_audit = AuditEnum.INSERT.GetAudit(agentInstanceContext.StatementContext.Annotations) != null;
}
public RouteResultViewHandlerFirst(
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableStateInstance[] tableStateInstances,
EPStatementStartMethodOnTriggerItem[] items,
ResultSetProcessor[] processors,
ExprEvaluator[] whereClauses,
AgentInstanceContext agentInstanceContext)
: base(
epStatementHandle, internalEventRouter, tableStateInstances, items, processors, whereClauses,
agentInstanceContext)
{
}
public NamedWindowOnSelectViewFactory(EventType namedWindowEventType, InternalEventRouter internalEventRouter, bool addToFront, EPStatementHandle statementHandle, EventBeanReader eventBeanReader, bool distinct, StatementResultService statementResultService, InternalEventRouteDest internalEventRouteDest, bool deleteAndSelect, StreamSelector?optionalStreamSelector, string optionalInsertIntoTableName)
: base(namedWindowEventType)
{
InternalEventRouter = internalEventRouter;
IsAddToFront = addToFront;
StatementHandle = statementHandle;
EventBeanReader = eventBeanReader;
IsDistinct = distinct;
StatementResultService = statementResultService;
InternalEventRouteDest = internalEventRouteDest;
_deleteAndSelect = deleteAndSelect;
OptionalStreamSelector = optionalStreamSelector;
_optionalInsertIntoTableName = optionalInsertIntoTableName;
}
public RouteResultViewHandlerBase(
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableInstance[] tableStateInstances,
OnSplitItemEval[] items,
ResultSetProcessor[] processors,
AgentInstanceContext agentInstanceContext)
{
this.internalEventRouter = internalEventRouter;
this.tableStateInstances = tableStateInstances;
this.items = items;
this.epStatementHandle = epStatementHandle;
this.processors = processors;
this.agentInstanceContext = agentInstanceContext;
audit = AuditEnum.INSERT.GetAudit(agentInstanceContext.Annotations) != null;
}
public TableOnMergeActionIns(
ExprEvaluator optionalFilter,
SelectExprProcessor insertHelper,
InternalEventRouter internalEventRouter,
EPStatementHandle statementHandle,
InternalEventRouteDest internalEventRouteDest,
bool audit,
TableStateRowFactory tableStateRowFactory)
: base(optionalFilter)
{
_insertHelper = insertHelper;
_internalEventRouter = internalEventRouter;
_statementHandle = statementHandle;
_internalEventRouteDest = internalEventRouteDest;
_audit = audit;
_tableStateRowFactory = tableStateRowFactory;
}
protected RouteResultViewHandlerBase(
EPStatementHandle epStatementHandle,
InternalEventRouter internalEventRouter,
TableStateInstance[] tableStateInstances,
EPStatementStartMethodOnTriggerItem[] items,
ResultSetProcessor[] processors,
ExprEvaluator[] whereClauses,
AgentInstanceContext agentInstanceContext)
{
InternalEventRouter = internalEventRouter;
_tableStateInstances = tableStateInstances;
Items = items;
EPStatementHandle = epStatementHandle;
Processors = processors;
WhereClauses = whereClauses;
AgentInstanceContext = agentInstanceContext;
Audit = AuditEnum.INSERT.GetAudit(agentInstanceContext.StatementContext.Annotations) != null;
}
public OutputStrategyPostProcessFactory(
bool route,
SelectClauseStreamSelectorEnum?insertIntoStreamSelector,
SelectClauseStreamSelectorEnum selectStreamDirEnum,
InternalEventRouter internalEventRouter,
EPStatementHandle epStatementHandle,
bool addToFront,
TableService tableService,
string tableName)
{
IsRoute = route;
InsertIntoStreamSelector = insertIntoStreamSelector;
SelectStreamDirEnum = selectStreamDirEnum;
InternalEventRouter = internalEventRouter;
EpStatementHandle = epStatementHandle;
IsAddToFront = addToFront;
TableService = tableService;
TableName = tableName;
}
public NamedWindowOnMergeActionIns(
ExprEvaluator optionalFilter,
SelectExprProcessor insertHelper,
InternalEventRouter internalEventRouter,
String insertIntoTableName,
TableService tableService,
EPStatementHandle statementHandle,
InternalEventRouteDest internalEventRouteDest,
bool audit)
: base(optionalFilter)
{
_insertHelper = insertHelper;
_internalEventRouter = internalEventRouter;
_insertIntoTableName = insertIntoTableName;
_tableService = tableService;
_statementHandle = statementHandle;
_internalEventRouteDest = internalEventRouteDest;
_audit = audit;
}
public StageSpecificServices(
DeploymentLifecycleService deploymentLifecycleService,
IReaderWriterLock eventProcessingRWLock,
FilterServiceSPI filterService,
InternalEventRouter internalEventRouter,
MetricReportingService metricReportingService,
SchedulingServiceSPI schedulingService,
StageRuntimeServices stageRuntimeServices,
ThreadingService threadingService)
{
this.deploymentLifecycleService = deploymentLifecycleService;
this.eventProcessingRWLock = eventProcessingRWLock;
this.filterService = filterService;
this.internalEventRouter = internalEventRouter;
this.metricReportingService = metricReportingService;
this.schedulingService = schedulingService;
this.stageRuntimeServices = stageRuntimeServices;
this.threadingService = threadingService;
}
public TableOnMergeHelper(
StatementContext statementContext,
OnTriggerMergeDesc onTriggerDesc,
EventType triggeringEventType,
string triggeringStreamName,
InternalEventRouter internalEventRouter,
TableMetadata tableMetadata)
{
_matched = new List <TableOnMergeMatch>();
_unmatched = new List <TableOnMergeMatch>();
var count = 1;
var hasDeleteAction = false;
var hasInsertIntoTableAction = false;
var hasUpdateAction = false;
foreach (var matchedItem in onTriggerDesc.Items)
{
IList <TableOnMergeAction> actions = new List <TableOnMergeAction>();
foreach (var item in matchedItem.Actions)
{
try {
if (item is OnTriggerMergeActionInsert)
{
var insertDesc = (OnTriggerMergeActionInsert)item;
var action = SetupInsert(tableMetadata, internalEventRouter, count, insertDesc, triggeringEventType, triggeringStreamName, statementContext);
actions.Add(action);
hasInsertIntoTableAction = action.IsInsertIntoBinding;
}
else if (item is OnTriggerMergeActionUpdate)
{
var updateDesc = (OnTriggerMergeActionUpdate)item;
var updateHelper = EventBeanUpdateHelperFactory.Make(tableMetadata.TableName, tableMetadata.InternalEventType, updateDesc.Assignments, onTriggerDesc.OptionalAsName, triggeringEventType, false);
var filterEval = updateDesc.OptionalWhereClause == null ? null : updateDesc.OptionalWhereClause.ExprEvaluator;
var tableUpdateStrategy = statementContext.TableService.GetTableUpdateStrategy(tableMetadata, updateHelper, true);
var upd = new TableOnMergeActionUpd(filterEval, tableUpdateStrategy);
actions.Add(upd);
statementContext.TableService.AddTableUpdateStrategyReceiver(tableMetadata, statementContext.StatementName, upd, updateHelper, true);
hasUpdateAction = true;
}
else if (item is OnTriggerMergeActionDelete)
{
var deleteDesc = (OnTriggerMergeActionDelete)item;
var filterEval = deleteDesc.OptionalWhereClause == null ? null : deleteDesc.OptionalWhereClause.ExprEvaluator;
actions.Add(new TableOnMergeActionDel(filterEval));
hasDeleteAction = true;
}
else
{
throw new ArgumentException("Invalid type of merge item '" + item.GetType() + "'");
}
count++;
}
catch (ExprValidationException ex) {
var isNot = item is OnTriggerMergeActionInsert;
var message = "Validation failed in when-" + (isNot?"not-":"") + "matched (clause " + count + "): " + ex.Message;
throw new ExprValidationException(message, ex);
}
}
if (matchedItem.IsMatchedUnmatched)
{
_matched.Add(new TableOnMergeMatch(matchedItem.OptionalMatchCond, actions));
}
else
{
_unmatched.Add(new TableOnMergeMatch(matchedItem.OptionalMatchCond, actions));
}
}
// since updates may change future secondary keys
_requiresWriteLock = hasDeleteAction || hasInsertIntoTableAction || hasUpdateAction;
}
public static NamedWindowOnExprFactory Make(
EventType namedWindowEventType,
string namedWindowName,
string namedWindowAlias,
OnTriggerDesc onTriggerDesc,
EventType filterEventType,
string filterStreamName,
bool addToFront,
InternalEventRouter internalEventRouter,
EventType outputEventType,
StatementContext statementContext,
StatementMetricHandle createNamedWindowMetricsHandle,
bool isDistinct,
StreamSelector?optionalStreamSelector,
string optionalInsertIntoTableName)
{
if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_DELETE)
{
return(new NamedWindowOnDeleteViewFactory(namedWindowEventType, statementContext.StatementResultService));
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_SELECT)
{
EventBeanReader eventBeanReader = null;
if (isDistinct)
{
if (outputEventType is EventTypeSPI)
{
eventBeanReader = ((EventTypeSPI)outputEventType).GetReader();
}
if (eventBeanReader == null)
{
eventBeanReader = new EventBeanReaderDefaultImpl(outputEventType);
}
}
var windowDesc = (OnTriggerWindowDesc)onTriggerDesc;
return(new NamedWindowOnSelectViewFactory(
namedWindowEventType, internalEventRouter, addToFront,
statementContext.EpStatementHandle, eventBeanReader, isDistinct, statementContext.StatementResultService,
statementContext.InternalEventEngineRouteDest, windowDesc.IsDeleteAndSelect, optionalStreamSelector,
optionalInsertIntoTableName));
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_UPDATE)
{
var updateDesc = (OnTriggerWindowUpdateDesc)onTriggerDesc;
var updateHelper = EventBeanUpdateHelperFactory.Make(
namedWindowName, (EventTypeSPI)namedWindowEventType, updateDesc.Assignments, namedWindowAlias,
filterEventType, true);
return(new NamedWindowOnUpdateViewFactory(
namedWindowEventType, statementContext.StatementResultService, updateHelper));
}
else if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_MERGE)
{
var onMergeTriggerDesc = (OnTriggerMergeDesc)onTriggerDesc;
var onMergeHelper = new NamedWindowOnMergeHelper(
statementContext, onMergeTriggerDesc, filterEventType, filterStreamName, internalEventRouter,
namedWindowName, (EventTypeSPI)namedWindowEventType);
return(new NamedWindowOnMergeViewFactory(
namedWindowEventType, onMergeHelper, statementContext.StatementResultService,
createNamedWindowMetricsHandle, statementContext.MetricReportingService));
}
else
{
throw new IllegalStateException("Unknown trigger type " + onTriggerDesc.OnTriggerType);
}
}
public NamedWindowOnMergeHelper(StatementContext statementContext,
OnTriggerMergeDesc onTriggerDesc,
EventType triggeringEventType,
string triggeringStreamName,
InternalEventRouter internalEventRouter,
string namedWindowName,
EventTypeSPI namedWindowType)
{
Matched = new List <NamedWindowOnMergeMatch>();
Unmatched = new List <NamedWindowOnMergeMatch>();
var count = 1;
foreach (var matchedItem in onTriggerDesc.Items)
{
IList <NamedWindowOnMergeAction> actions = new List <NamedWindowOnMergeAction>();
foreach (var item in matchedItem.Actions)
{
try {
if (item is OnTriggerMergeActionInsert)
{
var insertDesc = (OnTriggerMergeActionInsert)item;
actions.Add(SetupInsert(namedWindowName, internalEventRouter, namedWindowType, count, insertDesc, triggeringEventType, triggeringStreamName, statementContext));
}
else if (item is OnTriggerMergeActionUpdate)
{
var updateDesc = (OnTriggerMergeActionUpdate)item;
var updateHelper = EventBeanUpdateHelperFactory.Make(namedWindowName, namedWindowType, updateDesc.Assignments, onTriggerDesc.OptionalAsName, triggeringEventType, true);
var filterEval = updateDesc.OptionalWhereClause == null ? null : updateDesc.OptionalWhereClause.ExprEvaluator;
actions.Add(new NamedWindowOnMergeActionUpd(filterEval, updateHelper));
}
else if (item is OnTriggerMergeActionDelete)
{
var deleteDesc = (OnTriggerMergeActionDelete)item;
var filterEval = deleteDesc.OptionalWhereClause == null ? null : deleteDesc.OptionalWhereClause.ExprEvaluator;
actions.Add(new NamedWindowOnMergeActionDel(filterEval));
}
else
{
throw new ArgumentException("Invalid type of merge item '" + item.GetType() + "'");
}
count++;
}
catch (ExprValidationException ex) {
var isNot = item is OnTriggerMergeActionInsert;
var message = "Validation failed in when-" + (isNot?"not-":"") + "matched (clause " + count + "): " + ex.Message;
throw new ExprValidationException(message, ex);
}
}
if (matchedItem.IsMatchedUnmatched)
{
Matched.Add(new NamedWindowOnMergeMatch(matchedItem.OptionalMatchCond, actions));
}
else
{
Unmatched.Add(new NamedWindowOnMergeMatch(matchedItem.OptionalMatchCond, actions));
}
}
}
public StatementContextRuntimeServices(
IContainer container,
ContextManagementService contextManagementService,
ContextServiceFactory contextServiceFactory,
DatabaseConfigServiceRuntime databaseConfigService,
DataFlowFilterServiceAdapter dataFlowFilterServiceAdapter,
EPDataFlowServiceImpl dataflowService,
string runtimeURI,
INamingContext runtimeEnvContext,
ImportServiceRuntime importServiceRuntime,
RuntimeSettingsService runtimeSettingsService,
RuntimeExtensionServices runtimeExtensionServices,
object epRuntime,
EPRenderEventService epRuntimeRenderEvent,
EventServiceSendEventCommon eventServiceSendEventInternal,
EPRuntimeEventProcessWrapped epRuntimeEventProcessWrapped,
EventBeanService eventBeanService,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTableIndexService eventTableIndexService,
EventTypeAvroHandler eventTypeAvroHandler,
PathRegistry<string, EventType> eventTypePathRegistry,
EventTypeRepositoryImpl eventTypeRepositoryPreconfigured,
EventTypeResolvingBeanFactory eventTypeResolvingBeanFactory,
ExceptionHandlingService exceptionHandlingService,
ExpressionResultCacheService expressionResultCacheService,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
FilterSharedBoolExprRepository filterSharedBoolExprRepository,
FilterSharedLookupableRepository filterSharedLookupableRepository,
HistoricalDataCacheFactory historicalDataCacheFactory,
InternalEventRouter internalEventRouter,
MetricReportingService metricReportingService,
NamedWindowConsumerManagementService namedWindowConsumerManagementService,
NamedWindowManagementService namedWindowManagementService,
PathRegistry<string, ContextMetaData> pathContextRegistry,
PathRegistry<string, NamedWindowMetaData> pathNamedWindowRegistry,
RowRecogStateRepoFactory rowRecogStateRepoFactory,
ResultSetProcessorHelperFactory resultSetProcessorHelperFactory,
StatementAgentInstanceLockFactory statementAgentInstanceLockFactory,
StatementResourceHolderBuilder statementResourceHolderBuilder,
TableExprEvaluatorContext tableExprEvaluatorContext,
TableManagementService tableManagementService,
VariableManagementService variableManagementService,
ViewFactoryService viewFactoryService,
ViewServicePreviousFactory viewServicePreviousFactory)
{
Container = container;
ContextManagementService = contextManagementService;
ContextServiceFactory = contextServiceFactory;
DatabaseConfigService = databaseConfigService;
DataFlowFilterServiceAdapter = dataFlowFilterServiceAdapter;
DataflowService = dataflowService;
RuntimeURI = runtimeURI;
RuntimeEnvContext = runtimeEnvContext;
ImportServiceRuntime = importServiceRuntime;
RuntimeSettingsService = runtimeSettingsService;
RuntimeExtensionServices = runtimeExtensionServices;
Runtime = epRuntime;
EPRuntimeRenderEvent = epRuntimeRenderEvent;
EventServiceSendEventInternal = eventServiceSendEventInternal;
EPRuntimeEventProcessWrapped = epRuntimeEventProcessWrapped;
EventBeanService = eventBeanService;
EventBeanTypedEventFactory = eventBeanTypedEventFactory;
EventTableIndexService = eventTableIndexService;
EventTypeAvroHandler = eventTypeAvroHandler;
EventTypePathRegistry = eventTypePathRegistry;
EventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured;
EventTypeResolvingBeanFactory = eventTypeResolvingBeanFactory;
ExceptionHandlingService = exceptionHandlingService;
ExpressionResultCacheService = expressionResultCacheService;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
FilterSharedBoolExprRepository = filterSharedBoolExprRepository;
FilterSharedLookupableRepository = filterSharedLookupableRepository;
HistoricalDataCacheFactory = historicalDataCacheFactory;
InternalEventRouter = internalEventRouter;
MetricReportingService = metricReportingService;
NamedWindowConsumerManagementService = namedWindowConsumerManagementService;
NamedWindowManagementService = namedWindowManagementService;
PathContextRegistry = pathContextRegistry;
PathNamedWindowRegistry = pathNamedWindowRegistry;
RowRecogStateRepoFactory = rowRecogStateRepoFactory;
ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory;
StatementAgentInstanceLockFactory = statementAgentInstanceLockFactory;
StatementResourceHolderBuilder = statementResourceHolderBuilder;
TableExprEvaluatorContext = tableExprEvaluatorContext;
TableManagementService = tableManagementService;
VariableManagementService = variableManagementService;
ViewFactoryService = viewFactoryService;
ViewServicePreviousFactory = viewServicePreviousFactory;
}
public static OutputProcessViewFactory Make(StatementSpecCompiled statementSpec, InternalEventRouter internalEventRouter, StatementContext statementContext, EventType resultEventType, OutputProcessViewCallback optionalOutputProcessViewCallback, TableService tableService, ResultSetProcessorType resultSetProcessorType)
{
// determine direct-callback
if (optionalOutputProcessViewCallback != null)
{
return(new OutputProcessViewFactoryCallback(optionalOutputProcessViewCallback));
}
// determine routing
var isRouted = false;
var routeToFront = false;
if (statementSpec.InsertIntoDesc != null)
{
isRouted = true;
routeToFront = statementContext.NamedWindowService.IsNamedWindow(statementSpec.InsertIntoDesc.EventTypeName);
}
OutputStrategyPostProcessFactory outputStrategyPostProcessFactory = null;
if ((statementSpec.InsertIntoDesc != null) || (statementSpec.SelectStreamSelectorEnum == SelectClauseStreamSelectorEnum.RSTREAM_ONLY))
{
SelectClauseStreamSelectorEnum?insertIntoStreamSelector = null;
string tableName = null;
if (statementSpec.InsertIntoDesc != null)
{
insertIntoStreamSelector = statementSpec.InsertIntoDesc.StreamSelector;
var tableMetadata = tableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName);
if (tableMetadata != null)
{
tableName = tableMetadata.TableName;
EPLValidationUtil.ValidateContextName(true, tableName, tableMetadata.ContextName, statementSpec.OptionalContextName, true);
}
}
outputStrategyPostProcessFactory = new OutputStrategyPostProcessFactory(isRouted, insertIntoStreamSelector, statementSpec.SelectStreamSelectorEnum, internalEventRouter, statementContext.EpStatementHandle, routeToFront, tableService, tableName);
}
// Do we need to enforce an output policy?
var streamCount = statementSpec.StreamSpecs.Length;
var outputLimitSpec = statementSpec.OutputLimitSpec;
var isDistinct = statementSpec.SelectClauseSpec.IsDistinct;
var isGrouped = statementSpec.GroupByExpressions != null && statementSpec.GroupByExpressions.GroupByNodes.Length > 0;
if (outputLimitSpec != null)
{
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
var validationContext =
new ExprValidationContext(
new StreamTypeServiceImpl(statementContext.EngineURI, false),
statementContext.MethodResolutionService, null,
statementContext.TimeProvider,
statementContext.VariableService,
statementContext.TableService,
evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, false, false, null, false);
if (outputLimitSpec.AfterTimePeriodExpr != null)
{
var timePeriodExpr = (ExprTimePeriod)ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.OUTPUTLIMIT, outputLimitSpec.AfterTimePeriodExpr, validationContext);
outputLimitSpec.AfterTimePeriodExpr = timePeriodExpr;
}
if (outputLimitSpec.TimePeriodExpr != null)
{
var timePeriodExpr = (ExprTimePeriod)ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.OUTPUTLIMIT, outputLimitSpec.TimePeriodExpr, validationContext);
outputLimitSpec.TimePeriodExpr = timePeriodExpr;
if (timePeriodExpr.IsConstantResult && timePeriodExpr.EvaluateAsSeconds(null, true, new ExprEvaluatorContextStatement(statementContext, false)) <= 0)
{
throw new ExprValidationException("Invalid time period expression returns a zero or negative time interval");
}
}
}
OutputProcessViewFactory outputProcessViewFactory;
if (outputLimitSpec == null)
{
if (!isDistinct)
{
outputProcessViewFactory = new OutputProcessViewDirectFactory(statementContext, outputStrategyPostProcessFactory);
}
else
{
outputProcessViewFactory = new OutputProcessViewDirectDistinctOrAfterFactory(statementContext, outputStrategyPostProcessFactory, isDistinct, null, null, resultEventType);
}
}
else if (outputLimitSpec.RateType == OutputLimitRateType.AFTER)
{
outputProcessViewFactory = new OutputProcessViewDirectDistinctOrAfterFactory(statementContext, outputStrategyPostProcessFactory, isDistinct, outputLimitSpec.AfterTimePeriodExpr, outputLimitSpec.AfterNumberOfEvents, resultEventType);
}
else
{
try {
var isWithHavingClause = statementSpec.HavingExprRootNode != null;
var isStartConditionOnCreation = HasOnlyTables(statementSpec.StreamSpecs);
var outputConditionFactory = OutputConditionFactoryFactory.CreateCondition(outputLimitSpec, statementContext, isGrouped, isWithHavingClause, isStartConditionOnCreation);
var hasOrderBy = statementSpec.OrderByList != null && statementSpec.OrderByList.Length > 0;
OutputProcessViewConditionFactory.ConditionType conditionType;
var hasAfter = outputLimitSpec.AfterNumberOfEvents != null || outputLimitSpec.AfterTimePeriodExpr != null;
var isUnaggregatedUngrouped = resultSetProcessorType == ResultSetProcessorType.HANDTHROUGH || resultSetProcessorType == ResultSetProcessorType.UNAGGREGATED_UNGROUPED;
// hint checking with order-by
var hasOptHint = HintEnum.ENABLE_OUTPUTLIMIT_OPT.GetHint(statementSpec.Annotations) != null;
if (hasOptHint && hasOrderBy)
{
throw new ExprValidationException("The " + HintEnum.ENABLE_OUTPUTLIMIT_OPT + " hint is not supported with order-by");
}
if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.SNAPSHOT;
}
// For FIRST without groups we are using a special logic that integrates the first-flag, in order to still conveniently use all sorts of output conditions.
// FIRST with group-by is handled by setting the output condition to null (OutputConditionNull) and letting the ResultSetProcessor handle first-per-group.
// Without having-clause there is no required order of processing, thus also use regular policy.
else if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.FIRST && statementSpec.GroupByExpressions == null)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_FIRST;
}
else if (isUnaggregatedUngrouped && outputLimitSpec.DisplayLimit == OutputLimitLimitType.LAST)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else if (hasOptHint && outputLimitSpec.DisplayLimit == OutputLimitLimitType.ALL && !hasOrderBy)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else if (hasOptHint && outputLimitSpec.DisplayLimit == OutputLimitLimitType.LAST && !hasOrderBy)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_NONFIRST;
}
var selectClauseStreamSelectorEnum = statementSpec.SelectStreamSelectorEnum;
var terminable = outputLimitSpec.RateType == OutputLimitRateType.TERM || outputLimitSpec.IsAndAfterTerminate;
outputProcessViewFactory = new OutputProcessViewConditionFactory(statementContext, outputStrategyPostProcessFactory, isDistinct, outputLimitSpec.AfterTimePeriodExpr, outputLimitSpec.AfterNumberOfEvents, resultEventType, outputConditionFactory, streamCount, conditionType, outputLimitSpec.DisplayLimit, terminable, hasAfter, isUnaggregatedUngrouped, selectClauseStreamSelectorEnum);
}
catch (Exception ex) {
throw new ExprValidationException("Error in the output rate limiting clause: " + ex.Message, ex);
}
}
return(outputProcessViewFactory);
}