/* *************************************************************************************** * Copyright (C) 2006 EsperTech, Inc. All rights reserved. * * http://www.espertech.com/esper * * http://www.espertech.com * * ---------------------------------------------------------------------------------- * * The software in this package is published under the terms of the GPL license * * a copy of which has been included with this distribution in the license.txt file. * *************************************************************************************** */ package com.espertech.esper.regression.nwtable; import com.espertech.esper.client.*; import com.espertech.esper.client.scopetest.EPAssertionUtil; import com.espertech.esper.client.scopetest.SupportUpdateListener; import com.espertech.esper.client.time.CurrentTimeEvent; import com.espertech.esper.core.service.EPServiceProviderSPI; import com.espertech.esper.metrics.instrumentation.InstrumentationHelper; import com.espertech.esper.supportregression.subscriber.SupportSubscriberMultirowObjectArrayNStmt; import com.espertech.esper.supportregression.bean.SupportBean; import com.espertech.esper.supportregression.bean.SupportBean_S0; import com.espertech.esper.supportregression.bean.SupportBean_S1; import com.espertech.esper.supportregression.bean.SupportBean_S2; import com.espertech.esper.supportregression.client.SupportConfigFactory; import com.espertech.esper.util.support.SupportEventTypeAssertionEnum; import com.espertech.esper.util.support.SupportEventTypeAssertionUtil; import junit.framework.TestCase; import java.util.Collection; import java.util.concurrent.atomic.AtomicLong; public class TestTableSelectStarPublicTypeVisibility extends TestCase { private EPServiceProvider epService; private SupportUpdateListener listener; private SupportSubscriberMultirowObjectArrayNStmt subscriber; public void setUp() { Configuration config = SupportConfigFactory.getConfiguration(); epService = EPServiceProviderManager.getDefaultProvider(config); epService.initialize(); for (Class clazz : new Class[] {SupportBean.class, SupportBean_S0.class, SupportBean_S1.class, SupportBean_S2.class}) { epService.getEPAdministrator().getConfiguration().addEventType(clazz); } listener = new SupportUpdateListener(); subscriber = new SupportSubscriberMultirowObjectArrayNStmt(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.startTest(epService, this.getClass(), getName());} } public void tearDown() { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.endTest();} listener = null; subscriber = null; } public void testSelectPublicTypeAndUnderlying() throws Exception { AtomicLong currentTime = new AtomicLong(0); epService.getEPRuntime().sendEvent(new CurrentTimeEvent(currentTime.get())); epService.getEPAdministrator().createEPL("@name('create') create table MyTable as (\n" + "key string primary key,\n" + "totalInt sum(int),\n" + "p0 string,\n" + "winsb window(*) @type(SupportBean),\n" + "totalLong sum(long),\n" + "p1 string,\n" + "winsb0 window(*) @type(SupportBean_S0)\n" + ")"); Object[][] expectedType = new Object[][]{ {"key", String.class}, {"totalInt", Integer.class}, {"p0", String.class}, {"winsb", SupportBean[].class}, {"totalLong", Long.class}, {"p1", String.class}, {"winsb0", SupportBean_S0[].class}, }; epService.getEPAdministrator().createEPL("into table MyTable " + "select sum(intPrimitive) as totalInt, sum(longPrimitive) as totalLong," + "window(*) as winsb from SupportBean#keepall group by theString"); epService.getEPAdministrator().createEPL("into table MyTable " + "select window(*) as winsb0 from SupportBean_S0#keepall group by p00"); epService.getEPAdministrator().createEPL("on SupportBean_S1 " + "merge MyTable where p10 = key when matched then " + "update set p0 = p11, p1 = p12"); SupportBean e1_sb = makeSupportBean("G1", 10, 100); epService.getEPRuntime().sendEvent(e1_sb); // update some aggs SupportBean_S0 e2_sb0 = new SupportBean_S0(5, "G1"); epService.getEPRuntime().sendEvent(e2_sb0); // update more aggs epService.getEPRuntime().sendEvent(new SupportBean_S1(6, "G1", "a", "b")); // merge more values Object[] rowValues = {"G1", 10, "a", new SupportBean[] {e1_sb}, 100L, "b", new SupportBean_S0[] {e2_sb0}}; runAssertionSubqueryWindowAgg(rowValues); runAssertionOnSelectWindowAgg(expectedType, rowValues); runAssertionSubquerySelectStar(rowValues); runAssertionSubquerySelectWEnumMethod(rowValues); runAssertionIterateCreateTable(expectedType, rowValues, epService.getEPAdministrator().getStatement("create")); runAssertionJoinSelectStar(expectedType, rowValues); runAssertionJoinSelectStreamName(expectedType, rowValues); runAssertionJoinSelectStreamStarNamed(expectedType, rowValues); runAssertionJoinSelectStreamStarUnnamed(expectedType, rowValues); runAssertionInsertIntoBean(rowValues); runAssertionSingleRowFunc(rowValues); runAssertionOutputSnapshot(expectedType, rowValues, currentTime); runAssertionFireAndForgetSelectStar(expectedType, rowValues); runAssertionFireAndForgetInsertUpdateDelete(expectedType); } 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 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(); } private void runAssertionOutputSnapshot(Object[][] expectedType, Object[] rowValues, AtomicLong currentTime) { EPStatement stmt = epService.getEPAdministrator().createEPL("select * from MyTable output snapshot every 1 second"); stmt.addListener(listener); assertEventType(stmt.getEventType(), expectedType); currentTime.set(currentTime.get() + 1000L); epService.getEPRuntime().sendEvent(new CurrentTimeEvent(currentTime.get())); EventBean event = listener.assertOneGetNewAndReset(); assertEventTypeAndEvent(event.getEventType(), expectedType, event.getUnderlying(), rowValues); } private void runAssertionFireAndForgetInsertUpdateDelete(Object[][] expectedType) { EPOnDemandQueryResult result = epService.getEPRuntime().executeQuery("insert into MyTable(key) values ('dummy')"); assertEventType(result.getEventType(), expectedType); result = epService.getEPRuntime().executeQuery("delete from MyTable where key = 'dummy'"); assertEventType(result.getEventType(), expectedType); result = epService.getEPRuntime().executeQuery("update MyTable set key='dummy' where key='dummy'"); assertEventType(result.getEventType(), expectedType); } private void runAssertionIterateCreateTable(Object[][] expectedType, Object[] rowValues, EPStatement stmtCreate) { assertEventTypeAndEvent(stmtCreate.getEventType(), expectedType, stmtCreate.iterator().next().getUnderlying(), rowValues); } 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(); } 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(); } 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 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 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 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(); } private void runAssertionJoinSelectStreamStarNamed(Object[][] expectedType, Object[] rowValues) { String joinEpl = "select mt.* as mymt from MyTable as mt, SupportBean_S2 where key = p20"; EPStatement stmt = epService.getEPAdministrator().createEPL(joinEpl); stmt.addListener(listener); stmt.setSubscriber(subscriber); assertEventType(stmt.getEventType().getFragmentType("mymt").getFragmentType(), expectedType); // listener assertion epService.getEPRuntime().sendEvent(new SupportBean_S2(0, "G1")); EventBean event = listener.assertOneGetNewAndReset(); assertEventTypeAndEvent(event.getEventType().getFragmentType("mymt").getFragmentType(), expectedType, event.get("mymt"), rowValues); // subscriber assertion Object[][] newData = subscriber.getAndResetIndicateArr().get(0).getFirst(); assertEventUnd(newData[0][0], 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(); } private void runAssertionJoinSelectStar(Object[][] expectedType, Object[] rowValues) { String joinEpl = "select * from MyTable, SupportBean_S2 where key = p20"; EPStatement stmt = epService.getEPAdministrator().createEPL(joinEpl); stmt.addListener(listener); stmt.setSubscriber(subscriber); assertEventType(stmt.getEventType().getFragmentType("stream_0").getFragmentType(), expectedType); // listener assertion epService.getEPRuntime().sendEvent(new SupportBean_S2(0, "G1")); EventBean event = listener.assertOneGetNewAndReset(); assertEventTypeAndEvent(event.getEventType().getFragmentType("stream_0").getFragmentType(), expectedType, event.get("stream_0"), rowValues); // subscriber assertion Object[][] newData = subscriber.getAndResetIndicateArr().get(0).getFirst(); assertEventUnd(newData[0][0], rowValues); stmt.destroy(); } private void runAssertionFireAndForgetSelectStar(Object[][] expectedType, Object[] rowValues) { EPOnDemandQueryResult result = epService.getEPRuntime().executeQuery("select * from MyTable where key = 'G1'"); assertEventTypeAndEvent(result.getEventType(), expectedType, result.getArray()[0].getUnderlying(), rowValues); } private void assertEventTypeAndEvent(EventType eventType, Object[][] expectedType, Object underlying, Object[] expectedValues) { assertEventType(eventType, expectedType); assertEventUnd(underlying, expectedValues); } private void assertEventUnd(Object underlying, Object[] expectedValues) { Object[] und = (Object[]) underlying; EPAssertionUtil.assertEqualsExactOrder(expectedValues, und); } private void assertEventType(EventType eventType, Object[][] expectedType) { SupportEventTypeAssertionUtil.assertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE); } private SupportBean makeSupportBean(String theString, int intPrimitive, int longPrimitive) { SupportBean supportBean = new SupportBean(theString, intPrimitive); supportBean.setLongPrimitive(longPrimitive); return supportBean; } public static Object[] myServiceEventBean(EventBean event) { return (Object[]) event.getUnderlying(); } public static Object[] myServiceObjectArray(Object[] data) { return data; } public EventType getTablePublicType(String tableName) { return ((EPServiceProviderSPI) epService).getServicesContext().getTableService().getTableMetadata(tableName).getPublicEventType(); } private static final class MyBeanCtor { private final SupportBean_S2 sb; private final Object[] arr; public MyBeanCtor(SupportBean_S2 sb, Object[] arr) { this.sb = sb; this.arr = arr; } public SupportBean_S2 getSb() { return sb; } public Object[] getArr() { return arr; } } }