com.espertech.esper.client.EventBean

Here are the examples of the java api class com.espertech.esper.client.EventBean taken from open source projects.

1. TestTableLookupExecNode#testFlow()

Project: esper
File: TestTableLookupExecNode.java
public void testFlow() {
    EventBean[] indexEvents = SupportEventBeanFactory.makeEvents(new String[] { "a1", "a2" });
    index.add(indexEvents);
    EventBean[] lookupEvents = SupportEventBeanFactory.makeMarketDataEvents(new String[] { "a2", "a3" });
    List<EventBean[]> result = new LinkedList<EventBean[]>();
    EventBean[] prefill = new EventBean[] { lookupEvents[0], null };
    exec.process(lookupEvents[0], prefill, result, null);
    // Test lookup found 1 row
    assertEquals(1, result.size());
    EventBean[] events = result.iterator().next();
    assertSame(indexEvents[1], events[1]);
    assertSame(lookupEvents[0], events[0]);
    // Test lookup found no rows
    result.clear();
    exec.process(lookupEvents[1], prefill, result, null);
    assertEquals(0, result.size());
}

2. TestJoinExecStrategyDispatchable#testFlow()

Project: esper
File: TestJoinExecStrategyDispatchable.java
public void testFlow() {
    EventBean[] oldDataOne = SupportEventBeanFactory.makeEvents(new String[] { "a" });
    EventBean[] newDataOne = SupportEventBeanFactory.makeEvents(new String[] { "b" });
    EventBean[] oldDataTwo = SupportEventBeanFactory.makeEvents(new String[] { "c" });
    EventBean[] newDataTwo = SupportEventBeanFactory.makeEvents(new String[] { "d" });
    bufferViewOne.update(newDataOne, oldDataOne);
    dispatchable.execute();
    assertEquals(1, joinExecutionStrategy.getLastNewDataPerStream()[0].length);
    assertSame(newDataOne[0], joinExecutionStrategy.getLastNewDataPerStream()[0][0]);
    assertSame(oldDataOne[0], joinExecutionStrategy.getLastOldDataPerStream()[0][0]);
    assertNull(joinExecutionStrategy.getLastNewDataPerStream()[1]);
    assertNull(joinExecutionStrategy.getLastOldDataPerStream()[1]);
    bufferViewOne.update(newDataTwo, oldDataTwo);
    bufferViewTwo.update(newDataOne, oldDataOne);
    dispatchable.execute();
    assertEquals(1, joinExecutionStrategy.getLastNewDataPerStream()[0].length);
    assertEquals(1, joinExecutionStrategy.getLastNewDataPerStream()[1].length);
    assertSame(newDataTwo[0], joinExecutionStrategy.getLastNewDataPerStream()[0][0]);
    assertSame(oldDataTwo[0], joinExecutionStrategy.getLastOldDataPerStream()[0][0]);
    assertSame(newDataOne[0], joinExecutionStrategy.getLastNewDataPerStream()[1][0]);
    assertSame(oldDataOne[0], joinExecutionStrategy.getLastOldDataPerStream()[1][0]);
}

3. TestUpdateDispatchView#testUpdateTwiceAndDispatch()

Project: esper
File: TestUpdateDispatchView.java
public void testUpdateTwiceAndDispatch() {
    EventBean[] oldDataOne = makeEvents("old1");
    EventBean[] newDataOne = makeEvents("new1");
    updateDispatchView.newResult(new UniformPair<EventBean[]>(newDataOne, oldDataOne));
    EventBean[] oldDataTwo = makeEvents("old2");
    EventBean[] newDataTwo = makeEvents("new2");
    updateDispatchView.newResult(new UniformPair<EventBean[]>(newDataTwo, oldDataTwo));
    assertFalse(listenerOne.isInvoked() || listenerTwo.isInvoked());
    dispatchService.dispatch();
    assertTrue(listenerOne.isInvoked() && listenerTwo.isInvoked());
    assertTrue(listenerOne.getLastNewData()[1] == newDataTwo[0]);
    assertTrue(listenerTwo.getLastOldData()[1] == oldDataTwo[0]);
}

4. SupportStmtAwareUpdateListener#flatten()

Project: esper
File: SupportStmtAwareUpdateListener.java
private EventBean[] flatten(List<EventBean[]> list) {
    int count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            count += events.length;
        }
    }
    EventBean[] array = new EventBean[count];
    count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            for (int i = 0; i < events.length; i++) {
                array[count++] = events[i];
            }
        }
    }
    return array;
}

5. SupportMTUpdateListener#flatten()

Project: esper
File: SupportMTUpdateListener.java
private EventBean[] flatten(List<EventBean[]> list) {
    int count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            count += events.length;
        }
    }
    EventBean[] array = new EventBean[count];
    count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            for (int i = 0; i < events.length; i++) {
                array[count++] = events[i];
            }
        }
    }
    return array;
}

6. ResultSetProcessorUtil#getSelectEventsNoHavingWithOrderBy()

Project: esper
File: ResultSetProcessorUtil.java
/**
     * Applies the select-clause to the given events returning the selected events. The number of events stays the
     * same, i.e. this method does not filter it just transforms the result set.
     * @param exprProcessor - processes each input event and returns output event
     * @param orderByProcessor - orders the outgoing events according to the order-by clause
     * @param events - input events
     * @param isNewData - indicates whether we are dealing with new data (istream) or old data (rstream)
     * @param isSynthesize - set to true to indicate that synthetic events are required for an iterator result set
     * @param exprEvaluatorContext context for expression evalauation
     * @return output events, one for each input event
     */
protected static EventBean[] getSelectEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, boolean isNewData, boolean isSynthesize, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return null;
    }
    EventBean[] result = new EventBean[events.length];
    EventBean[][] eventGenerators = new EventBean[events.length][];
    EventBean[] eventsPerStream = new EventBean[1];
    for (int i = 0; i < events.length; i++) {
        eventsPerStream[0] = events[i];
        result[i] = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        eventGenerators[i] = new EventBean[] { events[i] };
    }
    return orderByProcessor.sort(result, eventGenerators, isNewData, exprEvaluatorContext);
}

7. TestEventBeanUtility#testAppend()

Project: esper
File: TestEventBeanUtility.java
public void testAppend() {
    EventBean[] setOne = makeEventArray(new String[] { "a1", "a2" });
    EventBean[] setTwo = makeEventArray(new String[] { "b1", "b2", "b3" });
    EventBean[] total = EventBeanUtility.append(setOne, setTwo);
    assertEquals(setOne[0], total[0]);
    assertEquals(setOne[1], total[1]);
    assertEquals(setTwo[0], total[2]);
    assertEquals(setTwo[1], total[3]);
    assertEquals(setTwo[2], total[4]);
    setOne = makeEventArray(new String[] { "a1" });
    setTwo = makeEventArray(new String[] { "b1" });
    total = EventBeanUtility.append(setOne, setTwo);
    assertEquals(setOne[0], total[0]);
    assertEquals(setTwo[0], total[1]);
}

8. TestNestedIterationExecNode#testLookup()

Project: esper
File: TestNestedIterationExecNode.java
public void testLookup() {
    List<EventBean[]> result = new LinkedList<EventBean[]>();
    EventBean[] prefill = new EventBean[4];
    prefill[2] = streamEvents[2][0];
    exec.process(streamEvents[2][0], prefill, result, null);
    assertEquals(8, result.size());
    EventBean[][] received = makeArray(result);
    EventBean[][] expected = makeExpected();
    EPAssertionUtil.assertEqualsAnyOrder(expected, received);
}

9. TestSingleOptionalAssemblyNode#testChildResult()

Project: esper
File: TestSingleOptionalAssemblyNode.java
protected static void testChildResult(BaseAssemblyNode nodeUnderTest, SupportJoinProcNode mockParentNode) {
    EventBean[] childRow = new EventBean[4];
    childRow[3] = SupportJoinResultNodeFactory.makeEvent();
    EventBean myEvent = SupportJoinResultNodeFactory.makeEvent();
    Node myNode = SupportJoinResultNodeFactory.makeNode(3, 1);
    // indicate child result
    List<EventBean[]> resultFinalRows = new ArrayList<EventBean[]>();
    nodeUnderTest.result(childRow, 3, myEvent, myNode, resultFinalRows, null);
    // assert parent node got the row
    assertEquals(1, mockParentNode.getRowsList().size());
    EventBean[] resultRow = mockParentNode.getRowsList().get(0);
    // assert the node has added his event to the row
    assertEquals(myEvent, resultRow[1]);
}

10. TestSingleOptionalAssemblyNode#testProcessMultipleEvents()

Project: esper
File: TestSingleOptionalAssemblyNode.java
public void testProcessMultipleEvents() {
    List<EventBean[]> resultFinalRows = new ArrayList<EventBean[]>();
    optAssemblyNode.init(resultMultipleEvents);
    // generate an event row originating from a child for 1 of the 2 events in the result
    EventBean[] childRow = new EventBean[4];
    Node nodeOne = resultMultipleEvents[1].get(0);
    EventBean eventOne = nodeOne.getEvents().iterator().next();
    optAssemblyNode.result(childRow, 3, eventOne, nodeOne, resultFinalRows, null);
    // test that the node indeed manufactures event rows for any event not received from a child
    parentNode.getRowsList().clear();
    optAssemblyNode.process(resultMultipleEvents, resultFinalRows, null);
    // check generated row
    assertEquals(1, parentNode.getRowsList().size());
    EventBean[] row = parentNode.getRowsList().get(0);
    assertEquals(4, row.length);
    Node nodeTwo = resultMultipleEvents[1].get(1);
    assertEquals(nodeTwo.getEvents().iterator().next(), row[1]);
}

11. SupportUpdateListener#flatten()

Project: esper
File: SupportUpdateListener.java
private EventBean[] flatten(List<EventBean[]> list) {
    int count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            count += events.length;
        }
    }
    EventBean[] array = new EventBean[count];
    count = 0;
    for (EventBean[] events : list) {
        if (events != null) {
            for (int i = 0; i < events.length; i++) {
                array[count++] = events[i];
            }
        }
    }
    return array;
}

12. WrapperEventBeanCopyMethod#copy()

Project: esper
File: WrapperEventBeanCopyMethod.java
public EventBean copy(EventBean theEvent) {
    DecoratingEventBean decorated = (DecoratingEventBean) theEvent;
    EventBean decoratedUnderlying = decorated.getUnderlyingEvent();
    EventBean copiedUnderlying = underlyingCopyMethod.copy(decoratedUnderlying);
    if (copiedUnderlying == null) {
        return null;
    }
    Map<String, Object> copiedMap = new HashMap<String, Object>(decorated.getDecoratingProperties());
    return eventAdapterService.adapterForTypedWrapper(copiedUnderlying, copiedMap, wrapperEventType);
}

13. EventBeanUtility#addToArray()

Project: esper
File: EventBeanUtility.java
/**
     * Expand the array passed in by the multiple elements to add.
     * @param array to expand
     * @param eventsToAdd elements to add
     * @return resized array
     */
public static EventBean[] addToArray(EventBean[] array, Collection<EventBean> eventsToAdd) {
    EventBean[] newArray = new EventBean[array.length + eventsToAdd.size()];
    System.arraycopy(array, 0, newArray, 0, array.length);
    int counter = array.length;
    for (EventBean eventToAdd : eventsToAdd) {
        newArray[counter++] = eventToAdd;
    }
    return newArray;
}

14. OutputStrategyUtil#output()

Project: esper
File: OutputStrategyUtil.java
public static void output(boolean forceUpdate, UniformPair<EventBean[]> result, UpdateDispatchView finalView) {
    EventBean[] newEvents = result != null ? result.getFirst() : null;
    EventBean[] oldEvents = result != null ? result.getSecond() : null;
    if (newEvents != null || oldEvents != null) {
        finalView.newResult(result);
    } else if (forceUpdate) {
        finalView.newResult(result);
    }
}

15. FilterExprView#update()

Project: esper
File: FilterExprView.java
public void update(EventBean[] newData, EventBean[] oldData) {
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().qWhereClauseFilter(exprNode, newData, oldData);
    }
    EventBean[] filteredNewData = filterEvents(exprEvaluator, newData, true, exprEvaluatorContext);
    EventBean[] filteredOldData = filterEvents(exprEvaluator, oldData, false, exprEvaluatorContext);
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().aWhereClauseFilter(filteredNewData, filteredOldData);
    }
    if ((filteredNewData != null) || (filteredOldData != null)) {
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().qWhereClauseIR(filteredNewData, filteredOldData);
        }
        this.updateChildren(filteredNewData, filteredOldData);
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().aWhereClauseIR();
        }
    }
}

16. SubselectAggregationPreprocessorUnfilteredUngrouped#evaluate()

Project: esper
File: SubselectAggregationPreprocessorUnfilteredUngrouped.java
public void evaluate(EventBean[] eventsPerStream, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext) {
    aggregationService.clearResults(exprEvaluatorContext);
    if (matchingEvents == null) {
        return;
    }
    EventBean[] events = new EventBean[eventsPerStream.length + 1];
    System.arraycopy(eventsPerStream, 0, events, 1, eventsPerStream.length);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        aggregationService.applyEnter(events, null, exprEvaluatorContext);
    }
}

17. SubselectAggregationPreprocessorUnfilteredGrouped#evaluate()

Project: esper
File: SubselectAggregationPreprocessorUnfilteredGrouped.java
public void evaluate(EventBean[] eventsPerStream, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext) {
    aggregationService.clearResults(exprEvaluatorContext);
    if (matchingEvents == null) {
        return;
    }
    EventBean[] events = new EventBean[eventsPerStream.length + 1];
    System.arraycopy(eventsPerStream, 0, events, 1, eventsPerStream.length);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Object groupKey = generateGroupKey(events, true, exprEvaluatorContext);
        aggregationService.applyEnter(events, groupKey, exprEvaluatorContext);
    }
}

18. SubselectAggregationPreprocessorFilteredUngrouped#evaluate()

Project: esper
File: SubselectAggregationPreprocessorFilteredUngrouped.java
public void evaluate(EventBean[] eventsPerStream, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext) {
    aggregationService.clearResults(exprEvaluatorContext);
    if (matchingEvents == null) {
        return;
    }
    EventBean[] events = new EventBean[eventsPerStream.length + 1];
    System.arraycopy(eventsPerStream, 0, events, 1, eventsPerStream.length);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) filterExpr.evaluate(events, true, exprEvaluatorContext);
        if ((pass != null) && (pass)) {
            aggregationService.applyEnter(events, null, exprEvaluatorContext);
        }
    }
}

19. SubselectAggregationPreprocessorFilteredGrouped#evaluate()

Project: esper
File: SubselectAggregationPreprocessorFilteredGrouped.java
public void evaluate(EventBean[] eventsPerStream, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext) {
    aggregationService.clearResults(exprEvaluatorContext);
    if (matchingEvents == null) {
        return;
    }
    EventBean[] events = new EventBean[eventsPerStream.length + 1];
    System.arraycopy(eventsPerStream, 0, events, 1, eventsPerStream.length);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) filterExpr.evaluate(events, true, exprEvaluatorContext);
        if ((pass != null) && (pass)) {
            Object groupKey = generateGroupKey(events, true, exprEvaluatorContext);
            aggregationService.applyEnter(events, groupKey, exprEvaluatorContext);
        }
    }
}

20. ExcludePlanHint#filter()

Project: esper
File: ExcludePlanHint.java
public boolean filter(int streamLookup, int streamIndexed, ExcludePlanFilterOperatorType opType, ExprNode... exprNodes) {
    EventBean event = ExcludePlanHintExprUtil.toEvent(streamLookup, streamIndexed, streamNames[streamLookup], streamNames[streamIndexed], opType.name().toLowerCase(), exprNodes);
    if (queryPlanLogging && queryPlanLog.isInfoEnabled()) {
        queryPlanLog.info("Exclude-plan-hint combination " + EventBeanUtility.printEvent(event));
    }
    EventBean[] eventsPerStream = new EventBean[] { event };
    for (ExprEvaluator evaluator : evaluators) {
        Boolean pass = (Boolean) evaluator.evaluate(eventsPerStream, true, exprEvaluatorContext);
        if (pass != null && pass) {
            if (queryPlanLogging && queryPlanLog.isInfoEnabled()) {
                queryPlanLog.info("Exclude-plan-hint combination : true");
            }
            return true;
        }
    }
    if (queryPlanLogging && queryPlanLog.isInfoEnabled()) {
        queryPlanLog.info("Exclude-plan-hint combination : false");
    }
    return false;
}

21. JoinExecStrategyDispatchable#execute()

Project: esper
File: JoinExecStrategyDispatchable.java
public void execute() {
    if (!hasNewData) {
        return;
    }
    hasNewData = false;
    EventBean[][] oldDataPerStream = new EventBean[numStreams][];
    EventBean[][] newDataPerStream = new EventBean[numStreams][];
    for (int i = 0; i < numStreams; i++) {
        oldDataPerStream[i] = getBufferData(oldStreamBuffer.get(i));
        newDataPerStream[i] = getBufferData(newStreamBuffer.get(i));
    }
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().qJoinDispatch(newDataPerStream, oldDataPerStream);
    }
    joinExecutionStrategy.join(newDataPerStream, oldDataPerStream);
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().aJoinDispatch();
    }
}

22. ExprSubselectRowNodeUtility#evaluateFilterExpectSingleMatch()

Project: esper
File: ExprSubselectRowNodeUtility.java
public static EventBean evaluateFilterExpectSingleMatch(EventBean[] eventsZeroSubselect, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean subSelectResult = null;
    for (EventBean subselectEvent : matchingEvents) {
        // Prepare filter expression event list
        eventsZeroSubselect[0] = subselectEvent;
        Boolean pass = (Boolean) parent.filterExpr.evaluate(eventsZeroSubselect, newData, exprEvaluatorContext);
        if ((pass != null) && (pass)) {
            if (subSelectResult != null) {
                log.warn(parent.getMultirowMessage());
                return null;
            }
            subSelectResult = subselectEvent;
        }
    }
    return subSelectResult;
}

23. ExprSubselectRowEvalStrategyUnfilteredSelected#typableEvaluateMultirow()

Project: esper
File: ExprSubselectRowEvalStrategyUnfilteredSelected.java
// No filter and with select clause
public Object[][] typableEvaluateMultirow(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    Object[][] rows = new Object[matchingEvents.size()][];
    int index = -1;
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (EventBean matchingEvent : matchingEvents) {
        index++;
        events[0] = matchingEvent;
        Object[] results = new Object[parent.selectClauseEvaluator.length];
        for (int i = 0; i < results.length; i++) {
            results[i] = parent.selectClauseEvaluator[i].evaluate(events, isNewData, exprEvaluatorContext);
        }
        rows[index] = results;
    }
    return rows;
}

24. ExprSubselectRowEvalStrategyFilteredUnselected#evaluateGetCollEvents()

Project: esper
File: ExprSubselectRowEvalStrategyFilteredUnselected.java
// Filter and no-select
public Collection<EventBean> evaluateGetCollEvents(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    ArrayDeque<EventBean> filtered = null;
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) parent.filterExpr.evaluate(events, true, context);
        if ((pass != null) && (pass)) {
            if (filtered == null) {
                filtered = new ArrayDeque<EventBean>();
            }
            filtered.add(subselectEvent);
        }
    }
    return filtered;
}

25. ExprSubselectRowEvalStrategyFilteredSelected#typableEvaluate()

Project: esper
File: ExprSubselectRowEvalStrategyFilteredSelected.java
// Filter and Select
public Object[] typableEvaluate(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(events, isNewData, matchingEvents, exprEvaluatorContext, parent);
    if (subSelectResult == null) {
        return null;
    }
    events[0] = subSelectResult;
    Object[] results = new Object[parent.selectClauseEvaluator.length];
    for (int i = 0; i < results.length; i++) {
        results[i] = parent.selectClauseEvaluator[i].evaluate(events, isNewData, exprEvaluatorContext);
    }
    return results;
}

26. ExprSubselectRowEvalStrategyFilteredSelected#evaluateGetCollScalar()

Project: esper
File: ExprSubselectRowEvalStrategyFilteredSelected.java
// Filter and Select
public Collection evaluateGetCollScalar(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    List<Object> result = new ArrayList<Object>();
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) parent.filterExpr.evaluate(events, true, context);
        if ((pass != null) && (pass)) {
            result.add(parent.selectClauseEvaluator[0].evaluate(events, isNewData, context));
        }
    }
    return result;
}

27. ExprSubselectRowEvalStrategyFilteredSelected#evaluate()

Project: esper
File: ExprSubselectRowEvalStrategyFilteredSelected.java
// Filter and Select
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] eventsZeroBased = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(eventsZeroBased, newData, matchingEvents, exprEvaluatorContext, parent);
    if (subSelectResult == null) {
        return null;
    }
    eventsZeroBased[0] = subSelectResult;
    Object result;
    if (parent.selectClauseEvaluator.length == 1) {
        result = parent.selectClauseEvaluator[0].evaluate(eventsZeroBased, true, exprEvaluatorContext);
    } else {
        // we are returning a Map here, not object-array, preferring the self-describing structure
        result = parent.evaluateRow(eventsZeroBased, true, exprEvaluatorContext);
    }
    return result;
}

28. ExprPriorEvalStrategyBase#evaluate()

Project: esper
File: ExprPriorEvalStrategyBase.java
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext exprEvaluatorContext, int streamNumber, ExprEvaluator evaluator, int constantIndexNumber) {
    EventBean originalEvent = eventsPerStream[streamNumber];
    EventBean substituteEvent = getSubstituteEvent(originalEvent, isNewData, constantIndexNumber);
    // Substitute original event with prior event, evaluate inner expression
    eventsPerStream[streamNumber] = substituteEvent;
    Object evalResult = evaluator.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
    eventsPerStream[streamNumber] = originalEvent;
    return evalResult;
}

29. ExprPreviousMatchRecognizeNode#evaluate()

Project: esper
File: ExprPreviousMatchRecognizeNode.java
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext exprEvaluatorContext) {
    RegexPartitionStateRandomAccess access = strategy.getAccess(exprEvaluatorContext);
    EventBean substituteEvent = access.getPreviousEvent(assignedIndex);
    if (substituteEvent == null) {
        return null;
    }
    // Substitute original event with prior event, evaluate inner expression
    EventBean originalEvent = eventsPerStream[streamNumber];
    eventsPerStream[streamNumber] = substituteEvent;
    Object evalResult = evaluator.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
    eventsPerStream[streamNumber] = originalEvent;
    return evalResult;
}

30. ExprPreviousEvalStrategyPrev#evaluate()

Project: esper
File: ExprPreviousEvalStrategyPrev.java
public Object evaluate(EventBean[] eventsPerStream, ExprEvaluatorContext exprEvaluatorContext) {
    EventBean substituteEvent = getSubstitute(eventsPerStream, exprEvaluatorContext);
    if (substituteEvent == null) {
        return null;
    }
    // Substitute original event with prior event, evaluate inner expression
    EventBean originalEvent = eventsPerStream[streamNumber];
    eventsPerStream[streamNumber] = substituteEvent;
    Object evalResult = evalNode.evaluate(eventsPerStream, true, exprEvaluatorContext);
    eventsPerStream[streamNumber] = originalEvent;
    return evalResult;
}

31. ExprStreamUnderlyingNodeImpl#evaluate()

Project: esper
File: ExprStreamUnderlyingNodeImpl.java
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext exprEvaluatorContext) {
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().qExprStreamUnd(this);
    }
    EventBean theEvent = eventsPerStream[streamNum];
    if (theEvent == null) {
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().aExprStreamUnd(null);
        }
        return null;
    }
    if (InstrumentationHelper.ENABLED) {
        InstrumentationHelper.get().aExprStreamUnd(theEvent.getUnderlying());
    }
    return theEvent.getUnderlying();
}

32. ExprNodeUtility#applyFilterExpressionsIterable()

Project: esper
File: ExprNodeUtility.java
public static void applyFilterExpressionsIterable(Iterable<EventBean> iterable, List<ExprNode> filterExpressions, ExprEvaluatorContext exprEvaluatorContext, Collection<EventBean> eventsInWindow) {
    ExprEvaluator[] evaluators = ExprNodeUtility.getEvaluators(filterExpressions);
    EventBean[] events = new EventBean[1];
    for (EventBean theEvent : iterable) {
        events[0] = theEvent;
        boolean add = true;
        for (ExprEvaluator filter : evaluators) {
            Object result = filter.evaluate(events, true, exprEvaluatorContext);
            if ((result == null) || (!((Boolean) result))) {
                add = false;
                break;
            }
        }
        if (add) {
            eventsInWindow.add(events[0]);
        }
    }
}

33. ResultSetProcessorUtil#populateSelectEventsHavingWithOrderBy()

Project: esper
File: ResultSetProcessorUtil.java
protected static void populateSelectEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, ExprEvaluator havingNode, boolean isNewData, boolean isSynthesize, List<EventBean> result, List<Object> optSortKeys, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return;
    }
    EventBean[] eventsPerStream = new EventBean[1];
    for (EventBean theEvent : events) {
        eventsPerStream[0] = theEvent;
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().qHavingClauseNonJoin(theEvent);
        }
        Boolean passesHaving = (Boolean) havingNode.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().aHavingClauseNonJoin(passesHaving);
        }
        if ((passesHaving == null) || (!passesHaving)) {
            continue;
        }
        EventBean resultEvent = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        if (resultEvent != null) {
            result.add(resultEvent);
            optSortKeys.add(orderByProcessor.getSortKey(eventsPerStream, isNewData, exprEvaluatorContext));
        }
    }
}

34. ResultSetProcessorUtil#populateSelectEventsHaving()

Project: esper
File: ResultSetProcessorUtil.java
protected static void populateSelectEventsHaving(SelectExprProcessor exprProcessor, EventBean[] events, ExprEvaluator havingNode, boolean isNewData, boolean isSynthesize, List<EventBean> result, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return;
    }
    EventBean[] eventsPerStream = new EventBean[1];
    for (EventBean theEvent : events) {
        eventsPerStream[0] = theEvent;
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().qHavingClauseNonJoin(theEvent);
        }
        Boolean passesHaving = (Boolean) havingNode.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
        if (InstrumentationHelper.ENABLED) {
            InstrumentationHelper.get().aHavingClauseNonJoin(passesHaving);
        }
        if ((passesHaving == null) || (!passesHaving)) {
            continue;
        }
        EventBean resultEvent = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        if (resultEvent != null) {
            result.add(resultEvent);
        }
    }
}

35. ResultSetProcessorUtil#populateSelectEventsNoHavingWithOrderBy()

Project: esper
File: ResultSetProcessorUtil.java
protected static void populateSelectEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, boolean isNewData, boolean isSynthesize, Collection<EventBean> result, List<Object> sortKeys, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return;
    }
    EventBean[] eventsPerStream = new EventBean[1];
    for (EventBean theEvent : events) {
        eventsPerStream[0] = theEvent;
        EventBean resultEvent = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        if (resultEvent != null) {
            result.add(resultEvent);
            sortKeys.add(orderByProcessor.getSortKey(eventsPerStream, isNewData, exprEvaluatorContext));
        }
    }
}

36. ResultSetProcessorUtil#populateSelectEventsNoHaving()

Project: esper
File: ResultSetProcessorUtil.java
protected static void populateSelectEventsNoHaving(SelectExprProcessor exprProcessor, EventBean[] events, boolean isNewData, boolean isSynthesize, Collection<EventBean> result, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return;
    }
    EventBean[] eventsPerStream = new EventBean[1];
    for (EventBean theEvent : events) {
        eventsPerStream[0] = theEvent;
        EventBean resultEvent = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        if (resultEvent != null) {
            result.add(resultEvent);
        }
    }
}

37. ResultSetProcessorUtil#getSelectJoinEventsNoHavingWithOrderBy()

Project: esper
File: ResultSetProcessorUtil.java
/**
     * Applies the select-clause to the given events returning the selected events. The number of events stays the
     * same, i.e. this method does not filter it just transforms the result set.
     * @param exprProcessor - processes each input event and returns output event
     * @param orderByProcessor - for sorting output events according to the order-by clause
     * @param events - input events
     * @param isNewData - indicates whether we are dealing with new data (istream) or old data (rstream)
     * @param isSynthesize - set to true to indicate that synthetic events are required for an iterator result set
     * @param exprEvaluatorContext context for expression evalauation
     * @return output events, one for each input event
     */
protected static EventBean[] getSelectJoinEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, Set<MultiKey<EventBean>> events, boolean isNewData, boolean isSynthesize, ExprEvaluatorContext exprEvaluatorContext) {
    if ((events == null) || (events.isEmpty())) {
        return null;
    }
    EventBean[] result = new EventBean[events.size()];
    EventBean[][] eventGenerators = new EventBean[events.size()][];
    int count = 0;
    for (MultiKey<EventBean> key : events) {
        EventBean[] eventsPerStream = key.getArray();
        result[count] = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
        eventGenerators[count] = eventsPerStream;
        count++;
    }
    return orderByProcessor.sort(result, eventGenerators, isNewData, exprEvaluatorContext);
}

38. TestWrapperEventBean#setUp()

Project: esper
File: TestWrapperEventBean.java
protected void setUp() {
    eventService = SupportEventAdapterService.getService();
    EventType underlyingEventTypeSimple = eventService.addBeanType("underlyingSimpleBean", SupportBeanSimple.class, true, true, true);
    EventType underlyingEventTypeCombined = eventService.addBeanType("underlyingCombinedBean", SupportBeanCombinedProps.class, true, true, true);
    Map<String, Object> typeMap = new HashMap<String, Object>();
    typeMap.put("string", String.class);
    typeMap.put("int", Integer.class);
    EventTypeMetadata meta = EventTypeMetadata.createWrapper("test", true, false, false);
    eventTypeSimple = new WrapperEventType(meta, "mytype", 1, underlyingEventTypeSimple, typeMap, eventService);
    eventTypeCombined = new WrapperEventType(meta, "mytype", 1, underlyingEventTypeCombined, typeMap, eventService);
    properties = new HashMap<String, Object>();
    properties.put("string", "xx");
    properties.put("int", 11);
    EventBean wrappedSimple = eventService.adapterForBean(new SupportBeanSimple("eventString", 0));
    eventBeanSimple = eventService.adapterForTypedWrapper(wrappedSimple, properties, eventTypeSimple);
    EventBean wrappedCombined = eventService.adapterForBean(SupportBeanCombinedProps.makeDefaultBean());
    eventBeanCombined = eventService.adapterForTypedWrapper(wrappedCombined, properties, eventTypeCombined);
}

39. TestJoinSetFilter#testFilter()

Project: esper
File: TestJoinSetFilter.java
public void testFilter() throws Exception {
    ExprNode topNode = SupportExprNodeFactory.make2SubNodeAnd();
    EventBean[] pairOne = new EventBean[2];
    pairOne[0] = makeEvent(1, 2, "a");
    pairOne[1] = makeEvent(2, 1, "a");
    EventBean[] pairTwo = new EventBean[2];
    pairTwo[0] = makeEvent(1, 2, "a");
    pairTwo[1] = makeEvent(2, 999, "a");
    Set<MultiKey<EventBean>> eventSet = new HashSet<MultiKey<EventBean>>();
    eventSet.add(new MultiKey<EventBean>(pairOne));
    eventSet.add(new MultiKey<EventBean>(pairTwo));
    JoinSetFilter.filter(topNode.getExprEvaluator(), eventSet, true, null);
    assertEquals(1, eventSet.size());
    assertSame(pairOne, eventSet.iterator().next().getArray());
}

40. TestSelectExprJoinWildcardProcessor#testProcess()

Project: esper
File: TestSelectExprJoinWildcardProcessor.java
public void testProcess() {
    EventBean[] testEvents = SupportStreamTypeSvc3Stream.getSampleEvents();
    EventBean result = processor.process(testEvents, true, false, null);
    assertEquals(testEvents[0].getUnderlying(), result.get("s0"));
    assertEquals(testEvents[1].getUnderlying(), result.get("s1"));
    // Test null events, such as in an outer join
    testEvents[1] = null;
    result = processor.process(testEvents, true, false, null);
    assertEquals(testEvents[0].getUnderlying(), result.get("s0"));
    assertNull(result.get("s1"));
}

41. TestSelectExprEvalProcessor#testProcess()

Project: esper
File: TestSelectExprEvalProcessor.java
public void testProcess() throws Exception {
    EventBean[] events = new EventBean[] { makeEvent(8.8, 3, 4) };
    EventBean result = methodOne.getEvaluator().process(events, true, false, null);
    assertEquals(8.8d, result.get("resultOne"));
    assertEquals(12, result.get("resultTwo"));
    result = methodTwo.getEvaluator().process(events, true, false, null);
    assertEquals(8.8d, result.get("a"));
    assertEquals(12, result.get("b"));
    assertSame(result.getEventType(), methodTwo.getEvaluator().getResultEventType());
}

42. TestResultSetProcessorRowPerGroup#testProcess()

Project: esper
File: TestResultSetProcessorRowPerGroup.java
public void testProcess() {
    EventBean[] newData = new EventBean[] { makeEvent(1, 2), makeEvent(3, 4) };
    EventBean[] oldData = new EventBean[] { makeEvent(1, 2), makeEvent(1, 10) };
    UniformPair<EventBean[]> result = processor.processViewResult(newData, oldData, false);
    assertEquals(2, supportAggregationService.getEnterList().size());
    assertEquals(2, supportAggregationService.getLeaveList().size());
    assertEquals(3, result.getFirst().length);
    assertEquals(3, result.getSecond().length);
}

43. TestUpdateDispatchView#testUpdateOnceAndDispatch()

Project: esper
File: TestUpdateDispatchView.java
public void testUpdateOnceAndDispatch() {
    EventBean[] oldData = makeEvents("old");
    EventBean[] newData = makeEvents("new");
    updateDispatchView.newResult(new UniformPair<EventBean[]>(newData, oldData));
    assertFalse(listenerOne.isInvoked() || listenerTwo.isInvoked());
    dispatchService.dispatch();
    assertTrue(listenerOne.isInvoked() && listenerTwo.isInvoked());
    assertTrue(listenerOne.getLastNewData()[0] == newData[0]);
    assertTrue(listenerTwo.getLastOldData()[0] == oldData[0]);
}

44. TestRollingEventBuffer#testFlowSizeOne()

Project: esper
File: TestRollingEventBuffer.java
public void testFlowSizeOne() {
    bufferOne.add((EventBean[]) null);
    assertNull(bufferOne.get(0));
    EventBean[] set1 = make(2);
    bufferOne.add(set1);
    assertSame(set1[1], bufferOne.get(0));
    tryInvalid(bufferOne, 1);
    EventBean[] set2 = make(1);
    bufferOne.add(set2);
    assertSame(set2[0], bufferOne.get(0));
    tryInvalid(bufferOne, 1);
}

45. OneEventCollection#toArray()

Project: esper
File: OneEventCollection.java
/**
     * Returns an array holding the collected events.
     * @return event array
     */
public EventBean[] toArray() {
    if (firstEvent == null) {
        return new EventBean[0];
    }
    if (additionalEvents == null) {
        return new EventBean[] { firstEvent };
    }
    EventBean[] events = new EventBean[1 + additionalEvents.size()];
    events[0] = firstEvent;
    int count = 1;
    for (EventBean theEvent : additionalEvents) {
        events[count] = theEvent;
        count++;
    }
    return events;
}

46. SupportUpdateListener#assertPairGetIRAndReset()

Project: esper
File: SupportUpdateListener.java
/**
     * Asserts that exactly one insert stream event and exactly one remove stream event was received, resets the listener clearing all state and returns the received events as a pair.
     * @return pair of insert-stream and remove-stream events
     */
public synchronized UniformPair<EventBean> assertPairGetIRAndReset() {
    ScopeTestHelper.assertTrue("Listener invocation not received but expected", isInvoked);
    ScopeTestHelper.assertEquals("Mismatch in the number of invocations", 1, newDataList.size());
    ScopeTestHelper.assertEquals("Mismatch in the number of invocations", 1, oldDataList.size());
    if (lastNewData == null) {
        ScopeTestHelper.fail("No new-data events received");
    }
    if (lastOldData == null) {
        ScopeTestHelper.fail("No old-data events received");
    }
    ScopeTestHelper.assertEquals("Mismatch in the number of new-data events", 1, lastNewData.length);
    ScopeTestHelper.assertEquals("Mismatch in the number of old-data events", 1, lastOldData.length);
    EventBean lastNew = lastNewData[0];
    EventBean lastOld = lastOldData[0];
    reset();
    return new UniformPair<EventBean>(lastNew, lastOld);
}

47. ResultSetProcessorUtil#getSelectEventsNoHaving()

Project: esper
File: ResultSetProcessorUtil.java
/**
     * Applies the select-clause to the given events returning the selected events. The number of events stays the
     * same, i.e. this method does not filter it just transforms the result set.
     * @param exprProcessor - processes each input event and returns output event
     * @param events - input events
     * @param isNewData - indicates whether we are dealing with new data (istream) or old data (rstream)
     * @param isSynthesize - set to true to indicate that synthetic events are required for an iterator result set
     * @param exprEvaluatorContext context for expression evalauation
     * @return output events, one for each input event
     */
protected static EventBean[] getSelectEventsNoHaving(SelectExprProcessor exprProcessor, EventBean[] events, boolean isNewData, boolean isSynthesize, ExprEvaluatorContext exprEvaluatorContext) {
    if (events == null) {
        return null;
    }
    EventBean[] result = new EventBean[events.length];
    EventBean[] eventsPerStream = new EventBean[1];
    for (int i = 0; i < events.length; i++) {
        eventsPerStream[0] = events[i];
        result[i] = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
    }
    return result;
}

48. ResultSetProcessorRowPerGroupRollup#convertToArrayMaySort()

Project: esper
File: ResultSetProcessorRowPerGroupRollup.java
private UniformPair<EventBean[]> convertToArrayMaySort(List<EventBean> newEvents, List<Object> newEventsSortKey, List<EventBean> oldEvents, List<Object> oldEventsSortKey) {
    EventBean[] newEventsArr = (newEvents.isEmpty()) ? null : newEvents.toArray(new EventBean[newEvents.size()]);
    EventBean[] oldEventsArr = null;
    if (prototype.isSelectRStream()) {
        oldEventsArr = (oldEvents.isEmpty()) ? null : oldEvents.toArray(new EventBean[oldEvents.size()]);
    }
    if (orderByProcessor != null) {
        Object[] sortKeysNew = (newEventsSortKey.isEmpty()) ? null : newEventsSortKey.toArray(new Object[newEventsSortKey.size()]);
        newEventsArr = orderByProcessor.sort(newEventsArr, sortKeysNew, agentInstanceContext);
        if (prototype.isSelectRStream()) {
            Object[] sortKeysOld = (oldEventsSortKey.isEmpty()) ? null : oldEventsSortKey.toArray(new Object[oldEventsSortKey.size()]);
            oldEventsArr = orderByProcessor.sort(oldEventsArr, sortKeysOld, agentInstanceContext);
        }
    }
    if ((newEventsArr == null) && (oldEventsArr == null)) {
        return null;
    }
    return new UniformPair<EventBean[]>(newEventsArr, oldEventsArr);
}

49. ResultSetProcessorRowPerGroupOutputLastHelperImpl#output()

Project: esper
File: ResultSetProcessorRowPerGroupOutputLastHelperImpl.java
private UniformPair<EventBean[]> output(boolean isSynthesize, boolean join) {
    List<EventBean> newEvents = new ArrayList<EventBean>(4);
    processor.generateOutputBatchedArr(join, groupReps.entrySet().iterator(), true, isSynthesize, newEvents, null);
    groupReps.clear();
    EventBean[] newEventsArr = (newEvents.isEmpty()) ? null : newEvents.toArray(new EventBean[newEvents.size()]);
    EventBean[] oldEventsArr = null;
    if (groupRepsOutputLastUnordRStream != null && !groupRepsOutputLastUnordRStream.isEmpty()) {
        Collection<EventBean> oldEvents = groupRepsOutputLastUnordRStream.values();
        oldEventsArr = oldEvents.toArray(new EventBean[oldEvents.size()]);
    }
    if (newEventsArr == null && oldEventsArr == null) {
        return null;
    }
    return new UniformPair<EventBean[]>(newEventsArr, oldEventsArr);
}

50. ResultSetProcessorRowPerGroupOutputAllHelperImpl#output()

Project: esper
File: ResultSetProcessorRowPerGroupOutputAllHelperImpl.java
private UniformPair<EventBean[]> output(boolean isSynthesize, boolean join) {
    // generate latest new-events from group representatives
    List<EventBean> newEvents = new ArrayList<EventBean>(4);
    processor.generateOutputBatchedArr(join, groupReps.entrySet().iterator(), true, isSynthesize, newEvents, null);
    EventBean[] newEventsArr = (newEvents.isEmpty()) ? null : newEvents.toArray(new EventBean[newEvents.size()]);
    // use old-events as retained, if any
    EventBean[] oldEventsArr = null;
    if (!groupRepsOutputLastUnordRStream.isEmpty()) {
        Collection<EventBean> oldEvents = groupRepsOutputLastUnordRStream.values();
        oldEventsArr = oldEvents.toArray(new EventBean[oldEvents.size()]);
        groupRepsOutputLastUnordRStream.clear();
    }
    first = true;
    if (newEventsArr == null && oldEventsArr == null) {
        return null;
    }
    return new UniformPair<EventBean[]>(newEventsArr, oldEventsArr);
}

51. ResultSetProcessorRowForAllOutputAllHelperImpl#output()

Project: esper
File: ResultSetProcessorRowForAllOutputAllHelperImpl.java
private UniformPair<EventBean[]> output(boolean isGenerateSynthetic, boolean isJoin) {
    EventBean[] oldEvents = EventBeanUtility.toArrayNullIfEmpty(eventsOld);
    EventBean[] newEvents = EventBeanUtility.toArrayNullIfEmpty(eventsNew);
    if (newEvents == null) {
        newEvents = processor.getSelectListEvents(true, isGenerateSynthetic, isJoin);
    }
    if (oldEvents == null && processor.prototype.isSelectRStream()) {
        oldEvents = processor.getSelectListEvents(false, isGenerateSynthetic, isJoin);
    }
    UniformPair<EventBean[]> result = null;
    if (oldEvents != null || newEvents != null) {
        result = new UniformPair<EventBean[]>(newEvents, oldEvents);
    }
    eventsOld.clear();
    eventsNew.clear();
    return result;
}

52. ResultSetProcessorRowForAllOutputAllHelperImpl#processView()

Project: esper
File: ResultSetProcessorRowForAllOutputAllHelperImpl.java
public void processView(EventBean[] newData, EventBean[] oldData, boolean isGenerateSynthetic) {
    if (processor.prototype.isSelectRStream()) {
        EventBean[] events = processor.getSelectListEvents(false, isGenerateSynthetic, false);
        EventBeanUtility.addToCollection(events, eventsOld);
    }
    EventBean[] eventsPerStream = new EventBean[1];
    ResultSetProcessorUtil.applyAggViewResult(processor.aggregationService, processor.exprEvaluatorContext, newData, oldData, eventsPerStream);
    EventBean[] events = processor.getSelectListEvents(true, isGenerateSynthetic, false);
    EventBeanUtility.addToCollection(events, eventsNew);
}

53. ResultSetProcessorHandThrough#getSelectEventsNoHaving()

Project: esper
File: ResultSetProcessorHandThrough.java
/**
     * Applies the select-clause to the given events returning the selected events. The number of events stays the
     * same, i.e. this method does not filter it just transforms the result set.
     * @param exprProcessor - processes each input event and returns output event
     * @param events - input events
     * @param isNewData - indicates whether we are dealing with new data (istream) or old data (rstream)
     * @param isSynthesize - set to true to indicate that synthetic events are required for an iterator result set
     * @return output events, one for each input event
     */
protected static EventBean[] getSelectEventsNoHaving(SelectExprProcessor exprProcessor, EventBean[] events, boolean isNewData, boolean isSynthesize, ExprEvaluatorContext agentInstanceContext) {
    if (events == null) {
        return null;
    }
    EventBean[] result = new EventBean[events.length];
    EventBean[] eventsPerStream = new EventBean[1];
    for (int i = 0; i < events.length; i++) {
        eventsPerStream[0] = events[i];
        result[i] = exprProcessor.process(eventsPerStream, isNewData, isSynthesize, agentInstanceContext);
    }
    return result;
}

54. ResultSetProcessorHandThrough#processViewResult()

Project: esper
File: ResultSetProcessorHandThrough.java
public UniformPair<EventBean[]> processViewResult(EventBean[] newData, EventBean[] oldData, boolean isSynthesize) {
    EventBean[] selectOldEvents = null;
    if (prototype.isSelectRStream()) {
        selectOldEvents = getSelectEventsNoHaving(selectExprProcessor, oldData, false, isSynthesize, agentInstanceContext);
    }
    EventBean[] selectNewEvents = getSelectEventsNoHaving(selectExprProcessor, newData, true, isSynthesize, agentInstanceContext);
    return new UniformPair<EventBean[]>(selectNewEvents, selectOldEvents);
}

55. ResultSetProcessorHandThrough#processJoinResult()

Project: esper
File: ResultSetProcessorHandThrough.java
public UniformPair<EventBean[]> processJoinResult(Set<MultiKey<EventBean>> newEvents, Set<MultiKey<EventBean>> oldEvents, boolean isSynthesize) {
    EventBean[] selectOldEvents = null;
    EventBean[] selectNewEvents;
    if (prototype.isSelectRStream()) {
        selectOldEvents = getSelectEventsNoHaving(selectExprProcessor, oldEvents, false, isSynthesize, agentInstanceContext);
    }
    selectNewEvents = getSelectEventsNoHaving(selectExprProcessor, newEvents, true, isSynthesize, agentInstanceContext);
    return new UniformPair<EventBean[]>(selectNewEvents, selectOldEvents);
}

56. ResultSetProcessorAggregateGroupedOutputLastHelperImpl#continueOutputLimitedLastNonBuffered()

Project: esper
File: ResultSetProcessorAggregateGroupedOutputLastHelperImpl.java
private UniformPair<EventBean[]> continueOutputLimitedLastNonBuffered() {
    EventBean[] newEventsArr = (outputLastUnordGroupNew.isEmpty()) ? null : outputLastUnordGroupNew.values().toArray(new EventBean[outputLastUnordGroupNew.size()]);
    EventBean[] oldEventsArr = null;
    if (processor.prototype.isSelectRStream()) {
        oldEventsArr = (outputLastUnordGroupOld.isEmpty()) ? null : outputLastUnordGroupOld.values().toArray(new EventBean[outputLastUnordGroupOld.size()]);
    }
    if ((newEventsArr == null) && (oldEventsArr == null)) {
        return null;
    }
    outputLastUnordGroupNew.clear();
    outputLastUnordGroupOld.clear();
    return new UniformPair<EventBean[]>(newEventsArr, oldEventsArr);
}

57. ResultSetProcessorAggregateGroupedOutputAllHelperImpl#output()

Project: esper
File: ResultSetProcessorAggregateGroupedOutputAllHelperImpl.java
private UniformPair<EventBean[]> output(boolean isSynthesize) {
    // generate remaining key events
    for (Map.Entry<Object, EventBean[]> entry : repsPerGroup.entrySet()) {
        if (lastSeenKeys.contains(entry.getKey())) {
            continue;
        }
        EventBean newEvent = processor.generateOutputBatchedSingle(entry.getKey(), entry.getValue(), true, isSynthesize);
        if (newEvent != null) {
            eventsNew.add(newEvent);
        }
    }
    lastSeenKeys.clear();
    EventBean[] newEventsArr = EventBeanUtility.toArray(eventsNew);
    EventBean[] oldEventsArr = null;
    if (processor.prototype.isSelectRStream()) {
        oldEventsArr = EventBeanUtility.toArray(eventsOld);
    }
    eventsNew.clear();
    eventsOld.clear();
    if ((newEventsArr == null) && (oldEventsArr == null)) {
        return null;
    }
    return new UniformPair<EventBean[]>(newEventsArr, oldEventsArr);
}

58. ResultSetProcessorAggregateAllOutputAllHelperImpl#output()

Project: esper
File: ResultSetProcessorAggregateAllOutputAllHelperImpl.java
public UniformPair<EventBean[]> output() {
    EventBean[] oldEvents = EventBeanUtility.toArrayNullIfEmpty(eventsOld);
    EventBean[] newEvents = EventBeanUtility.toArrayNullIfEmpty(eventsNew);
    UniformPair<EventBean[]> result = null;
    if (oldEvents != null || newEvents != null) {
        result = new UniformPair<EventBean[]>(newEvents, oldEvents);
    }
    eventsOld.clear();
    eventsNew.clear();
    return result;
}

59. TestAddPropertyValueView#testAddProperty()

Project: esper
File: TestAddPropertyValueView.java
public void testAddProperty() {
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("STDDEV", 100);
    EventBean eventBean = SupportEventBeanFactory.createMapFromValues(eventData, parentEventType);
    Map<String, Object> addProps = new HashMap<String, Object>();
    addProps.put("test", Integer.class);
    EventType newEventType = SupportEventAdapterService.getService().createAnonymousWrapperType("test", parentEventType, addProps);
    EventBean newBean = AddPropertyValueOptionalView.addProperty(eventBean, new String[] { "test" }, new MultiKeyUntyped(new Object[] { 2 }), newEventType, SupportEventAdapterService.getService());
    assertEquals(2, newBean.get("test"));
    assertEquals(100, newBean.get("STDDEV"));
}

60. TestPriorEventView#testUpdate()

Project: esper
File: TestPriorEventView.java
public void testUpdate() {
    // Send some data
    EventBean newEventsOne[] = makeBeans("a", 2);
    view.update(newEventsOne, null);
    // make sure received
    assertSame(newEventsOne, childView.getLastNewData());
    assertNull(childView.getLastOldData());
    childView.reset();
    // Assert random access
    assertSame(newEventsOne[0], buffer.getRelativeToEvent(newEventsOne[1], 0));
    EventBean[] newEventsTwo = makeBeans("b", 3);
    view.update(newEventsTwo, null);
    assertSame(newEventsTwo[1], buffer.getRelativeToEvent(newEventsTwo[2], 0));
    assertSame(newEventsTwo[0], buffer.getRelativeToEvent(newEventsTwo[1], 0));
    assertSame(newEventsOne[1], buffer.getRelativeToEvent(newEventsTwo[0], 0));
}

61. TestBufferView#testUpdate()

Project: esper
File: TestBufferView.java
public void testUpdate() {
    // Observer starts with no data
    assertFalse(observer.getAndResetHasNewData());
    // Send some data
    EventBean newEvents[] = makeBeans("n", 1);
    EventBean oldEvents[] = makeBeans("o", 1);
    bufferView.update(newEvents, oldEvents);
    // make sure received
    assertTrue(observer.getAndResetHasNewData());
    assertEquals(1, observer.getAndResetStreamId());
    assertNotNull(observer.getAndResetNewEventBuffer());
    assertNotNull(observer.getAndResetOldEventBuffer());
    // Reset and send null data
    assertFalse(observer.getAndResetHasNewData());
    bufferView.update(null, null);
    assertTrue(observer.getAndResetHasNewData());
}

62. SupportStreamImpl#insert()

Project: esper
File: SupportStreamImpl.java
/**
     * Insert a bunch of events to the stream
     * @param eventArray
     */
public void insert(EventBean[] eventArray) {
    for (EventBean theEvent : eventArray) {
        events.add(theEvent);
    }
    EventBean[] oldEvents = null;
    int expiredCount = events.size() - depth;
    if (expiredCount > 0) {
        oldEvents = new EventBean[expiredCount];
        for (int i = 0; i < expiredCount; i++) {
            oldEvents[i] = events.remove(0);
        }
    }
    for (View child : childViews) {
        child.update(eventArray, oldEvents);
    }
}

63. SupportJoinResultNodeFactory#convertTo2DimArr()

Project: esper
File: SupportJoinResultNodeFactory.java
public static EventBean[][] convertTo2DimArr(List<EventBean[]> rowList) {
    EventBean[][] result = new EventBean[rowList.size()][];
    int count = 0;
    for (EventBean[] row : rowList) {
        result[count++] = row;
    }
    return result;
}

64. TestViewTimeWin#assertEvents()

Project: esper
File: TestViewTimeWin.java
private void assertEvents(String symbol, long volume, double sum, boolean unique) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    if (!unique)
        assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals(symbol, newData[0].get("symbol"));
    assertEquals(volume, newData[0].get("volume"));
    assertEquals(sum, newData[0].get("mySum"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

65. TestHavingNoGroupBy#assertOldEvents()

Project: esper
File: TestHavingNoGroupBy.java
private void assertOldEvents(String symbol, Double oldPrice, Double oldAvgPrice) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(newData);
    assertEquals(1, oldData.length);
    assertEquals(symbol, oldData[0].get("symbol"));
    assertEquals(oldPrice, oldData[0].get("price"));
    assertEquals(oldAvgPrice, oldData[0].get("avgPrice"));
    listener.reset();
}

66. TestHavingNoGroupBy#assertNewEvents()

Project: esper
File: TestHavingNoGroupBy.java
private void assertNewEvents(String symbol, Double newPrice, Double newAvgPrice) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals(symbol, newData[0].get("symbol"));
    assertEquals(newPrice, newData[0].get("price"));
    assertEquals(newAvgPrice, newData[0].get("avgPrice"));
    listener.reset();
}

67. TestHavingNoGroupBy#assertOldNewSpreadEvent()

Project: esper
File: TestHavingNoGroupBy.java
private void assertOldNewSpreadEvent(double oldaprice, double oldbprice, double oldspread, double newaprice, double newbprice, double newspread) {
    Assert.assertEquals(1, listener.getOldDataList().size());
    Assert.assertEquals(1, listener.getLastOldData().length);
    // since event null is put into the list
    Assert.assertEquals(1, listener.getNewDataList().size());
    Assert.assertEquals(1, listener.getLastNewData().length);
    EventBean oldEvent = listener.getLastOldData()[0];
    EventBean newEvent = listener.getLastNewData()[0];
    compareSpreadEvent(oldEvent, oldaprice, oldbprice, oldspread);
    compareSpreadEvent(newEvent, newaprice, newbprice, newspread);
    listener.reset();
}

68. TestGroupByMaxMin#assertEvents()

Project: esper
File: TestGroupByMaxMin.java
private void assertEvents(String symbolOld, Long minVolOld, Long maxVolOld, Long minDistVolOld, Long maxDistVolOld, String symbolNew, Long minVolNew, Long maxVolNew, Long minDistVolNew, Long maxDistVolNew) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertEquals(1, oldData.length);
    assertEquals(1, newData.length);
    assertEquals(symbolOld, oldData[0].get("symbol"));
    assertEquals(minVolOld, oldData[0].get("minVol"));
    assertEquals(maxVolOld, oldData[0].get("maxVol"));
    assertEquals(minDistVolOld, oldData[0].get("minDistVol"));
    assertEquals(maxDistVolOld, oldData[0].get("maxDistVol"));
    assertEquals(symbolNew, newData[0].get("symbol"));
    assertEquals(minVolNew, newData[0].get("minVol"));
    assertEquals(maxVolNew, newData[0].get("maxVol"));
    assertEquals(minDistVolNew, newData[0].get("minDistVol"));
    assertEquals(maxDistVolNew, newData[0].get("maxDistVol"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

69. TestGroupByEventPerRow#assertEvents()

Project: esper
File: TestGroupByEventPerRow.java
private void assertEvents(String symbolOld, long volumeOld, double sumOld, String symbolNew, long volumeNew, double sumNew) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertEquals(1, oldData.length);
    assertEquals(1, newData.length);
    assertEquals(symbolOld, oldData[0].get("symbol"));
    assertEquals(volumeOld, oldData[0].get("volume"));
    assertEquals(sumOld, oldData[0].get("mySum"));
    assertEquals(symbolNew, newData[0].get("symbol"));
    assertEquals(volumeNew, newData[0].get("volume"));
    assertEquals(sumNew, newData[0].get("mySum"));
    listener.reset();
    assertFalse(listener.isInvoked());
}

70. TestGroupByEventPerRow#assertEvents()

Project: esper
File: TestGroupByEventPerRow.java
private void assertEvents(String symbol, long volume, double sum) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals(symbol, newData[0].get("symbol"));
    assertEquals(volume, newData[0].get("volume"));
    assertEquals(sum, newData[0].get("mySum"));
    listener.reset();
    assertFalse(listener.isInvoked());
}

71. TestGroupByEventPerGroupHaving#assertOldEvent()

Project: esper
File: TestGroupByEventPerGroupHaving.java
private void assertOldEvent(String symbol, double newSum) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertNull(newData);
    assertEquals(1, oldData.length);
    assertEquals(newSum, oldData[0].get("mySum"));
    assertEquals(symbol, oldData[0].get("symbol"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

72. TestGroupByEventPerGroupHaving#assertNewEvent()

Project: esper
File: TestGroupByEventPerGroupHaving.java
private void assertNewEvent(String symbol, double newSum) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals(newSum, newData[0].get("mySum"));
    assertEquals(symbol, newData[0].get("symbol"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

73. TestGroupByCount#assertEvents()

Project: esper
File: TestGroupByCount.java
private void assertEvents(String symbolOld, Long countAllOld, Long countDistVolOld, Long countVolOld, String symbolNew, Long countAllNew, Long countDistVolNew, Long countVolNew) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertEquals(1, oldData.length);
    assertEquals(1, newData.length);
    assertEquals(symbolOld, oldData[0].get("symbol"));
    assertEquals(countAllOld, oldData[0].get("countAll"));
    assertEquals(countDistVolOld, oldData[0].get("countDistVol"));
    assertEquals(countVolOld, oldData[0].get("countVol"));
    assertEquals(symbolNew, newData[0].get("symbol"));
    assertEquals(countAllNew, newData[0].get("countAll"));
    assertEquals(countDistVolNew, newData[0].get("countDistVol"));
    assertEquals(countVolNew, newData[0].get("countVol"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

74. TestAggregateRowPerEventDistinct#assertEvents()

Project: esper
File: TestAggregateRowPerEventDistinct.java
private void assertEvents(String symbolOld, long volSumOld, String symbolNew, long volSumNew) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertEquals(1, oldData.length);
    assertEquals(1, newData.length);
    assertEquals(symbolOld, oldData[0].get("symbol"));
    assertEquals(volSumOld, oldData[0].get("volSum"));
    assertEquals(symbolNew, newData[0].get("symbol"));
    assertEquals(volSumNew, newData[0].get("volSum"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

75. TestAggregateRowPerEventDistinct#assertEvents()

Project: esper
File: TestAggregateRowPerEventDistinct.java
private void assertEvents(String symbol, long volSum) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals(symbol, newData[0].get("symbol"));
    assertEquals(volSum, newData[0].get("volSum"));
    testListener.reset();
    assertFalse(testListener.isInvoked());
}

76. TestAggregateRowPerEvent#assertPostedNew()

Project: esper
File: TestAggregateRowPerEvent.java
private void assertPostedNew(Double newAvg, Long newSum) {
    EventBean[] oldData = testListener.getLastOldData();
    EventBean[] newData = testListener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEquals("IBM stats", newData[0].get("title"));
    assertEquals(newAvg, newData[0].get("myAvg"));
    assertEquals(newSum, newData[0].get("mySum"));
    testListener.reset();
}

77. TestPreviousFunction#assertOldEventWTail()

Project: esper
File: TestPreviousFunction.java
private void assertOldEventWTail(String currSymbol, String prevSymbol, Double prevPrice, String prevTailSymbol, Double prevTailPrice, String prevTail1Symbol, Double prevTail1Price, Long prevcount, Object[] prevwindow) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(newData);
    assertEquals(1, oldData.length);
    assertEventWTail(oldData[0], currSymbol, prevSymbol, prevPrice, prevTailSymbol, prevTailPrice, prevTail1Symbol, prevTail1Price, prevcount, prevwindow);
    listener.reset();
}

78. TestPreviousFunction#assertNewEventWTail()

Project: esper
File: TestPreviousFunction.java
private void assertNewEventWTail(String currSymbol, String prevSymbol, Double prevPrice, String prevTailSymbol, Double prevTailPrice, String prevTail1Symbol, Double prevTail1Price, Long prevcount, Object[] prevwindow) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEventWTail(newData[0], currSymbol, prevSymbol, prevPrice, prevTailSymbol, prevTailPrice, prevTail1Symbol, prevTail1Price, prevcount, prevwindow);
    listener.reset();
}

79. TestPreviousFunction#assertNewEvents()

Project: esper
File: TestPreviousFunction.java
private void assertNewEvents(String currSymbol, String prev0Symbol, Double prev0Price, String prev1Symbol, Double prev1Price, String prev2Symbol, Double prev2Price, String prevTail0Symbol, Double prevTail0Price, String prevTail1Symbol, Double prevTail1Price, Long prevCount, Object[] prevWindow) {
    EventBean[] oldData = listener.getLastOldData();
    EventBean[] newData = listener.getLastNewData();
    assertNull(oldData);
    assertEquals(1, newData.length);
    assertEventProps(newData[0], currSymbol, prev0Symbol, prev0Price, prev1Symbol, prev1Price, prev2Symbol, prev2Price, prevTail0Symbol, prevTail0Price, prevTail1Symbol, prevTail1Price, prevCount, prevWindow);
    listener.reset();
}

80. TestExistsExpr#testExistsSimple()

Project: esper
File: TestExistsExpr.java
public void testExistsSimple() {
    String stmtText = "select exists(theString) as t0, " + " exists(intBoxed?) as t1, " + " exists(dummy?) as t2, " + " exists(intPrimitive?) as t3, " + " exists(intPrimitive) as t4 " + " from " + SupportBean.class.getName();
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(stmtText);
    selectTestCase.addListener(listener);
    for (int i = 0; i < 5; i++) {
        assertEquals(Boolean.class, selectTestCase.getEventType().getPropertyType("t" + i));
    }
    SupportBean bean = new SupportBean("abc", 100);
    bean.setFloatBoxed(9.5f);
    bean.setIntBoxed(3);
    epService.getEPRuntime().sendEvent(bean);
    EventBean theEvent = listener.assertOneGetNewAndReset();
    assertResults(theEvent, new boolean[] { true, true, false, true, true });
}

81. TestCaseExpr#testCaseSyntax2NoAsName()

Project: esper
File: TestCaseExpr.java
public void testCaseSyntax2NoAsName() {
    String caseSubExpr = "case intPrimitive when 1 then 0 end";
    String caseExpr = "select " + caseSubExpr + " from " + SupportBean.class.getName() + ".win:length(10)";
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(caseExpr);
    selectTestCase.addListener(testListener);
    assertEquals(Integer.class, selectTestCase.getEventType().getPropertyType(caseSubExpr));
    sendSupportBeanEvent(1);
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(0, theEvent.get(caseSubExpr));
}

82. TestCaseExpr#testCaseSyntax2EnumResult()

Project: esper
File: TestCaseExpr.java
public void testCaseSyntax2EnumResult() {
    String caseExpr = "select case intPrimitive * 2 " + " when 2 then com.espertech.esper.support.bean.SupportEnum.getValueForEnum(0) " + " when 4 then com.espertech.esper.support.bean.SupportEnum.getValueForEnum(1) " + " else com.espertech.esper.support.bean.SupportEnum.getValueForEnum(2) " + " end as p1 " + " from " + SupportBean.class.getName() + ".win:length(10)";
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(caseExpr);
    selectTestCase.addListener(testListener);
    assertEquals(SupportEnum.class, selectTestCase.getEventType().getPropertyType("p1"));
    sendSupportBeanEvent(1);
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(SupportEnum.ENUM_VALUE_1, theEvent.get("p1"));
    sendSupportBeanEvent(2);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(SupportEnum.ENUM_VALUE_2, theEvent.get("p1"));
    sendSupportBeanEvent(3);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(SupportEnum.ENUM_VALUE_3, theEvent.get("p1"));
}

83. TestCaseExpr#testCaseSyntax2EnumChecks()

Project: esper
File: TestCaseExpr.java
public void testCaseSyntax2EnumChecks() {
    String caseExpr = "select case supportEnum " + " when com.espertech.esper.support.bean.SupportEnum.getValueForEnum(0) then 1 " + " when com.espertech.esper.support.bean.SupportEnum.getValueForEnum(1) then 2 " + " end as p1 " + " from " + SupportBeanWithEnum.class.getName() + ".win:length(10)";
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(caseExpr);
    selectTestCase.addListener(testListener);
    assertEquals(Integer.class, selectTestCase.getEventType().getPropertyType("p1"));
    sendSupportBeanEvent("a", SupportEnum.ENUM_VALUE_1);
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(1, theEvent.get("p1"));
    sendSupportBeanEvent("b", SupportEnum.ENUM_VALUE_2);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(2, theEvent.get("p1"));
    sendSupportBeanEvent("c", SupportEnum.ENUM_VALUE_3);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(null, theEvent.get("p1"));
}

84. TestCaseExpr#testCaseSyntax2WithinExpression()

Project: esper
File: TestCaseExpr.java
public void testCaseSyntax2WithinExpression() {
    String caseExpr = "select 2 * (case " + " intPrimitive when 1 then 2 " + " when 2 then 3 " + " else 10 end) as p1 " + " from " + SupportBean.class.getName() + ".win:length(1)";
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(caseExpr);
    selectTestCase.addListener(testListener);
    assertEquals(Integer.class, selectTestCase.getEventType().getPropertyType("p1"));
    sendSupportBeanEvent(1);
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(4, theEvent.get("p1"));
    sendSupportBeanEvent(2);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(6, theEvent.get("p1"));
    sendSupportBeanEvent(3);
    theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals(20, theEvent.get("p1"));
}

85. TestCaseExpr#testCaseSyntax1Branches3()

Project: esper
File: TestCaseExpr.java
public void testCaseSyntax1Branches3() {
    // Same test but the where clause doesn't match any of the condition of the case expresssion
    String caseExpr = "select case " + " when (symbol='GE') then volume " + " when (symbol='DELL') then volume / 2.0 " + " when (symbol='MSFT') then volume / 3.0 " + " end as p1 from " + SupportMarketDataBean.class.getName();
    EPStatement selectTestCase = epService.getEPAdministrator().createEPL(caseExpr);
    selectTestCase.addListener(testListener);
    assertEquals(Double.class, selectTestCase.getEventType().getPropertyType("p1"));
    sendMarketDataEvent("DELL", 10000, 0);
    EventBean theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(10000 / 2.0, theEvent.get("p1"));
    sendMarketDataEvent("MSFT", 10000, 0);
    theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(10000 / 3.0, theEvent.get("p1"));
    sendMarketDataEvent("GE", 10000, 0);
    theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(10000.0, theEvent.get("p1"));
}

86. TestCaseExpr#runCaseSyntax1Sum()

Project: esper
File: TestCaseExpr.java
private void runCaseSyntax1Sum() {
    sendMarketDataEvent("DELL", 10000, 50);
    EventBean theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(50.0, theEvent.get("p1"));
    sendMarketDataEvent("DELL", 10000, 50);
    theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(100.0, theEvent.get("p1"));
    sendMarketDataEvent("CSCO", 4000, 5);
    theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(null, theEvent.get("p1"));
    sendMarketDataEvent("GE", 20, 30);
    theEvent = testListener.assertOneGetNewAndReset();
    assertEquals(20.0, theEvent.get("p1"));
}

87. TestBigNumberSupport#testAggregation()

Project: esper
File: TestBigNumberSupport.java
public void testAggregation() {
    String fields = "sum(bigint),sum(bigdec)," + "avg(bigint),avg(bigdec)," + "median(bigint),median(bigdec)," + "stddev(bigint),stddev(bigdec)," + "avedev(bigint),avedev(bigdec)," + "min(bigint),min(bigdec)";
    EPStatement stmt = epService.getEPAdministrator().createEPL("select " + fields + " from SupportBeanNumeric");
    stmt.addListener(listener);
    listener.reset();
    String[] fieldList = fields.split(",");
    sendBigNumEvent(1, 2);
    EventBean theEvent = listener.assertOneGetNewAndReset();
    EPAssertionUtil.assertProps(theEvent, fieldList, new Object[] { // sum
    BigInteger.valueOf(1), // sum
    new BigDecimal(2d), // avg
    new BigDecimal(1), // avg
    new BigDecimal(2), // median
    1d, // median
    2d, null, null, 0.0, 0.0, BigInteger.valueOf(1), new BigDecimal(2) });
}

88. TestArrayExpression#testComplexTypes()

Project: esper
File: TestArrayExpression.java
public void testComplexTypes() {
    String stmtText = "select {arrayProperty, nested} as field" + " from " + SupportBeanComplexProps.class.getName();
    EPStatement stmt = epService.getEPAdministrator().createEPL(stmtText);
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);
    SupportBeanComplexProps bean = SupportBeanComplexProps.makeDefaultBean();
    epService.getEPRuntime().sendEvent(bean);
    EventBean theEvent = listener.assertOneGetNewAndReset();
    Object[] arr = (Object[]) theEvent.get("field");
    assertSame(bean.getArrayProperty(), arr[0]);
    assertSame(bean.getNested(), arr[1]);
}

89. TestArrayExpression#testArrayExpressions_Compile()

Project: esper
File: TestArrayExpression.java
public void testArrayExpressions_Compile() {
    String stmtText = "select {\"a\",\"b\"} as stringArray, " + "{} as emptyArray, " + "{1} as oneEleArray, " + "{1,2,3} as intArray " + "from " + SupportBean.class.getName();
    EPStatementObjectModel model = epService.getEPAdministrator().compileEPL(stmtText);
    assertEquals(stmtText, model.toEPL());
    EPStatement stmt = epService.getEPAdministrator().create(model);
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);
    SupportBean bean = new SupportBean("a", 10);
    epService.getEPRuntime().sendEvent(bean);
    EventBean theEvent = listener.assertOneGetNewAndReset();
    EPAssertionUtil.assertEqualsExactOrder((String[]) theEvent.get("stringArray"), new String[] { "a", "b" });
    EPAssertionUtil.assertEqualsExactOrder((Object[]) theEvent.get("emptyArray"), new Object[0]);
    EPAssertionUtil.assertEqualsExactOrder((Integer[]) theEvent.get("oneEleArray"), new Integer[] { 1 });
    EPAssertionUtil.assertEqualsExactOrder((Integer[]) theEvent.get("intArray"), new Integer[] { 1, 2, 3 });
}

90. TestSubselectUnfiltered#testUnfilteredExpression()

Project: esper
File: TestSubselectUnfiltered.java
public void testUnfilteredExpression() {
    String stmtText = "select (select p10 || p11 from S1.std:lastevent()) as value from S0";
    EPStatement stmt = epService.getEPAdministrator().createEPL(stmtText);
    stmt.addListener(listener);
    // check type
    assertEquals(String.class, stmt.getEventType().getPropertyType("value"));
    // test no event, should return null
    epService.getEPRuntime().sendEvent(new SupportBean_S0(1));
    EventBean theEvent = listener.assertOneGetNewAndReset();
    assertEquals(null, theEvent.get("value"));
    // test one event
    epService.getEPRuntime().sendEvent(new SupportBean_S1(-1, "a", "b"));
    epService.getEPRuntime().sendEvent(new SupportBean_S0(1));
    theEvent = listener.assertOneGetNewAndReset();
    assertEquals("ab", theEvent.get("value"));
}

91. TestSelectExprStreamSelector#testJoinNoAliasWithProperties()

Project: esper
File: TestSelectExprStreamSelector.java
public void testJoinNoAliasWithProperties() {
    String viewExpr = "select intPrimitive, s1.*, symbol as sym from " + SupportBean.class.getName() + ".win:length(3) as s0, " + SupportMarketDataBean.class.getName() + ".win:keepall() as s1";
    EPStatement selectTestView = epService.getEPAdministrator().createEPL(viewExpr);
    selectTestView.addListener(testListener);
    EventType type = selectTestView.getEventType();
    assertEquals(7, type.getPropertyNames().length);
    assertEquals(int.class, type.getPropertyType("intPrimitive"));
    assertEquals(Pair.class, type.getUnderlyingType());
    sendBeanEvent("E1", 11);
    assertFalse(testListener.isInvoked());
    Object theEvent = sendMarketEvent("E1");
    String[] fields = new String[] { "intPrimitive", "sym", "symbol" };
    EventBean received = testListener.assertOneGetNewAndReset();
    EPAssertionUtil.assertProps(received, fields, new Object[] { 11, "E1", "E1" });
    assertSame(theEvent, ((Pair) received.getUnderlying()).getFirst());
}

92. TestSelectExprStreamSelector#testJoinWildcardWithAlias()

Project: esper
File: TestSelectExprStreamSelector.java
public void testJoinWildcardWithAlias() {
    String viewExpr = "select *, s1.* as s1stream, s0.* as s0stream from " + SupportBean.class.getName() + ".win:length(3) as s0, " + SupportMarketDataBean.class.getName() + ".win:keepall() as s1";
    EPStatement selectTestView = epService.getEPAdministrator().createEPL(viewExpr);
    selectTestView.addListener(testListener);
    EventType type = selectTestView.getEventType();
    assertEquals(4, type.getPropertyNames().length);
    assertEquals(SupportBean.class, type.getPropertyType("s0stream"));
    assertEquals(SupportBean.class, type.getPropertyType("s0"));
    assertEquals(SupportMarketDataBean.class, type.getPropertyType("s1stream"));
    assertEquals(SupportMarketDataBean.class, type.getPropertyType("s1"));
    assertEquals(Map.class, type.getUnderlyingType());
    Object eventOne = sendBeanEvent("E1", 13);
    assertFalse(testListener.isInvoked());
    Object eventTwo = sendMarketEvent("E2");
    String[] fields = new String[] { "s0", "s1", "s0stream", "s1stream" };
    EventBean received = testListener.assertOneGetNewAndReset();
    EPAssertionUtil.assertProps(received, fields, new Object[] { eventOne, eventTwo, eventOne, eventTwo });
}

93. TestSelectExprStreamSelector#testJoinWildcardNoAlias()

Project: esper
File: TestSelectExprStreamSelector.java
public void testJoinWildcardNoAlias() {
    String viewExpr = "select *, s1.* from " + SupportBean.class.getName() + ".win:length(3) as s0, " + SupportMarketDataBean.class.getName() + ".win:keepall() as s1";
    EPStatement selectTestView = epService.getEPAdministrator().createEPL(viewExpr);
    selectTestView.addListener(testListener);
    EventType type = selectTestView.getEventType();
    assertEquals(7, type.getPropertyNames().length);
    assertEquals(Long.class, type.getPropertyType("volume"));
    assertEquals(SupportBean.class, type.getPropertyType("s0"));
    assertEquals(SupportMarketDataBean.class, type.getPropertyType("s1"));
    assertEquals(Pair.class, type.getUnderlyingType());
    Object eventOne = sendBeanEvent("E1", 13);
    assertFalse(testListener.isInvoked());
    Object eventTwo = sendMarketEvent("E2");
    String[] fields = new String[] { "s0", "s1", "symbol", "volume" };
    EventBean received = testListener.assertOneGetNewAndReset();
    EPAssertionUtil.assertProps(received, fields, new Object[] { eventOne, eventTwo, "E2", 0L });
}

94. TestPatternInsertInto#sendEventsAndAssert()

Project: esper
File: TestPatternInsertInto.java
private void sendEventsAndAssert() {
    sendEventS1(10, "");
    EventBean theEvent = updateListener.assertOneGetNewAndReset();
    assertNull(theEvent.get("es0id"));
    assertEquals(10, theEvent.get("es1id"));
    sendEventS0(20, "");
    theEvent = updateListener.assertOneGetNewAndReset();
    assertEquals(20, theEvent.get("es0id"));
    assertNull(theEvent.get("es1id"));
}

95. TestPatternEventProperties#testPropertiesSimplePattern()

Project: esper
File: TestPatternEventProperties.java
public void testPropertiesSimplePattern() {
    setupSimplePattern("a, a as myEvent, a.intPrimitive as myInt, a.theString");
    SupportBean theEvent = new SupportBean();
    theEvent.setIntPrimitive(1);
    theEvent.setTheString("test");
    epService.getEPRuntime().sendEvent(theEvent);
    EventBean eventBean = updateListener.assertOneGetNewAndReset();
    assertSame(theEvent, eventBean.get("a"));
    assertSame(theEvent, eventBean.get("myEvent"));
    assertEquals(1, eventBean.get("myInt"));
    assertEquals("test", eventBean.get("a.theString"));
}

96. TestPatternEventProperties#testWildcardOrPattern()

Project: esper
File: TestPatternEventProperties.java
public void testWildcardOrPattern() {
    setupOrPattern("*");
    Object theEvent = new SupportBean();
    epService.getEPRuntime().sendEvent(theEvent);
    EventBean eventBean = updateListener.assertOneGetNewAndReset();
    assertSame(theEvent, eventBean.get("a"));
    assertNull(eventBean.get("b"));
    theEvent = SupportBeanComplexProps.makeDefaultBean();
    epService.getEPRuntime().sendEvent(theEvent);
    eventBean = updateListener.assertOneGetNewAndReset();
    assertSame(theEvent, eventBean.get("b"));
    assertNull(eventBean.get("a"));
}

97. TestJoinPropertyAccess#testOuterJoin()

Project: esper
File: TestJoinPropertyAccess.java
public void testOuterJoin() {
    String viewExpr = "select * from " + SupportBeanComplexProps.class.getName() + ".win:length(3) s0" + " left outer join " + SupportBeanCombinedProps.class.getName() + ".win:length(3) s1" + " on mapped('keyOne') = indexed[2].mapped('2ma').value";
    EPStatement testView = epService.getEPAdministrator().createEPL(viewExpr);
    testListener = new SupportUpdateListener();
    testView.addListener(testListener);
    SupportBeanCombinedProps combined = SupportBeanCombinedProps.makeDefaultBean();
    epService.getEPRuntime().sendEvent(combined);
    SupportBeanComplexProps complex = SupportBeanComplexProps.makeDefaultBean();
    epService.getEPRuntime().sendEvent(complex);
    // double check that outer join criteria match
    assertEquals(complex.getMapped("keyOne"), combined.getIndexed(2).getMapped("2ma").getValue());
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals("simple", theEvent.get("s0.simpleProperty"));
    assertSame(complex, theEvent.get("s0"));
    assertSame(combined, theEvent.get("s1"));
}

98. TestJoinPropertyAccess#testRegularJoin()

Project: esper
File: TestJoinPropertyAccess.java
public void testRegularJoin() {
    SupportBeanCombinedProps combined = SupportBeanCombinedProps.makeDefaultBean();
    SupportBeanComplexProps complex = SupportBeanComplexProps.makeDefaultBean();
    assertEquals("0ma0", combined.getIndexed(0).getMapped("0ma").getValue());
    String viewExpr = "select nested.nested, s1.indexed[0], nested.indexed[1] from " + SupportBeanComplexProps.class.getName() + ".win:length(3) nested, " + SupportBeanCombinedProps.class.getName() + ".win:length(3) s1" + " where mapped('keyOne') = indexed[2].mapped('2ma').value and" + " indexed[0].mapped('0ma').value = '0ma0'";
    EPStatement testView = epService.getEPAdministrator().createEPL(viewExpr);
    testListener = new SupportUpdateListener();
    testView.addListener(testListener);
    epService.getEPRuntime().sendEvent(combined);
    epService.getEPRuntime().sendEvent(complex);
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertSame(complex.getNested(), theEvent.get("nested.nested"));
    assertSame(combined.getIndexed(0), theEvent.get("s1.indexed[0]"));
    assertEquals(complex.getIndexed(1), theEvent.get("nested.indexed[1]"));
}

99. TestJoinMapType#runAssertion()

Project: esper
File: TestJoinMapType.java
private void runAssertion() {
    sendMapEvent("MapS0", "a", 1);
    assertFalse(listener.isInvoked());
    sendMapEvent("MapS1", "a", 2);
    EventBean theEvent = listener.assertOneGetNewAndReset();
    assertEquals("a", theEvent.get("S0.id"));
    assertEquals("a", theEvent.get("S1.id"));
    assertEquals(1, theEvent.get("S0.p00"));
    assertEquals(2, theEvent.get("S1.p00"));
    sendMapEvent("MapS1", "b", 3);
    sendMapEvent("MapS0", "c", 4);
    assertFalse(listener.isInvoked());
}

100. TestJoinInheritAndInterface#testInterfaceJoin()

Project: esper
File: TestJoinInheritAndInterface.java
public void testInterfaceJoin() {
    String viewExpr = "select a, b from " + ISupportA.class.getName() + ".win:length(10), " + ISupportB.class.getName() + ".win:length(10)" + " where a = b";
    EPStatement testView = epService.getEPAdministrator().createEPL(viewExpr);
    testListener = new SupportUpdateListener();
    testView.addListener(testListener);
    epService.getEPRuntime().sendEvent(new ISupportAImpl("1", "ab1"));
    epService.getEPRuntime().sendEvent(new ISupportBImpl("2", "ab2"));
    assertFalse(testListener.isInvoked());
    epService.getEPRuntime().sendEvent(new ISupportBImpl("1", "ab3"));
    assertTrue(testListener.isInvoked());
    EventBean theEvent = testListener.getAndResetLastNewData()[0];
    assertEquals("1", theEvent.get("a"));
    assertEquals("1", theEvent.get("b"));
}