Examples with ComplexEventChunk io.siddhi.core.event.ComplexEventChunk used on opensource projects

Example 36 with ComplexEventChunk

use of io.siddhi.core.event.ComplexEventChunk in project siddhi by wso2.

the class SelectOnDemandQueryRuntime method generateResetComplexEventChunk.

private ComplexEventChunk<ComplexEvent> generateResetComplexEventChunk(MetaStreamEvent metaStreamEvent) {
    StreamEvent streamEvent = new StreamEvent(metaStreamEvent.getOutputData().size(), metaStreamEvent.getOnAfterWindowData().size(), metaStreamEvent.getOutputData().size());
    streamEvent.setType(ComplexEvent.Type.RESET);
    StateEvent stateEvent = stateEventFactory.newInstance();
    if (eventType == MetaStreamEvent.EventType.AGGREGATE) {
        stateEvent.addEvent(1, streamEvent);
    } else {
        stateEvent.addEvent(0, streamEvent);
    }
    stateEvent.setType(ComplexEvent.Type.RESET);
    ComplexEventChunk<ComplexEvent> complexEventChunk = new ComplexEventChunk<>();
    complexEventChunk.add(stateEvent);
    return complexEventChunk;
}

Example 37 with ComplexEventChunk

use of io.siddhi.core.event.ComplexEventChunk in project siddhi by wso2.

the class UpdateOrInsertOnDemandQueryRuntime method generateResetComplexEventChunk.

private ComplexEventChunk<ComplexEvent> generateResetComplexEventChunk(MetaStreamEvent metaStreamEvent) {
    StreamEvent streamEvent = new StreamEvent(metaStreamEvent.getBeforeWindowData().size(), metaStreamEvent.getOnAfterWindowData().size(), metaStreamEvent.getOutputData().size());
    streamEvent.setType(ComplexEvent.Type.RESET);
    StateEvent stateEvent = stateEventFactory.newInstance();
    stateEvent.addEvent(0, streamEvent);
    stateEvent.setType(ComplexEvent.Type.RESET);
    ComplexEventChunk<ComplexEvent> complexEventChunk = new ComplexEventChunk<>();
    complexEventChunk.add(stateEvent);
    return complexEventChunk;
}

Example 38 with ComplexEventChunk

use of io.siddhi.core.event.ComplexEventChunk in project siddhi by wso2.

the class JoinProcessor method execute.

private void execute(ComplexEventChunk complexEventChunk, List<ComplexEventChunk> returnEventChunkList) {
    StateEvent joinStateEvent = new StateEvent(2, 0);
    StreamEvent nextEvent = (StreamEvent) complexEventChunk.getFirst();
    complexEventChunk.clear();
    while (nextEvent != null) {
        StreamEvent streamEvent = nextEvent;
        nextEvent = streamEvent.getNext();
        streamEvent.setNext(null);
        ComplexEvent.Type eventType = streamEvent.getType();
        if (eventType == ComplexEvent.Type.TIMER) {
            continue;
        } else if (eventType == ComplexEvent.Type.RESET) {
            if (!leftJoinProcessor) {
                StateEvent outputStateEvent = joinEventBuilder(null, streamEvent, eventType);
                returnEventChunkList.add(new SelectorTypeComplexEventChunk(new ComplexEventChunk<>(outputStateEvent, outputStateEvent), false));
            } else {
                StateEvent outputStateEvent = joinEventBuilder(streamEvent, null, eventType);
                returnEventChunkList.add(new SelectorTypeComplexEventChunk(new ComplexEventChunk<>(outputStateEvent, outputStateEvent), false));
            }
        } else {
            joinStateEvent.setEvent(matchingStreamIndex, streamEvent);
            StreamEvent foundStreamEvent;
            if (this.isOptimisedQuery) {
                try {
                    foundStreamEvent = query(joinStateEvent);
                } catch (SiddhiAppRuntimeException e) {
                    log.warn("Performing select clause in databases failed due to '" + e.getMessage() + " in query '" + queryName + "' within Siddhi app '" + siddhiAppName + "' hence reverting back to querying only with where clause.", e);
                    this.isOptimisedQuery = false;
                    foundStreamEvent = findableProcessor.find(joinStateEvent, compiledCondition);
                }
            } else {
                foundStreamEvent = findableProcessor.find(joinStateEvent, compiledCondition);
            }
            joinStateEvent.setEvent(matchingStreamIndex, null);
            if (foundStreamEvent == null) {
                if (outerJoinProcessor && !leftJoinProcessor) {
                    StateEvent outputStateEvent = joinEventBuilder(null, streamEvent, eventType);
                    returnEventChunkList.add(new SelectorTypeComplexEventChunk(new ComplexEventChunk<>(outputStateEvent, outputStateEvent), false));
                } else if (outerJoinProcessor && leftJoinProcessor) {
                    StateEvent outputStateEvent = joinEventBuilder(streamEvent, null, eventType);
                    returnEventChunkList.add(new SelectorTypeComplexEventChunk(new ComplexEventChunk<>(outputStateEvent, outputStateEvent), false));
                }
            } else if (!isOptimisedQuery) {
                ComplexEventChunk<ComplexEvent> returnEventChunk = new ComplexEventChunk<>();
                while (foundStreamEvent != null) {
                    StreamEvent nextFoundStreamEvent = foundStreamEvent.getNext();
                    foundStreamEvent.setNext(null);
                    if (!leftJoinProcessor) {
                        returnEventChunk.add(joinEventBuilder(foundStreamEvent, streamEvent, eventType));
                    } else {
                        returnEventChunk.add(joinEventBuilder(streamEvent, foundStreamEvent, eventType));
                    }
                    foundStreamEvent = nextFoundStreamEvent;
                }
                returnEventChunkList.add(new SelectorTypeComplexEventChunk(returnEventChunk, false));
            } else {
                ComplexEventChunk<ComplexEvent> returnEventChunk = new ComplexEventChunk<>();
                while (foundStreamEvent != null) {
                    StreamEvent nextFoundStreamEvent = foundStreamEvent.getNext();
                    StateEvent returnEvent = stateEventFactory.newInstance();
                    returnEvent.setType(eventType);
                    returnEvent.setTimestamp(foundStreamEvent.getTimestamp());
                    Object[] outputData = foundStreamEvent.getOutputData();
                    for (int i = 0; i < outputData.length; i++) {
                        Object data = outputData[i];
                        returnEvent.setOutputData(data, i);
                    }
                    returnEventChunk.add(returnEvent);
                    foundStreamEvent = nextFoundStreamEvent;
                }
                returnEventChunkList.add(new SelectorTypeComplexEventChunk(returnEventChunk, true));
            }
        }
    }
}

Example 39 with ComplexEventChunk

use of io.siddhi.core.event.ComplexEventChunk in project siddhi by wso2.

the class AbsentLogicalPreStateProcessor method process.

@Override
public void process(ComplexEventChunk complexEventChunk) {
    StreamPreState state = stateHolder.getState();
    try {
        if (!((LogicalStreamPreState) state).active) {
            return;
        }
        boolean notProcessed = true;
        ComplexEventChunk<StateEvent> retEventChunk = new ComplexEventChunk<>();
        this.lock.lock();
        try {
            long currentTime = complexEventChunk.getFirst().getTimestamp();
            if (currentTime >= ((LogicalStreamPreState) state).lastArrivalTime + waitingTime) {
                Iterator<StateEvent> iterator;
                if (isStartState && stateType == StateInputStream.Type.SEQUENCE && state.getNewAndEveryStateEventList().isEmpty() && state.getPendingStateEventList().isEmpty()) {
                    StateEvent stateEvent = stateEventFactory.newInstance();
                    addState(stateEvent);
                } else if (stateType == StateInputStream.Type.SEQUENCE && !state.getNewAndEveryStateEventList().isEmpty()) {
                    this.resetState();
                }
                this.updateState();
                StateEvent expiredStateEvent = null;
                iterator = state.getPendingStateEventList().iterator();
                while (iterator.hasNext()) {
                    StateEvent stateEvent = iterator.next();
                    // Remove expired events based on within
                    if (isExpired(stateEvent, currentTime)) {
                        expiredStateEvent = stateEvent;
                        iterator.remove();
                        continue;
                    }
                    // Collect the events that came before the waiting time
                    if (waitingTimePassed(currentTime, stateEvent)) {
                        iterator.remove();
                        if (logicalType == LogicalStateElement.Type.OR && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) == null) {
                            // OR Partner not received
                            stateEvent.addEvent(stateId, streamEventFactory.newInstance());
                            retEventChunk.add(stateEvent);
                        } else if (logicalType == LogicalStateElement.Type.AND && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) != null) {
                            // AND partner received but didn't send out
                            retEventChunk.add(stateEvent);
                        } else if (logicalType == LogicalStateElement.Type.AND && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) == null) {
                            // AND partner didn't receive
                            // Let the partner to process or not
                            stateEvent.addEvent(stateId, streamEventFactory.newInstance());
                        }
                    }
                }
                if (expiredStateEvent != null && withinEveryPreStateProcessor != null) {
                    withinEveryPreStateProcessor.addEveryState(expiredStateEvent);
                    withinEveryPreStateProcessor.updateState();
                }
                retEventChunk.reset();
                notProcessed = retEventChunk.getFirst() == null;
                while (retEventChunk.hasNext()) {
                    StateEvent stateEvent = retEventChunk.next();
                    retEventChunk.remove();
                    stateEvent.setTimestamp(currentTime);
                    sendEvent(stateEvent, state);
                }
                ((LogicalStreamPreState) state).lastArrivalTime = 0;
            }
        } finally {
            this.lock.unlock();
        }
        if (thisStatePostProcessor.nextEveryStatePreProcessor != null || (notProcessed && isStartState)) {
            // If every or (notProcessed and startState), schedule again
            long nextBreak;
            if (((LogicalStreamPreState) state).lastArrivalTime == 0) {
                nextBreak = siddhiQueryContext.getSiddhiAppContext().getTimestampGenerator().currentTime() + waitingTime;
            } else {
                nextBreak = ((LogicalStreamPreState) state).lastArrivalTime + waitingTime;
            }
            this.scheduler.notifyAt(nextBreak);
        }
    } finally {
        stateHolder.returnState(state);
    }
}

Example 40 with ComplexEventChunk

use of io.siddhi.core.event.ComplexEventChunk in project siddhi by wso2.

the class CountPreStateProcessor method processAndReturn.

@Override
public ComplexEventChunk<StateEvent> processAndReturn(ComplexEventChunk complexEventChunk) {
    ComplexEventChunk<StateEvent> returnEventChunk = new ComplexEventChunk<StateEvent>();
    complexEventChunk.reset();
    // Sure only one will be sent
    StreamEvent streamEvent = (StreamEvent) complexEventChunk.next();
    CountStreamPreState state = (CountStreamPreState) stateHolder.getState();
    lock.lock();
    try {
        for (Iterator<StateEvent> iterator = state.getPendingStateEventList().iterator(); iterator.hasNext(); ) {
            StateEvent stateEvent = iterator.next();
            if (removeIfNextStateProcessed(stateEvent, iterator, stateId + 1)) {
                continue;
            }
            if (removeIfNextStateProcessed(stateEvent, iterator, stateId + 2)) {
                continue;
            }
            stateEvent.addEvent(stateId, streamEventCloner.copyStreamEvent(streamEvent));
            state.successCondition = false;
            process(stateEvent);
            if (this.thisLastProcessor.isEventReturned()) {
                this.thisLastProcessor.clearProcessedEvent();
                returnEventChunk.add(stateEvent);
            }
            if (state.isStateChanged()) {
                iterator.remove();
            }
            if (!state.successCondition) {
                switch(stateType) {
                    case PATTERN:
                        stateEvent.removeLastEvent(stateId);
                        break;
                    case SEQUENCE:
                        stateEvent.removeLastEvent(stateId);
                        iterator.remove();
                        break;
                }
            }
        }
    } finally {
        lock.unlock();
        stateHolder.returnState(state);
    }
    return returnEventChunk;
}