Java EPAdministrator.createEPL方法代码示例

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
@Test
public void testTimestamp() {
	final Configuration cepConfig = new Configuration();
	cepConfig.addEventType("Event", EapEvent.class.getName());
	final EPServiceProvider cep = EPServiceProviderManager.getProvider("myCEPEngine", cepConfig);
	final EPRuntime cepRT = cep.getEPRuntime();
	final EPAdministrator cepAdm = cep.getEPAdministrator();

	// create statement
	final EPStatement timeStatement = cepAdm.createEPL("select count(*) from Event.win:time(1 hour)");
	timeStatement.addListener(new CEPListener());

	// create events
	final List<EapEvent> ratingEvents = this.createRatingEvents();
	this.sortEventListByDate(ratingEvents);

	// pass events to Esper engine
	for (final EapEvent event : ratingEvents) {
		cepRT.sendEvent(new TimerControlEvent(TimerControlEvent.ClockType.CLOCK_EXTERNAL));
		// System.out.println(new
		// CurrentTimeEvent(event.getTimestamp().getTime()).toString());
		cepRT.sendEvent(new CurrentTimeEvent(event.getTimestamp().getTime()));
		cepRT.sendEvent(event);
	}
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public FindMissingEventStmt(EPAdministrator admin) {
    // The inner table to both A and B is C.
    //
    // The listener will consider old events generated when either A or B leave the window, with
    // a window size for A and B of 30 minutes.
    //
    // The window of C is declared large to ensure the C events don't leave the window before A and B
    // thus generating false alerts, making these obvious via timestamp. Lets keep 1 hour of data for C.
    String stmt = "select irstream * from " +
            "TxnEventA#time(30 min) A " +
            "full outer join " +
            "TxnEventC#time(1 hour) C on A.transactionId = C.transactionId " +
            "full outer join " +
            "TxnEventB#time(30 min) B on B.transactionId = C.transactionId " +
            "where C.transactionId is null";

    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public CombinedEventStmt(EPAdministrator admin) {
    // We need to take in events A, B and C and produce a single, combined event
    String stmt = "insert into CombinedEvent(transactionId, customerId, supplierId, latencyAC, latencyBC, latencyAB)" +
            "select C.transactionId," +
            "customerId," +
            "supplierId," +
            "C.timestamp - A.timestamp," +
            "C.timestamp - B.timestamp," +
            "B.timestamp - A.timestamp " +
            "from TxnEventA#time(30 min) A," +
            "TxnEventB#time(30 min) B," +
            "TxnEventC#time(30 min) C " +
            "where A.transactionId = B.transactionId and B.transactionId = C.transactionId";

    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public static void createStatement(EPAdministrator admin) {
    EPStatement statement = admin.createEPL("select istream ipAddress, avg(duration) from SampleEvent#time(10 sec) group by ipAddress output snapshot every 2 seconds order by ipAddress asc");
    statement.addListener(new UpdateListener() {
        public void update(EventBean[] newEvents, EventBean[] oldEvents) {
            if (newEvents == null) {
                return;
            }

            for (int i = 0; i < newEvents.length; i++) {
                if (log.isInfoEnabled()) {
                    log.info("IPAddress: " + newEvents[i].get("ipAddress") +
                            " Avg Duration: " + newEvents[i].get("avg(duration)"));
                }
            }
        }
    });

}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public EsperOperation() {
	Configuration cepConfig = new Configuration();
	cepConfig.addEventType("StockTick", Stock.class.getName());
	EPServiceProvider cep = EPServiceProviderManager.getProvider(
			"myCEPEngine", cepConfig);
	cepRT = cep.getEPRuntime();

	EPAdministrator cepAdm = cep.getEPAdministrator();
	EPStatement cepStatement = cepAdm
			.createEPL("select sum(price),product from "
					+ "StockTick.win:time_batch(5 sec) "
					+ "group by product");

	cepStatement.addListener(new CEPListener());
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
@Test
public void testContextQuery() {
	final Configuration cepConfig = new Configuration();
	cepConfig.addEventType("Event", EapEvent.class.getName());
	final EPServiceProvider cep = EPServiceProviderManager.getProvider("myCEPEngine", cepConfig);
	final EPRuntime cepRT = cep.getEPRuntime();

	final EPAdministrator cepAdm = cep.getEPAdministrator();

	cepAdm.createEPL("" + "CREATE CONTEXT NestedContext " + "CONTEXT SegmentedByLocation PARTITION BY values('Location') FROM Event, " + "CONTEXT SegmentedByTime INITIATED BY Event(values('Action')='Ende') TERMINATED AFTER 1 hour, " + "CONTEXT SegmentedByRating PARTITION BY values('Rating') FROM Event");

	final EPStatement transformationStatement = cepAdm.createEPL("" + "CONTEXT NestedContext " + "SELECT ID, values('Location'), values('Rating'), count(*) " + "FROM Event " + "GROUP BY values('Location'), values('Rating') " + "OUTPUT LAST EVERY 30 minute");

	transformationStatement.addListener(new CEPListener());

	final List<EapEvent> events = new ArrayList<EapEvent>();
	events.addAll(this.createRatingEvents());
	events.addAll(this.createKinoEvents());
	this.sortEventListByDate(events);

	for (final EapEvent event : events) {
		cepRT.sendEvent(new TimerControlEvent(TimerControlEvent.ClockType.CLOCK_EXTERNAL));
		cepRT.sendEvent(new CurrentTimeEvent(event.getTimestamp().getTime()));
		cepRT.sendEvent(event);
	}

	cepRT.sendEvent(new TimerControlEvent(TimerControlEvent.ClockType.CLOCK_INTERNAL));
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public RealtimeSummaryStmt(EPAdministrator admin) {
    //
    // Min,Max,Average total latency from the events (difference in time between A and C) over the past 30 minutes.
    // Min,Max,Average latency between events A/B (time stamp of B minus A) and B/C (time stamp of C minus B).
    //
    String stmtTotal = "select min(latencyAC) as minLatencyAC, " +
            "max(latencyAC) as maxLatencyAC, " +
            "avg(latencyAC) as avgLatencyAC, " +
            "min(latencyAB) as minLatencyAB, " +
            "max(latencyAB) as maxLatencyAB, " +
            "avg(latencyAB) as avgLatencyAB, " +
            "min(latencyBC) as minLatencyBC, " +
            "max(latencyBC) as maxLatencyBC, " +
            "avg(latencyBC) as avgLatencyBC " +
            "from CombinedEvent#time(30 min)";

    totalsStatement = admin.createEPL(stmtTotal);

    //
    // Min,Max,Average latency grouped by (a) customer ID and (b) supplier ID.
    // In other words, metrics on the the latency of the orders coming from each customer and going to each supplier.
    //
    String stmtCustomer = "select customerId," +
            "min(latencyAC) as minLatency," +
            "max(latencyAC) as maxLatency," +
            "avg(latencyAC) as avgLatency " +
            "from CombinedEvent#time(30 min) " +
            "group by customerId";

    byCustomerStatement = admin.createEPL(stmtCustomer);

    String stmtSupplier = "select supplierId," +
            "min(latencyAC) as minLatency," +
            "max(latencyAC) as maxLatency," +
            "avg(latencyAC) as avgLatency " +
            "from CombinedEvent#time(30 min) " +
            "group by supplierId";

    bySupplierStatement = admin.createEPL(stmtSupplier);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public static void start() {
    EPAdministrator admin = EPServiceProviderManager.getDefaultProvider().getEPAdministrator();

    EPStatement statView = admin.createEPL(
            "select * from " + OperationMeasurement.class.getName() +
                    "#groupwin(customerId, operationName)" +
                    "#length(100)#uni(latency)");

    statView.addListener(new AverageLatencyListener(10000));
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public TicksFalloffStatement(EPAdministrator admin) {
    String stmt = "select feed, avg(cnt) as avgCnt, cnt as feedCnt from TicksPerSecond#time(10 sec) " +
            "group by feed " +
            "having cnt < avg(cnt) * 0.75 ";

    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public RFIDTagsPerSensorStmt(EPAdministrator admin) {
    String stmt = "select ID as sensorId, coalesce(sum(countTags), 0) as numTagsPerSensor " +
            "from AutoIdRFIDExample#time(60 sec) " +
            "where Observation[0].Command = 'READ_PALLET_TAGS_ONLY' " +
            "group by ID";

    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public EsperTestAggregationStatement(EPAdministrator admin) {
  admin.createEPL("INSERT INTO S SELECT 1.1+guid AS V, workerId, guid FROM EsperTestAggregationEvent");
  admin.createEPL("INSERT INTO S SELECT 2.2+guid AS V, workerId, guid FROM EsperTestAggregationEvent");
  admin.createEPL("INSERT INTO S SELECT 3.3+guid AS V, workerId, guid FROM EsperTestAggregationEvent");
  admin.createEPL("INSERT INTO S SELECT 4.4+guid AS V, workerId, guid FROM EsperTestAggregationEvent");
  admin.createEPL("CREATE WINDOW SW.win:keepall() AS (V double, workerId long, guid int)");
  admin.createEPL("INSERT INTO SW SELECT V, workerId, guid FROM S");
  admin.createEPL("ON CleanupWindowEvent DELETE FROM SW WHERE SW.workerId = CleanupWindowEvent.workerId");
  statement = admin.createEPL("SELECT * FROM OutputEvent");
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
@Override
public EPStatement createStatement(EPAdministrator administrator) {
    return administrator.createEPL(query);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public TicksPerSecondStatement(EPAdministrator admin) {
    String stmt = "insert into TicksPerSecond " +
            "select feed, count(*) as cnt from MarketDataEvent#time_batch(1 sec) group by feed";

    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
public EsperTestStatement(EPAdministrator admin) {
	String stmt = "select id, field1, field2, field3 from EsperTestEvent";
    statement = admin.createEPL(stmt);
}
 

import com.espertech.esper.client.EPAdministrator; //导入方法依赖的package包/类
protected void handleDeployRule(String strategyName, String moduleName, String ruleName, Integer targetId) throws Exception {

		EPAdministrator administrator = getServiceProvider(strategyName).getEPAdministrator();

		// do nothing if the statement already exists
		EPStatement oldStatement = administrator.getStatement(ruleName);
		if (oldStatement != null && oldStatement.isStarted()) {
			return;
		}

		// read the statement from the module
		EPDeploymentAdmin deployAdmin = administrator.getDeploymentAdmin();
		Module module = deployAdmin.read("module-" + moduleName + ".epl");
		List<ModuleItem> items = module.getItems();

		// go through all statements in the module
		EPStatement newStatement = null;
		items: for (ModuleItem item : items) {
			String exp = item.getExpression();

			// get the ObjectModel for the statement
			EPStatementObjectModel model;
			EPPreparedStatementImpl prepared = null;
			if (exp.contains("?")) {
				prepared = (EPPreparedStatementImpl) administrator.prepareEPL(exp);
				model = prepared.getModel();
			} else {
				model = administrator.compileEPL(exp);
			}

			// go through all annotations and check if the statement has the 'name' 'ruleName'
			List<AnnotationPart> annotationParts = model.getAnnotations();
			for (AnnotationPart annotationPart : annotationParts) {
				if (annotationPart.getName().equals("Name")) {
					for (AnnotationAttribute attribute : annotationPart.getAttributes()) {
						if (attribute.getValue().equals(ruleName)) {

							// create the statement
							newStatement = administrator.createEPL(model.toEPL());

							// check if the statement is elgible, other destory it righ away
							processAnnotations(strategyName, newStatement);

							// break iterating over the statements
							break items;
						}
					}
				}
			}
		}

		if (newStatement == null) {
			logger.warn("statement " + ruleName + " was not found");
		} else {
			logger.debug("deployed rule " + newStatement.getName() + " on service provider: " + strategyName);
		}
	}