use of io.siddhi.query.api.execution.query.input.stream.BasicSingleInputStream in project siddhi by wso2.
the class StateInputStreamParser method parse.
private static InnerStateRuntime parse(StateElement stateElement, Map<String, AbstractDefinition> streamDefinitionMap, Map<String, AbstractDefinition> tableDefinitionMap, Map<String, AbstractDefinition> windowDefinitionMap, Map<String, AbstractDefinition> aggregationDefinitionMap, Map<String, Table> tableMap, MetaStateEvent metaStateEvent, List<VariableExpressionExecutor> variableExpressionExecutors, Map<String, ProcessStreamReceiver> processStreamReceiverMap, StreamPreStateProcessor streamPreStateProcessor, StreamPostStateProcessor streamPostStateProcessor, StateInputStream.Type stateType, boolean multiValue, List<PreStateProcessor> preStateProcessors, boolean isStartState, List<PreStateProcessor> startupPreStateProcessors, SiddhiQueryContext siddhiQueryContext) {
if (stateElement instanceof StreamStateElement) {
BasicSingleInputStream basicSingleInputStream = ((StreamStateElement) stateElement).getBasicSingleInputStream();
SingleStreamRuntime singleStreamRuntime = SingleInputStreamParser.parseInputStream(basicSingleInputStream, variableExpressionExecutors, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, processStreamReceiverMap.get(basicSingleInputStream.getUniqueStreamIds().get(0)), false, false, false, multiValue, siddhiQueryContext);
int stateIndex = metaStateEvent.getStreamEventCount() - 1;
if (streamPreStateProcessor == null) {
if (stateElement instanceof AbsentStreamStateElement) {
AbsentStreamPreStateProcessor absentProcessor = new AbsentStreamPreStateProcessor(stateType, ((AbsentStreamStateElement) stateElement).getWaitingTime().value());
// Set the scheduler
startupPreStateProcessors.add(absentProcessor);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(absentProcessor);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
absentProcessor.setScheduler(scheduler);
// Assign the AbsentStreamPreStateProcessor to streamPreStateProcessor
streamPreStateProcessor = absentProcessor;
} else {
streamPreStateProcessor = new StreamPreStateProcessor(stateType);
}
streamPreStateProcessor.init(siddhiQueryContext);
}
streamPreStateProcessor.setStateId(stateIndex);
streamPreStateProcessor.setStartState(isStartState);
streamPreStateProcessor.setNextProcessor(singleStreamRuntime.getProcessorChain());
singleStreamRuntime.setProcessorChain(streamPreStateProcessor);
if (streamPostStateProcessor == null) {
if (stateElement instanceof AbsentStreamStateElement) {
streamPostStateProcessor = new AbsentStreamPostStateProcessor();
} else {
streamPostStateProcessor = new StreamPostStateProcessor();
}
}
streamPostStateProcessor.setStateId(stateIndex);
singleStreamRuntime.getProcessorChain().setToLast(streamPostStateProcessor);
streamPostStateProcessor.setThisStatePreProcessor(streamPreStateProcessor);
streamPreStateProcessor.setThisStatePostProcessor(streamPostStateProcessor);
streamPreStateProcessor.setThisLastProcessor(streamPostStateProcessor);
StreamInnerStateRuntime innerStateRuntime = new StreamInnerStateRuntime(stateType);
innerStateRuntime.setFirstProcessor(streamPreStateProcessor);
innerStateRuntime.setLastProcessor(streamPostStateProcessor);
innerStateRuntime.addStreamRuntime(singleStreamRuntime);
preStateProcessors.add(streamPreStateProcessor);
return innerStateRuntime;
} else if (stateElement instanceof NextStateElement) {
StateElement currentElement = ((NextStateElement) stateElement).getStateElement();
InnerStateRuntime currentInnerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
StateElement nextElement = ((NextStateElement) stateElement).getNextStateElement();
InnerStateRuntime nextInnerStateRuntime = parse(nextElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, preStateProcessors, false, startupPreStateProcessors, siddhiQueryContext);
currentInnerStateRuntime.getLastProcessor().setNextStatePreProcessor(nextInnerStateRuntime.getFirstProcessor());
NextInnerStateRuntime nextStateRuntime = new NextInnerStateRuntime(currentInnerStateRuntime, nextInnerStateRuntime, stateType);
nextStateRuntime.setFirstProcessor(currentInnerStateRuntime.getFirstProcessor());
nextStateRuntime.setLastProcessor(nextInnerStateRuntime.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : currentInnerStateRuntime.getSingleStreamRuntimeList()) {
nextStateRuntime.addStreamRuntime(singleStreamRuntime);
}
for (SingleStreamRuntime singleStreamRuntime : nextInnerStateRuntime.getSingleStreamRuntimeList()) {
nextStateRuntime.addStreamRuntime(singleStreamRuntime);
}
return nextStateRuntime;
} else if (stateElement instanceof EveryStateElement) {
StateElement currentElement = ((EveryStateElement) stateElement).getStateElement();
List<PreStateProcessor> withinEveryPreStateProcessors = new ArrayList<>();
InnerStateRuntime innerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, withinEveryPreStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
EveryInnerStateRuntime everyInnerStateRuntime = new EveryInnerStateRuntime(innerStateRuntime, stateType);
everyInnerStateRuntime.setFirstProcessor(innerStateRuntime.getFirstProcessor());
everyInnerStateRuntime.setLastProcessor(innerStateRuntime.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime.getSingleStreamRuntimeList()) {
everyInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
everyInnerStateRuntime.getLastProcessor().setNextEveryStatePreProcessor(everyInnerStateRuntime.getFirstProcessor());
for (PreStateProcessor preStateProcessor : withinEveryPreStateProcessors) {
preStateProcessor.setWithinEveryPreStateProcessor(everyInnerStateRuntime.getFirstProcessor());
}
preStateProcessors.addAll(withinEveryPreStateProcessors);
return everyInnerStateRuntime;
} else if (stateElement instanceof LogicalStateElement) {
LogicalStateElement.Type type = ((LogicalStateElement) stateElement).getType();
LogicalPreStateProcessor logicalPreStateProcessor1;
if (((LogicalStateElement) stateElement).getStreamStateElement1() instanceof AbsentStreamStateElement) {
logicalPreStateProcessor1 = new AbsentLogicalPreStateProcessor(type, stateType, ((AbsentStreamStateElement) ((LogicalStateElement) stateElement).getStreamStateElement1()).getWaitingTime());
// Set the scheduler
startupPreStateProcessors.add(logicalPreStateProcessor1);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(logicalPreStateProcessor1);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
((SchedulingProcessor) logicalPreStateProcessor1).setScheduler(scheduler);
} else {
logicalPreStateProcessor1 = new LogicalPreStateProcessor(type, stateType);
}
logicalPreStateProcessor1.init(siddhiQueryContext);
LogicalPostStateProcessor logicalPostStateProcessor1;
if (((LogicalStateElement) stateElement).getStreamStateElement1() instanceof AbsentStreamStateElement) {
logicalPostStateProcessor1 = new AbsentLogicalPostStateProcessor(type);
} else {
logicalPostStateProcessor1 = new LogicalPostStateProcessor(type);
}
LogicalPreStateProcessor logicalPreStateProcessor2;
if (((LogicalStateElement) stateElement).getStreamStateElement2() instanceof AbsentStreamStateElement) {
logicalPreStateProcessor2 = new AbsentLogicalPreStateProcessor(type, stateType, ((AbsentStreamStateElement) ((LogicalStateElement) stateElement).getStreamStateElement2()).getWaitingTime());
startupPreStateProcessors.add(logicalPreStateProcessor2);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(logicalPreStateProcessor2);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
((SchedulingProcessor) logicalPreStateProcessor2).setScheduler(scheduler);
} else {
logicalPreStateProcessor2 = new LogicalPreStateProcessor(type, stateType);
}
logicalPreStateProcessor2.init(siddhiQueryContext);
LogicalPostStateProcessor logicalPostStateProcessor2;
if (((LogicalStateElement) stateElement).getStreamStateElement2() instanceof AbsentStreamStateElement) {
logicalPostStateProcessor2 = new AbsentLogicalPostStateProcessor(type);
} else {
logicalPostStateProcessor2 = new LogicalPostStateProcessor(type);
}
logicalPostStateProcessor1.setPartnerPreStateProcessor(logicalPreStateProcessor2);
logicalPostStateProcessor2.setPartnerPreStateProcessor(logicalPreStateProcessor1);
logicalPostStateProcessor1.setPartnerPostStateProcessor(logicalPostStateProcessor2);
logicalPostStateProcessor2.setPartnerPostStateProcessor(logicalPostStateProcessor1);
logicalPreStateProcessor1.setPartnerStatePreProcessor(logicalPreStateProcessor2);
logicalPreStateProcessor2.setPartnerStatePreProcessor(logicalPreStateProcessor1);
StateElement stateElement2 = ((LogicalStateElement) stateElement).getStreamStateElement2();
InnerStateRuntime innerStateRuntime2 = parse(stateElement2, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, logicalPreStateProcessor2, logicalPostStateProcessor2, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
StateElement stateElement1 = ((LogicalStateElement) stateElement).getStreamStateElement1();
InnerStateRuntime innerStateRuntime1 = parse(stateElement1, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, logicalPreStateProcessor1, logicalPostStateProcessor1, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
LogicalInnerStateRuntime logicalInnerStateRuntime = new LogicalInnerStateRuntime(innerStateRuntime1, innerStateRuntime2, stateType);
logicalInnerStateRuntime.setFirstProcessor(innerStateRuntime1.getFirstProcessor());
logicalInnerStateRuntime.setLastProcessor(innerStateRuntime2.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime2.getSingleStreamRuntimeList()) {
logicalInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime1.getSingleStreamRuntimeList()) {
logicalInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
return logicalInnerStateRuntime;
} else if (stateElement instanceof CountStateElement) {
int minCount = ((CountStateElement) stateElement).getMinCount();
int maxCount = ((CountStateElement) stateElement).getMaxCount();
if (minCount == SiddhiConstants.ANY) {
minCount = 0;
}
if (maxCount == SiddhiConstants.ANY) {
maxCount = Integer.MAX_VALUE;
}
CountPreStateProcessor countPreStateProcessor = new CountPreStateProcessor(minCount, maxCount, stateType);
countPreStateProcessor.init(siddhiQueryContext);
CountPostStateProcessor countPostStateProcessor = new CountPostStateProcessor(minCount, maxCount);
countPreStateProcessor.setCountPostStateProcessor(countPostStateProcessor);
StateElement currentElement = ((CountStateElement) stateElement).getStreamStateElement();
InnerStateRuntime innerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, countPreStateProcessor, countPostStateProcessor, stateType, true, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
return new CountInnerStateRuntime((StreamInnerStateRuntime) innerStateRuntime);
} else {
throw new OperationNotSupportedException();
}
}
use of io.siddhi.query.api.execution.query.input.stream.BasicSingleInputStream in project siddhi by wso2.
the class SiddhiQLBaseVisitorImpl method visitDefinition_aggregation.
@Override
public AggregationDefinition visitDefinition_aggregation(@NotNull SiddhiQLParser.Definition_aggregationContext ctx) {
// Read the name of the aggregation
String aggregationName = (String) visitAggregation_name(ctx.aggregation_name());
// Create the aggregation using the extracted aggregation name
AggregationDefinition aggregationDefinition = AggregationDefinition.id(aggregationName);
// Get all annotation and populate the aggregation
for (SiddhiQLParser.AnnotationContext annotationContext : ctx.annotation()) {
aggregationDefinition.annotation((Annotation) visit(annotationContext));
}
// Attach the input stream
BasicSingleInputStream basicSingleInputStream = (BasicSingleInputStream) visit(ctx.standard_stream());
aggregationDefinition.from(basicSingleInputStream);
// Extract the selector and attach it to the new aggregation
BasicSelector selector = (BasicSelector) visit(ctx.group_by_query_selection());
aggregationDefinition.select(selector);
// Get the variable (if available) and aggregate on that variable
if (ctx.attribute_reference() != null) {
Variable aggregatedBy = (Variable) visit(ctx.attribute_reference());
aggregationDefinition.aggregateBy(aggregatedBy);
}
// Extract the specified time-durations and attache it to the aggregation definition
TimePeriod timePeriod = (TimePeriod) visit(ctx.aggregation_time());
aggregationDefinition.every(timePeriod);
populateQueryContext(aggregationDefinition, ctx);
return aggregationDefinition;
}
use of io.siddhi.query.api.execution.query.input.stream.BasicSingleInputStream in project siddhi by wso2.
the class SiddhiQLBaseVisitorImpl method visitStandard_stream.
/**
* {@inheritDoc}
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*
* @param ctx
*/
@Override
public SingleInputStream visitStandard_stream(@NotNull SiddhiQLParser.Standard_streamContext ctx) {
// standard_stream
// : io (basic_source_stream_handler)* window? (basic_source_stream_handler)*
// ;
Source source = (Source) visit(ctx.source());
BasicSingleInputStream basicSingleInputStream = new BasicSingleInputStream(null, source.streamId, source.isInnerStream, source.isFaultStream);
if (ctx.pre_window_handlers != null) {
basicSingleInputStream.addStreamHandlers((List<StreamHandler>) visit(ctx.pre_window_handlers));
}
if (ctx.window() == null && ctx.post_window_handlers == null) {
populateQueryContext(basicSingleInputStream, ctx);
return basicSingleInputStream;
} else if (ctx.window() != null) {
SingleInputStream singleInputStream = new SingleInputStream(basicSingleInputStream, (Window) visit(ctx.window()));
if (ctx.post_window_handlers != null) {
singleInputStream.addStreamHandlers((List<StreamHandler>) visit(ctx.post_window_handlers));
}
populateQueryContext(singleInputStream, ctx);
return singleInputStream;
} else {
throw newSiddhiParserException(ctx);
}
}
use of io.siddhi.query.api.execution.query.input.stream.BasicSingleInputStream in project siddhi by wso2.
the class SiddhiQLBaseVisitorImpl method visitJoin_source.
/**
* {@inheritDoc}
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*
* @param ctx
*/
@Override
public Object visitJoin_source(@NotNull SiddhiQLParser.Join_sourceContext ctx) {
// join_source
// :io (basic_source_stream_handler)* window? (AS alias)?
// ;
Source source = (Source) visit(ctx.source());
String streamAlias = null;
if (ctx.alias() != null) {
streamAlias = (String) visit(ctx.alias());
activeStreams.remove(ctx.source().getText());
activeStreams.add(streamAlias);
}
BasicSingleInputStream basicSingleInputStream = new BasicSingleInputStream(streamAlias, source.streamId, source.isInnerStream, source.isFaultStream);
if (ctx.basic_source_stream_handlers() != null) {
basicSingleInputStream.addStreamHandlers((List<StreamHandler>) visit(ctx.basic_source_stream_handlers()));
}
if (ctx.window() != null) {
SingleInputStream inputStream = new SingleInputStream(basicSingleInputStream, (Window) visit(ctx.window()));
populateQueryContext(inputStream, ctx);
return inputStream;
} else {
populateQueryContext(basicSingleInputStream, ctx);
return basicSingleInputStream;
}
}
use of io.siddhi.query.api.execution.query.input.stream.BasicSingleInputStream in project siddhi by wso2.
the class InputStreamParser method parse.
/**
* Parse an InputStream returning corresponding StreamRuntime
*
* @param inputStream input stream to be parsed
* @param streamDefinitionMap map containing user given stream definitions
* @param tableDefinitionMap table definition map
* @param windowDefinitionMap window definition map
* @param aggregationDefinitionMap aggregation definition map
* @param tableMap Table Map
* @param windowMap event window map
* @param aggregationMap aggregator map
* @param executors List to hold VariableExpressionExecutors to update after query parsing
* @param outputExpectsExpiredEvents is expired events sent as output
* @param siddhiQueryContext Siddhi query context.
* @return StreamRuntime
*/
public static StreamRuntime parse(InputStream inputStream, Query query, Map<String, AbstractDefinition> streamDefinitionMap, Map<String, AbstractDefinition> tableDefinitionMap, Map<String, AbstractDefinition> windowDefinitionMap, Map<String, AbstractDefinition> aggregationDefinitionMap, Map<String, Table> tableMap, Map<String, Window> windowMap, Map<String, AggregationRuntime> aggregationMap, List<VariableExpressionExecutor> executors, boolean outputExpectsExpiredEvents, SiddhiQueryContext siddhiQueryContext) {
if (inputStream instanceof BasicSingleInputStream || inputStream instanceof SingleInputStream) {
SingleInputStream singleInputStream = (SingleInputStream) inputStream;
ProcessStreamReceiver processStreamReceiver = new ProcessStreamReceiver(singleInputStream.getStreamId(), siddhiQueryContext);
return SingleInputStreamParser.parseInputStream((SingleInputStream) inputStream, executors, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, new MetaStreamEvent(), processStreamReceiver, true, outputExpectsExpiredEvents, false, false, siddhiQueryContext);
} else if (inputStream instanceof JoinInputStream) {
return JoinInputStreamParser.parseInputStream(((JoinInputStream) inputStream), query, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, windowMap, aggregationMap, executors, outputExpectsExpiredEvents, siddhiQueryContext);
} else if (inputStream instanceof StateInputStream) {
MetaStateEvent metaStateEvent = new MetaStateEvent(inputStream.getAllStreamIds().size());
return StateInputStreamParser.parseInputStream(((StateInputStream) inputStream), metaStateEvent, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, executors, siddhiQueryContext);
} else {
throw new OperationNotSupportedException();
}
}
Aggregations