Reproduce issue discussed at http://old.nabble.com/Selecting-from-patterns-with-MapEventBeans-and-.*-td34426479.html

InsertFromPatternTest.java

package repro;

import com.espertech.esper.client.*;
import com.espertech.esper.event.map.MapEventBean;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class InsertFromPatternTest {

    EPServiceProvider esperProvider;
    EPAdministrator esperAdmin;
    EPRuntime esperRuntime;
    ConfigurationOperations esperConfig;
    private LoggingUpdateListener loggingUpdateListener;

    private class LoggingUpdateListener implements StatementAwareUpdateListener {

        @Override
        public void update(EventBean[] newEvents, EventBean[] oldEvents, EPStatement statement, EPServiceProvider epServiceProvider) {
            for(EventBean newEvent : newEvents) {
                System.out.print("Triggered statement ");
                System.out.print(statement.getName());
                System.out.print(": ");
                System.out.println(newEvent.toString());
                if (newEvent instanceof MapEventBean) {
                    MapEventBean mapEvent = (MapEventBean) newEvent;
                    System.out.println("  Map with fields:");
                    Map<String, Object> props = mapEvent.getProperties();
                    for(Map.Entry<String, Object> entry : props.entrySet()) {
                        System.out.println("    " + entry.getKey() + " => " + entry.getValue().toString());
                    }
                }
            }
        }
    }

    InsertFromPatternTest() {
        loggingUpdateListener = new LoggingUpdateListener();
        esperProvider = EPServiceProviderManager.getProvider("InsertFromPatternTest");
        esperProvider.initialize();
        esperAdmin = esperProvider.getEPAdministrator();
        esperConfig = esperAdmin.getConfiguration();
        esperRuntime = esperProvider.getEPRuntime();
    }

    /* small but sufficient subset of the Clojure implementation */
    void defineEventType(String event_name, String[] names, Object[] types, String[] superclasses) {
        ConfigurationEventTypeMap extraConfig = new ConfigurationEventTypeMap();

        HashMap<String, Object> typeMap = new HashMap<String, Object>();
        for(int i=0; i < types.length; i++) {
            typeMap.put(names[i], types[i]);
        }

        Set<String> supertypes = new HashSet<String>();
        for(String superclass : superclasses) {
            supertypes.add(superclass);
        }

        esperConfig.addEventType(event_name, typeMap, extraConfig);
    }

    void defineStatement(String statementName, String statementText) {
        EPStatement oldQuery = esperAdmin.getStatement(statementName);
        if(oldQuery != null) {
            oldQuery.destroy();
        }

        EPStatement newQuery = esperAdmin.createEPL(statementText, statementName);
        newQuery.addListener(loggingUpdateListener);
    }

    void insertEvent(String eventName, String[] eventProperties, Object[] eventValues) {
        Map<String, Object> eventMap = new HashMap<String, Object>();
        for(int i=0; i<eventProperties.length; i++) {
            eventMap.put(eventProperties[i], eventValues[i]);
        }
        esperRuntime.sendEvent(eventMap, eventName);
    }

    void run() {
        defineEventType("Car",
            new String[] {"color", "weight"},
            new Object[] {java.lang.String.class, java.lang.Long.class},
            new String[] {});
        defineEventType("NewCar",
            new String[] {},
            new Object[] {},
            new String[] {"Car"});
        defineEventType("WreckedCar",
            new String[] {},
            new Object[] {},
            new String[] {"Car"});
        defineEventType("Wreck",
            new String[] {},
            new Object[] {},
            new String[] {});
        defineStatement("wreck-new-car",
            "insert into WreckedCar select C.* from pattern[C=NewCar -> Wreck]");
        defineStatement("select-wrecked-cars",
            "select * from WreckedCar");
        insertEvent("NewCar",
            new String[] {"color", "weight"},
            new Object[] {"red", 1500});
        insertEvent("Wreck",
            new String[] {},
            new Object[] {});
    }

    public static void main(String[] args) {
        InsertFromPatternTest instance = new InsertFromPatternTest();
        instance.run();
    }
}

sample-output-actual.txt

Triggered statement wreck-new-car: MapEventBean eventType=com.espertech.esper.event.map.MapEventType@1018f51f
  Map with fields:
    C => MapEventBean eventType=com.espertech.esper.event.map.MapEventType@61acfa31
Triggered statement select-wrecked-cars: MapEventBean eventType=com.espertech.esper.event.map.MapEventType@1018f51f
  Map with fields:
    C => MapEventBean eventType=com.espertech.esper.event.map.MapEventType@61acfa31