private static void AddFilters(StreamSpecCompiled[] streams, IList <FilterSpecCompiled> filters, IList <NamedWindowConsumerStreamSpec> namedWindows)
{
foreach (StreamSpecCompiled compiled in streams)
{
if (compiled is FilterStreamSpecCompiled)
{
FilterStreamSpecCompiled c = (FilterStreamSpecCompiled)compiled;
filters.Add(c.FilterSpec);
}
if (compiled is PatternStreamSpecCompiled)
{
PatternStreamSpecCompiled r = (PatternStreamSpecCompiled)compiled;
EvalNodeAnalysisResult evalNodeAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes((r.EvalFactoryNode));
IList <EvalFilterFactoryNode> filterNodes = evalNodeAnalysisResult.FilterNodes;
foreach (EvalFilterFactoryNode filterNode in filterNodes)
{
filters.Add(filterNode.FilterSpec);
}
}
if (compiled is NamedWindowConsumerStreamSpec)
{
namedWindows.Add((NamedWindowConsumerStreamSpec)compiled);
}
}
}
public ViewableActivatorPatternForge(
EventType eventType,
PatternStreamSpecCompiled spec,
PatternContext patternContext,
bool isCanIterate)
{
_eventType = eventType;
_spec = spec;
_patternContext = patternContext;
_isCanIterate = isCanIterate;
}
private OnTriggerActivatorDesc ActivatorPattern(
PatternStreamSpecCompiled patternStreamSpec,
StatementCompileTimeServices services)
{
var triggerEventTypeName = patternStreamSpec.OptionalStreamName;
var patternType =
ViewableActivatorPatternForge.MakeRegisterPatternType(@base, 0, patternStreamSpec, services);
var patternContext = new PatternContext(0, patternStreamSpec.MatchedEventMapMeta, false, -1, false);
var activator = new ViewableActivatorPatternForge(patternType, patternStreamSpec, patternContext, false);
return new OnTriggerActivatorDesc(activator, triggerEventTypeName, patternType);
}
private void TryAssertionEPL(EPServiceProvider epService, string epl, string patternText, string expectedIfDifferent)
{
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(epl);
EPStatementSPI spi = (EPStatementSPI)epService.EPAdministrator.Create(model);
StatementSpecCompiled spec = ((EPServiceProviderSPI)epService).StatementLifecycleSvc.GetStatementSpec(spi.StatementId);
PatternStreamSpecCompiled pattern = (PatternStreamSpecCompiled)spec.StreamSpecs[0];
var writer = new StringWriter();
pattern.EvalFactoryNode.ToEPL(writer, PatternExpressionPrecedenceEnum.MINIMUM);
if (expectedIfDifferent == null)
{
Assert.AreEqual(patternText, writer.ToString());
}
else
{
Assert.AreEqual(expectedIfDifferent, writer.ToString());
}
spi.Dispose();
}
public void Activate(EventBean optionalTriggeringEvent, MatchedEventMap priorMatches, long timeOffset, bool isRecoveringResilient)
{
if (PatternStopCallback != null)
{
PatternStopCallback.Stop();
}
PatternStreamSpecCompiled patternStreamSpec = _endpointPatternSpec.PatternCompiled;
StatementContext stmtContext = _agentInstanceContext.StatementContext;
EvalRootFactoryNode rootFactoryNode = _servicesContext.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode);
int streamNum = _isStartEndpoint ? _contextStatePathKey.SubPath : -1 * _contextStatePathKey.SubPath;
bool allowResilient = _contextStatePathKey.Level == 1;
PatternContext patternContext = stmtContext.PatternContextFactory.CreateContext(stmtContext, streamNum, rootFactoryNode, new MatchedEventMapMeta(patternStreamSpec.AllTags, !patternStreamSpec.ArrayEventTypes.IsEmpty()), allowResilient);
PatternAgentInstanceContext patternAgentInstanceContext = stmtContext.PatternContextFactory.CreatePatternAgentContext(patternContext, _agentInstanceContext, false);
EvalRootNode rootNode = EvalNodeUtil.MakeRootNodeFromFactory(rootFactoryNode, patternAgentInstanceContext);
if (priorMatches == null)
{
priorMatches = new MatchedEventMapImpl(patternContext.MatchedEventMapMeta);
}
// capture any callbacks that may occur right after start
ConditionPatternMatchCallback callback = new ConditionPatternMatchCallback(this);
PatternStopCallback = rootNode.Start(callback.MatchFound, patternContext, priorMatches, isRecoveringResilient);
callback.ForwardCalls = true;
if (_agentInstanceContext.StatementContext.StatementExtensionServicesContext != null &&
_agentInstanceContext.StatementContext.StatementExtensionServicesContext.StmtResources != null)
{
_agentInstanceContext.StatementContext.StatementExtensionServicesContext.StmtResources
.StartContextPattern(PatternStopCallback, _isStartEndpoint, _contextStatePathKey);
}
if (callback.IsInvoked)
{
MatchFound(Collections.GetEmptyMap <String, Object>());
}
}
public static MapEventType MakeRegisterPatternType(
StatementBaseInfo @base,
int stream,
PatternStreamSpecCompiled patternStreamSpec,
StatementCompileTimeServices services)
{
var patternEventTypeName = services.EventTypeNameGeneratorStatement.GetPatternTypeName(stream);
var metadata = new EventTypeMetadata(
patternEventTypeName,
@base.ModuleName,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.MAP,
NameAccessModifier.PRIVATE,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
IDictionary<string, object> propertyTypes = new LinkedHashMap<string, object>();
foreach (var entry in patternStreamSpec.TaggedEventTypes) {
propertyTypes.Put(entry.Key, entry.Value.First);
}
foreach (var entry in patternStreamSpec.ArrayEventTypes) {
propertyTypes.Put(entry.Key, new[] {entry.Value.First});
}
var patternType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
propertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(patternType);
return patternType;
}
public static StreamSpecCompiledDesc CompilePatternWTags(
PatternStreamSpecRaw streamSpecRaw,
ISet<string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
ISet<string> priorAllTags,
bool isJoin,
bool isContextDeclaration,
bool isOnTrigger,
int streamNum,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// validate
if ((streamSpecRaw.IsSuppressSameEventMatches || streamSpecRaw.IsDiscardPartialsOnMatch) &&
(isJoin || isContextDeclaration || isOnTrigger)) {
throw new ExprValidationException(
"Discard-partials and suppress-matches is not supported in a joins, context declaration and on-action");
}
if (tags == null) {
tags = new MatchEventSpec();
}
var nodeStack = new Stack<EvalForgeNode>();
// determine ordered tags
ISet<string> allTagNamesOrdered = FilterSpecCompilerTagUtil.AssignEventAsTagNumber(priorAllTags, streamSpecRaw.EvalForgeNode);
// construct root : assigns factory node ids
var top = streamSpecRaw.EvalForgeNode;
var root = new EvalRootForgeNode(services.IsAttachPatternText, top, statementRawInfo.Annotations);
var additionalForgeables = new List<StmtClassForgeableFactory>();
RecursiveCompile(
top,
tags,
nodeStack,
allTagNamesOrdered,
streamNum,
additionalForgeables,
statementRawInfo,
services);
var hook = (PatternCompileHook) ImportUtil.GetAnnotationHook(
statementRawInfo.Annotations,
HookType.INTERNAL_PATTERNCOMPILE,
typeof(PatternCompileHook),
services.ImportServiceCompileTime);
hook?.Pattern(root);
PatternStreamSpecCompiled compiled = new PatternStreamSpecCompiled(
root,
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered,
streamSpecRaw.ViewSpecs,
streamSpecRaw.OptionalStreamName,
streamSpecRaw.Options,
streamSpecRaw.IsSuppressSameEventMatches,
streamSpecRaw.IsDiscardPartialsOnMatch);
return new StreamSpecCompiledDesc(compiled, additionalForgeables);
}
