EQL — Event Query Language Hilfedokumentation

Inhaltsverzeichnis

Überblick
Wo wird EQL verwendet
Grundlegende Syntax
Event-Streams (14 Typen + 3 intern)
Fenster
WHERE-Bedingungen
Aggregatfunktionen
Gruppierung und Sortierung
JOIN — Stream-Verknüpfung
Pattern Matching
Zeit- und Zustandsfunktionen
Variablen und Kontexte
12 praktische Beispiele
Performance-Leitfaden
Häufig gestellte Fragen
Zugehörige Bildschirme

Überblick

Hauptverwendungsort Im linken Menü Automation > EQL-Abfragen(/query/index) direkt ausführen; die gleiche Syntax wird auch in erweiterten EQL-Alarmen · Triggern und Statements · Flows verwendet.

EQL (Event Query Language) ist eine proprietäre Abfragesprache der PlantPulse-Plattform, mit der Echtzeit-Streaming-Daten ähnlich wie mit SQL abgefragt, aggregiert und mit Pattern Matching verarbeitet werden können. Während SQL normalerweise auf statischen Tabellen arbeitet, läuft EQL auf kontinuierlich eingehenden Event-Streams und gibt bei jedem Schritt Ergebnisse aus.

Mit einer einzigen EQL-Zeile können Sie Folgendes implementieren:

Echtzeit-Überwachung — Tag-Wert überschreitet Schwellenwert, Ergebnis wird sofort ausgegeben
Aggregation nach Anlage — Durchschnitt/Maximum/Minimum alle 5 Minuten automatisch berechnet
Pattern Matching — „Wenn B-Event nicht innerhalb von 30 Sekunden nach A-Event kommt, Alarm"
Zeitreihen-Join — Zeitlich abgestimmter Vergleich zweier Tags

EQL verwendet fast die gleiche Syntax wie SQL, aber mit einem zusätzlichen Fenster-Konzept, das „letzte N Sekunden / N Ereignisse" angibt.

Wo wird EQL verwendet

Die Verwendungsorte von EQL in der Plattform sind wie folgt:

EQL-Abfragen, Trigger und Statements befinden sich nebeneinander im Automation-Bereich des linken Menüs. (Es gibt kein Menü mit dem Namen CEP — ältere Dokumentation hat diese drei als CEP-Bildschirme aufgelistet.)

Menü · Bildschirm	Interne URL	Zweck
Automation > EQL-Abfragen — Dokumentation	`/query/index`	Operatoren führen EQL ad hoc aus und überprüfen Ergebnisse (Exploration·Debugging)
Automation > Trigger — Dokumentation	`/trigger/index`	EQL-Matching-Ergebnisse werden automatisch an MQ-Topics oder Storage veröffentlicht
Automation > Statements — Dokumentation	`/statement/index`	Pro Anlage registrierte Regeln (Zustand/Aggregation/Ereignis/Befehl)
Alarme → EQL-Alarme	—	Alarm-Veröffentlichung für beliebige Bedingungen mit EQL
Flow → Scripting	—	`flow_script_filter` / `flow_script_transform` / `flow_switch` EQL-Ausdrucksmodus
Tag-Formular — KI-Tab	—	Eingabebedingungen für Prognose- und Anomalieerkennung-Regeln

EQL ist schreibgeschützt — es ändert keine Daten. Um Matching-Ergebnisse als Alarme zu veröffentlichen oder Flow-Aktionsknoten aufzurufen, verbinden Sie Ergebnisse über CEP → Trigger oder EQL-Alarme.

Grundlegende Syntax

Die grundlegende Struktur von EQL ist fast identisch mit SQL.

SELECT <column-or-function>
FROM   <stream>.<window>
WHERE  <condition>
GROUP  BY <field>
HAVING <aggregation-condition>
ORDER  BY <field> [ASC|DESC]

Die einfachste EQL:

SELECT * FROM Point.win:time(1 sec)

Gibt alle Tag-Datenpunkte aus, die in den letzten 1 Sekunde eingegangen sind, alle 1 Sekunde aus.

Wildcards und Spaltenauswahl

Syntax	Bedeutung
`SELECT *`	Alle Spalten einschließen
`SELECT tag_id, value`	Nur bestimmte Spalten
`SELECT value AS v, tag_id AS id`	Alias zuweisen
`SELECT value * 9 / 5 + 32 AS fahrenheit`	Arithmetischer Ausdruck-Ergebnis
`SELECT CASE WHEN value > 80 THEN 'HIGH' ELSE 'OK' END AS level`	Bedingter Ausdruck

Kommentare

-- 한 줄 주석
/* 여러 줄
   주석 */
SELECT * FROM Point.win:time(1 sec)

Event-Streams (14 Typen + 3 intern)

Die Streams (Event-Quellen), die in der FROM-Klausel vorkommen können, sind wie folgt. Alle Streams werden von der Plattform automatisch generiert und sind sofort einsatzbereit.

Wenn Sie einen Namen verwenden, der hier nicht vorhanden ist, in FROM, wird die Regel nicht bereitgestellt. Nur registrierte Event-Typen können Streams sein (plantpulse.core.engine.eql.EventTypes).

Tag-Domäne (3 Typen)

Stream	Ausgelöst bei	Hauptfelder
Point	Jedes Mal, wenn ein Tag-Wert empfangen wird	`tag_id`, `value`, `quality`, `ts`, `site_id`, `asset_id`, `unit`, `java_type`
PointMap	Gleich wie oben, aber zusammen mit `tag('<id>')`-Funktion zur Abfrage mehrerer Tags als Schlüssel-Wert	(PointMap-spezifische Helfer)
Alarm	Wenn ein Tag-Alarm auftritt	`tag_id`, `alarm_band`, `value`, `threshold`, `priority`, `band_message`

Anlagen-Domäne (6 Typen)

Stream	Ausgelöst bei	Hauptfelder
AssetData	Zeitreihendaten pro Anlage (Aggregationsergebnisse)	`asset_id`, `values`(Schlüssel-Wert), `ts`
AssetEvent	Anlage-Ereignis tritt auf (Start·Stopp·Wartung usw.)	`asset_id`, `event_type`, `details`, `ts`
AssetAlarm	Anlage-Alarm tritt auf	`asset_id`, `alarm_band`, `priority`, `message`
AssetCommand	Befehl wird an Anlage ausgegeben	`asset_id`, `command`, `args`
AssetAggregation	1-Minuten/5-Minuten/1-Stunden-Aggregationsergebnisse der Anlage	`asset_id`, `window`, `agg_type`, `values`
AssetContext	Änderung des Anlage-Kontexts (Metadaten)	`asset_id`, `context_key`, `before`, `after`

AssetHealthStatus · AssetConnectionStatus sind keine Streams

Ältere Dokumentation hat diese beiden als Anlage-Domäne-Streams aufgelistet, aber es sind keine registrierten Event-Typen. Wenn Sie FROM AssetHealthStatus... schreiben, wird die Regel nicht bereitgestellt.

Bewertung des Zustands und der Verbindung erfolgt nicht als Stream, sondern als regelmäßig ausgeführter Job (AssetHealthStatusDeployer / AssetConnectionStatusDeployer). Ergebnisse werden auf dem Bildschirm und über die API angezeigt; wenn Sie Zustandsänderungen in EQL erfassen möchten, verwenden Sie den Ursprung AssetEvent · AssetAlarm oder Nicht-Empfang von Point mit not Pattern.

Produktionsdomäne (3 Typen)

Stream	Ausgelöst bei	Hauptfelder
Calendar	Schichtstart/Ende/Wechsel	`shift_id`, `calendar_id`, `event`, `start_time`, `end_time`
WorkOrder	Arbeitsbestellung-Lebenszyklus-Übergang	`order_id`, `status`, `prev_status`, `asset_id`, `product_id`
OEE	OEE-Bewertungsergebnis aktualisiert	`order_id`, `asset_id`, `oee`, `availability`, `performance`, `quality`

Systemdomäne (2 Typen)

Stream	Ausgelöst bei	Hauptfelder
Log	Systemdiagnosemeldung	`module`, `level`, `code`, `summary`, `ts`
OSPerformance	Server-OS-Ressourcen-Metriken (periodisch)	CPU·Speicher·Festplatte usw.

Es gibt keinen Status-Stream

Der Event-Typ Status ist nicht registriert. Wenn Sie Verbindungszustandsänderungen von OPC oder Edge mit EQL erfassen wollten, funktioniert dieser Stream nicht — verwenden Sie die Methode, Nicht-Empfang von Point mit not Pattern zu erkennen.

Interne Streams (3 Typen)

Registriert, aber nicht für Regelschreibung vorgesehen. Wird für Diagnose und Zustandsprüfungen verwendet.

Stream	Zweck
DateTime	Periodisch ausgelöste Zeit-Ereignisse (Trigger für zeitbasierte Regeln)
Ping	Engine-Lebenszeichen-Überprüfung
Test	Regelvalidierung

Alle Streams müssen vor der Verwendung mit einem Fenster kombiniert werden (wie Point.win:time(1 sec)). Wenn Sie nur FROM Point ohne Fenster verwenden, verschwindet das Ergebnis sofort und ist nicht sichtbar.

Fenster

Ein Fenster ist „ein zeitlicher oder längenbezogener Abschnitt, der aus einem Stream ausgeschnitten wird". EQL unterstützt zwei Arten von Fenstern.

Zeitfenster (Time Window)

Syntax	Bedeutung
`Point.win:time(1 sec)`	Alle Ereignisse der letzten 1 Sekunde (Sliding)
`Point.win:time(10 sec)`	Letzte 10 Sekunden
`Point.win:time(5 min)`	Letzte 5 Minuten
`Point.win:time(1 hour)`	Letzte 1 Stunde

Unterstützte Zeiteinheiten: sec(Sekunden) · min(Minuten) · hour(Stunden) · day(Tage).

Längenfenster (Length Window)

Syntax	Bedeutung
`Point.win:length(100)`	Letzte 100 Ereignisse
`Point.win:length(1000)`	Letzte 1.000 Ereignisse

Batch-Fenster (Batch Window)

win:time_batch / win:length_batch — Gibt nur einmal aus, wenn Fenster voll ist oder Zeit abläuft. Ressourceneinsparung.

-- 매 1분마다 한 번씩 그 1분간 평균을 emit
SELECT avg(value) FROM Point.win:time_batch(1 min) WHERE tag_id = 'MOTOR-001.TEMP'

Fensterauswahl-Leitfaden

Situation	Empfohlenes Fenster
Echtzeitüberwachung (Wert selbst anzeigen)	`win:time(1 sec)`
Kurzfristige Durchschnitte/Maxima (5-Minuten-Durchschnitt usw.)	`win:time(5 min)`
Stündliche Aggregation	`win:time_batch(1 hour)`
Vergleich der letzten N Ereignisse	`win:length(N)`
Verfolgung von Änderungen	`win:length(2)` + `prev()`-Funktion

WHERE-Bedingungen

Verwenden Sie die gleichen Vergleichsoperatoren wie SQL.

Operator	Beispiel	Bedeutung
`=` `!=` `<>`	`tag_id = 'MOTOR-001'`	Gleich/Ungleich
`<` `<=` `>` `>=`	`value > 80`	Vergleich
`BETWEEN`	`value BETWEEN 70 AND 90`	Bereich
`IN`	`tag_id IN ('A','B','C')`	In Liste enthalten
`LIKE`	`tag_id LIKE 'MOTOR-%'`	Pattern Matching (`%` Wildcard)
`IS NULL` / `IS NOT NULL`	`quality IS NOT NULL`	Null-Prüfung
`AND` `OR` `NOT`	`value > 80 AND quality = 'GOOD'`	Logische Kombination

Reguläre Ausdrücke

SELECT * FROM Point.win:time(1 sec)
WHERE tag_id REGEXP '.*\\.TEMP$'

Nur Tags, die auf .TEMP enden, werden abgeglichen. Backslash wird doppelt eingegeben (\\.).

Dynamische Standort-/Anlagenfilter

SELECT * FROM Point.win:time(1 sec)
WHERE site_id = 'SITE-A'
  AND asset_id LIKE 'LINE-1.%'
  AND value > 75

Aggregatfunktionen

Aggregieren von Ereignissen im Fenster.

Grundlegende Aggregation

Funktion	Bedeutung	Beispiel
`count(*)`	Ereignisanzahl	`SELECT count(*) FROM Point.win:time(10 sec)`
`sum(field)`	Summe	`sum(value)`
`avg(field)`	Durchschnitt	`avg(value)`
`min(field)`	Minimum	`min(value)`
`max(field)`	Maximum	`max(value)`
`median(field)`	Median	`median(value)`
`stddev(field)`	Standardabweichung	`stddev(value)`
`variance(field)`	Varianz	`variance(value)`
`first(field)`	Erstes Wert im Fenster	`first(value)`
`last(field)`	Letztes Wert im Fenster	`last(value)`

DISTINCT-Aggregation

SELECT count(distinct tag_id) AS unique_tags
FROM Point.win:time(1 min)

Kombiniert mit CASE

SELECT
  count(CASE WHEN value > 80 THEN 1 END) AS high_count,
  count(CASE WHEN value <= 80 THEN 1 END) AS ok_count
FROM Point.win:time(1 min)
WHERE tag_id = 'MOTOR-001.TEMP'

Zeitreihenfunktionen

Funktion	Bedeutung	Beispiel
`prev(N, field)`	Wert vor N Schritten	`value - prev(1, value)` (Differenz zum vorherigen Wert)
`prevwindow(field)`	Array aller vorherigen Werte im Fenster	`prevwindow(value)`
`rate(field)`	Änderungsrate pro Zeiteinheit	`rate(value)`

Gruppierung und Sortierung

GROUP BY

-- 자산별 최근 1분 평균 온도
SELECT asset_id, avg(value) AS avg_temp
FROM Point.win:time(1 min)
WHERE tag_id LIKE '%.TEMP'
GROUP BY asset_id

HAVING — Filter nach Aggregation

-- 평균 > 80 인 자산만
SELECT asset_id, avg(value) AS avg_temp
FROM Point.win:time(1 min)
WHERE tag_id LIKE '%.TEMP'
GROUP BY asset_id
HAVING avg(value) > 80

ORDER BY · LIMIT

-- 가장 뜨거운 5개 자산
SELECT asset_id, max(value) AS peak
FROM Point.win:time(5 min)
WHERE tag_id LIKE '%.TEMP'
GROUP BY asset_id
ORDER BY peak DESC
LIMIT 5

LIMIT enthält nur die Top-N-Ergebnisse zum Zeitpunkt der Ergebnis-Ausgabe.

JOIN — Stream-Verknüpfung

Sie können zwei oder mehr Streams zeitlich abgestimmt verknüpfen.

-- 같은 자산에서 같은 시간대의 온도와 압력을 한 행으로
SELECT  p1.value AS temp, p2.value AS pressure, p1.asset_id
FROM    Point.win:time(1 sec) AS p1,
        Point.win:time(1 sec) AS p2
WHERE   p1.tag_id LIKE '%.TEMP'
  AND   p2.tag_id LIKE '%.PRESSURE'
  AND   p1.asset_id = p2.asset_id

Join von Anlage-Ereignis + Arbeitsbestellung

SELECT e.asset_id, e.event_type, w.order_id, w.status
FROM   AssetEvent.win:time(5 min) AS e,
       WorkOrder.win:time(5 min)  AS w
WHERE  e.asset_id = w.asset_id
  AND  e.event_type = 'STARTUP'
  AND  w.status = 'START'

Join-Ergebnisse treten nur auf, wenn sich die Zeitfenster beider Streams überlappen. Wenn Sie Daten mit unterschiedlichen Zeiteinheiten vergleichen, verwenden Sie win:time_batch zur Anpassung an ähnliche Zyklen.

Pattern Matching

Eine starke EQL-Funktion — Sie können Sequenzen wie „N Sekunden nach Ereignis A tritt B auf (nicht auf)" definieren.

`every` — Match bei jedem Vorkommen

SELECT * FROM pattern [
  every  a = AssetEvent(event_type = 'STARTUP')
         -> b = AssetEvent(event_type = 'SHUTDOWN', asset_id = a.asset_id)
              where timer:within(60 sec)
]

Start-Ereignis → Stopp-Ereignis innerhalb 60 Sekunden-Paare werden bei jedem Match abgeglichen. Erkennung abnormaler Muster bei kurzer Ausführung und sofortiger Stoppung.

`not` — Tritt N Stunden lang nicht auf

SELECT * FROM pattern [
  every  a = AssetEvent(event_type = 'STARTUP')
         -> ( timer:interval(30 min)
              and not AssetData(asset_id = a.asset_id) )
]

Match, wenn keine Daten 30 Minuten nach dem Start eingehen (Erkennung reaktionsloser Anlagen).

`and` / `or` — Gleichzeitig oder eines von beiden

SELECT * FROM pattern [
  ( every AssetAlarm(priority = 'ERROR') )
    and
  ( every WorkOrder(status = 'START') )
]

Kern-Schlüsselwörter für Pattern Matching

Schlüsselwort	Bedeutung
`every <e>`	Match, wenn `e` auftritt
`e1 -> e2`	`e1` vor `e2` (Sequenz-Match)
`e1 and e2`	Beide Ereignisse treten auf (Reihenfolge egal)
`e1 or e2`	Eines von beiden tritt auf
`not e`	`e` tritt nicht auf
`timer:within(<duration>)`	Match nur innerhalb der angegebenen Zeit
`timer:interval(<duration>)`	Warten für die angegebene Zeit

Zeit- und Zustandsfunktionen

Zeitfunktionen

Funktion	Bedeutung
`current_timestamp`	Aktuelle Zeit (ms)
`current_date()`	Heutiges Datum (yyyy-MM-dd)
`timestamp(field)`	Timestamp des Ereignisses extrahieren
`hour_of_day(ts)`	0~23 Stunden
`day_of_week(ts)`	1(Sonntag)~7(Samstag)
`minute_of_hour(ts)`	0~59 Minuten
`dayofmonth(ts)`	1~31 Tage

-- 야간 (22시~6시) 발생 알람만
SELECT * FROM Alarm.win:time(1 hour)
WHERE hour_of_day(ts) >= 22 OR hour_of_day(ts) < 6

Zustandsfunktionen

Funktion	Bedeutung
`tag('<tag_id>')`	Aktuellster Wert dieses Tags (PointMap-Kontext)
`prev_status(asset_id)`	Vorheriger Zustand der Anlage
`health(asset_id)`	Zustand der Anlagengesundheit (`OK`/`WARN`/`ERROR`/`UNKNOWN`)
`is_in_shift(asset_id)`	Anlage befindet sich innerhalb einer Schicht

Arithmetik- und String-Funktionen

Funktion	Bedeutung
`abs(x)` / `round(x, n)` / `floor(x)` / `ceil(x)`	Mathematik
`pow(x, y)`	x hoch y
`sqrt(x)`	Quadratwurzel
`length(s)`	String-Länge
`upper(s)` / `lower(s)`	Groß-/Kleinschreibung ändern
`substring(s, start, len)`	Substring
`concat(a, b, ...)`	Verkettung

Variablen und Kontexte

Variablen — Dynamische Schwellenwerte

-- 변수 정의 (운영자가 화면에서 조정 가능)
create variable double max_temp = 80;

-- 변수 사용
SELECT * FROM Point.win:time(1 sec)
WHERE tag_id LIKE '%.TEMP' AND value > max_temp

Variablenwerte können während des Betriebs geändert werden und alle EQL-Regeln verwenden sofort den neuen Wert.

Kontexte — Zeitbasierte oder bedingungsbasierte Aktivierung

Die Plattform hat häufig verwendete Kontexte vordefiniert, die Sie direkt verwenden können.

Kontext	Aktivierungsbedingung
`EVERY_1_MINUTES`	Jede Minute
`EVERY_5_MINUTES`	Alle 5 Minuten
`EVERY_10_MINUTES`	Alle 10 Minuten
`EVERY_30_MINUTES`	Alle 30 Minuten
`EVERY_1_HOURS`	Jede Stunde
`EVERY_3_HOURS`	Alle 3 Stunden
`EVERY_6_HOURS`	Alle 6 Stunden
`EVERY_12_HOURS`	Alle 12 Stunden
`DAY_WORK_TIME`	Wochentags 09:00~18:00

-- 5분마다 한 번씩 평균 온도 emit (그 사이에는 결과가 안 옴)
context EVERY_5_MINUTES
SELECT avg(value) AS avg_temp
FROM Point.win:time(5 min)
WHERE tag_id = 'MOTOR-001.TEMP'

-- 주간 근무시간에만 평가
context DAY_WORK_TIME
SELECT * FROM AssetAlarm.win:time(1 sec)
WHERE priority = 'ERROR'

12 praktische Beispiele

Beispiel 1 — Echtzeit-Überwachung eines Tags

SELECT value, ts, quality
FROM Point.win:time(1 sec)
WHERE tag_id = 'MOTOR-001.SPEED'

Beispiel 2 — Sofortige Erkennung von Schwellenwertüberschreitung

SELECT tag_id, value, ts
FROM Point.win:time(1 sec)
WHERE tag_id LIKE '%.TEMP' AND value > 90

Beispiel 3 — 5-Minuten-Durchschnitt pro Anlage (alle 5 Minuten ausgeben)

context EVERY_5_MINUTES
SELECT asset_id, avg(value) AS avg_temp, max(value) AS peak
FROM   Point.win:time(5 min)
WHERE  tag_id LIKE '%.TEMP'
GROUP  BY asset_id

Beispiel 4 — Änderungsrate (gegenüber vorherigem Wert)

SELECT tag_id, value, value - prev(1, value) AS delta
FROM   Point.win:length(2)
WHERE  tag_id = 'TANK-001.LEVEL'

Beispiel 5 — Nur Fehleralarm während Nachtschicht

SELECT tag_id, priority, band_message, ts
FROM   Alarm.win:time(1 sec)
WHERE  priority = 'ERROR'
  AND  hour_of_day(ts) >= 22 OR hour_of_day(ts) < 6

Beispiel 6 — Anlage-Zustandsübergang (OK → WARN)

SELECT asset_id, status, prev_status, ts
FROM   AssetHealthStatus.win:time(1 sec)
WHERE  prev_status = 'OK' AND status = 'WARN'

Beispiel 7 — Schlechte Arbeitsbestellung-OEE

SELECT order_id, asset_id, oee, availability, performance, quality
FROM   OEE.win:time(1 sec)
WHERE  oee < 0.6

Beispiel 8 — Erkennung von 30 Minuten ohne Reaktion

SELECT * FROM pattern [
  every a = AssetData()
        -> ( timer:interval(30 min)
             and not AssetData(asset_id = a.asset_id) )
]

Beispiel 9 — Stopp sofort nach dem Start (instabile Ausführung)

SELECT * FROM pattern [
  every  a = AssetEvent(event_type = 'STARTUP')
         -> b = AssetEvent(event_type = 'SHUTDOWN', asset_id = a.asset_id)
              where timer:within(60 sec)
]

Beispiel 10 — Vergleich mehrerer Tags gleichzeitig (PointMap)

SELECT
  tag('MOTOR-001.TEMP')     AS temp,
  tag('MOTOR-001.PRESSURE') AS pressure,
  tag('MOTOR-001.VIBRATION') AS vibration
FROM PointMap.win:time(1 sec)

Beispiel 11 — Kumulative Produktion pro Stunde pro Zeile

context EVERY_1_HOURS
SELECT asset_id, sum(value) AS hourly_count
FROM   AssetAggregation.win:time(1 hour)
WHERE  agg_type = 'PRODUCED' AND asset_id LIKE 'LINE-%'
GROUP  BY asset_id

Beispiel 12 — TOP 10 Alarme verursachende Anlagen

context EVERY_10_MINUTES
SELECT asset_id, count(*) AS alarm_count
FROM   AssetAlarm.win:time(10 min)
GROUP  BY asset_id
ORDER  BY alarm_count DESC
LIMIT  10

Performance-Leitfaden

1. Fenstergröße bewusst klein halten

-- ❌ 나쁜 예 — 24시간을 메모리에 유지
SELECT avg(value) FROM Point.win:time(24 hour)

-- ✅ 좋은 예 — 1시간만 메모리에 유지 + context 로 emit 주기 분리
context EVERY_1_HOURS
SELECT avg(value) FROM Point.win:time(1 hour)

2. WHERE-Klausel näher am Trigger

Statische Filter wie Tag-ID, Anlagen-ID, Standort-ID gehören ganz am Anfang der WHERE-Klausel. Sie werden vor GROUP BY/HAVING ausgewertet.

3. `LIKE '%...%'` Wildcard auf beiden Seiten hat höhere Kosten

-- ❌ 나쁜 예
WHERE tag_id LIKE '%TEMP%'

-- ✅ 좋은 예
WHERE tag_id LIKE '%.TEMP'   -- 접미사 매칭만

4. Pattern Matching mit kurzen Fenstern

Vergessen Sie den Zeitqualifikator in pattern [ ... timer:within(<n-minutes>) ] nicht. Unbegrenzte Muster belegen kontinuierlich Speicher.

5. Ausgabehäufigkeit anpassen

Mit context EVERY_N_MINUTES Kontext wird die EQL-Evaluierung alle 1 Sekunde durchgeführt, aber Ausgabe nur alle N Minuten, was die Downstream-Last reduziert.

Häufig gestellte Fragen

F. Ich habe eine EQL-Abfrage eingegeben, aber auf dem Ergebnisbildschirm wird nichts angezeigt. A. Bitte überprüfen Sie Folgendes: ① Haben Sie nur FROM Point geschrieben — ein Fenster ist erforderlich (Point.win:time(1 sec)). ② Ist die WHERE-Bedingung zu eng, sodass kein Match erfolgt? ③ Haben Sie die Play-Taste oben rechts gedrückt? ④ Ist der Ergebnisbereich nicht im ⏸ Pause-Status?

F. Was ist der Unterschied zu SQL? A. Der größte Unterschied ist das Fenster-Konzept. EQL läuft auf einem unendlichen Stream, daher müssen Sie „welcher Bereich" angeben. Darüber hinaus sind pattern [ ... ] Sequenz-Matching und context Zeit-Kontext SQL-fremde Funktionen.

F. Was ist der Unterschied zwischen win:time(1 sec) und win:time_batch(1 sec)? A. win:time(1 sec) ist Sliding — Ergebnis wird bei jedem eingehenden Ereignis aktualisiert. win:time_batch(1 sec) ist Tumbling — wird in 1-Sekunden-Einheiten zusammengefasst und nur ausgegeben, wenn die 1-Sekunde abläuft. Wenn Sie genau einmal pro Sekunde ein Ergebnis benötigen, verwenden Sie Batch.

F. Was ist der Unterschied zwischen pattern [ ... ] und regularem SELECT ... WHERE ...? A. SELECT bewertet ein einzelnes Ereignis (oder Fenster), aber pattern bewertet Event-Sequenzen (A, dann B; B ohne A usw.). Wenn zeitliche Reihenfolge und Kausalität wichtig sind, verwenden Sie Pattern.

F. Wird die registrierte Variable sofort angewendet? A. Ja. Wenn Sie den in create variable definierten Variablenwert im Bildschirm ändern, verwenden alle bereits bereitgestellten EQL-Regeln ab der nächsten Bewertung den neuen Wert.

F. Wie kann ich EQL-Matching-Ergebnisse als Alarm senden? A. Registrieren Sie EQL in CEP → Trigger, schalten Sie „MQ-Streaming" oder „Speicherung" ein, oder registrieren Sie EQL in Alarme → EQL-Alarme, und bei einem Match wird automatisch ein Alarm veröffentlicht.

F. Kann ich eine Regel pro Anlage auf alle Anlagen anwenden? A. Ja. Definieren Sie eine pro-Anlage EQL-Regel in CEP → Statement und ordnen Sie diese Regel im Modell/in der Ontologie einer Anlagekategorie zu — alle Anlagen derselben Kategorie werden automatisch bereitgestellt. Sie wird automatisch auf neue Anlagen angewendet.

F. Kann ich zwei Streams gleichzeitig in einer EQL-Zeile verwenden? A. Ja. Wie im obigen JOIN-Abschnitt gezeigt, listen Sie zwei Streams in der FROM-Klausel kommagetrennt auf und schreiben Sie die Join-Bedingung mit WHERE.

F. Ich erhalte zu viele Ergebnisse. A. Verwenden Sie LIMIT N zur Begrenzung auf Top-N, erhöhen Sie die Ausgabehäufigkeit mit context EVERY_N_MINUTES, oder verwenden Sie win:time_batch zur Batch-Fensterung. Es ist auch effektiv, die WHERE-Klausel strenger zu gestalten.

F. Wo kann ich EQL-Schreibung üben? A. Der CEP → Abfragen-Bildschirm ist das EQL-Trainings-Tool. Geben Sie eine Zeile ein und drücken Sie ▶ Ausführen, um sofort Ergebnisse zu erhalten. Versuchen Sie, von den obigen 12 praktischen Beispielen zu kopieren.

Zugehörige Bildschirme

CEP — Bildschirm zum Schreiben von EQL-Abfragen/Triggern/Statements
Alarme → EQL-Alarme — Alarm-Veröffentlichung für beliebige Bedingungen mit EQL
Flow — flow_script_filter / flow_script_transform / flow_switch EQL-Modus
Tag-Formular — KI-Tab — EQL-Bedingungen für Prognose- und Anomalieerkennung-Regeln
Integrierte Domänen-ID-Suche — Schnelle Abfrage von Tag/Anlagen-IDs zur Verwendung in EQL (Strg+K)

Inhaltsverzeichnis​

Überblick​

Wo wird EQL verwendet​

Grundlegende Syntax​

Wildcards und Spaltenauswahl​

Kommentare​

Event-Streams (14 Typen + 3 intern)​

Tag-Domäne (3 Typen)​

Anlagen-Domäne (6 Typen)​

Produktionsdomäne (3 Typen)​

Systemdomäne (2 Typen)​

Interne Streams (3 Typen)​

Fenster​

Zeitfenster (Time Window)​

Längenfenster (Length Window)​

Batch-Fenster (Batch Window)​

Fensterauswahl-Leitfaden​

WHERE-Bedingungen​

Reguläre Ausdrücke​

Dynamische Standort-/Anlagenfilter​

Aggregatfunktionen​

Grundlegende Aggregation​

DISTINCT-Aggregation​

Kombiniert mit CASE​

Zeitreihenfunktionen​

Gruppierung und Sortierung​

GROUP BY​

HAVING — Filter nach Aggregation​

ORDER BY · LIMIT​

JOIN — Stream-Verknüpfung​

Join von Anlage-Ereignis + Arbeitsbestellung​

Pattern Matching​

every — Match bei jedem Vorkommen​

not — Tritt N Stunden lang nicht auf​

and / or — Gleichzeitig oder eines von beiden​

Kern-Schlüsselwörter für Pattern Matching​

Zeit- und Zustandsfunktionen​

Zeitfunktionen​

Zustandsfunktionen​

Arithmetik- und String-Funktionen​

Variablen und Kontexte​

Variablen — Dynamische Schwellenwerte​

Kontexte — Zeitbasierte oder bedingungsbasierte Aktivierung​

12 praktische Beispiele​

Beispiel 1 — Echtzeit-Überwachung eines Tags​

Beispiel 2 — Sofortige Erkennung von Schwellenwertüberschreitung​

Beispiel 3 — 5-Minuten-Durchschnitt pro Anlage (alle 5 Minuten ausgeben)​

Beispiel 4 — Änderungsrate (gegenüber vorherigem Wert)​

Beispiel 5 — Nur Fehleralarm während Nachtschicht​

Beispiel 6 — Anlage-Zustandsübergang (OK → WARN)​

Beispiel 7 — Schlechte Arbeitsbestellung-OEE​

Beispiel 8 — Erkennung von 30 Minuten ohne Reaktion​

Beispiel 9 — Stopp sofort nach dem Start (instabile Ausführung)​

Beispiel 10 — Vergleich mehrerer Tags gleichzeitig (PointMap)​

Beispiel 11 — Kumulative Produktion pro Stunde pro Zeile​

Beispiel 12 — TOP 10 Alarme verursachende Anlagen​

Performance-Leitfaden​

1. Fenstergröße bewusst klein halten​

2. WHERE-Klausel näher am Trigger​

3. LIKE '%...%' Wildcard auf beiden Seiten hat höhere Kosten​

4. Pattern Matching mit kurzen Fenstern​

5. Ausgabehäufigkeit anpassen​

Häufig gestellte Fragen​

Zugehörige Bildschirme​