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 enthalten Messdaten und Zustandsinformationen ab, sofern sie nicht bedingt durch technischen Defekt oder Messfehler ungültige Daten enthalten 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. 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 Tarife 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 Modellierung 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.
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.
Da innerhalb des semantischen Web angestrebt wird, in RDF vorliegende Informationen gemeinsam zu nutzen und miteinander zu 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.
\todo{GRAFIK: Verbildlichung durch mehrere mit URI gekennzeichneten Container, die ein paar Tripel enthalten, die aufeinander verweisen.}
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 beispielsweise 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 sinnvolle 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 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 durchgefü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 Ereignisse als Instanzen von Ereignistypen betrachtet. Eine Ereignisinstanz trägt neben inhaltlichen Informationen über den Vorgang durch den es 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 Ereignisssen, 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.
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 häufig über Muster aus den Ereignissen erkennen, die sie auslösen. Hierbei spielen Ereignissequenzen und die zeitlichen Beziehungen zwischen Ereignissen eine Rolle. Um ein \enquote{bedeutungsvolles Ereignismuster} zu erkennen, wird eine CEP-Regel definiert, die dieses Muster in ihrem \texttt{CONDITION}-Teil beschreibt.
Ein Beispiel für ein Ereignismuster, welches unsachgemäß abgestellte PKW erkennen kann, könnte so aussehen:
\begin{itemize}
\item Ereignis: Motor wurde abgeschaltet
\item\st{Ereignis: Handbremse wurde angezogen} (\textbf{nicht} passiert!)
\item Ereignis: PKW wurde verriegelt
\end{itemize}
Um nun eine CEP-Regel zu definieren, die für jeweils \emph{den selben} PKW nach den Ereignissen \enquote{Motor wurde abgeschaltet} und \enquote{PKW wurde verriegelt} sucht und zwischen diesen Ereignissen kein Ereignis \enquote{Handbremse wurde angezogen} erwartet, müssen zunächst weitere Sprachkonstrukte für CEP-Regeln vorgestellt werden.
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_two},caption={CEP-Regel mit Definition eines Ereignisfensters}]
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 in regelmäßigen Intervallen 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, in dem es verschoben wird, gleich sind. Es wird daher \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 primitiver Ereignisse ist die Aggregation von Ereignissen zu höherwertigeren Ereignissen. Hierbei werden alle Ereignisse gleichen Typs in einem Zeitfenster betrachtet und beispielsweise über eine Summen- oder Differenzbildung, einen Mittelwert oder durch simples Zählen aggregiert. Dadurch können erste Kennzahlen und Trends gewonnen werden, die dabei helfen können, die Entwicklung der Situation in diesem Zeitfenster besser nachzuvollziehen.
Hat man in der Verarbeitung der Ereignisse durch CEP-Regeln alle Register gezogen, so kommt die Integration des Domänenwissens ins Spiel. Alle Fakten, die über die auszuwertenden Ereignisse bekannt sind, liegen hier vor. Beispiele dafür wären:
Das Domänenwissen kann somit verwendet werden, um einer durch Ereignisdaten beschriebenen Situation einen eindeutigen Kontext zuzuordnen und somit die Interpretation der Daten stark zu erleichtern. Hat die Ereignisverarbeitung beispielsweise festgestellt, dass die durchschnittliche Drehzahl eines Motors bei 4200 Umdrehungen pro Minute liegt, so kann über das Domänenwissen nachgeschlagen werden, in welchem Fahrzeug der betroffene Motor montiert ist, von welchem Typen das Fahrzeug ist, und ob die Motordrehzahl für diesen Fahrzeugtypen zulässig ist.
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. Somit sind folgende Kriterien für die Auswahl der Engine verwendet worden:
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 auf die C-SPARQL-Engine gefallen ist, sollen in diesem Kapitel nun ihre Möglichkeiten zur Verarbeitung von RDF-Datenströmen beleuchtet werden.
Ereignisse 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 Ereignisse 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 jedes Ereignis 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 Ereignisse mit RDF-Quadrupeln beschrieben werden. Listing~\ref{lst:sample_event_rdf_quads} zeigt die Beschreibung der Ereignisse aus Listing~\ref{lst:sample_abstract_event_data} mit RDF-Quadrupeln.
Über RDF-Ereignisdatenströme ausgelieferte Ereignisdaten, die zur Verarbeitung einer RDF-fähigen CEP-Engine zugeführt werden, sind von der Struktur her angelehnt an die Beispielereignisse aus Listing~\ref{lst:sample_abstract_event_data} aufgebaut.
Um die Ereignisdatenströme von RDF-Quadrupeln nun in der C-SPARQL-Engine verarbeiten zu können, werden im Verarbeitungsprozess CEP-Regeln benötigt, um die Ereignisdaten auszuwerten. Im Fall der C-SPARQL-Engine sind CEP-Regeln als C-SPARQL-Queries zu formulieren. Anhand einer abstrakten CEP-Regelsprache soll dieses Kapitel veranschaulichen, wie die einzelnen Aspekte eines C-SPARQL-Queries zur Verarbeitung von Ereignisdaten verwendet werden können.
Um mit der Verarbeitung von Ereignisdatenströmen beginnen zu können, müssen die kontinuierlich einströmenden Ereignisdaten auf eine endliche Menge an Daten reduziert werden. Da je nach Anforderungen ältere Ereignisse in die Verarbeitung mit eingebezogen werden sollen, muss eine CEP-Regel in der Lage sein, Einfluss auf das Sliding Window zu nehmen, indem sie dessen Größe definiert.
\todo{\dots} Ereignismuster lassen sich durch Sequenzen von auftretenden bzw. nicht auftretenden Ereignissen definieren. Um diese zu finden, müssen Tripel selektiert werden, die zu den benötigten Ereignistypen korrespondieren, wobei diese später über \texttt{FILTER}-Anweisungen in ihrer Reihenfolge festgelegt werden. Über Differenzen der durch \texttt{f:timestamp(?s,?p,?o)} angegebenen Zeitstempel von gegebenen Tripeln lassen sich auch zeitliche Beziehungen eingrenzen und festlegen.
Erzeugen von Ereignissen innerhalb von C-SPARQL-Queries (durch Registrierung der C-SPARQL-Queries als neue Ereignisströme an der Engine). Hinweise auf Möglichkeit der Auslösung von Reaktionen beim Beobachten der Abfrageergebnisse.
Integration von Hintergrundwissen findet live im Query statt ohne extra Klimmzüge, da alles innerhalb der C-SPARQL-Queries abzufragen ist. Lediglich der lokale Graph muss gegebenenfalls genannt werden.
\item Reasoning auf RDFS-Level kann die C-SPARQL-Engine laut Quellen definitiv; man braucht es sozusagen nur noch einzuschalten und ein RDFS-Vokabular + RDFS-Entailment-Regeln füttern \dots
\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}.
