1157 lines
106 KiB
TeX
1157 lines
106 KiB
TeX
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
% Setup des Dokuments
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
\documentclass[12pt,DIV14,BCOR10mm,a4paper,twoside,parskip=half-,headsepline,headinclude]{scrreprt} % Grundgröße 12pt, zweiseitig
|
|
% Packages from template
|
|
\usepackage[headsepline,automark]{scrpage2} % Seitenköpfe automatisch
|
|
\KOMAoptions{headinclude} % Fix
|
|
\usepackage[german]{babel} % Sprachpaket für Deutsch (Umlaute, Trennung,deutsche Überschriften)
|
|
\usepackage{graphicx,hyperref} % Graphikeinbindung, Hyperref (alles klickbar, Bookmarks)
|
|
\usepackage{amssymb} % Math. Symbole aus AmsTeX
|
|
\usepackage[utf8]{inputenc} % Umlaute
|
|
% Custom packages
|
|
\usepackage[autostyle=true,german=quotes]{csquotes} % Anführungszeichen mit \enquote{}
|
|
\usepackage{textcomp} % Zusätzliches Package für °C
|
|
\usepackage{listings} % Codesnippets
|
|
\usepackage{scrhack} % Hack for lstlisting i suspect :-/
|
|
\usepackage{xcolor}
|
|
\usepackage{float}
|
|
\usepackage{soul}
|
|
\usepackage{verbatim} % für comment-environment
|
|
\usepackage{amsmath}
|
|
% Setup für Codeblocks
|
|
\lstset{
|
|
% Optionen
|
|
breaklines=true,
|
|
breakatwhitespace=true,
|
|
breakautoindent=true,
|
|
frame=single,
|
|
%framexleftmargin=19pt,
|
|
inputencoding=utf8,
|
|
%language=awk,
|
|
%numbers=left,
|
|
%numbersep=8pt,
|
|
showspaces=false,
|
|
showstringspaces=false,
|
|
tabsize=1,
|
|
%xleftmargin=19pt,
|
|
captionpos=b,
|
|
% Styling
|
|
basicstyle=\footnotesize\ttfamily,
|
|
commentstyle=\footnotesize,
|
|
keywordstyle=\footnotesize\ttfamily,
|
|
numberstyle=\footnotesize,
|
|
stringstyle=\footnotesize\ttfamily,
|
|
}
|
|
% Hack für Sonderzeichen in Codeblocks
|
|
\lstset{literate=%
|
|
{Ö}{{\"O}}1
|
|
{Ä}{{\"A}}1
|
|
{Ü}{{\"U}}1
|
|
{ß}{{\ss}}1
|
|
{ü}{{\"u}}1
|
|
{ä}{{\"a}}1
|
|
{ö}{{\"o}}1
|
|
{°}{{${^\circ}$}}1
|
|
}
|
|
|
|
% Befehl für TODO-Markierungen
|
|
\newcommand{\todo}[1]{\textcolor{blue}{\emph{TODO: #1}}}
|
|
|
|
% Befehl für Entwürfe und grobe Pläne
|
|
\newenvironment{draft}{\par\color{orange}\begin{center}Entwurf / Konzept\end{center}\hrule}{\hrule\par}
|
|
|
|
% Broken citation needs broken command
|
|
\newcommand\mathplus{+}
|
|
|
|
% Festlegung Kopf- und Fußzeile
|
|
\defpagestyle{meinstil}{%
|
|
{\headmark \hfill}
|
|
{\hfill \headmark}
|
|
{\hfill \headmark\hfill}
|
|
(\textwidth,.4pt)
|
|
}{%
|
|
(\textwidth,.4pt)
|
|
{\pagemark\hfill Jan Philipp Timme}
|
|
{Version 1.0 vom \today \hfill \pagemark}
|
|
{Version 1.0 vom \today \hfill \pagemark}
|
|
}
|
|
\pagestyle{meinstil}
|
|
|
|
\raggedbottom
|
|
|
|
\renewcommand{\topfraction}{1}
|
|
\renewcommand{\bottomfraction}{1}
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
% Beginn des Dokuments (Titelseite und der ganze Krempel)
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
\begin{document}
|
|
|
|
% Titelseite
|
|
\thispagestyle{empty}
|
|
\includegraphics[width=0.2\textwidth]{res/Wortmarke_WI_schwarz.pdf}
|
|
{ ~ \sffamily
|
|
\vfill
|
|
{\Huge\bfseries Complex Event Processing auf RDF-Da\-ten\-strö\-men mit C-SPARQL}
|
|
\bigskip
|
|
|
|
{\Large Jan Philipp Timme
|
|
\\[2ex]
|
|
Bachelor-Arbeit im Studiengang "`Angewandte Informatik"'
|
|
\\[5ex]
|
|
\today
|
|
}
|
|
}
|
|
\vfill
|
|
~ \hfill
|
|
\includegraphics[height=0.3\paperheight]{res/H_WI_Pantone1665.pdf}
|
|
\vspace*{-3cm}
|
|
|
|
% Seite mit Personen und Selbstständigkeitserklärung
|
|
\newpage \thispagestyle{empty}
|
|
\begin{tabular}{ll}
|
|
{\bfseries\sffamily Autor} & Jan Philipp Timme \\
|
|
& Matrikelnummer 1271449 \\
|
|
& Abteilung Informatik, Fakultät IV \\
|
|
& Hochschule Hannover \\
|
|
& jan.philipp@timme.it \\[5ex]
|
|
{\bfseries\sffamily Erstprüfer} & Prof. Dr. Jürgen Dunkel \\
|
|
& Abteilung Informatik, Fakultät IV \\
|
|
& Hochschule Hannover \\
|
|
& juergen.dunkel@hs-hannover.de \\[5ex]
|
|
{\bfseries\sffamily Zweitprüfer} & Jeremias Dötterl, M. Sc. \\
|
|
& Abteilung Informatik, Fakultät IV \\
|
|
& Hochschule Hannover \\
|
|
& jeremias.doetterl@hs-hannover.de
|
|
\end{tabular}
|
|
|
|
\vfill
|
|
|
|
% fett und zentriert in der Minipage
|
|
\begin{center} \sffamily\bfseries Selbständigkeitserklärung \end{center}
|
|
|
|
Hiermit erkläre ich, dass ich die eingereichte Bachelor-Arbeit
|
|
selbständig und ohne fremde Hilfe verfasst, andere als die von mir angegebenen Quellen
|
|
und Hilfsmittel nicht benutzt und die den benutzten Werken wörtlich oder
|
|
inhaltlich entnommenen Stellen als solche kenntlich gemacht habe.
|
|
\vspace*{7ex}
|
|
|
|
Hannover, den \today \hfill Unterschrift
|
|
|
|
\pdfbookmark[0]{Inhalt}{contents}
|
|
% Inhaltsverzeichnis
|
|
\tableofcontents
|
|
|
|
% Abbildungsverzeichnis
|
|
%\listoffigures
|
|
% Codeverzeichnis
|
|
% \lstlistoflistings
|
|
% Tabellenverzeichnis
|
|
%\listoftables
|
|
|
|
\newpage
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%%% Hier geht es richtig los mit dem Text!
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
\chapter{Motivation}\label{cpt:motivation}
|
|
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.
|
|
\end{comment}
|
|
|
|
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.
|
|
|
|
|
|
\section{Szenario}\label{cpt:scenario}
|
|
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.
|
|
|
|
\paragraph{Anforderungen}
|
|
Um die Ziele der Autoverleihgesellschaft erreichen zu können, sollen folgende Situationen erkannt werden:
|
|
\begin{itemize}
|
|
\item Starker Verschleiß eines Fahrzeugs durch unsachgemäßes Fahrverhalten
|
|
\item Wartungsbedarf am Fahrzeug, wie beispielsweise:
|
|
\begin{itemize}
|
|
\item Schäden an den Reifen
|
|
\item Vom Fahrzeug selbst erkannte Probleme
|
|
\end{itemize}
|
|
\item Eintritt eines Unfalls
|
|
\item Unbeabsichtigtes Wegrollen von abgestellten Fahrzeugen
|
|
\end{itemize}
|
|
|
|
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.
|
|
|
|
\paragraph{Statusdatenstrom der PKW}
|
|
Über diesen Datenstrom sollen die einzelnen PKW kontinuierlich ihre Statuswerte melden:
|
|
\begin{itemize}
|
|
\item PKW verschlossen (ja/nein)
|
|
\item Status des Motors (an/aus)
|
|
\item Status der Handbremse (angezogen/gelöst)
|
|
\item Momentangeschwindigkeit in km/h
|
|
\item Drehzahl des Motors
|
|
\item Reifendruck jedes Reifens in bar
|
|
\end{itemize}
|
|
Besonders wichtige Ereignisse, wie das Aufleuchten der Motorkontrollleuchte oder das Auslösen des Airbags, sollen über diesen Datenstrom separat von den Statusdaten gemeldet werden.
|
|
|
|
\paragraph{Interaktionsstrom der Kunden}
|
|
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.
|
|
|
|
\paragraph{Domänenwissen}
|
|
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.
|
|
|
|
Das Domänenwissen soll in diesem Szenario folgende Informationen enthalten:
|
|
\begin{itemize}
|
|
\item Eindeutige Zuordnung von Kundennummer zu einem Kunden
|
|
\item Kundendaten wie Name und Telefonnummer
|
|
\item Eindeutige Zuordnung von Fahrzeugnummer zu Automodell
|
|
\item Wissen über Automodelle:
|
|
\begin{itemize}
|
|
\item Empfohlene Motordrehzahlbereiche für verschleißarmen Betrieb während der Fahrt
|
|
\item Vorgeschriebener Reifendruck
|
|
\end{itemize}
|
|
\end{itemize}
|
|
|
|
\todo{GRAFIK: Grobes Informationsnetzwerk zur Veranschaulichung der Zu\-sam\-men\-hän\-ge zwischen den drei Elementen (Ströme + Hintergrundwissen).}
|
|
|
|
|
|
\chapter{Grundlagen}\label{cpt:basics}
|
|
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.
|
|
|
|
|
|
\section{Einführung: RDF im semantischen Web}
|
|
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.
|
|
|
|
|
|
\subsection{RDF im semantischen Web}\label{cpt:rdf-semantic-web}
|
|
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.
|
|
\begin{lstlisting}[caption={Ein RDF-Tripel},label={lst:sample_rdf_triple}]
|
|
<http://example.org/carSim/objects/Car#23> <http://example.org/carSim/carSimulationOntology#isCarModel> <http://example.org/carSim/objects/CarModel#42> .
|
|
\end{lstlisting}
|
|
|
|
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}.
|
|
|
|
\begin{figure}[htbp]
|
|
\centering
|
|
\includegraphics[width=\textwidth]{img/triple-spo.pdf}
|
|
\caption{Prädikate verknüpfen ein Subjekt mit Objekt und Literalwert}
|
|
\label{fig:triple_spo}
|
|
\end{figure}
|
|
|
|
\paragraph{Turtle-Notation mit Prefixen}
|
|
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.
|
|
\begin{lstlisting}[caption={Das Tripel aus Listing~\ref{lst:sample_rdf_triple} mit Prefixen},label={lst:sample_rdf_triple_with_prefix}]
|
|
@prefix car: <http://example.org/carSim/objects/Car#> .
|
|
@prefix carModel: <http://example.org/carSim/objects/CarModel#> .
|
|
@prefix carOnt: <http://example.org/carSim/carSimulationOntology#> .
|
|
|
|
car:23 carOnt:isCarModel carModel:42 .
|
|
\end{lstlisting}
|
|
|
|
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.
|
|
\begin{lstlisting}[caption={RDF-Daten beschreiben einen Fahrer, ein PKW und dessen Modell},label={lst:sample_rdf_data}]
|
|
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
|
|
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
|
|
@prefix car: <http://example.org/carSim/objects/Car#> .
|
|
@prefix carModel: <http://example.org/carSim/objects/CarModel#> .
|
|
@prefix driver: <http://example.org/carSim/objects/Driver#> .
|
|
@prefix carOnt: <http://example.org/carSim/carSimulationOntology#> .
|
|
|
|
car:0 rdf:type carOnt:Car .
|
|
car:0 carOnt:isCarModel carModel:0 .
|
|
|
|
carModel:0 rdf:type carOnt:CarModel .
|
|
carModel:0 carOnt:minimumMotorRPM 2000 .
|
|
carModel:0 carOnt:maximumMotorRPM 4300 .
|
|
carModel:0 carOnt:minimumTirePressure 2.9 .
|
|
carModel:0 carOnt:maximumTirePressure 3.2 .
|
|
carModel:0 carOnt:requiresDriverLicense "B"^^xsd:string .
|
|
|
|
driver:0 rdf:type carOnt:Driver .
|
|
driver:0 carOnt:hasName "Max Mustermann"^^xsd:string .
|
|
driver:0 carOnt:hasPhoneNumber "+49 111 123456789"^^xsd:string .
|
|
driver:0 carOnt:hasDriverLicense "B"^^xsd:string .
|
|
|
|
car:0 carOnt:isDrivenBy driver:0 .
|
|
driver:0 carOnt:drives car:0 .
|
|
\end{lstlisting}
|
|
|
|
\paragraph{Objektklassen und -instanzen}
|
|
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}]
|
|
@prefix car: <http://example.org/carSim/objects/Car#> .
|
|
@prefix carOnt: <http://example.org/carSim/carSimulationOntology#> .
|
|
|
|
car:0 a carOnt:Car .
|
|
\end{lstlisting}
|
|
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.)
|
|
|
|
\paragraph{Graphen}
|
|
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.
|
|
|
|
\todo{GRAFIK: Verbildlichung durch mehrere mit URI gekennzeichneten Container, die ein paar Tripel enthalten, die aufeinander verweisen.}
|
|
|
|
\paragraph{RDF-Schema für einfache Ontologien}
|
|
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}]
|
|
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
|
|
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
|
|
@prefix carOnt: <http://example.org/carSim/carSimulationOntology#> .
|
|
|
|
carOnt:Car rdf:type rdfs:class .
|
|
carOnt:Driver rdf:type rdfs:class .
|
|
|
|
carOnt:drives rdf:type rdf:Property .
|
|
carOnt:drives rdfs:domain carOnt:Driver .
|
|
carOnt:drives rdfs:range carOnt:Car .
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
\paragraph{OWL-Ontologien}
|
|
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 weitere, mächtigere Sprachkonstrukte, um feiner granulare Regeln für Objektklassen und Attribute aufzustellen. Attribute können beispielsweise transitiv oder symmetrisch wirkend definiert werden, wodurch die Verwendung solcher Attribute deutlich mehr implizite Aussagekraft hat. Auch sind spezifische Einschränkungen für Attributtypen auf Datentypebene möglich. 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.
|
|
|
|
\paragraph{ABox und TBox}
|
|
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)}
|
|
|
|
\paragraph{Kombination verschiedener Ontologien}
|
|
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.
|
|
|
|
\paragraph{Open World Assumption}
|
|
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}.)
|
|
|
|
|
|
\subsection{Anreicherung von RDF-Daten durch Reasoning}\label{cpt:reasoning}
|
|
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, da PKW eine Unterklasse der Klasse Fahrzeug ist.}. Analog hierzu ist es auch möglich, übergeordnete Beziehungen aus vorhandenen Beziehungen abzuleiten: \enquote{Max fährt sein Auto. Da man zum Fahren eines Autos (meist) in dem Auto sitzen muss, folgt daraus: Max sitzt in seinem Auto.}.
|
|
|
|
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.
|
|
|
|
|
|
\subsection{Abfrage von RDF-Daten via SPARQL}\label{cpt:sparql_intro}
|
|
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}]
|
|
PREFIX carOnt: <http://example.org/carSim/carSimulationOntology#>
|
|
PREFIX car: <http://example.org/carSim/objects/Car#>
|
|
|
|
SELECT ?maxMotorRPM
|
|
WHERE {
|
|
car:0 carOnt:isCarModel ?carModel .
|
|
?carModel carOnt:maximumMotorRPM ?maxMotorRPM .
|
|
}
|
|
\end{lstlisting}
|
|
\paragraph{Selektion von Daten}
|
|
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}.
|
|
|
|
\paragraph{Konstruktion von Daten durch Abfragen}
|
|
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}]
|
|
PREFIX carOnt: <http://example.org/carSim/carSimulationOntology#>
|
|
PREFIX car: <http://example.org/carSim/objects/Car#>
|
|
|
|
CONSTRUCT {
|
|
?carModel carOnt:motorRPMTolerance ?rpmTolerance .
|
|
} WHERE {
|
|
?carModel rdf:type carOnt:CarModel .
|
|
?carModel carOnt:minimumMotorRPM ?minMotorRPM .
|
|
?carModel carOnt:maximumMotorRPM ?maxMotorRPM .
|
|
BIND(?maxMotorRPM - ?minMotorRPM AS ?rpmTolerance) .
|
|
}
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
|
|
\section{Einführung in Complex Event Processing}\label{cpt:cep_intro}
|
|
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.
|
|
|
|
\paragraph{CEP-Engine}
|
|
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.
|
|
|
|
\paragraph{Ereignisse}
|
|
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}.
|
|
|
|
\begin{lstlisting}[caption={Exemplarische Statusmeldung eines PKW in abstrakter Notation},label={lst:sample_abstract_car_status_event}]
|
|
CarStatusEvent(ID=2342, timestamp=1344829400, relatedCarID=11, speed=63)
|
|
\end{lstlisting}
|
|
|
|
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.
|
|
|
|
\paragraph{CEP-Regeln}
|
|
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.
|
|
\begin{lstlisting}[mathescape=true,label={},caption={}]
|
|
CONDITION (... Ereignismuster ...)
|
|
... weitere Bedingungen ...
|
|
\end{lstlisting}
|
|
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.
|
|
\begin{lstlisting}[mathescape=true,label={},caption={}]
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_basics},caption={Grundgerüst einer CEP-Regel}]
|
|
CONDITION (... Ereignismuster ...)
|
|
... weitere Bedingungen ...
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
|
|
\paragraph{Erkennung von Ereignismustern}
|
|
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:
|
|
\begin{itemize}
|
|
\item Ereignistyp A: Motor wurde abgestellt
|
|
\item \st{Ereignistyp B: Handbremse wurde angezogen} (trat \textbf{nicht} auf!)
|
|
\item Ereignistyp C: PKW wurde verriegelt
|
|
\end{itemize}
|
|
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.
|
|
|
|
Um ein Ereignismuster zu beschreiben werden Operatoren aus der Ereignisalgebra nach \cite{hsh:cep} benötigt:
|
|
\begin{itemize}
|
|
\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$.
|
|
\end{itemize}
|
|
|
|
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:
|
|
\[(A\ AS\ a)\rightarrow (\neg B) \rightarrow (C\ AS\ c)\]
|
|
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:
|
|
\begin{itemize}
|
|
\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.
|
|
\end{itemize}
|
|
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.
|
|
|
|
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_two},caption={CEP-Regel mit Ereignismuster und Kontextbedingungen}]
|
|
CONDITION ($(A\ AS\ a)\rightarrow (\neg B) \rightarrow (C\ AS\ c)$)
|
|
$\wedge$ a.pkwID = c.pkwID
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
|
|
\todo{GRAFIK: Mustererkennung grob veranschaulichen?}
|
|
|
|
|
|
\paragraph{Sliding Windows und Tumbling Windows}
|
|
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.
|
|
\todo{GRAFIK: Sliding Window vs Tumbling Window}
|
|
|
|
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:
|
|
\begin{lstlisting}[mathescape=true,label={},caption={}]
|
|
[WindowSize:15min,StepSize:10s]
|
|
\end{lstlisting}
|
|
|
|
Natürlich ist es auch möglich, ein Ereignisfenster auf Basis von Ereignissen zu definieren:
|
|
\begin{lstlisting}[mathescape=true,label={},caption={}]
|
|
[WindowSize:150events,StepSize:10events]
|
|
\end{lstlisting}
|
|
|
|
Die Definition des verwendeten Ereignisfensters wird am \texttt{CONDITION}-Teil der CEP-Regel platziert, sodass diese nun wie folgt aussieht:
|
|
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_with_window},caption={CEP-Regel mit Definition eines Ereignisfensters}]
|
|
CONDITION (Ereignismuster)[WindowSize:15min,StepSize:10s]
|
|
... weitere Bedingungen ...
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
|
|
\paragraph{Aggregation von Ereignissen}\label{cpt:cep_aggregate_events}
|
|
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.
|
|
\todo{GRAFIK: Aggregation visuell zeigen?}
|
|
|
|
In einer CEP-Regel können Aggregation mit dem Konstrukt
|
|
\begin{lstlisting}
|
|
AGGREGATE(event, "attribute", {groupByVariable}, function)
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{itemize}
|
|
\item COUNT: Zählt alle Ereignisinstanzen; die Angabe des Attributnamen wird nicht berücksichtigt.
|
|
\item SUM: Bildet Summe über Attributwerte
|
|
\item AVG: Bildet Mittelwert über Attributwerte
|
|
\item MIN: Ermittelt minimalen Attributwert
|
|
\item MAX: Ermittelt maximalen Attributwert
|
|
\end{itemize}
|
|
|
|
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.
|
|
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_four},caption={Beispiel zur Nutzung von \texttt{AGGREGATE()}}]
|
|
CONDITION ($MeasureEvent\ AS\ m$)
|
|
$\wedge$ AGGREGATE(m, "speed", {m.relatedCar}, AVG) AS averageSpeed
|
|
$\wedge$ averageSpeed < 60
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
|
|
Die in Listing~\ref{lst:abstract_cep_rule_four} gezeigte CEP-Regel demonstriert die Umsetzung dieses Beispiels. Der Aufruf
|
|
\begin{lstlisting}
|
|
AGGREGATE(m, "speed", {m.relatedCar}, AVG) AS averageSpeed
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
\paragraph{Integration von Domänenwissen}
|
|
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:
|
|
\begin{itemize}
|
|
\item Wo ein Sensor positioniert ist und was er misst
|
|
\item Von welchem Modell ein zu überwachendes Fahrzeug ist und welche bekannten Grenzwerte für den Betrieb eingehalten werden müssen
|
|
\item Wer ein überwachtes Fahrzeug gerade verwendet
|
|
\end{itemize}
|
|
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.
|
|
\todo{!!}
|
|
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
|
|
\begin{lstlisting}
|
|
lookup("maxMotorRPMForModel", fooEvent.carModel)
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
\paragraph{Auslösen von Aktionen}
|
|
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}]
|
|
CONDITION ($(A\ AS\ a)\rightarrow (\neg B) \rightarrow (C\ AS\ c)$)
|
|
$\wedge$ a.pkwID = c.pkwID
|
|
ACTION
|
|
callNotifyCarDriver(pkwID=a.pkwID)
|
|
\end{lstlisting}
|
|
|
|
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.
|
|
|
|
|
|
\chapter{Vergleich aktueller RDF-fähiger CEP-Engines}\label{cpt:engine_comparison}
|
|
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.
|
|
|
|
\section{EP-SPARQL mit der ETALIS-Engine}
|
|
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.
|
|
|
|
|
|
\section{Das CQELS-Framework}
|
|
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}.
|
|
|
|
|
|
\section{C-SPARQL-Engine}
|
|
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.
|
|
|
|
|
|
\section{Auswahl der Engine für die Arbeit}
|
|
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:
|
|
\begin{itemize}
|
|
\item Verfügbarkeit von einsteigerfreundlicher Dokumentation
|
|
\item Existierender Beispielcode zur Verwendung
|
|
\item Verwendung einer einzigen, weit verbreiteten Programmiersprache
|
|
\item Transparente Implementierung der Engine durch Verwendung bekannter Technologien
|
|
\end{itemize}
|
|
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:
|
|
|
|
\begin{tabular}{p{4.25cm}||p{3.3cm}|p{3.3cm}|p{3.3cm}}
|
|
& EP-SPARQL & CQELS & C-SPARQL \\
|
|
\hline\hline
|
|
Dokumentation & Mehrere Paper erläutern Features (o) & Paper über Umsetzung eines Projekts und Performance (o) & Mehrere Paper mit Erläuterungen (+) \\
|
|
\hline
|
|
Beispielcode & Archiviertes Projekt auf Google-Code \dots (o) & Projekt als VirtualBox (o) & Kommentiertes Beispielprojekt mit verschiedenen Szenarien (+) \\
|
|
\hline
|
|
Programmiersprache & Prolog, Java (-) & Java (+) & Java (+) \\
|
|
\hline
|
|
Technologien & Prolog, eigene (o) & eigene (-) & Apache Jena, Sesame, Esper (+)\\
|
|
\hline\hline
|
|
Ergebnis & (-) & (o) & (++++) \\
|
|
\end{tabular}
|
|
|
|
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.
|
|
|
|
|
|
\chapter{CEP auf RDF-Datenströmen anhand der C-SPARQL Engine}
|
|
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.
|
|
|
|
|
|
\section{Ereignisinstanzen in RDF-Datenströmen}
|
|
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}]
|
|
CarStatusEvent(ID=324, timestamp=1344829400, relatedCarID=0, speed=63)
|
|
CarStatusEvent(ID=325, timestamp=1344829405, relatedCarID=0, speed=75)
|
|
\end{lstlisting}
|
|
|
|
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.
|
|
\begin{lstlisting}[caption={RDF-Quadrupel mit Zeitstempeln beschreiben zwei Ereignisse eines PKW},label={lst:sample_event_rdf_quads}]
|
|
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
|
|
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
|
|
@prefix carOnt: <http://example.org/carSim/carSimulationOntology#> .
|
|
@prefix event: <http://example.org/carSim/objects/event#> .
|
|
|
|
(1344829400) event:324 rdf:type carOnt:CarStatusEvent .
|
|
(1344829400) event:324 carOnt:relatedCar car:0 .
|
|
(1344829400) event:324 carOnt:speed 63 .
|
|
|
|
(1344829405) event:325 rdf:type carOnt:CarStatusEvent .
|
|
(1344829405) event:325 carOnt:relatedCar car:0 .
|
|
(1344829405) event:325 carOnt:speed 75 .
|
|
\end{lstlisting}
|
|
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 in Kapitel~\ref{cpt:integrating_knowledge}.
|
|
|
|
|
|
\section{C-SPARQL als Sprache für CEP-Regeln}
|
|
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.
|
|
\begin{lstlisting}[label={lst:example_csparql_query},caption={Beispielhafter C-SPARQL-Query}]
|
|
REGISTER QUERY exampleQuery AS
|
|
SELECT ?a ?c
|
|
FROM STREAM <http://example.org> [RANGE 5s STEP 1s]
|
|
WHERE {
|
|
?a a <http://example.org/type/A> .
|
|
?c a <http://example.org/type/C> .
|
|
BIND(f:timestamp(?a,rdf:type,<http://example.org/type/A>) AS ?tsa)
|
|
BIND(f:timestamp(?c,rdf:type,<http://example.org/type/C>) AS ?tsc)
|
|
FILTER(?tsa < ?tsc)
|
|
FILTER NOT EXISTS {
|
|
?b a <http://example.org/type/B> .
|
|
BIND(f:timestamp(?b,rdf:type,<http://example.org/type/B>) AS ?tsb)
|
|
FILTER(?tsa < ?tsb && ?tsb < ?tsc)
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{lstlisting}[label={lst:register_query_csparql},caption={Registrierung von Queries in C-SPARQL}]
|
|
'REGISTER' ('QUERY'|'STREAM') QName 'AS' Query
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
\paragraph{Ereignisdatenströme in Sliding Windows}
|
|
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:
|
|
\begin{lstlisting}[mathescape=true]
|
|
Window $\rightarrow$ 'RANGE' LogicalWindow | 'RANGE' PhysicalWindow
|
|
LogicalWindow $\rightarrow$ Number TimeUnit WindowOverlap
|
|
TimeUnit $\rightarrow$ 'ms' | 's' | 'm' | 'h' | 'd'
|
|
WindowOverlap $\rightarrow$ 'STEP' Number TimeUnit | 'TUMBLING'
|
|
PhysicalWindow $\rightarrow$ 'TRIPLES' Number
|
|
\end{lstlisting}
|
|
|
|
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
|
|
\begin{lstlisting}
|
|
[WindowSize:15min,StepSize:5s]
|
|
\end{lstlisting}
|
|
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
|
|
\begin{lstlisting}
|
|
[WindowSize:1h,StepSize:1h]
|
|
\end{lstlisting}
|
|
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]}.
|
|
\end{itemize}
|
|
|
|
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
|
|
\begin{lstlisting}
|
|
FROM STEAM <http://example.org/exampleStream> [RANGE 30m STEP 5m]
|
|
\end{lstlisting}
|
|
verwendet werden.
|
|
|
|
\paragraph{Mustererkennung}
|
|
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:
|
|
\begin{itemize}
|
|
\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:
|
|
\begin{lstlisting}
|
|
PREFIX f: <http://larkc.eu/csparql/sparql/jena/ext#>
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{lstlisting}
|
|
f:timestamp(?s,rdf:type,<http://example.org/type/A>)
|
|
\end{lstlisting}
|
|
\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}:
|
|
\begin{lstlisting}
|
|
BIND(f:timestamp(?a,?b,?c) - f:timestamp(?x,?y,?z)) AS ?difference)
|
|
\end{lstlisting}
|
|
\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:
|
|
\begin{lstlisting}
|
|
WHERE {
|
|
?a :b :c .
|
|
OPTIONAL {
|
|
?d :e :f
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
Wurde durch die Abfrage kein Tripel für \texttt{?d :e :f} gefunden, so wird dennoch das Ergebnis für \texttt{?a :b :c} zurückgegeben.
|
|
\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:
|
|
\begin{lstlisting}
|
|
:alice rdf:type foaf:Person .
|
|
:alice foaf:name "Alice" .
|
|
:bob rdf:type foaf:Person .
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{lstlisting}
|
|
SELECT ?person
|
|
WHERE {
|
|
?person rdf:type foaf:Person .
|
|
FILTER NOT EXISTS { ?person foaf:name ?name }
|
|
}
|
|
\end{lstlisting}
|
|
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}.
|
|
\end{itemize}
|
|
|
|
Um nun in C-SPARQL Ereignismuster formulieren zu können, die den Mustern aus Kapitel~\ref{cpt:cep_intro} entsprechen, müssen zunächst die Operatoren der Ereignisalgebra in die C-SPARQL-Sprache übersetzt werden.
|
|
\begin{itemize}
|
|
\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}:
|
|
\begin{lstlisting}
|
|
?eventA rdf:type <http://example.org/type/A> .
|
|
\end{lstlisting}
|
|
\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:
|
|
\begin{lstlisting}
|
|
?eventX rdf:type <http://example.org/type/X> .
|
|
?eventY rdf:type <http://example.org/type/Y> .
|
|
FILTER(f:timestamp(?eventX,rdf:type,<http://example.org/type/X>) < f:timestamp(?eventY,rdf:type,<http://example.org/type/Y>))
|
|
\end{lstlisting}
|
|
\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:
|
|
\begin{lstlisting}
|
|
WHERE {
|
|
OPTIONAL {
|
|
?a rdf:type <http://example.org/type/A> .
|
|
}
|
|
OPTIONAL {
|
|
?b rdf:type <http://example.org/type/B> .
|
|
}
|
|
FILTER( (BOUND(?a) || BOUND(?b))
|
|
&& !(BOUND(?a) && BOUND(?b)) )
|
|
}
|
|
\end{lstlisting}
|
|
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.
|
|
\end{itemize}
|
|
|
|
\paragraph{Aggregation von Ereignissen}
|
|
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}:
|
|
\begin{itemize}
|
|
\item \texttt{COUNT(\emph{?var})}: Zählt die Anzahl Tupel pro Gruppe
|
|
\item \texttt{SUM(\emph{?var})}: Bildet Summe der Variable über jede Gruppe
|
|
\item \texttt{AVG(\emph{?var})}: Bildet Mittelwert der Variable über jede Gruppe
|
|
\item \texttt{MIN(\emph{?var})}: Ermittelt das Minimum der gegebenen Variable pro Gruppe
|
|
\item \texttt{MAX(\emph{?var})}: Ermittelt das Maximum der gegebenen Variable pro Gruppe
|
|
\end{itemize}
|
|
Ä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.
|
|
|
|
Abstrakt formuliert ergibt sich hierbei folgende CEP-Regel:
|
|
\begin{lstlisting}[mathescape=true,label={},caption={}]
|
|
CONDITION ($CarStatusEvent\ AS\ statusEvent$)
|
|
$\wedge$ AGGREGATE(statusEvent, "motorRPM", {statusEvent.relatedCar}, MIN) AS minRPM
|
|
$\wedge$ AGGREGATE(statusEvent, "motorRPM", {statusEvent.relatedCar}, MAX) AS maxRPM
|
|
$\wedge$ AGGREGATE(statusEvent, "motorRPM", {statusEvent.relatedCar}, AVG) > 3000
|
|
ACTION
|
|
... auszulösende Aktionen ...
|
|
\end{lstlisting}
|
|
|
|
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:
|
|
\begin{lstlisting}[label={lst:sample_csparql_aggregation_query},caption={Ermittlung minimaler und maximaler Motordrehzahl pro PKW}]
|
|
SELECT (MIN(?carRPM) AS ?minRPM) (MAX(?carRPM) AS ?maxRPM)
|
|
FROM STREAM ...
|
|
WHERE {
|
|
?carStatusEvent rdf:type carOnt:CarStatusEvent .
|
|
?carStatusEvent carOnt:relatedCar ?car .
|
|
?carStatusEvent carOnt:motorRPM ?carRPM .
|
|
}
|
|
GROUP BY ?car
|
|
HAVING AVG(?carRPM) > 3000
|
|
\end{lstlisting}
|
|
Somit stellt die Aggregation von Ereignisdaten kein Problem dar und kann regulär in CEP-Regeln verwendet werden.
|
|
|
|
|
|
\section{Auslösen von Aktionen}\label{cpt:register_stream}
|
|
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.
|
|
|
|
\paragraph{Auslösen von Ereignissen}
|
|
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}]
|
|
CONDITION ($(CarStatusEvent\ AS\ statusEvent)$)[WindowSize:15min,StepSize:5m]
|
|
$\wedge$ AGGREGATE(statusEvent, "speed", {statusEvent.relatedCar}, AVG) AS avgSpeed
|
|
ACTION
|
|
new AverageSpeedEvent(relatedCar=statusEvent.relatedCar, averageSpeed=avgSpeed)
|
|
\end{lstlisting}
|
|
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:
|
|
\begin{lstlisting}[label={lst:csparql_construct_query},caption={Konstruktion eines Ereignisstromes mit C-SPARQL}]
|
|
REGISTER STREAM getAverageSpeedByCar AS
|
|
CONSTRUCT {
|
|
[] rdf:type car:AverageSpeedEvent
|
|
; car:relatedCar ?car
|
|
; car:averageSpeed ?avgSpeed .
|
|
}
|
|
FROM STREAM <...> [RANGE 15m STEP 1m]
|
|
WHERE {
|
|
{
|
|
SELECT ?car (AVG(?speed) AS ?avgSpeed)
|
|
WHERE {
|
|
?e rdf:type car:CarStatusEvent .
|
|
?e car:relatedCar ?car .
|
|
?e car:speed ?speed .
|
|
}
|
|
GROUP BY (?car)
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
\paragraph{Ausführen von Code und Anstoßen externer Dienste}
|
|
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:
|
|
\begin{lstlisting}[mathescape=true,label={lst:abstract_cep_rule_six},caption={CEP-Regel stößt externen Dienst an}]
|
|
CONDITION ($(CarStatusEvent\ AS\ statusEvent)$)[WindowSize:15min,StepSize:5m]
|
|
$\wedge$ AGGREGATE(statusEvent, "speed", {statusEvent.relatedCar}, AVG) AS avgSpeed
|
|
$\wedge$ avgSpeed > 140
|
|
ACTION
|
|
callNotifyCustomerIsSpeedingService(relatedCar=statusEvent.relatedCar, averageSpeed=avgSpeed)
|
|
\end{lstlisting}
|
|
|
|
\begin{lstlisting}[label={lst:csparql_speedavg_greater_140},caption={Fahrzeuge mit Durchschnittsgeschwindigkeit $>$ 140km/h}]
|
|
REGISTER QUERY getSpeedingCars AS
|
|
SELECT ?car (AVG(?speed) AS ?avgSpeed)
|
|
FROM STREAM <...> [RANGE 15m STEP 1m]
|
|
WHERE {
|
|
?e rdf:type car:CarStatusEvent .
|
|
?e car:relatedCar ?car .
|
|
?e car:speed ?speed .
|
|
}
|
|
GROUP BY (?car)
|
|
\end{lstlisting}
|
|
|
|
\section{Einbindung von Domänenwissen}\label{cpt:integrating_knowledge}
|
|
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}:
|
|
\begin{lstlisting}
|
|
engine.putStaticNamedModel("http://example.org/carSimKnowledgeGraph",
|
|
CsparqlUtils.serializeRDFFile("data/carSimulationABox.rdf"));
|
|
\end{lstlisting}
|
|
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.
|
|
|
|
|
|
\section{Reasoning auf RDF-Datenströmen}
|
|
Die C-SPARQL-Engine unterstützt die automatische Anreicherung von RDF-Da\-ten\-strö\-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 Regelwerk zugeführt, welches die Axiome und Folgerungsregeln von RDFS implementiert. Somit ist die Engine in der Lage, auf RDF-Datenströmen Reasoning durchzuführen, um diese um implizites Wissen anzureichern. Der praktische Nutzen daraus ist höhere Flexibilität bei der Formulierung von C-SPARQL-Queries; insbesondere die automatische Anreicherung von Ereignisinstanztypen aus Hierarchien von Objektklassen kann Generalisierungen von CEP-Regeln deutlich vereinfachen. Hierzu ein Beispiel:
|
|
\todo{...}
|
|
Gegeben sei folgende TBox mit Vokabular im RDF-Schema:
|
|
\begin{lstlisting}[label={reasoning_tbox},caption={TBox mit Klassen und Attributdefinitionen aus RDFS}]
|
|
:CarWearEvent rdf:type rdfs:Class .
|
|
:CarBrakeWearEvent rdf:type rdfs:Class .
|
|
:CarBrakeWearEvent rdfs:subClassOf :CarWearEvent .
|
|
\end{lstlisting}
|
|
|
|
Kombiniert man diese nun in einem Reasoning-Prozess mit der folgenden ABox:
|
|
\begin{lstlisting}[label={reasoning_abox},caption={ABox mit Fakten, die sich auf die TBox aus Listing~\ref{reasoning_tbox} beziehen}]
|
|
:SomeThing rdf:type :Thing .
|
|
\end{lstlisting}
|
|
|
|
\begin{lstlisting}[label={reasoning_result},caption={Durch Reasoning ermitteltes, implizites Wissen}]
|
|
|
|
\end{lstlisting}
|
|
|
|
|
|
Um Reasoning mit der C-SPARQL-Engine zu nutzen, müssen die folgenden zwei Schritte durchgeführt werden:
|
|
\paragraph{Aktivierung der Inferenz}
|
|
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:
|
|
\begin{lstlisting}
|
|
CsparqlQueryResultProxy resultProxy = engine.registerQuery(query, true);
|
|
\end{lstlisting}
|
|
|
|
\paragraph{Konfiguration des Reasoners}
|
|
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 wiederum 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.
|
|
\item \textbf{Hybrid}: Ein Ansatz, welcher Forward Chaining und Backward Chaining kombiniert.
|
|
\end{itemize}
|
|
|
|
\todo{Erläuterung der praktischen Ergebnisse von Reasoning auf RDF-Datenströmen}
|
|
|
|
Die Details der technischen Implementierung von Reasoning in der C-SPARQL-Engine können in \cite{barbieri:reasoning} nachgelesen werden. Weiterführend kann über die Umsetzung von Reasoning mit Complex Event Processing in der Masterarbeit von Stefan Lier\cite{hsh:reasoning} gelesen werden.
|
|
|
|
|
|
\chapter{Umsetzung des Beispielszenarios}\label{cpt:csparql_in_practice}
|
|
Nachdem die Umsetzung von CEP-Regeln in C-SPARQL im vorherigen Kapitel erläutert wurde, soll nun das in Kapitel~\ref{cpt:scenario} angerissene Beispielszenario der Autoverleihgesellschaft umgesetzt werden. Ausgangspunkt hierfür sind zwei gegebene RDF-Ereignisdatenströme:
|
|
|
|
\paragraph{Ereignisstrom der PKW}
|
|
Dieser Ereignisdatenstrom übermittelt alle Ereignisse, die von den PKW aus dem Fuhrpark der Verleihgesellschaft ausgehen. Jedes einzelne Ereignis bezieht sich dabei auf einen konkreten PKW. Die folgenden Ereignistypen werden durch den Datenstrom übermittelt:
|
|
\begin{itemize}
|
|
\item \textbf{\texttt{CarStatusEvent}}: Wird von jedem PKW in regelmäßigen Abständen ausgelöst und übermittelt ein Paket von Statuswerten. Neben dem Attribut \texttt{relatedCar}, welches auf den jeweiligen PKW verweist, werden die Attribute \texttt{motorOn}, \texttt{motorRPM}, \texttt{speed}, \texttt{handbrakeEngaged}, \texttt{locked} und \texttt{tirePressure\{1-4\}} für die Beschreibung der Statuswerte verwendet. Da dieses der Ereignistyp mit den meisten Attributen ist, wird im Folgenden ein Beispiel für eine solche Ereignisinstanz gezeigt:
|
|
\begin{lstlisting}
|
|
:event rdf:type car:CarStatusEvent .
|
|
:event car:relatedCar :someCar .
|
|
:event car:motorOn true^^xsd:boolean .
|
|
:event car:motorRPM 1821^^xsd:integer .
|
|
:event car:speed 25^^xsd:integer .
|
|
:event car:handbrakeEngaged false^^xsd:boolean .
|
|
:event car:locked false^^xsd:boolean .
|
|
:event car:tirePressure1 29^^xsd:integer .
|
|
:event car:tirePressure2 28^^xsd:integer .
|
|
:event car:tirePressure3 30^^xsd:integer .
|
|
:event car:tirePressure4 29^^xsd:integer .
|
|
\end{lstlisting}
|
|
\item \textbf{\texttt{CarLockEvent} und \texttt{CarUnlockEvent}}: Sobald ein Fahrer den PKW auf- oder abschließt, wird jeweils ein \texttt{CarLockEvent} beziehungsweise \texttt{CarUnlockEvent} ausgelöst. Dieses enthält lediglich eine Angabe des betroffenen PKW über das Attribut \texttt{relatedCar}.
|
|
\item \textbf{\texttt{CarHandbrakeEngageEvent} und \texttt{CarHandbrakeReleaseEvent}}: Wird die Handbremse angezogen oder gelöst, so löst der PKW ein entsprechendes Ereignis vom Typ \texttt{CarHandbrakeEngageEvent} beziehungsweise \texttt{CarHandbrakeReleaseEvent} aus. Diese enthalten nur die Angabe des PKW über das Attribut \texttt{relatedCar}.
|
|
\item \textbf{\texttt{CarCheckEngineEvent}}: Sollte die Bordelektronik eines PKW eine Fehlermeldung auslösen, so wird diese mit einem \texttt{CarCheckEngineEvent} angezeigt. Hierbei wird der betroffene PKW über \texttt{relatedCar} angegeben.
|
|
\item \textbf{\texttt{CarAirbagTriggeredEvent}}: Wurde an einem PKW der Airbag ausgelöst, so wird ein Ereignis dieses Typen ausgelöst, um auf diesen Umstand aufmerksam zu machen. Auch hier wird lediglich der PKW über \texttt{relatedCar} angegeben.
|
|
\end{itemize}
|
|
|
|
\paragraph{DriverStream}
|
|
Die Ereignisse in diesem Datenstrom beziehen sich ausschließlich auf Interaktionen von Kunden mit den PKW. Somit werden durh diesen Ereignisdatenstrom nur Ereignisse dieser zwei Typen übertragen:
|
|
\begin{itemize}
|
|
\item \texttt{CarTakenEvent}: Wird ausgelöst, wenn ein Kunde einen PKW ausleiht. Ein solches Ereignis verweist über \texttt{relatedCar} auf den geliehenen PKW und über \texttt{relatedUser} auf den entsprechenden Kunden.
|
|
\item \texttt{CarReturnedEvent}: Analog zum Ereignistypen \texttt{CarTakenEvent} wird dieses Ereignis ausgelöst, wenn ein Kunde sein geliehenes Fahrzeug wieder zurückgibt. Ebenso wie das \texttt{CarTakenEvent} wird über \texttt{relatedCar} auf den entsprechenden PKW verwiesen und über \texttt{relatedUser} auf den Kunden.
|
|
\end{itemize}
|
|
|
|
\section{Umsetzung der Anforderungen}
|
|
Um diese Ereignisdatenströme nun zu Verarbeiten, werden die Anforderungen des Szenarios aus Kapitel~\ref{cpt:scenario} zunächst genauer betrachtet und CEP-Regeln für sie formuliert.
|
|
|
|
|
|
|
|
|
|
\section{Nutzung der C-SPARQL Engine in Java}
|
|
|
|
\todo{TBD}
|
|
Im Folgenden wird auf die praktische Anwendung der C-SPARQL-Engine in einem Java-Projekt eingegangen.
|
|
|
|
\begin{itemize}
|
|
\item Welche technischen Strukturen sieht die Engine vor,
|
|
\item wie werden Datenströme zugeführt,
|
|
\item wie werden Queries erzeugt, registriert und beobachtet,
|
|
\item was muss dabei beachtet werden, welche Fallstricke gibt es (zur Zeit)
|
|
\item wie wird Hintergrundwissen eingespeist und zur Laufzeit aktualisiert,
|
|
\item welche Schritte sind nötig um RDFS-Reasoning zu nutzen?
|
|
\item Und natürlich immer wieder mittendrin: Wie sehen die Ergebnisse aus, die dabei entstehen?
|
|
\end{itemize}
|
|
|
|
\todo{Die einzelnen Sections entstehen beim Schreiben der Texte.}
|
|
|
|
|
|
\section{Bewertung/Ergebnis}
|
|
|
|
\begin{itemize}
|
|
\item (Konnten die gestellten Anforderungen erfüllt werden?)
|
|
\item Was konnte erreicht werden?
|
|
\item Was konnte nicht erreicht werden?
|
|
\item Gab es Schwierigkeiten? [Guter Zeitpunkt, um hier f:timestamp() vs Tripel mit Literals zu erwähnen]
|
|
\item Wie hoch war der Aufwand?
|
|
\item Wie steht es um die Qualität der Ergebnisse?
|
|
\item Eventuell ein Blick auf die Performance?
|
|
\end{itemize}
|
|
|
|
|
|
\chapter{Fazit}\label{cpt:conclusion}
|
|
|
|
\todo{Zusammenfassungsüberleitung über das Kapitel}
|
|
|
|
\begin{itemize}
|
|
\item Bewertung der Ergebnisse im Abgleich mit den Anforderungen und dem Aufwand?
|
|
\item Ist es für die Anforderungen (und mehr) praxistauglich?
|
|
\item Oder gibt es zur Zeit bessere Alternativen?
|
|
\end{itemize}
|
|
|
|
Die Engine wurde in Version 0.9.6 verwendet, da in 0.9.7 einige Bugs enthalten sind, die dazu führen, dass sie nur eingeschränkt benutzbar ist.
|
|
Weiterhin gibt es einige False Positives des Tokenizers für die C-SPARQL-Sprache, die unter anderem dazu führen, dass Bezeichner, die das Wort \enquote{Stream} enthalten, fälschlicherweise für das Schlüsselwort \texttt{STREAM} gehalten werden.
|
|
|
|
|
|
\section{Ausblick}
|
|
|
|
\todo{Eventuell mit Fazit zusammenführen, wenn es nicht zu groß wird.}
|
|
|
|
\begin{itemize}
|
|
\item Kann man mit der Engine in Zukunft noch mehr schaffen?
|
|
\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?}
|
|
\end{itemize}
|
|
|
|
Vielleicht geht das mit dem Reasoning später ja noch besser --- aktueller Stand ist noch limitiert, aber es wird fleißig daran geforscht \dots
|
|
|
|
\begin{comment}
|
|
\chapter*{Dummy-Kapitel für Tests und Notizen}
|
|
\textcolor{red}{Dieses Kapitel fliegt am Ende natürlich raus.}
|
|
|
|
Sil-ben ge-trenn-t mit ei-nem Strich
|
|
|
|
C--SPARQL (Zwei Striche ergeben einen Bindestrich)
|
|
|
|
Und dann --- neben vielen anderen Zeichen --- gibt es mit drei Strichen den Gedankenstrich.
|
|
|
|
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}.
|
|
|
|
\begin{figure}[htbp]
|
|
\centering
|
|
\includegraphics[width=\textwidth]{img/aggregation-patternmatching.pdf}
|
|
\caption{Aggregation und Mustererkennung auf einem Ereignisstrom}
|
|
\label{fig:aggregation_patternmatching}
|
|
\end{figure}
|
|
|
|
Quellenreferenzen
|
|
\begin{itemize}
|
|
\item \cite{hsh:cep}[Einstieg in CEP mit Beispielen aus Esper-Welt]
|
|
\item \cite{hsh:integrating}[Esper vs C-SPARQL CEP ohne Reasoning]
|
|
\item \cite{barbieri:reasoning}[Ansatz für Reasoning auf RDF-Strömen mit C-SPARQL]
|
|
\item \cite{barbieri:querying}[Grundlagen C-SPARQL für CEP]
|
|
\item \cite{cqels:stream}[CQELS-Paper]
|
|
\item \cite{ep:etalis}[ETALIS-Paper]
|
|
\item \cite{ep:unified}[EP-SPARQL-Paper]
|
|
\item \cite{man:owl}[Owl Reasoning Examples]
|
|
\item \cite{w3c:sparql}[W3C zu SPARQL]
|
|
\item \cite{iao:esper}[Marktübersicht Real-Time Monitoring Software] <--- NOT CITED YET, nur für Esper relevant gewesen
|
|
\item \cite{w3c:turtle}[Die Turtle-Notation]
|
|
\item \cite{hitzler:semanticweb}[Grundlagen Semantic Web]
|
|
\item \cite{cqels:native}[Mehr CQELS]
|
|
\item \cite{barbieri:csparql}[Erstes C-SPARQL Proposal]
|
|
\end{itemize}
|
|
\end{comment}
|
|
|
|
%%% Ende inhaltlicher Inhalt! %%%
|
|
|
|
% Literaturverzeichnis
|
|
\clearpage
|
|
|
|
% Schlüssel als Buchstaben
|
|
\bibliographystyle{alpha}
|
|
\bibliography{Literaturverweise}
|
|
% Und JETZT zum Inhaltsverzeichnis hinzufügen. Geil!
|
|
\addcontentsline{toc}{chapter}{Literaturverweise}
|
|
\end{document}
|
|
% Nothing beyond this line!
|
|
|
|
|
|
% Referenz auf Bibtex mit Kommentar
|
|
% \cite{robbins:gawk}[Siehe ab S.95]
|
|
|
|
% Einbinden von Tex-Files
|
|
%\input{abkuerz.tex}
|
|
%\input{einfuehrung.tex}
|
|
|
|
% Einbinden von größeren Tex-Files, z.B. Kapiteln
|
|
%\include{normen}
|
|
%\include{aufbau}
|
|
%\include{zitieren}
|
|
%\include{form}
|
|
%\include{allgtips}
|