private void runAssertionSingleRowFunc(Object[] rowValues) {
    // try join passing of params
    String eplJoin =
        "select "
            + this.getClass().getName()
            + ".myServiceEventBean(mt) as c0, "
            + this.getClass().getName()
            + ".myServiceObjectArray(mt) as c1 "
            + "from SupportBean_S2, MyTable as mt";
    EPStatement stmtJoin = epService.getEPAdministrator().createEPL(eplJoin);
    stmtJoin.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    EventBean result = listener.assertOneGetNewAndReset();
    assertEventUnd(result.get("c0"), rowValues);
    assertEventUnd(result.get("c1"), rowValues);
    stmtJoin.destroy();

    // try subquery
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInSingleRowFunction(
            "pluginServiceEventBean", this.getClass().getName(), "myServiceEventBean");
    String eplSubquery =
        "select (select pluginServiceEventBean(mt) from MyTable as mt) as c0 "
            + "from SupportBean_S2";
    EPStatement stmtSubquery = epService.getEPAdministrator().createEPL(eplSubquery);
    stmtSubquery.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    result = listener.assertOneGetNewAndReset();
    assertEventUnd(result.get("c0"), rowValues);
    stmtSubquery.destroy();
  }
  public void testSingleMethod() throws Exception {
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("SupportBean", SupportBean.class);
    String text = "select power3(intPrimitive) as val from SupportBean";
    EPStatement stmt = epService.getEPAdministrator().createEPL(text);
    stmt.addListener(listener);

    runAssertionSingleMethod();

    stmt.destroy();
    EPStatementObjectModel model = epService.getEPAdministrator().compileEPL(text);
    assertEquals(text, model.toEPL());
    stmt = epService.getEPAdministrator().create(model);
    assertEquals(text, stmt.getText());
    stmt.addListener(listener);

    runAssertionSingleMethod();

    stmt.destroy();
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("SupportBean", SupportBean.class);
    text = "select power3(2) as val from SupportBean";
    stmt = epService.getEPAdministrator().createEPL(text);
    stmt.addListener(listener);

    runAssertionSingleMethod();
  }
Esempio n. 3
0
  public void testVariantTwoWildcard() throws InterruptedException {
    String stmtText =
        "insert into event1 select * from " + SupportBean.class.getName() + ".win:length(100)";
    String otherText = "select * from default.event1.win:length(10)";

    // Attach listener to feed
    EPStatement stmtOne = epService.getEPAdministrator().createEPL(stmtText, "stmt1");
    assertEquals(
        StatementType.INSERT_INTO,
        ((EPStatementSPI) stmtOne).getStatementMetadata().getStatementType());
    SupportUpdateListener listenerOne = new SupportUpdateListener();
    stmtOne.addListener(listenerOne);
    EPStatement stmtTwo = epService.getEPAdministrator().createEPL(otherText, "stmt2");
    SupportUpdateListener listenerTwo = new SupportUpdateListener();
    stmtTwo.addListener(listenerTwo);

    SupportBean theEvent = sendEvent(10, 11);
    assertTrue(listenerOne.getAndClearIsInvoked());
    assertEquals(1, listenerOne.getLastNewData().length);
    assertEquals(10, listenerOne.getLastNewData()[0].get("intPrimitive"));
    assertEquals(11, listenerOne.getLastNewData()[0].get("intBoxed"));
    assertEquals(20, listenerOne.getLastNewData()[0].getEventType().getPropertyNames().length);
    assertSame(theEvent, listenerOne.getLastNewData()[0].getUnderlying());

    assertTrue(listenerTwo.getAndClearIsInvoked());
    assertEquals(1, listenerTwo.getLastNewData().length);
    assertEquals(10, listenerTwo.getLastNewData()[0].get("intPrimitive"));
    assertEquals(11, listenerTwo.getLastNewData()[0].get("intBoxed"));
    assertEquals(20, listenerTwo.getLastNewData()[0].getEventType().getPropertyNames().length);
    assertSame(theEvent, listenerTwo.getLastNewData()[0].getUnderlying());

    // assert statement-type reference
    EPServiceProviderSPI spi = (EPServiceProviderSPI) epService;
    assertTrue(spi.getStatementEventTypeRef().isInUse("event1"));
    Set<String> stmtNames = spi.getStatementEventTypeRef().getStatementNamesForType("event1");
    EPAssertionUtil.assertEqualsAnyOrder(stmtNames.toArray(), new String[] {"stmt1", "stmt2"});
    assertTrue(spi.getStatementEventTypeRef().isInUse(SupportBean.class.getName()));
    stmtNames =
        spi.getStatementEventTypeRef().getStatementNamesForType(SupportBean.class.getName());
    EPAssertionUtil.assertEqualsAnyOrder(stmtNames.toArray(), new String[] {"stmt1"});

    stmtOne.destroy();
    assertTrue(spi.getStatementEventTypeRef().isInUse("event1"));
    stmtNames = spi.getStatementEventTypeRef().getStatementNamesForType("event1");
    EPAssertionUtil.assertEqualsAnyOrder(new String[] {"stmt2"}, stmtNames.toArray());
    assertFalse(spi.getStatementEventTypeRef().isInUse(SupportBean.class.getName()));

    stmtTwo.destroy();
    assertFalse(spi.getStatementEventTypeRef().isInUse("event1"));
  }
  private void runAssertionSubquerySelectStar(Object[] rowValues) {
    String eplFiltered =
        "select (select * from MyTable where key = 'G1') as mt from SupportBean_S2";
    runAssertionSubquerySelectStar(rowValues, eplFiltered);

    String eplUnfiltered = "select (select * from MyTable) as mt from SupportBean_S2";
    runAssertionSubquerySelectStar(rowValues, eplUnfiltered);

    // With @eventbean
    String eplEventBean = "select (select * from MyTable) @eventbean as mt from SupportBean_S2";
    EPStatement stmt = epService.getEPAdministrator().createEPL(eplEventBean);
    stmt.addListener(listener);
    assertEquals(Object[][].class, stmt.getEventType().getPropertyType("mt"));
    assertSame(
        getTablePublicType("MyTable"), stmt.getEventType().getFragmentType("mt").getFragmentType());

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    EventBean event = listener.assertOneGetNewAndReset();
    Object[][] value = (Object[][]) event.get("mt");
    assertEventUnd(value[0], rowValues);
    assertSame(
        getTablePublicType("MyTable"), ((EventBean[]) event.getFragment("mt"))[0].getEventType());

    stmt.destroy();
  }
  private void runAssertionOnSelectWindowAgg(Object[][] expectedType, Object[] rowValues) {
    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "on SupportBean_S2 select "
                    + "window(win.*) as c0,"
                    + "last(win.*) as c1, "
                    + "first(win.*) as c2, "
                    + "first(p1) as c3,"
                    + "window(p1) as c4,"
                    + "sorted(p1) as c5,"
                    + "minby(p1) as c6"
                    + " from MyTable as win");
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    EventBean event = listener.assertOneGetNewAndReset();
    for (String col : "c1,c2,c6".split(",")) {
      assertEventUnd(event.get(col), rowValues);
    }
    for (String col : "c0,c5".split(",")) {
      assertEventUnd(((Object[][]) event.get(col))[0], rowValues);
    }
    assertEquals("b", event.get("c3"));
    EPAssertionUtil.assertEqualsExactOrder(new String[] {"b"}, (String[]) event.get("c4"));

    stmt.destroy();
  }
  public void testScalar() {

    String[] fields = "val0,val1".split(",");
    String eplFragment =
        "select "
            + "strvals.mostFrequent() as val0, "
            + "strvals.leastFrequent() as val1 "
            + "from SupportCollection";
    EPStatement stmtFragment = epService.getEPAdministrator().createEPL(eplFragment);
    stmtFragment.addListener(listener);
    LambdaAssertionUtil.assertTypes(
        stmtFragment.getEventType(), fields, new Class[] {String.class, String.class});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E2,E1,E2,E1,E3,E3,E4,E3"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {"E3", "E4"});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E1"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {"E1", "E1"});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(null));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {null, null});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(""));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {null, null});
    stmtFragment.destroy();

    epService
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInSingleRowFunction(
            "extractNum", TestEnumMinMax.MyService.class.getName(), "extractNum");
    String eplLambda =
        "select "
            + "strvals.mostFrequent(v => extractNum(v)) as val0, "
            + "strvals.leastFrequent(v => extractNum(v)) as val1 "
            + "from SupportCollection";
    EPStatement stmtLambda = epService.getEPAdministrator().createEPL(eplLambda);
    stmtLambda.addListener(listener);
    LambdaAssertionUtil.assertTypes(
        stmtLambda.getEventType(), fields, new Class[] {Integer.class, Integer.class});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E2,E1,E2,E1,E3,E3,E4,E3"));
    EPAssertionUtil.assertProps(listener.assertOneGetNewAndReset(), fields, new Object[] {3, 4});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E1"));
    EPAssertionUtil.assertProps(listener.assertOneGetNewAndReset(), fields, new Object[] {1, 1});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(null));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {null, null});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(""));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {null, null});
  }
  public void testMapNamePropertyNested() {
    EPServiceProvider epService = getEngineInitialized(null, null, null);

    // create a named map
    Map<String, Object> namedDef = makeMap(new Object[][] {{"n0", int.class}});
    epService.getEPAdministrator().getConfiguration().addEventType("MyNamedMap", namedDef);

    // create a map using the name
    Map<String, Object> eventDef =
        makeMap(new Object[][] {{"p0", "MyNamedMap"}, {"p1", "MyNamedMap[]"}});
    epService.getEPAdministrator().getConfiguration().addEventType("MyMapWithAMap", eventDef);

    // test named-map at the second level of a nested map
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyObjectArrayMapOuter", new String[] {"outer"}, new Object[] {eventDef});

    SupportUpdateListener listener = new SupportUpdateListener();
    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "select outer.p0.n0 as a, outer.p1[0].n0 as b, outer.p1[1].n0 as c, outer.p0 as d, outer.p1 as e from MyObjectArrayMapOuter");
    stmt.addListener(listener);

    Map<String, Object> n0_1 = makeMap(new Object[][] {{"n0", 1}});
    Map<String, Object> n0_21 = makeMap(new Object[][] {{"n0", 2}});
    Map<String, Object> n0_22 = makeMap(new Object[][] {{"n0", 3}});
    Map[] n0_2 = new Map[] {n0_21, n0_22};
    Map<String, Object> theEvent = makeMap(new Object[][] {{"p0", n0_1}, {"p1", n0_2}});
    epService.getEPRuntime().sendEvent(new Object[] {theEvent}, "MyObjectArrayMapOuter");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        "a,b,c,d,e".split(","),
        new Object[] {1, 2, 3, n0_1, n0_2});
    assertEquals(int.class, stmt.getEventType().getPropertyType("a"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("b"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("c"));
    assertEquals(Map.class, stmt.getEventType().getPropertyType("d"));
    assertEquals(Map[].class, stmt.getEventType().getPropertyType("e"));

    stmt.destroy();
    stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "select outer.p0.n0? as a, outer.p1[0].n0? as b, outer.p1[1]?.n0 as c, outer.p0? as d, outer.p1? as e from MyObjectArrayMapOuter");
    stmt.addListener(listener);
    epService.getEPRuntime().sendEvent(new Object[] {theEvent}, "MyObjectArrayMapOuter");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        "a,b,c,d,e".split(","),
        new Object[] {1, 2, 3, n0_1, n0_2});
    assertEquals(int.class, stmt.getEventType().getPropertyType("a"));
  }
  public void testArrayProperty() {
    EPServiceProvider epService = getEngineInitialized(null, null, null);

    // test map containing first-level property that is an array of primitive or Class
    String[] props = {"p0", "p1"};
    Object[] types = {int[].class, SupportBean[].class};
    epService.getEPAdministrator().getConfiguration().addEventType("MyArrayOA", props, types);

    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "select p0[0] as a, p0[1] as b, p1[0].intPrimitive as c, p1[1] as d, p0 as e from MyArrayOA");
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);

    int[] p0 = new int[] {1, 2, 3};
    SupportBean[] beans = new SupportBean[] {new SupportBean("e1", 5), new SupportBean("e2", 6)};
    Object[] eventData = new Object[] {p0, beans};
    epService.getEPRuntime().sendEvent(eventData, "MyArrayOA");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        "a,b,c,d,e".split(","),
        new Object[] {1, 2, 5, beans[1], p0});
    assertEquals(int.class, stmt.getEventType().getPropertyType("a"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("b"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("c"));
    assertEquals(SupportBean.class, stmt.getEventType().getPropertyType("d"));
    assertEquals(int[].class, stmt.getEventType().getPropertyType("e"));
    stmt.destroy();

    // test map at the second level of a nested map that is an array of primitive or Class
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyArrayOAMapOuter", new String[] {"outer"}, new Object[] {"MyArrayOA"});

    stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "select outer.p0[0] as a, outer.p0[1] as b, outer.p1[0].intPrimitive as c, outer.p1[1] as d, outer.p0 as e from MyArrayOAMapOuter");
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new Object[] {eventData}, "MyArrayOAMapOuter");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), "a,b,c,d".split(","), new Object[] {1, 2, 5, beans[1]});
    assertEquals(int.class, stmt.getEventType().getPropertyType("a"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("b"));
    assertEquals(int.class, stmt.getEventType().getPropertyType("c"));
    assertEquals(SupportBean.class, stmt.getEventType().getPropertyType("d"));
    assertEquals(int[].class, stmt.getEventType().getPropertyType("e"));
  }
  private void runAssertionInsertIntoBean(Object[] rowValues) {
    epService.getEPAdministrator().getConfiguration().addEventType(MyBeanCtor.class);
    String epl = "insert into MyBeanCtor select * from SupportBean_S2, MyTable";
    EPStatement stmt = epService.getEPAdministrator().createEPL(epl);
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    assertEventUnd(listener.assertOneGetNewAndReset().get("arr"), rowValues);

    stmt.destroy();
  }
Esempio n. 10
0
  private void runAssertionPerformance(boolean namedWindow, EventRepresentationEnum outputType) {

    String eplCreate =
        namedWindow
            ? outputType.getAnnotationText()
                + " create window MyWindow.win:keepall() as (c1 string, c2 int)"
            : "create table MyWindow(c1 string primary key, c2 int)";
    EPStatement stmtNamedWindow = epService.getEPAdministrator().createEPL(eplCreate);
    assertEquals(outputType.getOutputClass(), stmtNamedWindow.getEventType().getUnderlyingType());

    // preload events
    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "insert into MyWindow select theString as c1, intPrimitive as c2 from SupportBean");
    final int totalUpdated = 5000;
    for (int i = 0; i < totalUpdated; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 0));
    }
    stmt.destroy();

    String epl =
        "on SupportBean sb merge MyWindow nw where nw.c1 = sb.theString "
            + "when matched then update set nw.c2=sb.intPrimitive";
    stmt = epService.getEPAdministrator().createEPL(epl);
    stmt.addListener(mergeListener);

    // prime
    for (int i = 0; i < 100; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 1));
    }
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < totalUpdated; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 1));
    }
    long endTime = System.currentTimeMillis();
    long delta = endTime - startTime;

    // verify
    Iterator<EventBean> events = stmtNamedWindow.iterator();
    int count = 0;
    for (; events.hasNext(); ) {
      EventBean next = events.next();
      assertEquals(1, next.get("c2"));
      count++;
    }
    assertEquals(totalUpdated, count);
    assertTrue("Delta=" + delta, delta < 500);

    epService.getEPAdministrator().destroyAllStatements();
    epService.getEPAdministrator().getConfiguration().removeEventType("MyWindow", true);
  }
  private void runAssertionSubquerySelectStar(Object[] rowValues, String epl) {
    EPStatement stmt = epService.getEPAdministrator().createEPL(epl);
    stmt.addListener(listener);

    assertEquals(Object[].class, stmt.getEventType().getPropertyType("mt"));

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    EventBean event = listener.assertOneGetNewAndReset();
    assertEventUnd(event.get("mt"), rowValues);

    stmt.destroy();
  }
  private void runAssertionSubquerySelectWEnumMethod(Object[] rowValues) {
    String epl = "select (select * from MyTable).where(v=>v.key = 'G1') as mt from SupportBean_S2";
    EPStatement stmt = epService.getEPAdministrator().createEPL(epl);
    stmt.addListener(listener);

    assertEquals(Collection.class, stmt.getEventType().getPropertyType("mt"));

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
    Collection coll = (Collection) listener.assertOneGetNewAndReset().get("mt");
    assertEventUnd(coll.iterator().next(), rowValues);

    stmt.destroy();
  }
 private void runAssertionSubqueryWindowAgg(Object[] rowValues) {
   EPStatement stmt =
       epService
           .getEPAdministrator()
           .createEPL(
               "select "
                   + "(select window(mt.*) from MyTable as mt) as c0,"
                   + "(select first(mt.*) from MyTable as mt) as c1"
                   + " from SupportBean_S2");
   stmt.addListener(listener);
   epService.getEPRuntime().sendEvent(new SupportBean_S2(0));
   EventBean event = listener.assertOneGetNewAndReset();
   assertEventUnd(((Object[][]) event.get("c0"))[0], rowValues);
   assertEventUnd(event.get("c1"), rowValues);
   stmt.destroy();
 }
  private void runAssertionJoinSelectStreamName(Object[][] expectedType, Object[] rowValues) {
    String joinEpl = "select mt from MyTable as mt, SupportBean_S2 where key = p20";
    EPStatement stmt = epService.getEPAdministrator().createEPL(joinEpl);
    stmt.addListener(listener);

    assertEventType(stmt.getEventType().getFragmentType("mt").getFragmentType(), expectedType);

    epService.getEPRuntime().sendEvent(new SupportBean_S2(0, "G1"));
    EventBean event = listener.assertOneGetNewAndReset();
    assertEventTypeAndEvent(
        event.getEventType().getFragmentType("mt").getFragmentType(),
        expectedType,
        event.get("mt"),
        rowValues);

    stmt.destroy();
  }
Esempio n. 15
0
  public void testJoinMapEvent() {
    String joinStatement =
        "select S0.id, S1.id, S0.p00, S1.p00 from MapS0.win:keepall() as S0, MapS1.win:keepall() as S1"
            + " where S0.id = S1.id";

    EPStatement stmt = epService.getEPAdministrator().createEPL(joinStatement);
    stmt.addListener(listener);

    runAssertion();

    stmt.destroy();
    joinStatement =
        "select * from MapS0.win:keepall() as S0, MapS1.win:keepall() as S1 where S0.id = S1.id";
    stmt = epService.getEPAdministrator().createEPL(joinStatement);
    stmt.addListener(listener);

    runAssertion();
  }
  private void runAssertionJoinSelectStreamStarUnnamed(
      Object[][] expectedType, Object[] rowValues) {
    String joinEpl = "select mt.* from MyTable as mt, SupportBean_S2 where key = p20";
    EPStatement stmt = epService.getEPAdministrator().createEPL(joinEpl);
    stmt.addListener(listener);
    stmt.setSubscriber(subscriber);

    assertEventType(stmt.getEventType(), expectedType);

    // listener assertion
    epService.getEPRuntime().sendEvent(new SupportBean_S2(0, "G1"));
    EventBean event = listener.assertOneGetNewAndReset();
    assertEventTypeAndEvent(event.getEventType(), expectedType, event.getUnderlying(), rowValues);

    // subscriber assertion
    Object[][] newData = subscriber.getAndResetIndicateArr().get(0).getFirst();
    assertEventUnd(newData[0][0], rowValues);

    stmt.destroy();
  }
Esempio n. 17
0
  public void testVariantRStreamOMToStmt() throws Exception {
    EPStatementObjectModel model = new EPStatementObjectModel();
    model.setInsertInto(
        InsertIntoClause.create("Event_1", new String[0], StreamSelector.RSTREAM_ONLY));
    model.setSelectClause(SelectClause.create().add("intPrimitive", "intBoxed"));
    model.setFromClause(FromClause.create(FilterStream.create(SupportBean.class.getName())));
    model = (EPStatementObjectModel) SerializableObjectCopier.copy(model);

    EPStatement stmt = epService.getEPAdministrator().create(model, "s1");

    String epl =
        "insert rstream into Event_1 "
            + "select intPrimitive, intBoxed "
            + "from "
            + SupportBean.class.getName();
    assertEquals(epl, model.toEPL());
    assertEquals(epl, stmt.getText());

    EPStatementObjectModel modelTwo = epService.getEPAdministrator().compileEPL(model.toEPL());
    model = (EPStatementObjectModel) SerializableObjectCopier.copy(model);
    assertEquals(epl, modelTwo.toEPL());

    // assert statement-type reference
    EPServiceProviderSPI spi = (EPServiceProviderSPI) epService;
    assertTrue(spi.getStatementEventTypeRef().isInUse("Event_1"));
    Set<String> stmtNames =
        spi.getStatementEventTypeRef().getStatementNamesForType(SupportBean.class.getName());
    assertTrue(stmtNames.contains("s1"));

    stmt.destroy();

    assertFalse(spi.getStatementEventTypeRef().isInUse("Event_1"));
    stmtNames =
        spi.getStatementEventTypeRef().getStatementNamesForType(SupportBean.class.getName());
    assertFalse(stmtNames.contains("s1"));
  }
Esempio n. 18
0
  public void testAnyType() {
    assertTrue(
        epService.getEPAdministrator().getConfiguration().isVariantStreamExists("MyVariantStream"));
    epService
        .getEPAdministrator()
        .createEPL("insert into MyVariantStream select * from " + SupportBean.class.getName());
    epService
        .getEPAdministrator()
        .createEPL(
            "insert into MyVariantStream select * from "
                + SupportBeanVariantStream.class.getName());
    epService
        .getEPAdministrator()
        .createEPL("insert into MyVariantStream select * from " + SupportBean_A.class.getName());
    epService
        .getEPAdministrator()
        .createEPL(
            "insert into MyVariantStream select symbol as theString, volume as intPrimitive, feed as id from "
                + SupportMarketDataBean.class.getName());

    EPStatement stmt = epService.getEPAdministrator().createEPL("select * from MyVariantStream");
    stmt.addListener(listener);
    assertEquals(0, stmt.getEventType().getPropertyNames().length);

    Object eventOne = new SupportBean("E0", -1);
    epService.getEPRuntime().sendEvent(eventOne);
    assertSame(eventOne, listener.assertOneGetNewAndReset().getUnderlying());

    Object eventTwo = new SupportBean_A("E1");
    epService.getEPRuntime().sendEvent(eventTwo);
    assertSame(eventTwo, listener.assertOneGetNewAndReset().getUnderlying());

    stmt.destroy();
    stmt =
        epService
            .getEPAdministrator()
            .createEPL("select theString,id,intPrimitive from MyVariantStream");
    stmt.addListener(listener);
    assertEquals(Object.class, stmt.getEventType().getPropertyType("theString"));
    assertEquals(Object.class, stmt.getEventType().getPropertyType("id"));
    assertEquals(Object.class, stmt.getEventType().getPropertyType("intPrimitive"));

    String[] fields = "theString,id,intPrimitive".split(",");
    epService.getEPRuntime().sendEvent(new SupportBeanVariantStream("E1"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {"E1", null, null});

    epService.getEPRuntime().sendEvent(new SupportBean("E2", 10));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {"E2", null, 10});

    epService.getEPRuntime().sendEvent(new SupportBean_A("E3"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {null, "E3", null});

    epService.getEPRuntime().sendEvent(new SupportMarketDataBean("s1", 100, 1000L, "f1"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {"s1", "f1", 1000L});
    epService.getEPAdministrator().destroyAllStatements();

    // Test inserting a wrapper of underlying plus properties
    epService.getEPAdministrator().getConfiguration().addEventType(SupportBean.class);
    epService.getEPAdministrator().createEPL("create variant schema TheVariantStream as *");
    epService
        .getEPAdministrator()
        .createEPL(
            "insert into TheVariantStream select 'test' as eventConfigId, * from SupportBean");
    epService
        .getEPAdministrator()
        .createEPL("select * from TheVariantStream")
        .addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean("E1", 1));
    EventBean event = listener.assertOneGetNewAndReset();
    assertEquals("test", event.get("eventConfigId"));
    assertEquals(1, event.get("intPrimitive"));
  }
  private void runAssertion(
      boolean enableIndexShareCreate,
      boolean disableIndexShareConsumer,
      boolean createExplicitIndex) {

    SupportUpdateListener listener = new SupportUpdateListener();
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("SupportBean", SupportBean.class);
    epService.getEPAdministrator().getConfiguration().addEventType("S0", SupportBean_S0.class);

    String createEpl = "create window SupportWindow.win:keepall() as select * from SupportBean";
    if (enableIndexShareCreate) {
      createEpl = "@Hint('enable_window_subquery_indexshare') " + createEpl;
    }
    epService.getEPAdministrator().createEPL(createEpl);
    epService.getEPAdministrator().createEPL("insert into SupportWindow select * from SupportBean");

    EPStatement indexStmt = null;
    if (createExplicitIndex) {
      indexStmt =
          epService
              .getEPAdministrator()
              .createEPL("create index MyIndex on SupportWindow(theString)");
    }

    epService.getEPRuntime().sendEvent(new SupportBean("E1", 1));
    epService.getEPRuntime().sendEvent(new SupportBean("E2", -2));

    String consumeEpl =
        "select (select intPrimitive from SupportWindow(intPrimitive<0) sw where s0.p00=sw.theString) as val from S0 s0";
    if (disableIndexShareConsumer) {
      consumeEpl = "@Hint('disable_window_subquery_indexshare') " + consumeEpl;
    }
    EPStatement consumeStmt = epService.getEPAdministrator().createEPL(consumeEpl);
    consumeStmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S0(10, "E1"));
    assertEquals(null, listener.assertOneGetNewAndReset().get("val"));

    epService.getEPRuntime().sendEvent(new SupportBean_S0(20, "E2"));
    assertEquals(-2, listener.assertOneGetNewAndReset().get("val"));

    epService.getEPRuntime().sendEvent(new SupportBean("E3", -3));
    epService.getEPRuntime().sendEvent(new SupportBean("E4", 4));

    epService.getEPRuntime().sendEvent(new SupportBean_S0(-3, "E3"));
    assertEquals(-3, listener.assertOneGetNewAndReset().get("val"));

    epService.getEPRuntime().sendEvent(new SupportBean_S0(20, "E4"));
    assertEquals(null, listener.assertOneGetNewAndReset().get("val"));

    consumeStmt.stop();
    if (indexStmt != null) {
      indexStmt.stop();
    }
    consumeStmt.destroy();
    if (indexStmt != null) {
      indexStmt.destroy();
    }
  }
Esempio n. 20
0
  public void testAddRemoveType() {
    epService = EPServiceProviderManager.getProvider("TestSchemaXML", getConfig(false));
    epService.initialize();
    updateListener = new SupportUpdateListener();
    ConfigurationOperations configOps = epService.getEPAdministrator().getConfiguration();

    // test remove type with statement used (no force)
    configOps.addEventType("MyXMLEvent", getConfigTestType("p01", false));
    EPStatement stmt =
        epService.getEPAdministrator().createEPL("select p01 from MyXMLEvent", "stmtOne");
    EPAssertionUtil.assertEqualsExactOrder(
        configOps.getEventTypeNameUsedBy("MyXMLEvent").toArray(), new String[] {"stmtOne"});

    try {
      configOps.removeEventType("MyXMLEvent", false);
    } catch (ConfigurationException ex) {
      assertTrue(ex.getMessage().contains("MyXMLEvent"));
    }

    // destroy statement and type
    stmt.destroy();
    assertTrue(configOps.getEventTypeNameUsedBy("MyXMLEvent").isEmpty());
    assertTrue(configOps.isEventTypeExists("MyXMLEvent"));
    assertTrue(configOps.removeEventType("MyXMLEvent", false));
    assertFalse(configOps.removeEventType("MyXMLEvent", false)); // try double-remove
    assertFalse(configOps.isEventTypeExists("MyXMLEvent"));
    try {
      epService.getEPAdministrator().createEPL("select p01 from MyXMLEvent");
      fail();
    } catch (EPException ex) {
      // expected
    }

    // add back the type
    configOps.addEventType("MyXMLEvent", getConfigTestType("p20", false));
    assertTrue(configOps.isEventTypeExists("MyXMLEvent"));
    assertTrue(configOps.getEventTypeNameUsedBy("MyXMLEvent").isEmpty());

    // compile
    epService.getEPAdministrator().createEPL("select p20 from MyXMLEvent", "stmtTwo");
    EPAssertionUtil.assertEqualsExactOrder(
        configOps.getEventTypeNameUsedBy("MyXMLEvent").toArray(), new String[] {"stmtTwo"});
    try {
      epService.getEPAdministrator().createEPL("select p01 from MyXMLEvent");
      fail();
    } catch (EPException ex) {
      // expected
    }

    // remove with force
    try {
      configOps.removeEventType("MyXMLEvent", false);
    } catch (ConfigurationException ex) {
      assertTrue(ex.getMessage().contains("MyXMLEvent"));
    }
    assertTrue(configOps.removeEventType("MyXMLEvent", true));
    assertFalse(configOps.isEventTypeExists("MyXMLEvent"));
    assertTrue(configOps.getEventTypeNameUsedBy("MyXMLEvent").isEmpty());

    // add back the type
    configOps.addEventType("MyXMLEvent", getConfigTestType("p03", false));
    assertTrue(configOps.isEventTypeExists("MyXMLEvent"));

    // compile
    epService.getEPAdministrator().createEPL("select p03 from MyXMLEvent");
    try {
      epService.getEPAdministrator().createEPL("select p20 from MyXMLEvent");
      fail();
    } catch (EPException ex) {
      // expected
    }
  }
Esempio n. 21
0
  public void testTopLevelReadUnGrouped() {
    epService.getEPAdministrator().getConfiguration().addEventType(AggBean.class);
    epService.getEPAdministrator().createEPL("create objectarray schema MyEvent(c0 int)");
    epService
        .getEPAdministrator()
        .createEPL(
            "create table windowAndTotal ("
                + "thewindow window(*) @type(MyEvent), thetotal sum(int))");
    epService
        .getEPAdministrator()
        .createEPL(
            "into table windowAndTotal "
                + "select window(*) as thewindow, sum(c0) as thetotal from MyEvent.win:length(2)");

    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL("select windowAndTotal as val0 from SupportBean_S0");
    stmt.addListener(listener);

    Object[] e1 = new Object[] {10};
    epService.getEPRuntime().sendEvent(e1, "MyEvent");

    String[] fieldsInner = "thewindow,thetotal".split(",");
    epService.getEPRuntime().sendEvent(new SupportBean_S0(0));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"), fieldsInner, new Object[][] {e1}, 10);

    Object[] e2 = new Object[] {20};
    epService.getEPRuntime().sendEvent(e2, "MyEvent");

    epService.getEPRuntime().sendEvent(new SupportBean_S0(1));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"),
        fieldsInner,
        new Object[][] {e1, e2},
        30);

    Object[] e3 = new Object[] {30};
    epService.getEPRuntime().sendEvent(e3, "MyEvent");

    epService.getEPRuntime().sendEvent(new SupportBean_S0(2));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"),
        fieldsInner,
        new Object[][] {e2, e3},
        50);

    // test typable output
    stmt.destroy();
    EPStatement stmtConvert =
        epService
            .getEPAdministrator()
            .createEPL("insert into AggBean select windowAndTotal as val0 from SupportBean_S0");
    stmtConvert.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S0(2));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        "val0.thewindow,val0.thetotal".split(","),
        new Object[] {new Object[][] {e2, e3}, 50});
  }
Esempio n. 22
0
  private void runAssertionTopLevelReadGrouped2Keys(boolean soda) {
    SupportModelHelper.createByCompileOrParse(
        epService, soda, "create objectarray schema MyEvent as (c0 int, c1 string, c2 int)");
    SupportModelHelper.createByCompileOrParse(
        epService,
        soda,
        "create table windowAndTotal ("
            + "keyi int primary key, keys string primary key, thewindow window(*) @type('MyEvent'), thetotal sum(int))");
    SupportModelHelper.createByCompileOrParse(
        epService,
        soda,
        "into table windowAndTotal "
            + "select window(*) as thewindow, sum(c2) as thetotal from MyEvent.win:length(2) group by c0, c1");

    EPStatement stmtSelect =
        SupportModelHelper.createByCompileOrParse(
            epService, soda, "select windowAndTotal[id,p00] as val0 from SupportBean_S0");
    stmtSelect.addListener(listener);
    assertTopLevelTypeInfo(stmtSelect);

    Object[] e1 = new Object[] {10, "G1", 100};
    epService.getEPRuntime().sendEvent(e1, "MyEvent");

    String[] fieldsInner = "thewindow,thetotal".split(",");
    epService.getEPRuntime().sendEvent(new SupportBean_S0(10, "G1"));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"),
        fieldsInner,
        new Object[][] {e1},
        100);

    Object[] e2 = new Object[] {20, "G2", 200};
    epService.getEPRuntime().sendEvent(e2, "MyEvent");

    epService.getEPRuntime().sendEvent(new SupportBean_S0(20, "G2"));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"),
        fieldsInner,
        new Object[][] {e2},
        200);

    Object[] e3 = new Object[] {20, "G2", 300};
    epService.getEPRuntime().sendEvent(e3, "MyEvent");

    epService.getEPRuntime().sendEvent(new SupportBean_S0(10, "G1"));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"), fieldsInner, null, null);
    epService.getEPRuntime().sendEvent(new SupportBean_S0(20, "G2"));
    EPAssertionUtil.assertPropsMap(
        (Map) listener.assertOneGetNewAndReset().get("val0"),
        fieldsInner,
        new Object[][] {e2, e3},
        500);

    // test typable output
    stmtSelect.destroy();
    EPStatement stmtConvert =
        epService
            .getEPAdministrator()
            .createEPL(
                "insert into AggBean select windowAndTotal[20, 'G2'] as val0 from SupportBean_S0");
    stmtConvert.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportBean_S0(0));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        "val0.thewindow,val0.thetotal".split(","),
        new Object[] {new Object[][] {e2, e3}, 500});

    epService.getEPAdministrator().destroyAllStatements();
  }
Esempio n. 23
0
  public void testAverageScalar() {

    String[] fields = "val0,val1".split(",");
    String eplFragment =
        "select "
            + "intvals.average() as val0,"
            + "bdvals.average() as val1 "
            + "from SupportCollection";
    EPStatement stmtFragment = epService.getEPAdministrator().createEPL(eplFragment);
    stmtFragment.addListener(listener);
    LambdaAssertionUtil.assertTypes(
        stmtFragment.getEventType(), fields, new Class[] {Double.class, BigDecimal.class});

    epService.getEPRuntime().sendEvent(SupportCollection.makeNumeric("1,2,3"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {2d, new BigDecimal(2d)});

    epService.getEPRuntime().sendEvent(SupportCollection.makeNumeric("1,null,3"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {2d, new BigDecimal(2d)});

    epService.getEPRuntime().sendEvent(SupportCollection.makeNumeric("4"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fields, new Object[] {4d, new BigDecimal(4d)});
    stmtFragment.destroy();

    // test average with lambda
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInSingleRowFunction(
            "extractNum", TestEnumMinMax.MyService.class.getName(), "extractNum");
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInSingleRowFunction(
            "extractBigDecimal", TestEnumMinMax.MyService.class.getName(), "extractBigDecimal");

    String[] fieldsLambda = "val0,val1".split(",");
    String eplLambda =
        "select "
            + "strvals.average(v => extractNum(v)) as val0, "
            + "strvals.average(v => extractBigDecimal(v)) as val1 "
            + "from SupportCollection";
    EPStatement stmtLambda = epService.getEPAdministrator().createEPL(eplLambda);
    stmtLambda.addListener(listener);
    LambdaAssertionUtil.assertTypes(
        stmtLambda.getEventType(), fieldsLambda, new Class[] {Double.class, BigDecimal.class});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E2,E1,E5,E4"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(),
        fieldsLambda,
        new Object[] {(2 + 1 + 5 + 4) / 4d, new BigDecimal((2 + 1 + 5 + 4) / 4d)});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString("E1"));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fieldsLambda, new Object[] {1d, new BigDecimal(1)});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(null));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fieldsLambda, new Object[] {null, null});

    epService.getEPRuntime().sendEvent(SupportCollection.makeString(""));
    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), fieldsLambda, new Object[] {null, null});
  }
  public void testMappedProperty() {
    EPServiceProvider epService = getEngineInitialized(null, null, null);

    // test map containing first-level property that is an array of primitive or Class
    Map<String, Object> mappedDef = makeMap(new Object[][] {{"p0", Map.class}});
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyMappedPropertyMap", mappedDef);

    EPStatement stmt =
        epService.getEPAdministrator().createEPL("select p0('k1') as a from MyMappedPropertyMap");
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);

    Map<String, Object> eventVal = new HashMap<String, Object>();
    eventVal.put("k1", "v1");
    Map<String, Object> theEvent = makeMap(new Object[][] {{"p0", eventVal}});
    epService.getEPRuntime().sendEvent(theEvent, "MyMappedPropertyMap");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), "a".split(","), new Object[] {"v1"});
    assertEquals(Object.class, stmt.getEventType().getPropertyType("a"));
    stmt.destroy();

    // test map at the second level of a nested map that is an array of primitive or Class
    Map<String, Object> mappedDefOuter = makeMap(new Object[][] {{"outer", mappedDef}});
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyMappedPropertyMapOuter", mappedDefOuter);

    stmt =
        epService
            .getEPAdministrator()
            .createEPL("select outer.p0('k1') as a from MyMappedPropertyMapOuter");
    stmt.addListener(listener);

    Map<String, Object> eventOuter = makeMap(new Object[][] {{"outer", theEvent}});
    epService.getEPRuntime().sendEvent(eventOuter, "MyMappedPropertyMapOuter");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), "a".split(","), new Object[] {"v1"});
    assertEquals(Object.class, stmt.getEventType().getPropertyType("a"));

    // test map that contains a bean which has a map property
    Map<String, Object> mappedDefOuterTwo =
        makeMap(new Object[][] {{"outerTwo", SupportBeanComplexProps.class}});
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyMappedPropertyMapOuterTwo", mappedDefOuterTwo);

    stmt =
        epService
            .getEPAdministrator()
            .createEPL("select outerTwo.mapProperty('xOne') as a from MyMappedPropertyMapOuterTwo");
    stmt.addListener(listener);

    Map<String, Object> eventOuterTwo =
        makeMap(new Object[][] {{"outerTwo", SupportBeanComplexProps.makeDefaultBean()}});
    epService.getEPRuntime().sendEvent(eventOuterTwo, "MyMappedPropertyMapOuterTwo");

    EPAssertionUtil.assertProps(
        listener.assertOneGetNewAndReset(), "a".split(","), new Object[] {"yOne"});
    assertEquals(String.class, stmt.getEventType().getPropertyType("a"));
  }