public TableOnUpdateViewFactory(StatementResultService statementResultService, TableMetadata tableMetadata, EventBeanUpdateHelper updateHelper, TableUpdateStrategy tableUpdateStrategy)
{
StatementResultService = statementResultService;
TableMetadata = tableMetadata;
UpdateHelper = updateHelper;
TableUpdateStrategy = tableUpdateStrategy;
}
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 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));
}
public EPPreparedExecuteIUDSingleStreamExecUpdate(QueryGraph queryGraph, ExprNode optionalWhereClause, Attribute[] annotations, EventBeanUpdateHelper updateHelper, TableUpdateStrategy tableUpdateStrategy, ExprTableAccessNode[] optionalTableNodes, EPServicesContext services)
{
QueryGraph = queryGraph;
OptionalWhereClause = optionalWhereClause;
Annotations = annotations;
UpdateHelper = updateHelper;
TableUpdateStrategy = tableUpdateStrategy;
OptionalTableNodes = optionalTableNodes;
Services = services;
}
public void InitTableUpdateStrategy(Table table)
{
try {
TableUpdateStrategy =
TableUpdateStrategyFactory.ValidateGetTableUpdateStrategy(table.MetaData, UpdateHelperTable, false);
}
catch (ExprValidationException ex) {
throw new EPException(ex.Message, ex);
}
}
public void InitTableUpdateStrategy(Table table)
{
try {
tableUpdateStrategy = TableUpdateStrategyFactory.ValidateGetTableUpdateStrategy(
table.MetaData,
tableUpdate,
true);
}
catch (ExprValidationException e) {
throw new EPException(e.Message, e);
}
}
public override void HandleMatching(EventBean[] triggerEvents, EventBean[] matchingEvents)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraOnAction(OnTriggerType.ON_UPDATE, triggerEvents, matchingEvents);
}
EventBean[] eventsPerStream = new EventBean[3];
bool postUpdates = parent.StatementResultService.IsMakeNatural || parent.StatementResultService.IsMakeSynthetic;
EventBean[] postedOld = null;
if (postUpdates)
{
postedOld = TableOnViewUtil.ToPublic(matchingEvents, parent.TableMetadata, triggerEvents, false, base.ExprEvaluatorContext);
}
TableUpdateStrategy tableUpdateStrategy = parent.TableUpdateStrategy;
foreach (EventBean triggerEvent in triggerEvents)
{
eventsPerStream[1] = triggerEvent;
tableUpdateStrategy.UpdateTable(matchingEvents, TableStateInstance, eventsPerStream, exprEvaluatorContext);
}
// The on-delete listeners receive the events deleted, but only if there is interest
if (postUpdates)
{
EventBean[] postedNew = TableOnViewUtil.ToPublic(matchingEvents, parent.TableMetadata, triggerEvents, true, base.ExprEvaluatorContext);
UpdateChildren(postedNew, postedOld);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraOnAction();
}
}
public void Update(TableUpdateStrategy updateStrategy)
{
TableUpdateStrategy = updateStrategy;
}
public TableOnMergeActionUpd(ExprEvaluator optionalFilter, TableUpdateStrategy tableUpdateStrategy)
: base(optionalFilter)
{
_tableUpdateStrategy = tableUpdateStrategy;
}
