private OnTriggerActivatorDesc ActivatorNamedWindow(
NamedWindowConsumerStreamSpec namedSpec,
StatementCompileTimeServices services)
{
var namedWindow = namedSpec.NamedWindow;
var triggerEventTypeName = namedSpec.NamedWindow.EventType.Name;
var typesFilterValidation = new StreamTypeServiceImpl(
namedWindow.EventType,
namedSpec.OptionalStreamName,
false);
var filterSingle =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe(
filterSingle,
typesFilterValidation,
@base.StatementRawInfo,
services);
var activator = new ViewableActivatorNamedWindowForge(
namedSpec,
namedWindow,
filterSingle,
filterQueryGraph,
false,
namedSpec.OptPropertyEvaluator);
var activatorResultEventType = namedWindow.EventType;
if (namedSpec.OptPropertyEvaluator != null) {
activatorResultEventType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
return new OnTriggerActivatorDesc(activator, triggerEventTypeName, activatorResultEventType);
}
public static FireAndForgetProcessor ValidateResolveProcessor(StreamSpecCompiled streamSpec, EPServicesContext services)
{
// resolve processor
string processorName;
if (streamSpec is NamedWindowConsumerStreamSpec)
{
NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
processorName = namedSpec.WindowName;
}
else
{
TableQueryStreamSpec tableSpec = (TableQueryStreamSpec)streamSpec;
processorName = tableSpec.TableName;
}
// get processor instance
TableMetadata tableMetadata = services.TableService.GetTableMetadata(processorName);
if (tableMetadata != null)
{
return(new FireAndForgetProcessorTable(services.TableService, tableMetadata));
}
else
{
NamedWindowProcessor nwprocessor = services.NamedWindowService.GetProcessor(processorName);
if (nwprocessor == null)
{
throw new ExprValidationException("A table or named window by name '" + processorName + "' does not exist");
}
return(new FireAndForgetProcessorNamedWindow(nwprocessor));
}
}
public void AddConsumer(StatementContext statementContext, NamedWindowConsumerStreamSpec namedSpec)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Statement '" + statementContext.StatementName + " registers consumer for '" + namedSpec.WindowName + "'");
}
}
public void AddConsumer(StatementContext statementContext, NamedWindowConsumerStreamSpec namedSpec)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Statement '{0} registers consumer for '{1}'", statementContext.StatementName, namedSpec.WindowName);
}
}
public ViewableActivatorNamedWindowForge(
NamedWindowConsumerStreamSpec spec,
NamedWindowMetaData namedWindow,
ExprNode filterEvaluator,
QueryGraphForge filterQueryGraph,
bool subquery,
PropertyEvaluatorForge optPropertyEvaluator)
{
this.spec = spec;
this.namedWindow = namedWindow;
this.filterEvaluator = filterEvaluator;
this.filterQueryGraph = filterQueryGraph;
this.subquery = subquery;
this.optPropertyEvaluator = optPropertyEvaluator;
}
public ViewableActivator CreateNamedWindow(
NamedWindowProcessor processor,
NamedWindowConsumerStreamSpec streamSpec,
StatementContext statementContext)
{
if (ProcCreateNamedWindow == null)
{
throw new NotSupportedException();
}
return(ProcCreateNamedWindow.Invoke(
processor,
streamSpec,
statementContext));
}
private static StatementSpecCompiled AssociatedFromClause(
StatementSpecCompiled statementSpec,
StatementCompileTimeServices services)
{
var raw = statementSpec.Raw;
if (raw.WhereClause != null ||
statementSpec.StreamSpecs.Length > 0 ||
raw.HavingClause != null ||
raw.OutputLimitSpec != null ||
raw.ForClauseSpec != null ||
raw.MatchRecognizeSpec != null ||
raw.OrderByList != null && !raw.OrderByList.IsEmpty() ||
raw.RowLimitSpec != null) {
throw new ExprValidationException(
"Insert-into fire-and-forget query can only consist of an insert-into clause and a select-clause");
}
var infraName = statementSpec.Raw.InsertIntoDesc.EventTypeName;
var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(infraName);
var table = services.TableCompileTimeResolver.Resolve(infraName);
if (namedWindow == null && table == null) {
throw new ExprValidationException("Failed to find named window or table '" + infraName + "'");
}
StreamSpecCompiled stream;
if (namedWindow != null) {
stream = new NamedWindowConsumerStreamSpec(
namedWindow,
null,
new ViewSpec[0],
Collections.GetEmptyList<ExprNode>(),
StreamSpecOptions.DEFAULT,
null);
}
else {
stream = new TableQueryStreamSpec(
null,
new ViewSpec[0],
StreamSpecOptions.DEFAULT,
table,
Collections.GetEmptyList<ExprNode>());
}
return new StatementSpecCompiled(statementSpec, new[] {stream});
}
private static StatementSpecCompiled AssociatedFromClause(StatementSpecCompiled statementSpec)
{
if (statementSpec.FilterRootNode != null ||
statementSpec.StreamSpecs.Length > 0 ||
statementSpec.HavingExprRootNode != null ||
statementSpec.OutputLimitSpec != null ||
statementSpec.ForClauseSpec != null ||
statementSpec.MatchRecognizeSpec != null ||
statementSpec.OrderByList.Length > 0 ||
statementSpec.RowLimitSpec != null)
{
throw new ExprValidationException("Insert-into fire-and-forget query can only consist of an insert-into clause and a select-clause");
}
var namedWindowName = statementSpec.InsertIntoDesc.EventTypeName;
var namedWindowStream = new NamedWindowConsumerStreamSpec(namedWindowName, null, new ViewSpec[0], Collections.GetEmptyList <ExprNode>(), new StreamSpecOptions(), null);
statementSpec.StreamSpecs = new StreamSpecCompiled[] { namedWindowStream };
return(statementSpec);
}
public ViewableActivator CreateNamedWindow(NamedWindowProcessor processor, NamedWindowConsumerStreamSpec streamSpec, StatementContext statementContext)
{
return(new ViewableActivatorNamedWindow(processor, streamSpec.FilterExpressions, streamSpec.OptPropertyEvaluator));
}
public static SubSelectActivationDesc CreateSubSelectActivation(
IList <FilterSpecCompiled> filterSpecCompileds,
IList <NamedWindowConsumerStreamSpec> namedWindowConsumers,
StatementBaseInfo statement,
StatementCompileTimeServices services)
{
IDictionary <ExprSubselectNode, SubSelectActivationPlan> result = new LinkedHashMap <ExprSubselectNode, SubSelectActivationPlan>();
IList <StmtClassForgeableFactory> additionalForgeables = new List <StmtClassForgeableFactory>();
// Process all subselect expression nodes
foreach (ExprSubselectNode subselect in statement.StatementSpec.SubselectNodes)
{
StatementSpecCompiled statementSpec = subselect.StatementSpecCompiled;
StreamSpecCompiled streamSpec = statementSpec.StreamSpecs[0];
int subqueryNumber = subselect.SubselectNumber;
if (subqueryNumber == -1)
{
throw new IllegalStateException("Unexpected subquery");
}
ViewFactoryForgeArgs args = new ViewFactoryForgeArgs(-1, true, subqueryNumber, streamSpec.Options, null, statement.StatementRawInfo, services);
if (streamSpec is FilterStreamSpecCompiled)
{
if (services.IsFireAndForget)
{
throw new ExprValidationException("Fire-and-forget queries only allow subqueries against named windows and tables");
}
FilterStreamSpecCompiled filterStreamSpec = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0];
// Register filter, create view factories
ViewableActivatorForge activatorDeactivator = new ViewableActivatorFilterForge(
filterStreamSpec.FilterSpecCompiled,
false,
null,
true,
subqueryNumber);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(
streamSpec.ViewSpecs,
args,
filterStreamSpec.FilterSpecCompiled.ResultEventType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
EventType eventType = forges.IsEmpty() ? filterStreamSpec.FilterSpecCompiled.ResultEventType : forges[forges.Count - 1].EventType;
subselect.RawEventType = eventType;
filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled);
// Add lookup to list, for later starts
result.Put(
subselect,
new SubSelectActivationPlan(filterStreamSpec.FilterSpecCompiled.ResultEventType, forges, activatorDeactivator, streamSpec));
}
else if (streamSpec is TableQueryStreamSpec)
{
TableQueryStreamSpec table = (TableQueryStreamSpec)streamSpec;
ExprNode filter = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(table.FilterExpressions);
ViewableActivatorForge viewableActivator = new ViewableActivatorTableForge(table.Table, filter);
result.Put(
subselect,
new SubSelectActivationPlan(table.Table.InternalEventType, EmptyList <ViewFactoryForge> .Instance, viewableActivator, streamSpec));
subselect.RawEventType = table.Table.InternalEventType;
}
else
{
NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0];
namedWindowConsumers.Add(namedSpec);
NamedWindowMetaData nwinfo = namedSpec.NamedWindow;
EventType namedWindowType = nwinfo.EventType;
if (namedSpec.OptPropertyEvaluator != null)
{
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
// if named-window index sharing is disabled (the default) or filter expressions are provided then consume the insert-remove stream
bool disableIndexShare = HintEnum.DISABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(statement.StatementRawInfo.Annotations) != null;
bool processorDisableIndexShare = !namedSpec.NamedWindow.IsEnableIndexShare;
if (disableIndexShare && namedSpec.NamedWindow.IsVirtualDataWindow)
{
disableIndexShare = false;
}
if ((!namedSpec.FilterExpressions.IsEmpty() || processorDisableIndexShare || disableIndexShare) && (!services.IsFireAndForget))
{
ExprNode filterEvaluator = null;
if (!namedSpec.FilterExpressions.IsEmpty())
{
filterEvaluator = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
}
ViewableActivatorForge activatorNamedWindow = new ViewableActivatorNamedWindowForge(
namedSpec,
nwinfo,
filterEvaluator,
null,
true,
namedSpec.OptPropertyEvaluator);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
subselect.RawEventType = forges.IsEmpty() ? namedWindowType : forges[forges.Count - 1].EventType;
result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec));
}
else
{
// else if there are no named window stream filter expressions and index sharing is enabled
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
subselect.RawEventType = namedWindowType;
ViewableActivatorForge activatorNamedWindow = new ViewableActivatorSubselectNoneForge(namedWindowType);
result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec));
}
}
}
return(new SubSelectActivationDesc(result, additionalForgeables));
}
public static StreamSpecCompiledDesc CompileFilter(
FilterStreamSpecRaw streamSpec,
bool isInsertInto,
bool isJoin,
bool isContextDeclaration,
bool isOnTrigger,
string optionalStreamName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// Determine the event type
var rawFilterSpec = streamSpec.RawFilterSpec;
var eventTypeName = rawFilterSpec.EventTypeName;
var table = services.TableCompileTimeResolver.Resolve(eventTypeName);
if (table != null) {
if (streamSpec.ViewSpecs != null && streamSpec.ViewSpecs.Length > 0) {
throw new ExprValidationException("Views are not supported with tables");
}
if (streamSpec.RawFilterSpec.OptionalPropertyEvalSpec != null) {
throw new ExprValidationException("Contained-event expressions are not supported with tables");
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
new[] {table.InternalEventType},
new[] {optionalStreamName},
new[] {true},
false,
false);
FilterSpecValidatedDesc descX = FilterSpecCompiler.ValidateAllowSubquery(
ExprNodeOrigin.FILTER,
rawFilterSpec.FilterExpressions,
streamTypeService,
null,
null,
statementRawInfo,
services);
TableQueryStreamSpec tableStreamSpec = new TableQueryStreamSpec(
streamSpec.OptionalStreamName,
streamSpec.ViewSpecs,
streamSpec.Options,
table,
descX.Expressions);
return new StreamSpecCompiledDesc(
tableStreamSpec,
descX.AdditionalForgeables);
}
// Could be a named window
var namedWindowInfo = services.NamedWindowCompileTimeResolver.Resolve(eventTypeName);
if (namedWindowInfo != null) {
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
new[] {namedWindowInfo.EventType},
new[] {optionalStreamName},
new[] {true},
false,
false);
FilterSpecValidatedDesc validated = FilterSpecCompiler.ValidateAllowSubquery(
ExprNodeOrigin.FILTER,
rawFilterSpec.FilterExpressions,
streamTypeService,
null,
null,
statementRawInfo,
services);
PropertyEvaluatorForge optionalPropertyEvaluator = null;
if (rawFilterSpec.OptionalPropertyEvalSpec != null) {
optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator(
rawFilterSpec.OptionalPropertyEvalSpec,
namedWindowInfo.EventType,
streamSpec.OptionalStreamName,
statementRawInfo,
services);
}
NamedWindowConsumerStreamSpec consumer = new NamedWindowConsumerStreamSpec(
namedWindowInfo,
streamSpec.OptionalStreamName,
streamSpec.ViewSpecs,
validated.Expressions,
streamSpec.Options,
optionalPropertyEvaluator);
return new StreamSpecCompiledDesc(consumer, validated.AdditionalForgeables);
}
var eventType = ResolveTypeName(eventTypeName, services.EventTypeCompileTimeResolver);
// Validate all nodes, make sure each returns a boolean and types are good;
// Also decompose all AND super nodes into individual expressions
StreamTypeService streamTypeServiceX = new StreamTypeServiceImpl(
new[] {eventType},
new[] {streamSpec.OptionalStreamName},
new[] {true},
false,
false);
FilterSpecCompiledDesc desc = FilterSpecCompiler.MakeFilterSpec(
eventType,
eventTypeName,
rawFilterSpec.FilterExpressions,
rawFilterSpec.OptionalPropertyEvalSpec,
null, null, null, // no tags
streamTypeServiceX,
streamSpec.OptionalStreamName,
statementRawInfo,
services);
FilterStreamSpecCompiled compiled = new FilterStreamSpecCompiled(
desc.FilterSpecCompiled,
streamSpec.ViewSpecs,
streamSpec.OptionalStreamName,
streamSpec.Options);
return new StreamSpecCompiledDesc(compiled, desc.AdditionalForgeables);
}
