Mit der fortschreitenden Digitalisierung von Alltagsgegenständen und ihrer Verbindung mit dem Internet wächst das sogenannte Internet of Things. Dadurch sind auch immer mehr offene Systeme online verfügbar, die ihre Sensordaten und Zustandsinformationen als \emph{RDF}\footnote{Resource Description Framework --- Mehr dazu in Kapitel \ref{cpt:basics}}-Datenstrom anbieten. Diese Ereignisdatenströme liefern durchgehend und hochfrequent Ereignisdaten, sodass innerhalb kurzer Zeit sehr große Datenmengen anfallen, die zwecks Extraktion von Informationen und Auslösen von Reaktionen in kürzester Zeit verarbeitet werden sollen.
Die Ereignisdaten aus diesen Strömen bilden kleine Teile der Realität zumindest nä\-herungs\-wei\-se über die in ihnen enthaltenen Messdaten und Zustandsinformationen ab, sofern sie nicht bedingt durch technischen Defekt oder Messfehler ungültige Daten ent\-hal\-ten und somit vor der weiteren Verarbeitung herausgefiltert werden sollten. Ein weiteres Problem ist die stark begrenzte Gültigkeit von Ereignisdaten: Oft werden sie schon durch ein neu aufgetretenes Ereignis hinfällig und sind nicht mehr aktuell.
Ereignisse haben für sich alleine betrachtet neben einer begrenzten Gültigkeit eine begrenzte Aussagekraft, daher ist es zum höheren Verständnis der dahinter verborgenen Situation notwendig, sie mit zuvor aufgetretenen Ereignissen in einen Kontext zu setzen. Dadurch können mehrere kleine, hochfrequent auftretende Ereignisse zu einzelnen, niederfrequent auftretenden komplexen Ereignissen aggregiert werden und mittels Mustererkennung höherwertige Informationen aus den Ereignissen extrahiert werden.
\begin{comment}
In Abbildung~\ref{fig:aggregation_patternmatching} wird die Aggregation von Ereignissen sowie die Mustererkennung exemplarisch dargestellt.
Die Integration von \emph{Domänenwissen}\footnote{Hintergrundwissen für den Kontext der Ereignisverarbeitung, verändert sich während der Verarbeitung nur selten} ist ein weiterer Schritt, der die Brücke zwischen den aus komplexen Ereignissen gewonnenen Kenntnissen und bereits bekannten Fakten schlagen soll, um die gewonnenen Kenntnisse in einen eindeutigen Zusammenhang stellen und eine eindeutige Interpretation zu ermöglichen.
Um unter diesen Bedingungen viele Ereignisdatenströme mit hochfrequenten Ereignissen in nahezu Echtzeit zu verarbeiten ist \emph{CEP}\footnote{Complex-Event-Processing} das Mittel der Wahl: Mit CEP werden die Ereignisse der verschiedenen Datenströme für begrenzte Zeiträume im Speicher vorgehalten und innerhalb von sogenannten \emph{Sliding-Windows}\footnote{Mehr dazu in Kapitel~\ref{cpt:cep_intro}} betrachtet. Dabei können Ereignismuster erkannt werden und verschiedene Ereignisse aggregiert werden um neue komplexe Ereignisse zu erzeugen.
Ziel dieser Arbeit ist die Einführung in die Konzepte von CEP und RDF, sowie die Demonstration der praktischen Nutzung der CEP-Engine \enquote{C-SPARQL} zur Verarbeitung von RDF-Datenströmen am Beispiel einer Autoverleihgesellschaft zur Überwachung von Leihfahrzeugen. Auch soll ergründet werden, welche technischen Möglichkeiten existieren, um \emph{Reasoning} auf RDF-Datenströmen zu betreiben --- ein Prozess, durch den eine vorhandene Sammlung von Fakten auf Basis von vorgegebener Terminologie automatisch um daraus ableitbarem Wissen angereichert werden kann.
Diesbezüglich soll ergründet werden, welche CEP-Engines Reasoning bereits implementieren und wie weit ihre technischen Möglichkeiten reichen --- eine große Herausforderung, da die mit einzubeziehenden Ereignisdaten sich kontinuierlich verändern.
Das Beispielszenario, welches für diese Arbeit verwendet wird, ist eine Autoverleihgesellschaft, die ihren Fuhrpark überwachen möchte, um ihren Kunden vergünstigte Ta\-ri\-fe für verschleißarmes Fahrverhalten anbieten zu können. Weiterhin soll auf plötzlich auftretende Probleme an den Leihwagen möglichst schnell reagiert werden können um Schäden zu begrenzen, gefährliche Situationen zu vermeiden und bei Bedarf dem Kunden unverzüglich einen Ersatzwagen oder weitere Serviceleistungen anbieten zu können.
Um diese Situationen zu erkennen, sollen zwei RDF-Ereignisdatenströme zur späteren Verarbeitung eingerichtet werden und eine Sammlung von Fakten in lokalem Do\-mä\-nen\-wis\-sen modelliert werden. Diese werden im Folgenden vorerst nur grob beschrieben.
Besonders wichtige Ereignisse, wie das Aufleuchten der Motorkontrollleuchte oder das Auslösen des Airbags, sollen über diesen Datenstrom separat von den Statusdaten gemeldet werden.
Wird einem Kunden ein PKW zugewiesen oder gibt ein Kunde einen geliehenen PKW wieder zurück, so soll hierfür ein Ereignis in diesen Datenstrom eingespeist werden. Diese Ereignisse sollen immer die eindeutige Kundennummer und die Nummer des geliehenen Fahrzeugs enthalten, um eine eindeutige Zuordnung vornehmen zu können.
Um die Ereignisdaten aus den beiden beschriebenen Datenströmen bei der Verarbeitung in einen eindeutigen Kontext setzen zu können, wird lokal ver\-füg\-ba\-res Hintergrundwissen benötigt. Es soll die Zuordnung von Kunden zu den von ihnen geliehenen PKW aufbauen, die einzelnen PKW konkreten Automodellen zuordnen und somit eine konkrete Interpretation der von den PKW gemeldeten Daten ermöglichen.
Nachdem in Kapitel~\ref{cpt:motivation} das Vorhaben dieser Arbeit grob beschrieben wurde, folgt nun eine Einführung in die dafür benötigten Grundlagen. Da die später zu verarbeitenden Ereignisdatenströme im RDF-Format vorliegen werden, soll zunächst eine Einführung in das semantische Web zeigen, wie RDF zur Modellierung und Beschreibung von Wissen eingesetzt werden kann, und welche Möglichkeiten dadurch geboten werden. Anschließend sollen die grundlegenden Konzepte von CEP erläutert mit Hinblick auf die Verarbeitung von RDF-Datenströmen erläutert werden.
Das sogenannte \enquote{semantische Web} ist ein großes Anwendungsgebiet für RDF-Daten und deren Verlinkung. In diesem Abschnitt soll erläutert werden, was RDF ist, wofür es eingesetzt wird, und wie man in RDF vorliegende Daten verwenden und weiter verarbeiten kann.
Das Resource Description Framework (RDF) wird im semantischen Web zur Mo\-del\-lie\-rung und Repräsentation von Wissen verwendet. RDF-Daten bestehen aus einer Menge von Tripeln, welche sich aus den drei Komponenten Subjekt, Prädikat und Objekt in genau dieser Abfolge zusammensetzen um eine Aussage zu formen. Jeder dieser drei Bestandteile eines Tripels kann durch einen eindeutigen Uniform Resource Identifier (URI\footnote{Der URI wird in RFC 3986 beschrieben. Anstelle eines URI kann auch ein IRI (Internationalized Resource Identifier) verwendet werden --- die internationalisierte Form des URI nach RFC 3987.}) identifiziert werden. Lediglich in der Position \enquote{Objekt} eines Tripels kommen auch sehr häufig sogenannte \emph{Literale} vor um konkrete Datenwerte beispielsweise in Form von Zeichenketten oder Ganzzahlen zu repräsentieren.
Das in Listing~\ref{lst:sample_rdf_triple} enthaltene Tripel ordnet das Car-Subjekt \texttt{\#23} über das Prädikat \texttt{isCarModel} dem Objekt CarModell \texttt{\#42} zu. Abbildung~\ref{fig:triple_spo} illustriert neben diesem Tripel auch die Verknüpfung des Car-Subjektes über das Prädikat \texttt{hasNickname} zu dem Literalwert \enquote{Alf}.
Wie anhand des Beispiels aus Listing~\ref{lst:sample_rdf_triple} erkennbar ist, ist die explizite Notation für Tripel aufgrund der häufigen Nennung von vollständigen URIs wenig platzsparend und für große Datenmengen somit nicht empfehlenswert. Da es neben XML noch andere Repräsentationsformate für RDF-Daten gibt, bietet sich die Nutzung einer Notation an, die eine Nutzung von Prefixen erlaubt. Nach einer einmaligen Definition innerhalb eines Kontextes (zum Beispiel einer Datei) können diese Prefixe dann für den gesamten Kontext verwendet werden und verringern somit erheblich den Bedarf an Speicherplatz.
Listing~\ref{lst:sample_rdf_triple_with_prefix} zeigt die Notation von Tripeln im Turtle\footnote{Siehe auch die Spezifikation der Turtle-Notation nach \cite{w3c:turtle}}-Format unter Verwendung von Prefixen.
Aufgrund der Flexibilität dieser Struktur ist es möglich, nahezu jede Art von Informationen auf Tripel abzubilden, wie Listing~\ref{lst:sample_rdf_data} an einem Beispiel zeigt.
In RDF kann ein Subjekt grundsätzlich eine Instanz von mehreren Objektklassen sein. Um anzugeben, von welcher Objektklasse ein Tripel-Subjekt eine Instanz ist, wird das Prädikat \texttt{rdf:type} verwendet. Synonym dazu kann anstelle von \texttt{rdf:type} auch das Prädikat \texttt{a} verwendet werden, wie Listing~\ref{lst:sample_rdf_a_predicate} zeigt.
\begin{lstlisting}[caption={Das Prädikat \texttt{a} ist synonym zu \texttt{rdf:type}},label={lst:sample_rdf_a_predicate}]
Abhängig von den Objektklassen eines Subjektes können Ontologien nun einschränken, wie eine Objektinstanz mit anderen Objektinstanzen oder Werten verbunden werden darf. So kann beispielsweise definiert werden, dass das Prädikat \texttt{carOnt:drives} als Subjekt nur Instanzen der Klasse \texttt{carOnt:Driver} und als Objekt nur Instanzen der Klasse \texttt{carOnt:Car} zulässt, da die umgekehrte Richtung nicht sinnvoll wäre. (Für die umgekehrte Richtung wäre etwa \texttt{carOnt:isDrivenBy} sinnvoll.)
Da innerhalb des semantischen Web angestrebt wird, in RDF vorliegende Informationen gemeinsam zu nutzen und miteinander vernetzen zu können, werden RDF-Tripel meist als Quadrupel (oder kurz \enquote{Quad}) gehandhabt, in denen als zusätzliche Information der sogenannte Graph genannt wird, in dem die Tripel enthalten sind. Ein Graph wird durch eine URI identifiziert und dient als Namensraum für die Tripel, die er enthält. Dies vereinfacht die gleichzeitige Nutzung von mehreren Datenquellen, da jedes Tripel eindeutig einem Graphen zugeordnet werden kann und innerhalb von Abfragen spezifisch Tripel aus verschiedenen Graphen selektiert werden können.
Das \enquote{RDF-Schema} (kurz RDFS\footnote{Für eine detailreiche Einführung in RDFS siehe auch \cite{hitzler:semanticweb}[Kapitel 3.4]}) dient zur Spezifikation von Schemawissen durch die Definition von Objektklassen und Prädikaten, welche in hierarchischen Verhältnissen zueinander stehen können\footnote{Mittels \texttt{rdfs:subclassOf} und \texttt{rdfs:subpropertyOf} können hierarchische Verhältnisse zwischen verschiedene Properties beziehungsweise Objektklassen definiert werden.}. Betrachtet man bei\-spiels\-wei\-se die Daten aus Listing~\ref{lst:sample_rdf_data}, so ist in diesem Kontext für die Verwendung des Prädikats \texttt{carOnt:drives} offensichtlich, dass es nur zusammen mit einem Subjekt der Klasse \texttt{Driver} und einem Objekt der Klasse \texttt{Car} verwendet werden sollte um eine sinn\-volle Aussage zu ergeben. Eine solche Regel kann mit Hilfe von RDFS definiert werden, wie Listing~\ref{lst:sample_rdfs_data} zeigt.
\begin{lstlisting}[caption={Definition der Klassen \texttt{Car} und \texttt{Driver} sowie des Prädikats \texttt{drives} in RDFS},label={lst:sample_rdfs_data}]
In Listing~\ref{lst:sample_rdfs_data} werden zunächst die beiden Klassen \texttt{carOnt:car} und \texttt{carOnt:Driver} definiert. Im darauf folgenden Absatz wird dann das Merkmal \texttt{carOnt:drives} definiert und über \texttt{rdfs:domain} auf Subjekte der Klasse \texttt{Driver} und mit \texttt{rdfs:range} auf Objekte der Klasse \texttt{Car} eingeschränkt. Trifft man in diesem Kontext nun Tripel mit einem Prädikat \texttt{carOnt:drives} an, so kann man anhand der zugehörigen RDFS-Daten bereits erkennen, womit man es zutun hat.
In OWL (Web Ontology Language) formulierte Ontologien werden im semantischen Web neben RDF-Schemata sehr häufig zur Strukturierung von RDF-Daten verwendet. Ähnlich wie RDFS definieren OWL-Ontologien ein Vokabular mit logischen Do\-mä\-nen\-objekt\-klas\-sen und bestimmt für diese Objektklassen Prädikate und Attribute, um bestimmte Sachverhalte eindeutig abbilden zu können. Allerdings bietet OWL mächtigere Sprachkonstrukte, um feiner granulare Regeln für Objektklassen und Attribute aufzustellen. Eine Ontologie für Listing~\ref{lst:sample_rdf_data} könnte beispielsweise eine Objektklasse \texttt{Driver} definieren, auf welche das eigens hierfür definierte Prädikat \texttt{hasName} mit einem Attribut vom Typ \texttt{xsd:string} angewandt werden kann. Durch die Möglichkeiten dieser Restriktionen können RDF-Daten aus der Welt einer Ontologie --- ähnlich wie bei einem relationalen Datenbankschema --- eindeutig auf inhaltlicher Ebene strukturiert werden.
Bei der Modellierung von Wissen mit Hilfe von Beschreibungslogiken, zu denen auch OWL und RDFS zählen, werden die formulierten Aussagen in zwei Gruppen unterteilt\cite{hitzler:semanticweb}[Kapitel 6.1]: Die Assertion Box (ABox) und die Terminology Box (TBox). Während die TBox Aussagen mit terminologischem Schemawissen wie Definitionen von Objektklassen, Prädikaten und ihren Verhältnissen zueinander enthält, beinhaltet die ABox sogenanntes \emph{assertionales Instanzwissen}\cite{hitzler:semanticweb}[Kapitel 6.1], welches aus Aussagen über konkrete Klasseninstanzen und deren Merkmale und Beziehungen besteht. In diesen Aussagen der ABox wird dabei das in der TBox definierte Vokabular genutzt.
Ein Beispiel für eine TBox ist Listing~\ref{lst:sample_rdfs_data}, in welcher Objektklassen definiert werden, die innerhalb der ABox aus Listing~\ref{lst:sample_rdf_data} verwendet werden, um konkrete Instanzen dieser Objektklassen zu beschreiben.
\todo{GRAFIK: Ein wenig visualisiertes Wissen, welches TBox und ABox-Inhalte getrennt voneinander darstellt. (Eine Ebene mit Klassen und Attributen, eine andere Ebene mit konkreten Klasseninstanzen und deren Merkmalen)}
Natürlich ist es möglich, mehrere verschiedene Ontologien gleichzeitig zu verwenden. Diese Flexibilität ermöglicht beispielsweise, dass eine bereits in RDF abgebildete Person durch beliebige Informationen über Vokabular aus weiteren Ontologien ergänzt werden kann. Natürlich können die Informationen einer in RDF abgebildeten Person auch in verschiedenen, für andere Parteien geläufigen Strukturen verfügbar gemacht werden können. Innerhalb einer Ontologie kann auf die Objektklassen und Attribute zurückgegriffen werden, die in anderen Ontologien definiert werden. Dies ermöglicht neben Erweiterungen für spezifische Zwecke auch das Übersetzen von Wissen zwischen verschiedenen Ontologien durch die Definition von äquivalenten Objektklassen und Attributen.
Sollte es nötig sein, für eigene Terminologie eine Ontologie zu erzeugen, so ist es wichtig hervorzuheben, dass für in RDF abgebildete Fakten nahezu immer die Annahme gilt, dass diese Daten nicht vollständig sind und somit nicht alle realen Fakten auch in RDF erfasst sind. Die meisten existierenden Ontologien respektieren diese Annahme und verzichten auf die Definition von expliziten Regeln, die über die konkrete Bedeutung der Abwesenheit von bestimmten Fakten entscheiden würden. (In der Welt der relationalen Datenbanksysteme gibt es eine ähnliche Problematik in Zusammenhang mit der Verwendung des Schlüsselworts \texttt{NULL}.)
Durch den Einsatz von Terminologiewissen in Form von OWL-Ontologien oder RDF-Schemata ergibt sich die Möglichkeit, die Fakten aus der ABox automatisch um über die Terminologie abgeleitetes Wissen anzureichern. Diesen Prozess bezeichnet man als \emph{Reasoning}.
In diesem Prozess werden aus den in RDF vorliegenden Fakten (Assertion Box) und den in den verwendeten Ontologien definierten Objektklassen, Regeln und Zusammenhängen (Terminology Box) neues Wissen abgeleitet \cite{hitzler:semanticweb} und die lokale Datenbasis damit angereichert. So können beispielsweise implizite Klassentypen errechnet werden (\enquote{Ein PKW ist auch ein Fahrzeug}), oder regelbasierte Zugehörigkeiten zu Objektklassen ermittelt werden: Die Aussagen \enquote{Der PKW x rollt.} und \enquote{Der PKW x ist verriegelt.} können zu der Folgerung \enquote{Der PKW x ist eine Gefahrenquelle.} führen.
Enthält eine Ontologie strukturelle Informationen über Fahrer, PKW und Attribute bezüglich technischer Daten über PKW-Modelle, so ist es beispielsweise möglich auf Basis der Fakten aus Listing~\ref{lst:sample_rdf_data} zusätzliche Attribute der Fahrer wie \enquote{isDrivingCarModel} oder der PKW wie \enquote{hasEmergencyContactNumber} zu errechnen. Dieses funktioniert natürlich nur, falls in den Fakten bekannt ist, dass ein Fahrer ein Fahrzeug fährt und somit zu diesem Fahrzeug verbunden ist. Limitiert werden die Möglichkeiten des Reasoning ebenfalls durch die \emph{Open World Assumption} (OWA), also die Annahme einer offenen Welt, über die nur \emph{unvollständiges Wissen} vorliegt. Deshalb sollten für Reasoning nur explizit bekannte Fakten genutzt werden: Nur weil in Listing~\ref{lst:sample_rdf_data} keine Informationen über weitere PKW oder Fahrer vorhanden sind heißt das nicht, dass diese nicht existieren oder Einfluss auf die bekannten Fakten haben könnten. Weiterführende Beispiele zu den Möglichkeiten von OWL Reasoning finden sich unter \cite{man:owl}.
Da Ontologien auch genutzt werden können, um Wissen aus den Strukturen einer Ontologie in die Struktur einer anderen Ontologie zu übersetzen, kann ein Reasoner die daraus resultierende Übersetzung direkt errechnen und der lokalen Datenbasis hinzufügen. Dadurch steht Abfragen, die schon auf die Ziel-Ontologie zugeschnitten sind, ein viel größerer Informationspool zur Verfügung, aus dem das Abfrageergebnis berechnet werden soll.
Die Vorteile von Reasoning erkauft man sich durch einen nicht unerheblichen Einsatz von Rechenleistung, da im Prozess des Reasoning eine Menge von zusätzlichen Daten entsteht, für die zusätzlich zu den bereits vorhandenen Daten die Regeln aller genutzten Ontologien berücksichtigt werden müssen. Behandelt man lediglich statische Daten, die sich kaum bis garnicht ändern, so ist der nötige Aufwand für Reasoning übersichtlich und liegt auch für große Mengen von Daten und Ontologien in einem akzeptablem Rahmen. Ändern sich jedoch häufig Daten, so muss für das Subset der veränderten Daten der Reasoning-Prozess erneut durchgeführt werden um eine vollständig aktuelle Datenbasis zu erhalten.
Die Abfrage von Wissen aus RDF-Daten erfolgt über die Abfragesprache \emph{SPARQL} (\enquote{SPARQL Protocol And RDF Query Language}), welche in diesem Abschnitt grob erläutert wird. Eine detaillierte Beschreibung von SPARQL ist unter \cite{w3c:sparql} nachzulesen.
Im Gegensatz zu Abfragesprachen von relationalen Datenbanksystemen wie SQL ist es mit SPARQL möglich, Daten über verschiedene Datenquellen wie Tripel- oder Quadstores\footnote{Analog zu relationalen Datenbanksystemen für Relationen ein Speicher für RDF-Tripel beziehungsweise RDF-Quads} hinweg miteinander zu verknüpfen. Auch ist im Gegensatz zu SQL keine spezielle Anpassung der Abfragen an ein Datenbankschema notwendig; lediglich die Art und Weise, wie die angeforderten Daten miteinander in Verbindung stehen, ist für SPARQL-Abfragen wichtig. Kenntnisse über das verwendete Vokabular (RDF-Schema oder OWL-Ontologien) können jedoch bei der Formulierung der Abfragen hilfreich sein. Im Folgenden zeigt Listing~\ref{lst:sample_sparql_query} eine einfache Abfrage auf den Daten aus Listing~\ref{lst:sample_rdf_data}.
\begin{lstlisting}[caption={Abfrage der maximal zulässigen Motordrehzahl des Auto-Subjektes Nr. 0 aus Daten von Listing~\ref{lst:sample_rdf_data}},label={lst:sample_sparql_query}]
Listing~\ref{lst:sample_sparql_query} zeigt, dass SPARQL in der groben Grundstruktur eine Ähnlichkeit zu SQL aufweist; allerdings sind bedingt durch die Struktur der Daten (Relationen bei SQL gegenüber Tripel und Quadrupel bei SPARQL) große Unterschiede in der Gestaltung der Abfragen zu finden. Zunächst werden analog zur Turtle-Notation Prefixe notiert, die innerhalb der Abfrage verwendet werden sollen. In der \texttt{WHERE}-Klausel werden Tripel mit Platzhaltern verwendet, um aus dem vorhandenen Datenbestand die Tripel zu isolieren, die auf das angegebene Muster passen. So wird in diesem Beispiel zunächst ein Tripel gesucht, welches als Subjekt \texttt{car:0} gesetzt hat und das Prädikat \texttt{carOnt:isCarModel} verwendet, welches auf das zu dem Auto zugehörige Automodell-Subjekt zeigt. Ergibt sich ein Treffer, so wird der Objekt-Teil des gefundenen Tripels in den Platzhalter \texttt{?carModel} eingefügt und für die Suche des zweiten Tripels des SPARQL-Queries verwendet.
Für das gefundene \texttt{?carModel} wird nun ein Tripel gesucht, welches für \texttt{?carModel} das Prädikat \texttt{carOnt:maximumMotorRPM} nutzt, um die Angabe der maximalen Drehzahl für dieses Automodell zu definieren. Wird hierfür ebenfalls ein Treffer gelandet, so wird der Platzhalter \texttt{?maxMotorRPM} mit dem dazugehörigen Wert gefüllt und kann dann in der \texttt{SELECT}-Klausel selektiert werden. Für jede Tripelkombination, die auf die in der \texttt{WHERE}-Klausel formulierten Beschreibung passt, ergibt sich nun ein Ergebnis, für welches die in der \texttt{SELECT}-Klausel angegebenen Felder zurückgegeben werden --- in diesem Fall also lediglich ein Ergebnis mit dem Wert \enquote{4300}.
Neben \texttt{SELECT} unterstützt SPARQL auch den Befehl \texttt{CONSTRUCT}. Dieses ermöglicht die direkte Konstruktion von neuen Tripeln aus vorgegebenen Tripeln mit Platzhaltern, welche mit den Ergebnissen der Abfrage gefüllt werden. Listing~\ref{lst:sample_sparql_construct} zeigt die beispielhafte Erzeugung von Tripeln auf Basis der Daten aus Listing~\ref{lst:sample_rdf_data}, welche über das Prädikat \texttt{carOnt:motorRPMTolerance} Auskunft über die Größe des akzeptablen Drehzahlbereiches der Automodelle geben sollen.
\begin{lstlisting}[caption={Konstruktion von neuen Tripeln auf Basis des Wissens aus Listing~\ref{lst:sample_rdf_data}},label={lst:sample_sparql_construct}]
Wie in Listing~\ref{lst:sample_sparql_construct} gezeigt, können einfache Operationen in SPARQL-Abfragen durch\-ge\-führt werden, deren Ergebnisse über die \texttt{BIND}-Anweisung in einen vorgegebenen Platzhalter \texttt{?rpmTolerance} eingesetzt werden. In diesem Beispiel wurde die Differenz zwischen der maximalen und der minimalen empfohlenen Motordrehzahl eines Automodells ausgerechnet und ein neues Tripel mit dieser Information generiert.
Von Transaktionen im Handel über Messereignisse von Sensoren bis hin zu Benutzerinteraktionen auf Webseiten entstehen täglich eine Vielzahl von Ereignisdaten, die für einen begrenzten Zeitraum einen Teil der echten Welt abbilden. Um aus diesen großen Datenmengen durch Erkennung von Mustern oder durch Aggregation von Daten schnellstmöglich höherwertige Informationen gewinnen zu können, ist Complex Event Processing (CEP) das Mittel der Wahl. Wie der Begriff CEP bereits andeutet, geht es dabei um die Verarbeitung von komplexen Ereignissen. Im folgenden Abschnitt wird hierfür ein kurzer Einstieg in die Grundlagen von CEP gegeben. Für eine detailreiche Erläuterung und die beispielhafte Anwendung der CEP-Engine \enquote{Esper} sei auf \cite{hsh:cep} verwiesen.
Um Complex Event Processing durchführen zu können, wird eine CEP-Engine benötigt. Eine CEP-Engine ist eine Software, welche Ereignisdatenströme konsumiert und diese durch die Auswertung benutzerdefinierter CEP-Regeln verarbeitet. Aufgrund der großen Datenvolumen, die eine CEP-Engine verarbeiten muss, werden Ereignisse nur für die Dauer der Verarbeitung\footnote{Dieser Parameter hängt meist von der Größe der verwendeten Sliding Windows ab.} im Speicher gehalten und nicht persistiert.
Im Rahmen von Complex Event Processing werden Ereignisdaten als Instanzen von Ereignistypen betrachtet. Während ein Ereignistyp für eine bestimmte Klasse von Vorkommnissen grundlegende Eigenschaften und Attribute definiert, re\-prä\-sen\-tiert eine Ereignisinstanz ein konkretes Ereignis dieses Ereignistypen\cite{hsh:cep}. Diese trägt neben inhaltlichen Informationen über den Vorgang durch den sie ausgelöst wurde auch eine eindeutige ID sowie einen Zeitstempel mit sich. Während der Zeitstempel den Zeitpunkt der Ereignisauslösung angibt, dient die ID zur eindeutigen Abgrenzung von anderen Ereignissen, die vom selben Ereignistyp sind oder zum selben Zeitpunkt entstanden sind. Da es bedingt durch Übertragunglatenz und weitere technische Randbedingungen möglich ist, dass die Ereignisdaten zeitverzögert bei der CEP-Engine ankommen, wird der Zeitstempel ebenfalls benötigt, um die zeitlichen Beziehungen zwischen den Ereignissen zu erhalten.
Jedes Ereignis trägt abhängig von seinem Ereignistypen eine geringe Menge von Daten mit sich, die für das Ereignis spezifische Informationen enthalten. Dies können beispielsweise Daten von Sensoren, Angaben über eine Benutzersitzung oder Statusdaten eines Systems sein. Diese Daten sind jedoch nur \emph{Momentaufnahmen} und verlieren mit fortschreitender Zeit meist an Gültigkeit. Listing~\ref{lst:sample_abstract_car_status_event} zeigt beispielhaft eine Instanz des Ereignistypen \texttt{CarStatusEvent}.
Dafür treten diese primitiven Ereignisse häufig mit einer sehr hohen Frequenz auf, da ein komplexer Vorgang während seiner Durchführung eine Vielzahl von Ereignissen auslösen kann. Beobachtet man beispielsweise einen aus dem Stand anfahrenden PKW bis zu seiner Erreichung von 30km/h, so würde man zusätzlich zu periodisch gemeldeten Messwerten von Sensoren aus dem Motorraum und Informationen über Gangwechsel des Getriebes eine Flut von Informationen darüber erhalten, wie die Pedale durch den Fahrer bedient wurden oder wie das Lenkrades eingeschlagen wurde.
Natürlich können nicht nur externe Komponenten als Quelle von Ereignissen dienen. Viele CEP-Engines unterstützen die Erzeugung von Ereignisdaten und deren Injektion in die eigene Ereignisverarbeitung. So können durch CEP-Regeln gewonnene Erkenntnisse direkt Einfluss auf die weitere Verarbeitung nehmen, indem sie als neue Ereignisse in die Verarbeitung aufgenommen werden.
Zur Erläuterung von CEP-Regeln wird für diese hier eine aus Kapitel 3 von \cite{hsh:cep} entlehnte, abstrakte Sprache eingeführt, anhand derer die einzelnen Sprachkonstrukte von CEP-Regeln erläutert werden sollen.
Eine CEP-Regel besteht zunächst aus zwei Teilen: Zuerst definiert der \texttt{CONDITION}-Teil Ereignismuster, die in dem Ereignisdatenstrom gesucht werden sollen, sowie spezifische Bedingungen, die für auf das Muster passende Ereignisse erfüllt sein müssen.
Sind alle Bedingungen im \texttt{CONDITION}-Teil erfüllt, so \enquote{matcht} die Regel\cite{hsh:cep}. Im darauffolgenden \texttt{ACTION}-Teil wird eine Reihe von Aktionen definiert, die ausgeführt werden sollen, sobald die Bedingungen der Regel eintreffen. Dies kann beispielsweise die Erzeugung eines neuen Ereignisses oder das Anstoßen eines Dienstes sein. Da die Daten der Ereignisse, auf die der \texttt{CONDITION}-Teil gepasst hat, für die weitere Verarbeitung von Interesse ist, stehen sie im \texttt{ACTION}-Teil zur Verfügung.
Matcht eine Regel, so werden die in ihr definierten Aktionen ausgeführt --- die Regel feuert\cite{hsh:cep}. Zusammengefasst sieht eine CEP-Regel wie folgt aus:
Komplexe Vorgänge kann man durch Muster in den Ereignisfolgen erkennen, die sie bei ihrer Durchführung ausgelöst haben. Hierbei spielen Ereignisfolgen und die zeitlichen Beziehungen zwischen Ereignissen eine Rolle. Um ein \enquote{bedeutungsvolles Ereignismuster} zu erkennen, wird eine CEP-Regel benötigt, die dieses Muster in ihrem \texttt{CONDITION}-Teil beschreibt.
Ein Beispiel für eine Ereignisfolge, welche durch unsachgemäß abgestellte PKW ausgelöst werden kann, könnte so aussehen:
Um diese Folge von Ereignistypen mit einer CEP-Regel erkennen zu können, müssen die Bedingungen, die dieses Ereignismuster impliziert, mit Hilfe von \emph{Ereignisalgebra} beschrieben werden. Diese wurde größtenteils an \cite{hsh:cep} angelehnt und beschreibt mit Operatoren und Funktionen Bedingungen für eine Menge von Ereignissen.
Eine Ereignisfolge ist Teilmenge eines Ereignisdatenstromes. Sie kann nach dem Schema $a_1b_1a_2c_1$ notiert werden, wobei $a_i$ die $i$-te Instanz des Ereignistypen A bezeichnet\cite{hsh:cep}. Zur Unterscheidung von Ereignistypen und Instanzen werden für Instanzen kleine Buchstaben, für Ereignistypen Großbuchstaben verwendet. Die Typen von Ereignissen werden zur Beschreibungen von Bedingungen in Ereignismustern verwendet.
\item Der \textbf{Sequenzoperator}$X \rightarrow Y$ dient zur Formulierung zeitlicher Ab\-häng\-ig\-kei\-ten zwischen zwei Ereignistypen. So beschreibt der Ausdruck eine Ereignisfolge, in der zuerst ein Ereignis vom Typ X auftritt, gefolgt von einer Ereignisinstanz des Typ Y. Die Ereignisfolge $c_1a_1c_2b_1d_1$ erfüllt diese Bedingung.
\item Die \textbf{boolschen Operatoren}$\wedge$ und $\vee$: Sie definieren \textbf{keine} zeitlichen Ab\-häng\-ig\-kei\-ten zwischen Ereignissen, bestimmen aber, \emph{welche} Ereignisse in einer Folge vorkommen dürfen. So trifft der Ausdruck $(A \vee B)$ auf Ereignisfolgen zu, die entweder ein Ereignis vom Typ A oder ein Ereignis vom Typ B enthalten. Die Folgen $c_1b_1d_1d_2$, $a_1d_1d_2c_1c_2$ und $b_1c_1a_1$ passen auf diesen Ausdruck. Der Ausdruck $(A \wedge B)$ hingegen trifft nur auf Ereignisfolgen wie $d_1c_1a_1b_1c_2$ zu, in denen beide Ereignistypen vorkommen, wobei die zeitliche Reihenfolge keine Rolle spielt.
\item Den \textbf{Negationsoperator}$\neg X$ erlaubt keine Vorkommnisse des Ereignistyps X in der Ereignisfolge und ergibt nur in Kombination mit dem Sequenzoperator oder unter Verwendung von Sliding Windows (siehe nachfolgenden Abschnitt über Sliding Windows) Sinn. So würde der Ausdruck $(\neg A)$ für die Folge $b_1c_1b_2$ zutreffen, nicht jedoch für die Folge $b_1b_2a_1c_1$.
Nimmt man nun die oben angegebene Beispielfolge und formuliert daraus ein Muster in Ereignisalgebra, so erhält man: $(A)\rightarrow(\neg B)\rightarrow(C)$. Um auf die für dieses Muster passenden Ereignisinstanzen im Rahmen der weiteren Ereignisverarbeitung zugreifen zu können, müssen diese mit dem \texttt{AS}-Operator einer Variable zugewiesen werden können. Somit sieht dieses Muster nun wie folgt aus:
Dieses Muster kann man nun in einer CEP-Regel einsetzen, jedoch ist noch nicht garantiert, dass die auf das Muster passenden Ereignisinstanzen sich auf den \emph{selben} PKW beziehen --- es fehlen noch \emph{Kontextbedingungen}. Um diese zu definieren muss innerhalb der CEP-Regel Zugriff auf die Daten der gefundenen Ereignisinstanzen möglich sein. Um dies zu ermöglichen, gibt es drei Hilfsmittel:
\item Die \textbf{Aliasanweisung}\texttt{AS} ermöglicht die Definition eines Variablennamens innerhalb des Ereignismusters, der die für einen Ereignistypen gefundene Ereignisinstanz enthalten soll. So würde das Ereignismuster $(A\ AS\ eventA)$ dafür sorgen, dass die gefundene Ereignisinstanz vom Typ A in der Variable \texttt{eventA} für den Rest der CEP-Regel verfügbar ist.
\item Um nun auf Attribute einer Ereignisinstanz zuzugreifen, wird der \textbf{Attributoperator}\enquote{\textbf{.}} verwendet: Gegeben sei eine Ereignisinstanz, welche das Attribut \texttt{pkwID} enthält und in der Variable \texttt{eventA} enthalten ist, so würde der Ausdruck \[eventA.pkwID\] den Wert dieses Attributs zurückgeben.
Geht man davon aus, dass die Ereignistypen A und C aus dem obigen Ereignismuster die ID des PKW, von dem das Ereignis ausgelöst wurde, in dem Attribut \texttt{pkwID} enthalten, so kann man mit der Kontextbedingung
\[a.pkwID\ =\ c.pkwID\]
sicherstellen, dass die CEP-Regel nur für Ereignisfolgen matcht, die von dem selben PKW ausgelöst wurden und das Muster erfüllen. Listing~\ref{lst:abstract_cep_rule_two} zeigt diese CEP-Regel.
Um die großen Mengen von Ereignisdaten aus einem Datenstrom effizient verarbeiten zu können, werden sie in einem Fenster fester Größe betrachtet. Die Größe eines solchen Fensters wird häufig mit Zeiteinheiten wie Sekunden angegeben; selten wird die Größe durch eine Anzahl von Ereignissen angegeben, die das Fenster enthalten kann.
Ein \emph{Sliding Window} wird nach erfolgter Auswertung seines Inhalts um eine festgelegten Größe verschoben um aktuellere Ereignisse zu betrachten, wobei die älteren Ereignisse zugunsten der neuen Ereignisse aus dem Fenster herausfallen. Die Ergebnisse von CEP-Regeln verändern sich somit nach jedem Verschieben des Ereignisfensters. Das \emph{Tumbling Window} ist ein Sonderfall des Sliding Window, bei dem die Fenstergröße und das Intervall, um das es verschoben wird, gleich sind. Es wird quasi \enquote{umgeklappt}, sodass alle zuvor in ihm enthaltenen Ereignisse herausfallen und aktuellere Ereignisse in das nun leere Fenster gefüttert werden. Da somit ein Ereignis nur einmal in einem Tumbling Window Platz findet, kann es auch nur ein einziges Mal Einfluss auf die Auswertung nehmen.
Da je nach Anforderung einer CEP-Regel ein bestimmtes Ereignisfenster zweckmäßig ist, ist es notwendig, dies in der CEP-Regel festlegen zu können. Dafür werden die Angaben der Fenstergröße (\texttt{WindowSize}) und des Intervalls, in dem das Fenster verschoben wird (\texttt{StepSize}), wie folgt verwendet:
Eine weitere Möglichkeit zur Auswertung von Ereignisdaten ist die Aggregation der Attributdaten von Ereignissen zu höherwertigeren Ereignissen. Hierbei werden Ereignisse gleichen Typs innerhalb eines Sliding Windows betrachtet, mit Ereignismustern und Kontextbedingungen vorgefiltert. Dann können sie nach ihren Attributwerten gruppiert werden und diese dann mittels Aggregationsfunktionen zusammengefasst werden. So können Trends oder Kennzahlen aus Ereignisdaten gewonnen werden, die zur Interpretation der Ereignisdaten beitragen können.
notiert werden, wobei \texttt{event} eine Ereignisinstanz enthält, \texttt{'attribute'} den Namen des zu aggregierenden Attributs nennt, \texttt{\{groupByVariable\}} eine Liste von Variablen enthält, nach denen die Ereignistypen zu gruppieren sind, und \texttt{function} die Funktion nennt, mit der die Daten aggregiert werden sollen. Das Ergebnis der Aggregationsfunktion kann direkt in Kontextbedingungen verwendet werden oder mit dem \texttt{AS}-Operator einer lokalen Variable zugewiesen werden. Die folgenden Funktionen stehen zur Verfügung:
Um die Verwendung von Aggregationsfunktionen innerhalb von CEP-Regeln zu demonstrieren, folgt nun ein Beispiel: Innerhalb eines 15 Minuten Zeitfensters soll die durchschnittliche Geschwindigkeit von PKW bestimmt werden, die einen Messpunkt an einer Straße passieren. Unterschreitet die Durchschnittsgeschwindigkeit den Wert von 60km/h, so soll die Regel feuern.
sorgt hierbei dafür, dass alle durch das Ereignismuster gefundenen Ereignisinstanzen in der Variable \texttt{m} für die Aggregation vorgesehen werden. Die Werde des Attributes \enquote{speed} werden für alle gefunden Ereignisinstanzen nach \texttt{m.relatedCar} gruppiert, und mit der Funktion \texttt{AVG} ausgewertet und so die Durchschnittsgeschwindigkeit aller gemessenen PKW-Geschwindigkeiten in der Variable \texttt{averageSpeed} abgelegt, welche dann für die weitere Auswertung verwendet wird.
Die Kontextbedingungen der CEP-Regeln können auch Bezug auf \emph{Domänenwissen} nehmen, welches von der Anwendung lokal vorgehalten wird.
Hat man bei der Ereignisverarbeitung fast alle Register gezogen, so kommt die Integration des Domänenwissens ins Spiel. Alle Fakten, die für die auszuwertenden Ereignisdatenströme und deren Kontext bekannt sind, liegen hier vor. Beispiele dafür wären:
Das Domänenwissen kann somit verwendet werden, um einer durch Ereignisdaten be\-schrie\-be\-nen Situation einen eindeutigen Kontext zuzuordnen und somit die Interpretation der Daten stark zu erleichtern.
Wurde durch die Ereignisverarbeitung beispielsweise festgestellt, dass die durchschnittliche Drehzahl eines Motors bei 4200 Umdrehungen pro Minute liegt, so könnte über das Domänenwissen nachgeschlagen werden, in welchem Fahrzeug der betroffene Motor montiert ist, von welchem Typen dieses Fahrzeug ist, und letztendlich ob die Motordrehzahl für diesen Fahrzeugtypen im zulässigen Bereich liegt.
Um aus der CEP-Regel auf dieses Wissen zuzugreifen, kann innerhalb einer CEP-Regel das Konstrukt \texttt{lookup(\emph{key}, \emph{param...})} verwendet werden, wobei \texttt{key} für die aus dem Domänenwissen abzufragende Information steht und über \texttt{param...} beliebig viele Parameter erlaubt werden, die den Wissenszugriff spezifizieren. Parameter können dabei Variablen in der CEP-Regel sein. Der Aufruf kann direkt in Kontextbedingungen integriert werden, sodass die Formulierung dieser Bedingungen dadurch nicht erschwert wird. Soll beispielsweise die maximal zulässige Motordrehzahl für ein in \texttt{fooEvent.carModel} hinterlegtes Automodell nachgeschlagen werden, so kann der Ausdruck
die hierfür benötigten Daten aus dem Domänenwissen nachschlagen und liefern. Analog zu der Aggregationsfunktion \texttt{AGGREGATE()} kann auch das Ergebnis von \texttt{lookup()} mittels des \texttt{AS}-Operators in einer CEP-Regel in eine Variable abgelegt werden.
Um mit einer CEP-Regel nun auf die durch sie erkannten Sachverhalte reagieren zu können, können nahezu beliebige Aktionen im \texttt{ACTION}-Teil der Regel definiert werden. Diese lassen sich hauptsächlich in zwei Kategorien einteilen:
\begin{itemize}
\item Erzeugung eines höherwertigen Ereignis mit den gewonnen Erkenntnissen und Wiedereinspeisung dessen in den Verarbeitungsprozess
\item Anstoßen eines externen Dienstes beziehungsweise Ausführen von Programmcode
\end{itemize}
Sehr häufig werden die Auswertungsergebnisse einer CEP-Regel als höherwertiges Ereignis wieder in den Verarbeitungsprozess injiziert. Dies ist gerade dann nützlich, wenn durch eine mehrstufige Verarbeitung mit weiteren CEP-Regeln detailliertere Ergebnisse erzielt werden können. Um in dem \texttt{ACTION}-Teil einer CEP-Regel ein neues Ereignis auszulösen, wird ein mit dem Schlüsselwort \texttt{new} ein Ereignistyp wie zum Beispiel \texttt{CarAccelerationEvent} wie folgt instanziiert, wobei seine Attributwerte als Parameter übergeben werden:
\begin{lstlisting}
new CarAccelerationEvent(carID=eventA.pkwID, speed=eventC.speed-eventB.speed)
\end{lstlisting}
Um den Anstoß eines externen Dienstes beziehungsweise das Ausführen von Programmcode zu notieren, wird ein Methodenaufruf notiert, der zur Verdeutlichung mit \texttt{call} beginnt und Parameter übergeben bekommen kann. Der Aufruf eines \texttt{PushMessageService}, der einen Parameter \texttt{msg} erwartet, könnte wie folgt aussehen:
\begin{lstlisting}
callPushMessageService(msg="PKW mit ID"+eventA.pkwID+" hat ein Problem gemeldet.")
\end{lstlisting}
Erweitert man nun die CEP-Regel aus Listing~\ref{lst:abstract_cep_rule_two} mit einem Dienstaufruf, der den Fahrer des PKW auf Basis der \texttt{pkwID} benachrichtigen würde, so könnte dies so aussehen:
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_three},caption={CEP-Regel benachrichtigt Fahrer des PKW im Notfall}]
Mit den in diesem Kapitel vorgestellten Werkzeugen können abstrakte CEP-Regeln formuliert werden, die später zur Implementierung in die CEP-Sprache einer CEP-Engine übersetzt werden können.
Insgesamt liegt die Herausforderung von CEP darin, in kürzester Zeit große Datenströme von Ereignissen mit Hintergrundwissen anzureichern, diese zu höherwertigen Ereignissen zu kombinieren und bestimmte Muster zu finden, sowie die Ergebnisse mit möglichst geringer Verzögerung in Echtzeit ausgeben zu können oder Reaktionen einzuleiten.
Nachdem ein kurzer Einstieg in die Welt von RDF und CEP gegeben wurde, soll nun eine CEP-Engine ausgewählt werden, mit der RDF-Ereignisdatenströme verarbeitet werden können, um das Beispielszenario aus Kapitel~\ref{cpt:scenario} im weiteren Verlauf der Arbeit umsetzen zu können. In diesem Kapitel werden drei CEP-Engines vorgestellt, die einen C-SPARQL-Dialekt implementieren --- eine Form der Abfagesprache SPARQL, welche um Sprachkonstrukte erweitert wurde, die speziell auf die Verarbeitung von RDF-Datenströmen zugeschnitten sind. Eine der Engines soll in diesem Kapitel zur Umsetzung des Beispielszenarios aus Kapitel~\ref{cpt:scenario} ausgewählt werden.
Die ETALIS-Engine stellt zur Formulierung von CEP-Regeln neben der eigenen Sprache ELE (\enquote{Etalis Language for Events}) die Sprache EP-SPARQL (\enquote{Event Processing SPARQL}) zur Verfügung\cite{ep:etalis}. Ein erstes Paper\cite{ep:etalis} über die Engine erschien 2009; die Autoren lassen darauf schließen, dass die Engine vom FZI Forschungszentrum Informatik (Karlsruhe, Deutschland), dem Karlsruher Institut für Technologie (Karlsruhe, Deutschland), und der Stony Brook University (New York, USA) entwickelt wurde.
Bei der Engine handelt es sich um einen in Prolog implementierten Prototyp\cite{ep:unified}, der neben der Integration von lokalem Domänenwissen auch Reasoning auf Basis von gegebenem RDFS-Vokabular auf den Ereignisdaten unterstützt\cite{ep:etalis}. Dabei werden Fakten und CEP-Regeln direkt übersetzt um die vorhandene Prolog-Umgebung zur Auswertung nutzen zu können\cite{hsh:integrating}. Neben einer Schnittstelle für die Sprache Prolog stehen auch Schnittstellen für Java, C und C\# zur Verfügung\cite{ep:etalis}, jedoch wird für den Betrieb der Engine zusätzlich immer eine Prolog-Laufzeitumgebung benötigt.
Das CQELS-Framework (Continuous Query Evaluation over Linked Stream) wurde in Zusammenarbeit von dem Insight Centre for Data Analytics an der National University of Ireland (Galway, Irland), dem Institute of Information Systems an der Vienna University of Technology (Wien, Österreich) und dem Institut für Telekommunikationssysteme an der TU-Berlin (Berlin, Deutschland) entwickelt; ein erstes Paper über CQELS erschien 2011\cite{cqels:native}. Es wurde in Java implementiert und unterstützt die Einbindung von lokalem Domänenwissen in die Ereignisverarbeitung\cite{cqels:stream}. Über Reasoning-Fähigkeiten konnten bisher keine Angaben gefunden werden, jedoch kann nicht ausgeschlossen werden, dass Reasoning mit CQELS möglich ist.
Es kann als Grundlage zum Aufbau einer sehr leistungsfähigen RDF-fähigen CEP-Engine verwendet werden\cite{cqels:stream}, da es im Gegensatz zu vielen anderen RDF-fähigen CEP-Engines die eigentliche Datenverarbeitung nicht eine externe Engine delegieren, sondern eine eigene Implementierung verwendet. Dadurch reduziert sich die benötigte Rechenleistung, da so keine übersetzende Schnittstelle zu einer externen Engine benötigt wird \cite{cqels:native}.
Eine im Paper \cite{cqels:stream} vorgestellte Lösung\footnote{Unter \url{http://graphofthings.org/debs2015/cqels.zip} ist ein VirtualBox-Image mit der Lösung zum Ausprobieren erhältlich. (Größe ca. 1,1 GiB)} zur Verarbeitung von RDF-Er\-eig\-nis\-da\-ten\-strö\-men mit einem C-SPARQL-Dialekt konsumiert die Ereignisdaten über einen aus einer Datei lesenden CSV-Reader und schreibt die Ergebnisse der Verarbeitung über einen CSV-Writer in eine Datei, wobei die Engine intern mit RDF-Daten arbeitet, die von Reader und Writer jeweils konvertiert werden. Da es sich bei CQELS um ein Framework handelt\cite{cqels:native} ist im Gegensatz zu einer fertigen CEP-Engine zur Umsetzung eines Szenarios mit einem erhöhten Aufwand zu rechnen. Dafür punktet es im Vergleich zu klassischen, nicht RDF-fähigen CEP-Engines wie beispielsweise Esper mit einer hohen Performance\cite{cqels:stream}.
Die C-SPARQL-Engine wurde vom Polytechnikum Mailand (Italien) entwickelt; ein erstes Paper erschien im Jahr 2009\cite{barbieri:csparql}. Sie wurde zur Verarbeitung von RDF-Datenströmen im Rahmen eines Forschungsprojektes\cite{barbieri:csparql} in der Sprache Java entwickelt und bietet einen eigenen \emph{C-SPARQL-Dialekt} zur Formulierung von CEP-Regeln an, in denen direkt Bezug auf lokal vorhandenes Domänenwissen genommen werden kann. Weiterhin beinhaltet sie eine Implementierung von Reasoning auf RDFS-Vokabular, wie \cite{barbieri:reasoning} beschreibt.
Ein \enquote{Hello World}-Softwarepaket zur Demonstration der Engine, welches unter \url{http://streamreasoning.org/resources/c-sparql} zum Download angeboten wird, beinhaltet ein Eclipse/Maven-Projekt, welches Einsteigern einen ersten Überblick verschafft und leicht für eigene Zwecke angepasst werden kann. Da die Engine auf Software wie Apache Jena zum Speichern von RDF-Daten, Sesame zur Analyse und Abfrage von RDF-Daten via SPARQL, und die bekannte CEP-Engine Esper aufbaut, sind für die verwendeten Basistechnologien bereits gute Dokumentationen erhältlich.
Da in dieser Arbeit die Verarbeitung von RDF-Ereignisdatenströmen anhand einer konkreten CEP-Engine erläutert werden soll, muss nun eine Entscheidung für eine CEP-Engine gefällt werden. Um einen möglichst einfachen Einstieg in die Thematik zu bekommen, soll die vorgestellte Engine möglichst wenig zusätzlichen Aufwand hervorrufen. Um eine CEP-Engine auszuwählen, die für Einsteiger der Thematik möglichst leicht in der Handhabung ist, sind folgende Kriterien für die Auswahl der Engine verwendet worden:
Die Bewertung dieser Kriterien ist für EP-SPARQL\footnote{Quellen über Etalis/EP-SPARQL: \cite{ep:unified} und \cite{ep:etalis}}, CQELS\footnote{Paper über CQELS: \cite{cqels:native} und \cite{cqels:stream}} und C-SPARQL\footnote{Erläuternde Werke über C-SPARQL: \cite{barbieri:csparql},\cite{barbieri:reasoning} und \cite{barbieri:querying}} wie folgt ausgefallen:
Dokumentation & Mehrere Paper erläutern Features (o) & Paper über Umsetzung eines Projekts und Performance (o) & Mehrere Paper mit Erläuterungen (+) \\
Beispielcode & Archiviertes Projekt auf Google-Code \dots (o) & Projekt als VirtualBox (o) & Kommentiertes Beispielprojekt mit verschiedenen Szenarien (+) \\
Unter Berücksichtigung dieser Kriterien fiel die Wahl auf die CEP-Engine C-SPARQL; sie wird im weiteren Lauf der Arbeit vorgestellt, um die Verarbeitung von RDF-Er\-eig\-nis\-da\-ten\-strö\-men durchzuführen und das Beispielszenario aus Kapitel~\ref{cpt:scenario} umzusetzen.
Nachdem die Wahl der CEP-Engine im vorherigen Kapitel auf die C-SPARQL-Engine gefallen ist, sollen in diesem Kapitel nun ihre Möglichkeiten zur Verarbeitung von RDF-Datenströmen beleuchtet werden. Hierfür wird die Abbildung von Ereignisdaten mit RDF erläutert und die in Kapitel~\ref{cpt:cep_intro} eingeführte abstrakte Sprache für CEP-Regeln verwendet werden, um die Fähigkeiten von C-SPARQL-Queries zu demonstrieren --- die auf SPARQL aufgebaute Regelsprache der C-SPARQL-Engine.
Ereignisse --- genauer: Ereignisinstanzen --- werden aufgrund der Nutzung von RDF-Datenströmen als Transportmedium nun durch RDF-Tupel beschrieben. Diese tragen neben den typischen Inhalten von Tripeln (Subjekt, Prädikat und Objekt) nun eine vierte Information mit sich: den Zeitstempel, zu dem das Ereignis ausgelöst wurde. Da die Tupel nun mit dem Zeitstempel insgesamt vier Angaben enthalten, werden sie als \emph{Quadrupel} bezeichnet.
Um die Ereignisquadrupel trotz identischer Ereignistypen oder Zeitstempel voneinander unterscheiden zu können, ist es nötig, die Ereignisse mit einer eindeutigen ID zu versehen. Um dies zu erreichen, werden die einzelnen Ereignisinstanzen als eigene, separate Subjekte in RDF repräsentiert. Dadurch erhalten alle Quadrupel eines Ereignisses eine eindeutige Zuordnung zu ihrem Ereignissubjekt.
Um dies zu verdeutlichen folgt nun ein kleines Beispiel. Gegeben seien zwei beispielhafte Ereignisse mit Statusdaten über einen PKW. Listing~\ref{lst:sample_abstract_event_data} zeigt diese beiden Ereignisse in abstrakter Notation.
\begin{lstlisting}[caption={Zwei Statusereignisse eines PKW in abstrakter Notation},label={lst:sample_abstract_event_data}]
Wie aus Listing~\ref{lst:sample_abstract_event_data} zu erkennen ist, ist jede Ereignisinstanz quasi ein eigenes Objekt, welches alle für sich relevanten Daten entweder direkt oder als Zeiger auf andere Objekte enthalten kann. Um diese über RDF-Datenströme zu transportieren, müssen diese Ereignisinstanzen mit RDF-Quadrupeln beschrieben werden, wie Listing~\ref{lst:sample_event_rdf_quads} zeigt.
Wie in Listing~\ref{lst:sample_event_rdf_quads} zu sehen ist, wurde die ID der Ereignisinstanzen zur Generierung der Subjekt-URI verwendet, die in den Quadrupeln verwendet werden, um die Ereignisse zu beschreiben. Aus dem Ereignistyp wurde eine Aussage, die die Subjekt-URI via \texttt{rdf:type} mit einer RDFS-Objektklasse verknüpft, die diesen Ereignistypen repräsentieren soll. Alle weiteren Attribute der Ereignisinstanzen wurden über eigens hierfür definierte RDFS-Prädikate dem Ereignissubjekt zugeordnet. Die Angabe des PKW, auf den sich die Ereignisinstanzen beziehen, wurde durch eine direkte Verknüpfung der Ereignissubjekte mit dem zugehörigen PKW-Subjekt modelliert. Die PKW-Subjekte sind hierbei im Domänenwissen hinterlegt; dazu später mehr\todo{Kapitelreferenz!}.
Um die Ereignisdatenströme mit RDF-Quadrupeln nun in der C-SPARQL-Engine verarbeiten zu können, werden im Verarbeitungsprozess in C-SPARQL-Queries formulierte CEP-Regeln benötigt. Die Konstrukte und Fähigkeiten von C-SPARQL sollen in diesem Abschnitt erläutert werden. Weiterführend gibt es neben den Grundlagen zu SPARQL aus Kapitel~\ref{cpt:sparql_intro} noch ein Dokument der W3C\cite{w3c:sparql}. Eine detailliertere Erläuterung von C-SPARQL mit Beispielabfragen ist unter \cite{barbieri:csparql} nachzulesen.
Da C-SPARQL die Abfragesprache SPARQL lediglich erweitert, sind alle gültigen SPARQL-Abfragen automatisch auch gültige C-SPARQL-Abfragen\cite{barbieri:csparql}. Bevor nun die einzelnen Features von C-SPARQL erläutert werden, folgt nun ein ein gültiger Beispiel-Query, der als Grundlage der Erläuterungen dienen soll. Die Angabe von Prefixen mit der \texttt{PREFIX}-Klausel ist natürlich auch in C-SPARQL-Abfragen erforderlich, wird in diesem Abschnitt aber aus Gründen der Übersichtlichkeit weggelassen.
Betrachtet man den Beispielquery aus Listing~\ref{lst:example_csparql_query}, so ist erkennbar, dass C-SPARQL die Registrierung des Queries an der Engine erfordert. Diese wird nach dem folgenden Schema durchgeführt, wobei \texttt{QName} einen Namen für die Abfrage angibt und \texttt{Query} für die gesamte, restliche Abfrage steht:
Vorerst werden C-SPARQL-Queries unter Angabe des Schlüsselwortes \texttt{QUERY} registriert, mit dem Schlüsselwort \texttt{STREAM} wird sich später im Abschnitt~\ref{cpt:register_stream} beschäftigt.
Somit wurde die in Listing~\ref{lst:example_csparql_query} angegebene Abfrage als \texttt{QUERY} unter dem Namen \enquote{exampleQuery} an der Engine registriert.
Um mit der Verarbeitung von Ereignisdatenströmen beginnen zu können, müssen die für die Verarbeitung benötigten RDF-Datenströme in der CEP-Regel angegeben werden. Das Konstrukt \texttt{FROM [NAMED] STREAM <\emph{streamUri}> [\emph{window}]} wird zwischen den Klauseln \texttt{SELECT} und \texttt{WHERE} angegeben und definiert neben der in \texttt{streamUri} zu hinterlegenden URI des zu konsumierenden RDF-Datenstroms auch das an Stelle von \texttt{window} zu definierende Sliding Window, in dem dieser betrachtet werden soll\cite{barbieri:csparql}. Die Angabe des Schlüsselworts \texttt{NAMED} ist hierbei optional und funktioniert ähnlich wie in herkömmlichen SPARQL-Queries indem die Herkunft der einströmenden Tripel in Variablen vorgehalten wird, die über die \texttt{GRAPH}-Klausel verwendet werden können.
Die Angabe des Sliding Windows ist zwingend erforderlich, da die kontinuierlich einströmenden Ereignisdaten zur Verarbeitung auf eine endliche Datenmenge reduziert werden müssen. Weiterhin ist die Spezifikation des Sliding Window sinnvoll, da je nach Anforderungen der CEP-Regel Ereignisse aus bestimmten Zeiträumen für die Verarbeitung interessant sind --- je nach Zweck der CEP-Regel können diese Zeiträume sich stark unterscheiden.
Um ein Sliding Window in C-SPARQL zu definieren, wird die folgende Grammatik (entnommen aus \cite{barbieri:querying}) ab dem Einstiegspunkt \texttt{Window} verwendet:
Mit dieser Grammatik können drei verschiedene Sorten von Sliding Windows definiert werden:
\begin{itemize}
\item Das reguläre \textbf{Sliding Window} erfasst einen definierten Zeitraum und wird nach jeder Auswertung um seine definierte Schrittgröße weitergeschoben. Die definierte Schrittgröße darf nicht größer als die Größe des Sliding Windows sein. Der Ausdruck
definiert ein Sliding Window, welches Ereignisdaten über einen Zeitraum von 15 Minuten beinhaltet und nach jeder erfolgten Auswertung in 5 Sekunden-Schritten verschoben wird. Übersetzt man diesen Ausdruck mit der obigen Grammatik in einen C-SPARQL-Ausdruck, so erhält man \texttt{[RANGE 15m STEP 5s]}.
\item Das \textbf{Tumbling Window} ist ein Sonderfall des Sliding Window, da es nach jeder erfolgten Auswertung um seine eigene Größe verschoben wird. Ein solches Ereignisfenster, welches Ereignisdaten über den Zeitraum einer Stunde fasst und nach jeder erfolgten Auswertung um diese Größe verschoben wird, kann durch den Ausdruck
beschrieben werden. In der Abfragesprache C-SPARQL kann dieses Tumbling Window durch den Ausdruck \texttt{[RANGE 1h TUMBLING]} definiert werden. Durch das Verschieben des Tumbling Windows um seine eigene Größe kommt es nicht zu Überlappungen zwischen den Fenstern, sodass eine Ereignisinstanz immer nur in einem Tumbling Window und somit auch nur in einer Auswertung vorkommt.
\item Das \textbf{Physical Window} nutzt keine Zeiträume zur Festlegung seiner Größe, sondern eine feste Anzahl von Ereignisinstanzen, die es enthalten kann. Da die C-SPARQL-Engine bei dieser Art von Ereignisfenster keine Angabe einer Schrittgröße erlaubt\cite{barbieri:csparql}, um die das Fenster nach jeder Auswertung verschoben wird, wird davon ausgegangen, dass das Fenster immer nur um eine Ereignisinstanz verschoben wird. Der folgende Ausdruck definiert ein Physical Window, welches 150 Ereignisinstanzen erfasst und immer nur um eine Ereignisinstanz verschoben wird:
\begin{lstlisting}
[WindowSize:150events,StepSize:1event]
\end{lstlisting}
Übersetzt man diese Definition in die C-SPARQL-Abfragesprache, so erhält man \texttt{[RANGE TRIPLES 150]}.
Um einen RDF-Ereignisdatenstrom innerhalb einer C-SPARQL-Abfrage verwenden zu können, ist also lediglich die Nutzung des \texttt{FROM STREAM}-Konstrukts notwendig. Gegeben sei ein RDF-Datenstrom, der innerhalb eines Sliding Window über einen Zeitraum von 30 Minuten bei einer Schrittgröße von 5 Minuten betrachtet werden soll, der unter der URI \texttt{http://example.org/exampleStream} erreichbar ist. Um ihn in eine C-SPARQL-Abfrage unter den genannten Bedingungen einzubringen, muss also die Anweisung
Um nun innerhalb der \texttt{WHERE}-Klausel von C-SPARQL-Abfragen Ereignismuster definieren zu können und diese mit Kontextbedingungen weiter zu verfeinern, müssen zunächst die Operatoren der Ereignisalgebra aus Kapitel~\ref{cpt:cep_intro} in Elemente der C-SPARQL-Sprache übersetzt werden. Um dies zu tun, werden folgende Ausdrücke aus C-SPARQL benötigt:
\item\textbf{Zeitstempel abfragen}: Die Funktion \texttt{f:timestamp(?s,?p,?o)} gibt für das gegebene Tripel eines Ereignis-Quadrupels, bestehend aus Subjekt, Prädikat und Objekt, den zugehörigen Zeitstempel des Quadrupels zurück. Das Ergenis dieser Funktion wird später dazu verwendet, zeitliche Abfolgen und Beziehungen von Ereignissen festzustellen. Um die Funktion über das Prefix \texttt{f} ansprechen zu können, ist in der Abfrage folgende Prefix-Definition notwendig:
Die Funktion akzeptiert für jeden der drei Parameter neben klassischen Platzhaltern wie \texttt{?var}, auch die direkte Angabe von Werten in Form von URIs, sowohl in vollständiger Notation (\texttt{<\emph{uri}>}) und unter Nutzung von Prefixen (\texttt{\emph{prefix:example}}). Auch Literale können als Parameter angegeben werden\footnote{In der aktuell verwendeten Version 0.9.7 der C-SPARQL-Engine gibt es diesbezüglich einen Bug, sodass die Funktion für Tripel, die Literalwerte enhalten, keinen Zeitstempel zurückgibt.}. Ein Beispiel für die Nutzung dieser Funktion kann wie folgt aussehen:
\item\textbf{Berechnungsergebnisse speichern}: Um einen Ausdruck in einer lokalen Variable zu speichern wird die Anweisung \texttt{BIND(\emph{ausdruck} AS \emph{?var})} verwendet. Ein Ausdruck kann nahezu alles sein, von einer mathematischen Berechnung wie \texttt{(?i+1)/2} bis hin zu dem Aufruf der \texttt{f:timestamp(?s,?p,?o)}-Funktion. Der folgende Ausdruck demonstriert das Abspeichern der Differenz zwischen den Zeitstempeln zweier Tripel in der Variable \texttt{?difference}:
\item\textbf{Eventuell vorhandene Tripel selektieren}: Manchmal kann man zur Zeit der Formulierung einer Abfrage nicht mit vollständiger Gewissheit eine Aussage darüber treffen, ob bestimmte Muster von Tripeln in den zur Verfügung stehenden Daten enthalten sind. In diesem Fall hilft der \texttt{OPTIONAL \{ ... \}}-Block weiter: Er erlaubt die Selektion von Tripeln, wobei der Fall, dass keine Tripel selektiert werden konnten keinen negativen Einfluss auf die restliche Abfrage hat. Möchte man beispielsweise das Tripelmuster \texttt{?a :b :c} selektieren und zusätzlich --- falls vorhanden --- die Tripel für das Muster \texttt{?d :e :f}, so kann dies in der \texttt{WHERE}-Klausel wie folgt notiert werden:
\item\textbf{Variablen auf Werte prüfen}: Hat man den \texttt{OPTIONAL \{ ... \}}-Block verwendet, so stellt sich innerhalb der restlichen Abfrage oft die Frage, ob nun ein Ergebnis vorliegt oder nicht. Über die Abfrage \texttt{ISBOUND(?var)} kann geprüft werden, ob die angegebene Variable --- in diesem Fall \texttt{?var} --- mit einem Wert versehen ist oder nicht.
\item\textbf{Gefundene Tripelmenge einschränken}: Hat man bereits Tripel selektiert und möchte die Ergebnismenge anhand von feineren Kriterien einschränken, so kommt \texttt{FILTER(\emph{bedingung})} zum Einsatz. Die Anweisung nimmt einen Ausdruck als Bedingung entgegen, die für alle gefundenen Tripel ausgewertet wird. Erfüllen gefundene Tripel die Bedingung, so bleiben sie in der Ergebnismenge.
Gegeben seien Tripel nach dem Schema:
\begin{lstlisting}
?person rdf:type :person .
?person :isOfAge ?someAge .
\end{lstlisting}
Um aus diesen Daten nun alle Personen zu selektieren, die über 18 sind, kann die \texttt{FILTER}-Anweisung in der \texttt{WHERE}-Klausel verwendet werden:
\begin{lstlisting}
WHERE {
?person rdf:type :person .
?person :isOfAge ?age .
FILTER(?age >= 18)
}
\end{lstlisting}
Das Ergebnis enthält dann nur noch Personen, die laut ihrer Altersangabe älter als 18 sind.
\item\textbf{Abwesenheit oder Präsenz von Tripeln erkennen}: Unter bestimmten Umständen kann es notwendig sein, die Abwesenheit von Tripeln als Kriterium für ein Ergebnis festzulegen. Hiefür kann der Block \texttt{FILTER NOT EXISTS \{ ... \}} eingesetzt werden. Ähnlich wie der \texttt{OPTIONAL}-Block nimmt er Tripelmuster entgegen. Jedoch stellen alle in ihm gefundenen Tripel das Ausschlusskriterium für die zu ihnen bezogene Tripel aus der restlichen Ergebnismenge dar. Ein Beispiel aus \cite{w3c:sparql}[Kapitel 8.1.1] zeigt dies sehr schön. Gegeben seien folgende Daten:
Möchte man nun alle Personentripel finden, zu denen \textbf{kein} Name via \texttt{foaf:name} angegeben ist, so führt die folgende Abfrage zum gewünschten Ergebnis und gibt das Personentripel von \texttt{:bob} als Ergebnis zurück:
Natürlich kann man diese Abfrage auch umkehren um alle Personentripel \textbf{mit} einer Namensangabe zu finden. Hierfür kommt anstelle von \texttt{FILTER NOT EXISTS \{ ... \}} nun \texttt{FILTER EXISTS \{ ... \}} zum Einsatz. Das Ergebnis der Abfrage wäre nun das Personentripel von \texttt{:alice}.
\todo{Es folgt die Übersetzung der Operatoren der Ereignisalgebra aus Kapitel~\ref{cpt:cep_intro}, um zu erläutern, wie das alles in C-SPARQL funktionieren kann.}
Um nun in C-SPARQL Ereignismuster formulieren zu können, die denen aus Kapitel~\ref{cpt:cep_intro} entsprechen, müssen zunächst die Operatoren aus der Ereignisalgebra aus Anweisungen in C-SPARQL übersetzt werden.
\item\textbf{Ereignistypen}$(A)$: Bevor die Operatoren aus der Ereignisalgebra verwendet werden können, muss zunächst die Selektion von Ereignissen spezifischer Typen gezeigt werden. Wie Listing~\ref{lst:sample_event_rdf_quads} bereits demonstriert hat, wird das Prädikat \texttt{rdf:type} verwendet, um den Ereignistyp einer Ereignisinstanz zu spezifizieren. Diese Angabe kann bei der Selektion von Tripeln verwendet werden, um nur Ereignisinstanzen eines bestimmten Ereignistypen zu erhalten. Platziert man das folgende Muster in der \texttt{WHERE}-Klausel einer C-SPARQL-Abfrage, so erhält man Subjekte von Ereignisinstanzen vom Typ \texttt{<http://example.org/type/A>} in der Variable \texttt{?eventA}:
\item Der \textbf{Sequenzoperator}$X\ \rightarrow\ Y$: Um die zeitliche Abfolge von Ereignissen mit C-SPARQL zu formulieren, wird die \texttt{f:timestamp(?s,?p,?o)}-Funktion mit der \texttt{FILTER}-Anweisung kombiniert. Hat man bereits zwei Ereignisse --- je eines vom Typ X beziehungsweise Y --- selektiert, so kann man diese Anhand ihrer Zeitstempel filtern, sodass nur in der Ergebnismenge nur die Ereignisinstanzen übrig bleiben, für die gilt: Ereignis vom Typ X kam vor dem Ereignis von Typ Y.
Innerhalb der \texttt{WHERE}-Klausel sieht dies wie folgt aus:
\item Die \textbf{boolschen Operatoren}$\wedge$ und $\vee$: Mit dem Operator $\wedge$ kann über Ausdrücke wie $(A \wedge B)$ definiert werden, dass sowohl ein Ereignis vom Typ A als auch ein Ereignis vom Typ B im Muster vorkommen müssen. Um dies innerhalb von C-SPARQL auszudrücken, müssen innerhalb der \texttt{WHERE}-Klausel lediglich die Tripel selektiert werden, die zu den Ereignistypen korrespondieren:
\begin{lstlisting}
WHERE {
?eventA rdf:type <http://example.org/type/A> .
?eventB rdf:type <http://example.org/type/B> .
}
\end{lstlisting}
Sollte eines der beiden Tripel nicht in der zu verarbeitenden Datenmenge enthalten sein, so gibt die gesamte C-SPARQL-Abfrage kein Ergebnis zurück. Somit ist gewährleistet, dass diese \texttt{WHERE}-Klausel dem Ereignismuster $(A \wedge B)$ entspricht.
Für den Operator $\vee$, mit dem eine entweder-oder-Beziehung ausgedrückt werden kann, ist etwas mehr Arbeit erforderlich. Nimmt man den Ausdruck $(A \vee B)$, so bedeutet dieser, dass \emph{entweder} ein Ereignis vom Typ A \emph{oder} ein Ereignis vom Typ B vorkommt, jedoch nicht beide zugleich. Innerhalb von C-SPARQL bedeutet dies, dass für die Selektion der Tripel für die Ereignistypen A und B zwei \emph{separate}\texttt{OPTIONAL}-Blöcke verwendet werden müssen. Auf Basis der selektierten Tripel wird dann eine \texttt{FILTER}-Anweisung gebaut, die mit Hilfe von \texttt{BOUND()} alle Tripel aus der Ergebnismenge ausschließt, bei denen beide oder keiner von beiden Ereignistypen vorhanden ist:
Das Ergebnis sind ausschließlich Tripel, in denen \emph{entweder} ein Ereignis vom Typ A \emph{oder} ein Ereignis vom Typ B vorkommt.
\item Der \textbf{Negationsoperator} ($\neg A$): Die Abbildung des Negationsoperators in C-SPARQL unterscheidet sich je nach Ereignismuster, in dem er verwendet wird. Um ein Muster vom Schema $(\neg A)$ abbilden zu können, kann eine Kombination aus \texttt{OPTIONAL}-Block und \texttt{FILTER}-Anweisung verwendet werden. Neben der Selektion aller verfügbaren Ereignistripel wird im \texttt{OPTIONAL
}-Block ein Tripel für den Ereignistypen A selektiert. Die auf den Block folgende \texttt{FILTER}-Anweisung filtert dann mit Hilfe von \texttt{BOUND()} nach dem Kriterium, ob das im \texttt{OPTIONAL}-Block selektierte Ereignistripel gefunden wurde oder nicht. Die entsprechende \texttt{WHERE}-Klausel dieser Abfrage sieht dann wie folgt aus:
\begin{lstlisting}
WHERE {
?anyEvent rdf:type ?anyEventType .
OPTIONAL {
?eventA rdf:type <http://example.org/type/A> .
}
FILTER(!BOUND(?eventA))
}
\end{lstlisting}
Ein komplexeres Beispiel, in dem ein bestimmter Ereignistyp lediglich nicht zwischen zwei anderen Ereignistypen auftauchen darf, zeigt das folgende Ereignismuster:
\[(A)\ \rightarrow\ (\neg B)\ \rightarrow\ (C)\]
Dieses Muster verbietet die Vorkommnis von Ereignistyp B lediglich dann, wenn er zeitlich zwischen Ereignissen von Typ A und C liegt. Die in Listing~\ref{lst:example_csparql_query} gezeigte Beispielabfrage löst genau dieses Problem mit Hilfe eines \texttt{FILTER NOT EXISTS}-Blocks. Hierfür werden zunächst existierende Ereignisse vom Typ A und C selektiert und mit einer \texttt{FILTER}-Anweisung die Ergebnisse verworfen, in denen die Ereignisse vom Typen C nicht vor denen vom Typ A vorkommen. Dann wird via \texttt{FILTER NOT EXISTS} ein Ereignistripel vom Typ B gesucht, welches zeitlich \emph{zwischen} den gefundenen Ereignissen vom Typ A und C liegt. Falls innerhalb des Blockes ein passendes Ereignistripel gefunden wurde, so gehören die zugehörigen Ereignistripel vom Typ A und C nicht zur Ergebnismenge. Damit bleiben nur noch Ereignisse übrig, die das oben genannte Ereignismuster erfüllen.
Ergeben sich für Ereignismuster über ein Sliding Window eine größere Menge an Ergebnissen, so kann es sinnvoll sein, diese Anhand von bestimmten Kriterien in einzelne Gruppen zusammenzufassen und mittels Aggregationsfunktionen diese Gruppen zusammenzufassen. Um dies zu tun wurde in Kapitel~\ref{cpt:cep_aggregate_events} das Konstrukt \texttt{AGGREGATE} eingeführt.
Als passendes Gegenstück gibt es C-SPARQL das Konstrukt \texttt{GROUP BY (\emph{?var})}, wobei \texttt{?var} eine Variable aus der \texttt{WHERE}-Klausel ist, nach der gruppiert werden soll. Wird eine solche Gruppierung vorgenommen, so können über die daraus resultierenden Gruppen die folgenden Aggregationsfunktionen zur Zusammenfassung der Ergebnisgruppen verwendet werden\cite{barbieri:querying}:
Ähnlich wie bei SQL gibt es auch in C-SPARQL die Anweisung \texttt{HAVING}, mit dem Kriterien für die durch \texttt{GROUP BY} gebildeten Gruppen festgelegt werden können. Ist die in \texttt{HAVING} angegebene Bedingung für eine Gruppe nicht erfüllt, so wird sie aus der Ergebnismenge entfernt.
Nachdem nun die grundlegenden Werkzeuge zur Aggregation von Daten in C-SPARQL erläutert wurden, sollen diese in mit einem Beispiel demonstriert werden: Gegeben seien Statusmeldeereignisse von PKW, die zur weiteren Auswertung aggregiert werden sollen. Hierbei sollen für jeden einzelnen PKW, dessen durchschnittliche Motordrehzahl über 3000 Umdrehungen pro Minute liegt, die minimale beziehungsweise maximale Motordrehzahl ermittelt werden.
Um dies in C-SPARQL umzusetzen, müssen die Ereignistupel nach den PKW, auf die sie sich beziehen mit \texttt{GROUP BY} gruppiert werden. Dann können die gewünschten Werte in der \texttt{SELECT}-Klausel unter Nutzung der Funktionen \texttt{MIN()} und \texttt{MAX()} selektiert werden. Zuletzt kann das Kriterium, dass die durchschnittliche Motordrehzahl 3000 Umdrehungen pro Minute überschreitet mit einer \texttt{HAVING}-Anweisung umgesetzt werden. Die folgende C-SPARQL-Abfrage demonstriert dies:
Ein wichtiges Werkzeug bei der Verarbeitung von Ereignisdatenströmen ist das Auslösen von Aktionen. Hier gibt es im allgemeinen zwei unterschiedliche Wege, um Aktionen auslösen zu können. Diese eignen sich je nach konkretem Vorhaben unterschiedlich gut.
Das Auslösen von Ereignissen innerhalb der Ereignisverarbeitung kann genutzt werden, um eine mehrstufige Auswertung mit CEP-Regeln zu erhalten. Hierbei werden die Ergebnisse aus der Verarbeitung durch CEP-Regel genutzt, um den Typen und die Attributwerte des neuen Ereignisses zu bestimmen.
In C-SPARQL können bestimmte Abfragen, wie etwa \texttt{CONSTRUCT}-Queries als Datenströme registriert werden, um somit ihre Ergebnisse in weiteren CEP-Regeln verarbeiten zu können. Hierzu wird nach dem Schlüsselwort \texttt{REGISTER}, wie die Grammatik aus Listing~\ref{lst:register_query_csparql} beschreibt, das Schlüsselwort \texttt{STREAM} angegeben\footnote{Zusätzlich ist es notwendig, den Query nach der Registrierung von einem \texttt{RDFStreamFormatter} beobachten zu lassen, den man separat als Stream an der Engine registrieren muss. Mehr dazu in Kapitel~\ref{cpt:csparql_in_practice}}.
Um dies zu zeigen, sei in Listing~\ref{lst:abstract_cep_rule_five} eine abstrakte CEP-Regel gegeben, die Ereignisse vom Typ \texttt{CarStatusEvent} nach den im Attribut \texttt{relatedCar} angegebenen PKW gruppiert, für jeden PKW dessen durchschnittliche Geschwindigkeit ermittelt und für jedes Ergebnis ein neues Ereignis vom Typ \texttt{AverageSpeedEvent} erzeugt, welches die Durchschnittsgeschwindigkeit enthalten soll.
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_five},caption={CEP-Regel erzeugt neue Ereignisse}]
Diese CEP-Regel lässt sich mit C-SPARQL umsetzen, indem eine entsprechende Abfrage mit dem Schlüsselwort \texttt{CONSTRUCT} formuliert wird, welche die Durchschnittsgeschwindigkeit der PKW ermittelt und daraus neue Ereignisinstanzen vom Typ \texttt{AverageSpeedEvent} generiert. Listing~\ref{lst:csparql_construct_query} zeigt diese C-SPARQL-Abfrage:
Da C-SPARQL die gleichzeitige Nutzung von \texttt{GROUP BY} mit \texttt{CONSTRUCT} erlaubt, nutzt die Abfrage aus Listing~\ref{lst:csparql_construct_query} einen in geschweiften Klammern eingefassten Subquery, um die Aggregation vornehmen zu können. Um für die innerhalb von \texttt{CONSTRUCT} neu zu erzeugten Ereignisinstanzen ein Subjekt zu erhalten, wird mit \texttt{[]} ein sogenannter \emph{Blank Node} verwendet. Innerhalb der \texttt{CONSTRUCT}-Anweisung wird nur das letzte Tripel mit einem Punkt beendet; die letzten beiden Tripel zeigen durch die Verwendung eines Semikolons an, dass sie das selbe Subjekt wie das erste Tripel für ihre Aussage verwenden. Somit haben alle drei der konstruierten Tripel das selbe Blank Node als Subjekt. Nach Auswertung des Queries erhält jeder Blank Node von der Engine eine Kennung, anhand welcher er identifiziert werden kann.
Natürlich bietet die C-SPARQL-Engine auch Möglichkeiten zum Ausführen von eigenem Code und somit auch zum Anstoßen von externen Diensten. Allerdings bietet sie dafür keine Möglichkeiten innerhalb der C-SPARQL-Sprache selbst, sondern erfordert das Anbringen von einem \texttt{Observer} an den durch die Registrierung eines Queries an der Engine entstandenen \texttt{CsparqlQueryResultProxy}. Dieser wird jedes Mal benachrichtigt, wenn für den registrierten Query ein Ergebnis vorliegt. Dabei wird die durch das \texttt{Observer}-Interface implementierte Methode \texttt{update()} aufgerufen, welcher der \texttt{CsparqlQueryResultProxy} des Queries sowie die \texttt{RDFTable} mit den Ergebnissen übergeben wird. Innerhalb der Methode \texttt{update()} kann dann beliebiger Java-Code hinterlegt werden, der mit den Ergebnisdaten arbeitet oder einen externen Dienst anstößt.
Somit kann von der CEP-Regel in Listing~\ref{lst:abstract_cep_rule_six} nur der \texttt{CONDITION}-Teil in C-SPARQL umgesetzt werden (Listing~\ref{lst:csparql_speedavg_greater_140}), da für den \texttt{ACTION}-Teil zusätzlicher Java-Code benötigt wird:
Zur Einbindung von lokalem Domänenwissen bietet C-SPARQL sehr leicht zugängliche Möglichkeiten. Bevor das lokale Domänenwissen in C-SPARQL-Queries zur Verfügung steht, muss es zunächst in einen Graphen geladen werden. Der folgende Code liest die in der Date \texttt{data/carSimulationABox.rdf} gespeicherten RDF-Daten und hinterlegt sie für die Engine in dem Graphen \texttt{http://example.org/carSimKnowledgeGraph}:
Um auf diese Daten aus einem C-SPARQL-Query zugreifen zu können, ist es lediglich notwendig, den Graphen mit einer zusätzlichen \texttt{FROM}-Klausel als Datenquelle anzugeben:
\begin{lstlisting}
FROM <http://example.org/carSimKnowledgeGraph>
\end{lstlisting}
Danach stehen die Daten aus dem Graphen im Kontext der Abfrage zur frei zur Verfügung. Der folgende C-SPARQL-Query nutzt Daten aus dem lokalen Domänenwissen, um für zu schnell fahrende PKW den aktuellen Fahrer zu ermitteln:
\begin{lstlisting}[label={lst:csparql_lookup_driver},caption={Zugriff auf lokales Domänenwissen aus Graph}]
REGISTER QUERY getSpeedingCars AS
SELECT ?driverName ?car (AVG(?speed) AS ?avgSpeed)
FROM STREAM <...> [RANGE 15m STEP 1m]
FROM <http://example.org/carSimKnowledgeGraph>
WHERE {
?e rdf:type car:CarStatusEvent .
?e car:relatedCar ?car .
?e car:speed ?speed .
?driver car:isDriving ?car .
?driver car:hasName ?driverName .
}
GROUP BY (?car)
\end{lstlisting}
Die Verknüpfung von Ereignisdaten mit lokalem Domänenwissen ist bei der Nutzung der C-SPARQL-Engine direkt innerhalb von CEP-Regeln möglich und erleichtert somit deutlich die Formulierung von Regeln.
Die C-SPARQL-Engine unterstützt die automatische Anreicherung von RDF-Datenströmen und Abfrageergebnissen durch implizites Wissen, welches durch ein gegebenes RDFS-Vokabular abgeleitet werden konnte. Hierfür wird in der C-SPARQL-Engine die Implementierung des \texttt{GenericRuleReasoner} aus Apache Jena verwendet. Diesem Reasoner wird ein eigenes Regelwerk zugeführt, welches die Axiome und Folgerungsregeln von RDFS implementiert.
Bei der Registrierung einer C-SPARQL-Abfrage an der Engine muss angegeben werden, ob Inferenz mit dem Reasoner für diesen Query verwendet werden soll. Die folgende Zeile zeigt diesen Schritt, wobei der zweite Parameter ausschlaggebend für die Aktivierung ist:
Hat man auf diese Weise einen Query an der Engine registriert, so muss als nächstes für den \texttt{CsparqlQueryResultProxy} Parameter angegeben werden, unter denen das Reasoning durchgeführt werden soll. Neben der Angabe des zu verwendenden Regelwerks, welches in diesem Fall RDFS implementiert, muss eine TBox mit Basisvokabular angegeben werden, die als Basis für die Schlussfolgerungen dient. Weiterhin ist es möglich zu konfigurieren, welche Logik zum Anstellen der Schlussfolgerungen verwendet werden soll. Hierbei gibt es drei Auswahlmöglichkeiten, die nun grob erklärt werden:
\begin{itemize}
\item\textbf{Forward Chaining}: Geht von den bereits existierenden Fakten aus und prüft anhand dieser Fakten, ob es Regeln gibt, die durch diese Fakten erfüllt sind. Ist dies der Fall, werden diese erfüllten Regeln verwendet, um daraus Wissen abzuleiten. Stellt das standardmäßige Vorgehen dar, falls keine Logik explizit angegeben wurde.
\item\textbf{Backward Chaining}: Stellt quasi das gegenteilige Vorgehen zu Forward Chaining dar. Begonnen wird bei einer Aussage, die darauf überprüft werden soll, ob sie zutrifft. Nun werden alle Regeln gesucht, die zu dieser Aussage führen und geprüft, ob diese erfüllt sind. Somit sind alle Bedingungen dieser Regeln wiederrum Aussagen, die geprüft werden müssen. Dieser Ansatz setzt sich über weitere Regeln so weit fort, bis entweder ein erfüllender Fakt gefunden wurde, oder alle Regeln negativ getestet worden sind.
Weiterführendes über Reasoning auf RDF-Datenströmen mit der C-SPARQL-Engine kann in der Masterarbeit von Stefan Lier\cite{hsh:reasoning} nachgelesen werden. Über die Implementierung von Reasoning in der C-SPARQL-Engine kann in \cite{barbieri:reasoning} gelesen werden.
\todo{In diesem Kapitel wird die Engine konkret ausgepackt und mit Java-Code benutzt. Es werden Datenstromgeneratoren gezeigt, Queries registriert und vielleicht etwas Reasoning eingeschaltet und dessen Ergebnisse begutachtet.}
In diesem Kapitel wird die C-SPARQL-Engine konkret vorgestellt und verwendet um das Beispielszenario aus Kapitel~\ref{cpt:scenario} umzusetzen. Dafür werden die Anforderungen des Szenarios einzeln betrachtet, die Ereignisdatenströme und der ganze Kram, der da mit dranhängt um dann eine Lösung zu konzipieren und implementieren.
\item Wie steht es um Reasoning auf RDF-Ereignisdatenströmen? Geht das? Wenn ja, nur RDFS oder auch OWL? \todo{Ist der Unterschied zwischen den Beiden fürs erste sehr wichtig oder führt das zu weit?}
Mit \enquote{enquote} wird Text in Anführungszeichen gesetzt, aber manchmal ist vielleicht der Einsatz von \texttt{texttt} sinnvoll. Im \textbf{Notfall} kann auch \textbf{textbf} genutzt werden. Dann gibt es noch \textit{textit}, \textsc{textsc}, \textsf{textsf} und \textsl{textsl}.
