Anwendung von Pentaho

Anwendung der Open Source Business Intelligence Lösung
Pentaho am Dienst für elektronische Publikation der
Wirtschaftsuniversität Wien (ePub)
Application of the Open Source Business Intelligence Platform
Pentaho for ePub (the electronic Publication Service of the Vienna
University of Economics and Business Administration)
Amirian Tadeh (0253821) und Hamm Valentin (0250738)
Abteilung für Informationswirtschaft
Institut für Informationsverarbeitung und Informationswirtschaft
Wirtschaftsuniversität Wien
Augasse 2-6
A-1090 Wien, AUSTRIA
E-Mail:
[email protected]
[email protected]
-1-
Anwendung der Open Source Business Intelligence Lösung
Pentaho am Dienst für elektronische Publikation der
Wirtschaftsuniversität Wien (ePub)
Application of the Open Source Business Intelligence Platform
Pentaho for ePub (the electronic Publication Service of the Vienna
University of Economics and Business Administration)
Stichworte: Business Intelligence, Pentaho, Data Mining, OLAP, Open Source, ETL
Keywords: Business Intelligence, Pentaho, Data Mining, OLAP, Open Source, ETL
Zusammenfassung
Die vorliegende Arbeit stellt die Ergebnisse des Versuches der Anwendung der Open
Source Business Intelligence Plattform Pentaho am Dienst der Wirtschaftsuniversität
Wien für elektronische Publikationen dar. Neben einer allgemeinen Einleitung über
Business Intelligence Anwendungen, werden weiteres noch die Besonderheiten von
Pentaho dargestellt. Mittels Screenshots wird weiters der Import der Daten und die
Erstellung von Reports mittels des Pentaho Report Designers erläutert. Den
Abschluss der Arbeit liefert eine kurze Analyse der Schwierigkeiten bei der Erstellung
dieser Reports und einige Handlungsempfehlungen für den Dienst der elektronischen
Publikationen an der Wirtschaftsuniversität Wien.
Abstract
This paper describes the results from an empirical study application the open source
business intelligence platform Pentaho for ePub, which is the electronic publication
service of the Vienna University of Economics and Business Administration. Since
Pentaho is an open source application, we are presenting a short overview of the
development of Open Source Application, especially in the field of Business
Intelligence. Furthermore this paper tries to outline the special advantages of
Pentaho. To sum up, the paper is going to discuss some difficulties importing the
necessary data and designing the reports.
-2-
Inhaltsverzeichnis
1
ABBILDUNGSVERZEICHNIS .................................................................................................................4
2
EINLEITUNG..............................................................................................................................................5
3
BUSINESS INTELLIGENCE ....................................................................................................................6
4
OPEN SOURCE.......................................................................................................................................11
4.1
GESCHICHTE VON OPEN SOURCE
11
4.2
OPEN SOURCE DEFINITION
12
4.3
ARTEN VON OPEN SOURCE LIZENZEN
14
5
OPEN SOURCE LÖSUNGEN IM BUSINESS INTELLIGENCE BEREICH ......................................16
6
PENTAHO ................................................................................................................................................18
6.1
VORTEILE VON PENTAHO
23
7
TECHNISCHES UMFELD FÜR DIE PROJEKTUMSETZUNG ..........................................................24
8
SCHWIERIGKEITEN BEIM IMPORTIEREN DER DATEN IN DIE MYSQL-DATENBANK ............25
9 PROBLEME BEIM ERSTELLEN DER REPORTS MIT DEM PENTAHO REPORTDESIGNER
(INKL. WIZARD).............................................................................................................................................27
10
DAS ERSTELLEN EINES REPORTS (SCREENSHOTS)................................................................31
11
FAZIT......................................................................................................................................................46
12
ANHANG ................................................................................................................................................47
13
LITERATUR ...........................................................................................................................................59
-3-
1 Abbildungsverzeichnis
Abbildung 1: Pentaho Server Architektur (Quelle: www.pentaho.org)......................... 21
Abbildung 2: Fehlermmeldung („Interner Fehler aufgetreten“)....................................... 29
Abbildung 3: Hinzufügen der Datenquelle ......................................................................... 31
Abbildung 4: 1. Schritt der Report-Erstellung.................................................................... 32
Abbildung 5: Auswahl der Datenquelle .............................................................................. 33
Abbildung 6: Bearbeitung der Verbindung zur Datenquelle ........................................... 33
Abbildung 7: Gestaltungs- und Gruppierungsmöglichkeiten .......................................... 34
Abbildung 8: Weitere Auswahlmöglichkeiten zur Gruppierung ...................................... 35
Abbildung 9: Formatierungsmöglichkeiten ........................................................................ 36
Abbildung 10: Feintuning...................................................................................................... 37
Abbildung 11: Integration eines Charts.............................................................................. 38
Abbildung 12: Vorschau des ReportDesigners................................................................. 39
Abbildung 13: Entwurfsansicht des ReportDesigners ..................................................... 40
Abbildung 14: Nutzungs-Stärkster Tag der Woche.......................................................... 41
Abbildung 15: Meistaufgerufene WorkingPapers gruppiert nach Institut ..................... 42
Abbildung 16: Anteile der verschiedenen Sprachen an den Workingpapers .............. 43
Abbildung 17: Meistgesuchten Stichwörter ....................................................................... 44
-4-
2 Einleitung
Die Menge der Informationen die heutzutage in der Wissenschaft, der Wirtschaft und
der Industrie gespeichert werden, nimmt immer mehr und immer schneller zu.
Gleichzeitig weitet sich das Spektrum von selbstverständlichen Daten bis hin zu
komplexen Themen wie Kundenverhalten aus. Diese Daten sind einerseits wichtig,
um den Erfolg der Unternehmung zu analysieren, andererseits können in diesen
Daten wichtige Informationen versteckt sein, die auf den ersten Blick nicht ersichtlich
sind und die erst extrahiert werden müssen. Um diese versteckten Informationen
aufzudecken und den Erfolg der Unternehmen darzustellen, bedient man sich einer
Technologie, die sich „Business Intelligence“ nennt.
Diese Business Intelligence Systeme bieten die Möglichkeit, um Berichte zu
erstellen, die Daten dynamisch zu analysieren oder neue Informationen zu gewinnen.
Das Ziel der folgenden Arbeit war es, das Open Source Business Intelligence
System
„Pentaho“,
für
einen
Probedatensatz,
der
Seite
für
elektronische
Publikationen der Wirtschaftsuniversität Wien (ePubwu) anzuwenden und die
Arbeitsschritte, Schwierigkeiten, Vorteile und den Aufwand zu dokumentieren.
ePubwu steht für elektronische Publikationen der Wirtschaftsuniversität Wien und ist
die
Plattform
für
forschungsbezogene
Wirtschaftsuniversität.
-5-
elektronische
Dokumente
der
3 Business Intelligence
Business Intelligence bezeichnet den analytischen Prozess, der fragmentierte –
Unternehmens- und Wettbewerbsdaten in handlungsgerichtetes Wissen über die
Fähigkeiten, Positionen, Handlungen und Ziele der betrachteten internen oder
externen Handlungsfelder (Akteure und Prozesse) transformiert (KöMa02).
Mit anderen Worten werden unter Business Intelligence im Allgemeinen die
analytischen Konzepte, Prozesse und Werkzeuge zusammengefasst, deren Ziel es
ist, aus vorhandenen Daten neues Wissen zu erlangen. Dieses wird dann im
betriebswirtschaftlichen
Bereich
für
Entscheidungen
herangezogen
oder
im
wissenschaftlichen Bereich um empirisch ermittelte Daten zu interpretieren.
Dabei werden Business Intelligence Systeme aus mehreren Bestandteilen aufgebaut
(Moni05):
•
Datenquellen
•
Arbeitsbereich
•
Basisdatenbank
•
Data Warehouse / Data Marts
•
Analyse
Das Business Intelligence System holt sich die Daten aus unternehmensinternen
oder –externen Datenquellen. (KöMa02) Diese können z.B. relationale Datenbanken
oder Log-Dateien sein. Die Datenquellen sind aber kein Bestandteil des Business
Intelligence Systems.
Bevor die Daten dann zur Analyse in die Basisdatenbank eingespeichert werden,
werden sie zur Überarbeitung im Arbeitsbereich gespeichert. Für diese Vorgänge
sind die ETL – Komponenten verantwortlich (Extraktion, Transformation, Laden). Die
Daten werden auf Fehler untersucht und korrigiert. (RuJo03)
Die Transformation von Daten kann mehrer Schritte beinhalten: Während diesem
Vorgang können beispielsweise Duplikate entfernt werden, Werte aus den Daten
-6-
hergeleitet oder fehlende Werte mit Hilfe von Regeln ergänzt und wieder hergestellt
werden (DaWa07).
•
Unter Filterung werden die Extraktion aus den operativen Daten sowie die
Bereinigung syntaktischer oder inhaltlicher Fehler in den zu verarbeitenden
Daten verstanden.
•
Die Harmonisierung bezeichnet
den Prozess
der
syntaktischen und
betriebswirtschaftlichen Abstimmung der Daten.
•
Die Aggregation ist die Verdichtung gefilterter und harmonisierter Daten.
•
Als Anreicherung wird die Bildung und Speicherung betriebswirtschaftlicher
Kenngrößen aus gefilterten und harmonisierten Daten bezeichnet.
Die bereinigten Daten werden nun in die Basisdatenbank gespeichert, von wo sie
dann im Rahmen des Data Warehouses aus ihr wieder verdichtet werden können.
Bei der Analyse der Daten werden häufig drei Analyseverfahren unterschieden
(PrTo06):
•
Data Access
•
Online Analytical Processing (OLAP)
•
Data Mining
Beim Data Access beschränkt sich die Analyse der Daten nur auf das Lesen der
Daten und der Repräsentation. Die Ergebnisse werden dann in Form von Reports
und Auswertungen dargestellt. Ein häufig genutztes Tool sind Dashboards oder
Ampelfunktionen. Hier werden Grenzwerte angegeben, die festlegen ab welchem
Bereich sich der Wert im grünen, gelben oder roten Bereich befindet. Diese
Darstellung erfreut sich großer Beliebtheit, da die Ergebnisse visuell ansprechend
aufbereitet werden.
Bei Tools, die die OLAP (Online Analytical Processing) - Analyse unterstützen,
müssen Anfangs alle Kriterien definiert werden. Anschließend lassen sich mit
Pivotierung unter anderem die Reihenfolge der Spalten, sowie den aktuellen
-7-
Ausschnitt des so genannten OLAP-Würfels verändern. Als OLAP-Systeme werden
also analytische Tools zur Auswertung von multidimensionalen Datenmodellen auf
das Unternehmen verstanden (PaKa06). Die OLAP-Anwendungen sind die am
weitesten verbreiteten Analyseinstrumente zur Zeit. Sie ermöglichen dem Benutzer
Daten innerhalb eines multidimensionalen Modells zu untersuchen, analysieren und
Daten zusammenzufassen. Ein multidimensionales Modell stellt beispielsweise
Messwerte sowie auch die entsprechenden Messdimensionen, in einem einzigen
Modell zur Verfügung (RüWo05). Da in einem solchen Modell die Daten optimal
strukturiert sind wird die Anfragezeit erheblich verkürzt.
Anwender
geschäftsrelevante
Analysen
online,
OLAP erlaubt dem
ohne
großem
wird
erhöht,
Zeitaufwand
durchzuführen.
Zu den Standard – OLAP – Operationen zählen:
•
Drill-Down:
Detailierungsgrad
der
Daten
wobei
die
Dimensionalität der ursprünglichen OLAP-Abfrage erhalten bleibt.
•
Roll-Up: (Inverse Operation zum Drill-Down) Der Detailierungsgrad der Daten
entlang einer Dimension wird dabei verringert (PaKa06).
•
Pivoting: Pivoting ist das virtuelle Drehen des Data Cube bzw. das Betrachten
der Berichtsdaten aus unterschiedlichen Perspektiven. Die Reihenfolge der
aktuell dargestellten Dimensionen wird vertauscht. Die Dimensionalität der
ursprünglichen OLAP-Abfrage bleibt erhalten.
•
Slicing: Slicing kann man sich als Abschneiden einer der Scheiben des Data
Cube vorstellen, womit die Dimensionen der ursprünglichen OLAP-Abfrage
um eine Dimension verringert wird (PrTo06).
•
Dicing:
Dicing
ist
dagegen
das
Herausschneiden
(-greifen)
eines
Unterdatenwürfels. Beim Ausschneiden eines Teiles aus dem bestehenden
Data Cube (ein Filter wird über den Cube gelegt) bleibt die Dimensionalität der
ursprünglichen OLAP-Abfrage erhalten, aber die dargestellten Elemente der
Hierarchieobjekte werden verändert.
Unter dem Data Mining werden Analyseverfahren zusammengefasst, die versuchen
aus vorhandenen Informationen, neue Informationen zu extrahieren. Dieses
-8-
Analyseverfahren
unbekannten
beschreibt
die
Zusammenhängen
weitgehend
und
Trends
hypothesenfreie
in
großen
Suche
nach
Datenpools,
Data
Warehouses oder dem OLAP-Modell. Diese Anwendungen haben also zum Ziel,
Muster innerhalb strukturierter Daten zu finden und anzuzeigen. Um dies zu
erreichen gibt es mehrere Möglichkeiten (GaJa05).
Text Mining
Text Mining ist die Fortschreibung der Grundidee des Data Mining auf unstrukturierte
Textdokumente (Zeitungstexte, Patente, Gerichtsurteile, Buchreferenzen). Es verfolgt
die Ziele, einen Überblick der Inhalte großer Dokumentenkollektionen zu liefern,
Gemeinsamkeiten
zu
identifizieren,
eine
schnelle
Informationsaufnahme
zu
ermöglichen und ähnliche Texte leichter zu finden. Die Hauptfunktion des Text
Mining sind die Klassifikation und Gruppierung (Segmentierung, Clustering) von
Dokumente, Informationsextraktion sowie automatische Textzusammenfassungen
(ScTo06).
Web Mining
Aus der zunehmenden Komplexität des World Wide Web resultiert der wachsende
Bedarf an weiterführenden Analysen, die den Inhalt und die Struktur des World Wide
Web bzw. einzelner Websites sowie das Verhalten der Internetnutzer zum
Gegenstand haben. Dies ist Aufgabe des Web Mining, das sich beim verwendeten
und bei der Vorgehensweise an die Ansätze des Data Mining und Text Mining an
lehnt. Die Aufgabenbereiche des Web Mining lassen sich in drei Kategorien
unterteilen (ScTo06):
•
Web Content Mining befasst sich mit der inhaltlichen Analyse von Webseiten.
Hierbei bedient es sich häufig Ansätzen des Text Mining, um in den
Dokumenten Muster zu finden bzw. die Dokumente zu klassifizieren und zu
gruppieren.
•
Web Structure Mining versucht die Topologie zwischen den Hyperlinks des
World Wide Webs aufzudecken (Internet Dokumentstruktur)
•
Web Usage Mining analysiert das Verhalten einzelner Nutzer(Gruppen) auf
Basis dieser Logfiles (GaJa05).
-9-
Prozessorientierte Betrachtung von Business Intelligence
Business Intelligence lässt sich grundsätzlich in drei Phasen einteilen (WoUl03):
1. Phase: Innerhalb der Business Intelligence bildet die Aufbereitung und
Bereitstellung von Informationen den ersten Schritt, wobei fragmentierte
Informationen
aus
internen
Entscheidungsprozesse
und
zielgerichtet
externen
Datenquellen
zusammengeführt
für
werden.
Insbesondere Data Warehouse und Wissensmanagementsysteme dienen als
optimale Quellen.
2. Phase: Die Daten müssen dann je nach Zielsetzung und Anwendungsbereich
in einem zweiten Schritt einer Analyse unterzogen werden. Hierzu werden
zum Beispiel multidimensionale Verfahren und Tools wie OLAP oder das
Data Mining herangezogen. Oft entstehen auch eigene analytische
Anwendungssysteme wie Customer Relationship Intelligence oder Supply
Chain Intelligence, die sich auf einzelne Schwerpunkte des Unternehmens
konzentrieren. Neben den standardisierten Abfragemöglichkeiten ermöglichen
derartige
Systeme
rechtzeitig
erreignisgesteurte
Warnmeldungen
zu
erkennen (z.B. bei der Überschreitung von Planwerten).
3. Phase: In einem dritten Schritt sind dann – basierend auf den Ergebnissen
der Analyse – Maßnahmen festzulegen und auszuführen. Viele Systeme
liefern diesbezüglich Entscheidungsunterstützende Vorschläge die von
Menschen oder automatisiert (z.B. durch Wordklfow-Management-Systeme)
über einen adäquaten Kommunikationskanal übermittelt werden (RuJo07).
Wenn dabei Intra- oder Internet verwendet wird, spricht man auch oft von EBusiness-Intelligence (WoUl03).
- 10 -
4 Open Source
4.1 Geschichte von Open Source
Die Idee von Open Source hat die Softwareindustrie revolutioniert wie kaum eine
Idee zuvor. Heute gelten viele Open Source Produkte als ernstzunehmende
Konkurrenz für kommerzielle Lösungen. Die Kernidee hinter Open Source ist nicht
neu, doch stellt sich die Sinnhaftigkeit dieser Projekte aus der Sicht des Shareholder
Values in Frage.
„Open Source wird oft als Angriff gegen die kommerzielle Welt dargestellt. Die Idee
von Open Source kann jedoch durchaus einen Segen für kommerzielle Firmen
bedeuten. Die gemeinschaftliche Entwicklung von Produkten spart Ressourcen und
erlaubt flexible Weiterentwicklung der Technologie.“ (WiCh06)
Open
Source
untereinander
ermöglicht
eine
und
ihren
mit
Art
der
Zusammenarbeit
Kunden,
die
zwischen
ökonomisch
trotz
Firmen
höherer
Transaktionskosten und Koordinierungskosten sinnvoll ist, da der Gesamtnutzen
größer ist als die entstehenden Kosten. Dabei verhindert Open Source durch seine
Offenheit effizient das Entstehen wohlfahrtsschädlicher Monopole und verlagert
Wohlfahrtsgewinne von den Produzenten zu den Konsumenten. Die ökonomische
Sinnhaftigkeit von Open Source zeigt, dass ‚Kooperation und Wettbewerb sich nicht
prinzipiell ausschließen (LuBe04).
In der Tat sind heutzutage kommerzielle und
häufig börsennotierte Firmen die wohl wichtigsten Antriebsfedern hinter vielen
bedeutenden Open Source Projekten wie Linux, Eclipse oder OpenOffice. RedHat,
IBM und SUN sind nur drei der offensichtlicheren Beispiele für Firmen, die erhebliche
Ressourcen für Software-Entwicklung aufwenden und es dennoch schaffen, von
ihrem Einsatz nachhaltig zu profitieren (WiCh06).
Während
manche
Analytiker
Open
Source
primär
als
soziales
und
softwaretechnisches Phänomen und dementsprechenden Forschungsgegenstand
auffassen, gibt es Meinungen die ganz andere Punkte als die eigentlich
revolutionären hervorheben: Verkauf, Vertrieb und Marketing.
- 11 -
„Bei Open Source geht es darum, die Verbreitung eines Produktes zu maximieren,
es über Firewalls und Bürokratien hinweg in die Händler von Anwendern und
Entwicklern zu bekommen, sodass dieses es ausprobieren können. Später können
sie dann auf den Anbieter zurückkommen, etwa für Dienstleistungen oder
Supportverträge.“ (PlDa02)
Open Source ist also nicht nur eine bestimmte Art und Weise Software
gemeinschaftlich zu entwickeln, sondern auch, dieses zu vermarkten. Dabei kann
man das Wort Marketing durchaus in einem äußerst positiven Sinne betrachten
(WiCh06). Open Source steigert nicht nur die Möglichkeiten für Anwender, sich und
ihrer Arbeit in die Entwicklung von Software einzubringen und zu helfen sie
weiterzuentwickeln und zu verbessern, sondern auch, ihre Ideen und Wünsche in die
entstehenden Produkte einzubringen. Es gibt Unternehmen also eine sehr effektive
und kostengünstige Möglichkeit ihre Kunden besser zu verstehen.
Dafür müssen jedoch entsprechende Strukturen und Prozesse geschaffen und
professionell gehandhabt werden. Die Geschichte von Open Source handelt primär
vom kreativen Umgang mit geistigem Eigentum und der Durchsetzung eines
ungewohnten
Produktions-,
Konsumtions-,
und
Kooperationsmodus
in
der
Gesellschaft (LuBe04).
4.2 Open Source Definition
Software fällt unter die Kategorie Open Source, wenn folgende Kriterien erfüllt sind
(KoSt04):
Freie Wiedergabe
Die Lizenz darf niemanden in seinem Recht einschränken, die Software als Teil
eines Software-Paketes, das Programme unterschiedlichen Ursprungs enthält, zu
verschenken oder zu verkaufen. Die Lizenz darf für den Fall eines solchen Verkaufs
keine Lizenz- oder sonstigen Gebühren festschreiben.
- 12 -
Quellcode
Das Programm muss den Quellcode beinhalten. Die Wiedergabe muss sowohl für
den Quellcode als auch für die kompilierte Form zulässig sein. Wenn das Programm
in irgendeiner Form ohne Quellcode weitergegeben wird, so muss es eine allgemein
bekannte Möglichkeit geben, den Quellcode zum Selbstkostenpreis zu bekommen.
Der Quellcode soll die Form eines Programms sein, die ein Programmierer
vorzugsweise bearbeitet. Absichtlich unverständlich geschriebener Quellcode ist
daher nicht zulässig. Zwischenformen des Codes, so wie sie etwa ein Präprozessor
oder ein Konvertor erzeugt, sind unzulässig.
Abgeleitete Software
Die Lizenz muss Veränderungen und Derivate zulassen. Außerdem muss sie es
zulassen,
dass
die
solcherart
entstandenen
Programme
unter
denselben
Lizenzbestimmungen weiterverttrieben werden können wie die Ausgangssoftware.
Unversehrtheit des Quellcodes des Autors
Die Lizenz darf die Möglichkeit den Quellcode in veränderter Form weiterzugeben,
nur dann einschränken, wenn sie vorsieht dass zusammen mit dem Quellcode so
genannte Patch Files weitergegeben werden dürfen, die den Programmcode bei der
Kompilierung verändern. Die Lizenz, muss die Weitergabe von Software, die aus
verändertem Quellcode entstanden ist, ausdrücklich erlauben. Die Lizenz kann
verlangen, dass die abgeleiteten Programme einen anderen Namen oder eine
andere Versionsnummer als die Ausgangssoftware tragen.
Keine Diskriminierung von Personen oder Gruppen
Die Lizenz darf niemanden benachteiligen.
Keine Einschränkung bezüglich des Einsatzfeldes
Die Lizenz darf niemanden daran hindern das Programm in einem bestimmten
Bereich einzusetzen. Beispielsweise darf sie den Einsatz des Programms in einem
Geschäft oder in der Genforschung nicht ausschließen.
- 13 -
Weitergabe der Lizenz
Die Rechte an einem Programm müssen auf alle Personen übergehen, die diese
Software erhalten, ohne dass für diese die Notwendigkeit bestünde, eine eigene,
zusätzliche Lizenz zu erwerben.
Die Lizenz darf nicht auf ein bestimmtes Produktpaket beschränkt sein
Die Rechte an dem Programm dürfen nicht davon abhängig sein, ob das Programm
Teil eines bestimmten Software-Paketes ist. Wenn das Programm aus dem Paket
Herausgenommen und im Rahmen der zu diesem Programm gehörenden Lizenz
benutzt oder weiter gegeben wird, so sollen alle Personen, die dieses Programm
dann erhalten, alle Rechte daran haben, die auch in Verbindung mit dem
ursprünglichen Software-Paket gewährt wurden.
Die Lizenz darf die Weitergabe zusammen mit anderer Software nicht
einschränken
Die Lizenz darf keine Einschränkungen enthalten bezüglich anderer Software, die
Zusammen mit der lizenzierten Software weitergegeben wird. So darf die Lizenz z. B.
nicht verlangen, dass alle anderen Programme, die auf dem gleichen Medium
weitergegeben werden, auch quelloffen sein müssen.
Die Lizenz muss Technologie-neutral sein
Keine Vorschrift der Lizenz darf sich auf eine einzigartige Technologie oder ein e
individuelle Benutzerschnittstelle beziehen.
4.3 Arten von Open Source Lizenzen
Die Open Source Initiative, Inc. (OSI) hat bis heute knapp 60 Lizenzen als
definitionskonform bestätigt. Alle bis heute anerkannten Lizenzen lassen sich
vereinfacht
in
drei
Kategorien
einteilen.
Abgrenzungskriterium
ist
eine
Lizenzbedingung, welche unter dem Begriff des «Copyleft» bekannt geworden ist.
Über diese Bedingung stellt der Lizenzgeber sicher, dass veränderte Versionen des
Lizenzgegenstands
unter
denselben
Bedingungen
verbreitet
werden.
Die
bekannteste Lizenz mit Copyleft ist die GNU General Public License (GPL), jene
ohne Copyleft die BSD Lizenz, benannt nach der Berkely Software Distribution. In
- 14 -
der Regel führt eine sog. Copyleft-Lizenz dazu, dass der Einbezug des davon
betroffenen Softwarecodes in ein eigenes Programm zwar zulässig ist, dass das
erweiterte Programmpaket aber nur unter derselben Lizenz weiterverbreitet werden
darf. Differenzierungen sind zwar möglich, führen aber nicht immer zu eindeutigen
Resultaten.
Neben den Lizenzen mit Copyleft (GPL-artige) und solchen ohne Copyleft (BSDartige) gibt es Zwischenformen, welche für direkte Weiterentwicklungen des
lizenzierten Softwarecodes zwar das Copyleftprinzip vorsehen, den Einbezug in
Distributionen aber weitgehend erlauben. Für diese Kategorie scheint die
Bezeichnung «Copyleft-light» passend. Als Beispiel können die GNU Lesser General
Public License (L-GPL) oder die Mozilla Public License (MPL) angeführt werden
(WiCh06).
- 15 -
5 Open Source Lösungen im Business Intelligence
Bereich
Dem generellen Trend folgend, sind nun auch im Business Intelligence Bereich,
Open-Source-Lösungen im Vormarsch. Traditionell war Business Intelligence die
Domäne von Firmen wie Business Objects, Cognos, SAS und SAP, da komplexe
Software-Pakete hinter diesen Lösungen standen. Unter dem Begriff Business
Inteligence werden Techniken wie Datawarehousing, Datamining, Analyse und
Reporting
zusammengefasst,
mit
denen
Unternehmen
versuchen,
ihre
Geschäftsabläufe und Kontakte zu Kunden, Lieferanten und Partnern zu optimieren.
Bei all diesen Funktionen stehen die Sammlung, Speicherung, Auswertung und
Aufbereitung von Daten im Vordergrund. Aus riesigen, oft unstrukturierten
Datenmengen lassen sich mittels geeigneter Software strategische Erkenntnisse
gewinnen, Trends ableiten und Zielrichtungen definieren (RuJo07).
Nachdem die komplexen Techniken im Rahmen eines Kompletpakets von
kommerziellen Firmen angeboten wurden, konnten sich Open-Source-Lösungen erst
an das Thema Business Intelligence heranwagen, nachdem die einzelnen
Komponenten ebenso als quelloffene Varianten zur Verfügung standen.
So stehen beispielsweise für das verwalten der Datenmassen, quelloffene
Datenbanken
wie
MySQL
und
PostgreSQL
als
Datenspeicher
für
das
Datawarehousing zur Verfügung.
Um die oft aus verschiedenen Quellen stammenden Daten in das richtige Format zu
bringen und in das Datawarehouse zu befördern, kommt ein Verfahren zum Einsatz
das sich Extraction, Transformation
& Loading (ETL) nennt. Unter den diversen
Open-Source-Projekten, die sich dieser Aufgabe widmen, sind das belgische Tool
Kettle und das CloverETL-Framework (RuJo03).
Sind die Daten einmal in das System eingespeist, gilt es, sie zu analysieren und
miteinander in Bezug zu setzen, um implizite Strukturen erkennen zu können – ein
Prozess der auch unter dem Begriff Data Mining bekannt ist. Aus sonst
unüberschaubaren Datenbeständen lassen sich durch automatisierte Auswertungen
- 16 -
potenziell nützliche Informationen destillieren. Eine Methode die in diesem
Zusammenhang häufig zum Einsatz kommt ist OLAP. Das Akronym steht für On Line
Analytical Processing und beschreibt ein Verfahren, zuvor entwickelte Hypothesen
durch eine multidimensionale Analyse der Daten auf ihre Richtigkeit zu überprüfen.
Dabei wird die Analyse nicht direkt an den operationalen Datenbankdaten vollzogen,
sondern an einem so genannten OLAP Cube, einem mehrdimensionalen Modell
einer Momentaufnahme der Daten. Der bekannteste freie OLAP-Server ist das in
Java geschriebene Mondrian-Projekt (RüWo05). Die Aufbereitung der Ergebnisse zu
aussagekräftigen Berichten übernehmen Reporting-Engines wie die Java-Bibliothek
JaspersReports von der kalifornischen Software-Schmiede JasperSoft (Basi04).
- 17 -
6 Pentaho
Der amerikanische Open-Source Anbieter Pentaho, bietet eine Business Intelligence
Komplettlösung an, bei der versucht wird viele Einzellösungen zu einem kompletten
Framework zusammenzufassen und dafür Support aus einer Hand zu liefern. Die
Pentaho Business-Intelligence Suite umfasst, ETL-, Analyse-, Reporting- und
Workflow-Komponenten und bring die Projekte Mondrian, Kettle, die ReportingBibliothek JFreeReports und Pentahos Eigenentwicklungen wie Dashboards unter
einen Hut. Dashboards ermöglicht Anwendern über ein Web-Frontend einen
zentralen Zugang zu Auswertungen, Reports und anderen Informationen.
Das Geschäftskonzept von Pentaho ist wahrlich einfach und simple und beruht auf
der Tatsache, dass Unternehmen versuchen ihre Einnahmen zu vergrößern und
dabei ihre Kosten so gering wie möglich zu halten. In diesem Punkt kommen
Business Intelligence Lösungen zum Einsatz. Durch die Verwendung von Business
Intelligence Lösungen wird die Effektivität und Effizienz im Unternehmen gesteigert
und das Ziel der vergrößerten Einnahmen und geringen Kosten rückt in greifbare
Nähe. Doch dabei konzentrieren sich herkömmliche Business Intelligence Lösungen
auf einzelne Problembereiche und Geschäftsfelder. Durch die einzelnen Business
Intelligence Tools, die sich im Laufe der Zeit bei den Unternehmen anhäufen entsteht
ein undurchsichtiges Gebilde, welches einzelne Probleme ohne Zusammenhang
versucht zu lösen. Mit diesen Tools war es bisher notwendig das Problem immer in
einzelne Komponenten zu teilen und für jede Komponente das passende Tool mit
der jeweiligen Lösung in Anspruch zu nehmen. Somit hat sich Pentaho zur Aufgabe
gemacht, eine einheitliche Business Intelligence Plattform zu bilden, die es
ermöglicht all diese einzelnen Tools, zu einer Lösung zusammenzuführen.
Die Kritikpunkte bei traditionellen Business Intelligence Lösungen sind von der Seite
von Pentaho, neben dem Preisfaktor, auch die Benutzerfreundlichkeit und die
Anpassungsfähigkeit der kommerziell angeboten Software-Pakete.
Nach der Beschreibung von Pentaho, versucht Pentaho, diese Schwachstellen der
kommerziell
angebotenen
Produkte
zu
- 18 -
verbessern,
und
versucht
eine
Komplettlösung anzubieten. Im Vergleich zu traditionellen Business Intelligence
Lösungen ist die Pentaho Plattform eine Lösungs-orientierte und Prozess-zentrierte
Komplettlösung mit Business Intelligence Komponenten.
Die Business Intelligence Plattform von Pentaho gilt als Prozess-zentriert, da die
zentrale Kontrolleinheit eine „workflow-engine“ ist. Diese workflow-engine benutzt
Prozess-Definitionen, um die Business Intelligence Prozesse die im Rahmen der
Plattform ausgeführt werden, zu definieren. Diese Prozesse können leicht adaptiert
werden und weiters können neue Prozesse hinzugefügt werden.
Die Pentaho Business Intelligence Plattform besteht aus folgenden Komponenten:
•
Das Business Intelligence Framework: bestehend aus dem ETL, den WebDiensten, dem Sicherheitszentrum, etc.
•
Die einzelnen Business Intelligence Komponenten: Reporterstellung, Analyse,
Workflow, Dashboards und Data Mining
•
Dem Business Intelligence Workbench: Eine Reihe von Design- und
Administrativen Tools, welche in der Eclipse Plattform integriert sind. Diese
Tools erlauben es den Benutzern der Pentaho Business Intelligence Plattform
eigene Reports, Dashboards, Business Intelligence Prozesse, Regeln und
Analysemodelle zu erstellen.
•
Das Business Intelligence Framework kombiniert mit den einzelnen Business
Intelligence Komponenten stellen den Pentaho Server dar.
Wie bereits erwähnt ist die Architektur der Pentaho Business Intelligence Plattform
eine Kombination aus eigenem Source Code und bereits ausgiebig erprobtem Open
Source Code.
Der Pentaho Server, welcher aus dem Pentaho Business Intelligence Framework
und den einzelnen Pentaho Business Intelligence Komponenten besteht, läuft auf
einem J2EE fähigen Webserver (z.B.: Apache, JBOSS AS, WebSphere, WebLogic
und Oracle AS). Der Pentaho Server ermöglicht es, dass die einzelnen Funktionen
der Pentaho Business Intelligence Plattform den verschiedenen Usern, in
- 19 -
einheitlicher Form und Aussehen präsentiert werden. Der Pentaho Server enthält die
Engines und Komponenten für das Erstellen von Reports, die Analyse der Daten, die
Business Rules, die Email und Desktop Benachrichtigung und den Workflow. Diese
Komponenten sind derart integriert, dass sie Business Intelligence Probleme lösen
können. Während eines Lösungsprozesses werden das Verhalten, das Interagieren
mit anderen Komponenten der einzelnen Sub-Systeme durch eine Sammlung von
Solution-Definitions definiert.
Diese Solution Definitions sind XML Dokumente die folgende Punkte enthalten:
•
Die Definition der Geschächtsfprozesse
•
Die Definitionen von Aktivitäten, die das Bearbeiten von Daten veranlassen.
Weiters sind die Vorlagen für die Reporterstellung und die Dashboards durch
diese Dokumente definiert und festgelegt.
•
Die Beziehung zwischen den soeben genannten Komponenten
- 20 -
Abbildung 1: Pentaho Server Architektur (Quelle: www.pentaho.org)
Wie aus Abbildung 1 ersichtlich basiert die Server Architektur von Pentaho auf den
Open Source Komponenten auf. Die Pentaho Business Intelligence Plattform ist mit
externen
Applikationen
verbunden,
um
Lösungen
für
jeden
möglichen
Geschäftsprozess zur Verfügung zu stellen. Diese externen Daten werden in das
Data Warehouse geladen, indem das bereits beschriebene Open Source Tool ETL
- 21 -
benutzt wird. Die Solution Engine ist das Zentrum der Pentaho Business Intelligence
Plattform Architektur und kontrolliert alle Zugriffe auf die einzelnen Business
Intelligence Komponenten. Weiters ist aus der Abbildung 1 ersichtlich, dass die
einzelnen Komponenten wie Module ausgetauscht und zum System hinzugefügt
werden können. Dabei sind auf in Abbildung 1 nicht alle möglichen Komponenten
ersichtlich. Die einzelnen Komponenten für Emails, das Drucken und das
Formatieren von Nachrichten und Reports sind nicht verzeichnet.
Ein weiteres erwähnenswertes Detail der Pentaho Business Intelligence Plattform ist
das einfache Austauschen von bestimmten Technologien, durch gleichwertige
Technologien. So kann zum Beispiel der durch JBOSS AS realisierte J2EE Server,
durch jede Java JDK 1.4 kompatible Server Applikation ersetzt werden. Weiters
bietet die Plattform die Userinterfaces in Java Server Pages (JSPs) an. Third Party
oder eigene Java Server Pages können hinzugefügt werden. Das Mondrian Open
Source OLAP Projekt ist in der Pentaho Business Intelligence Plattform integriert.
Diese kann aber durch jede MDX kompatible OLAP Server Architektur genutzt
werden.
Neben den bereits erwähnten Open Source Komponenten der Pentaho Business
Intelligence Plattform, bedient sich Pentaho noch einer Reihe offener Standards und
Protokolle:
•
XML – W2C’s Extensible Markup Language
•
JSR-94 – JCP’s Rules Engine API
•
JSR-168 – JCP’s Portlet Spec
•
SVG – W3C’s Scalable Vector Graphics
•
XPDL – WFMC’s XML Process Definition Language
•
XForms W3C’s Web Forms
•
MDX – Microsoft’s OLAP Query Language
•
WSBPEL - Oasis’s Web Services Business Process Execution Language
•
WSDL - W3C’s Web Services Description Language
•
SOAP - W3C’s Simple Object Access Protocol
- 22 -
6.1 Vorteile von Pentaho
Nachdem der Aufbau der Pentaho Business Intelligence Plattform bereits in den
vorangehenden Kapiteln beschrieben wurde, beschäftigt sich das folgende Kapitel
mit den von Pentaho selbst erarbeiteten Vorteilen, ihrer Business Intelligence
Plattform im Gegensatz zu den kommerziell Angebotenen Produkten.
Neben der Komplettlösung von Pentaho werden bei der Implementierung die Kosten
für weitere Business Intelligence Tools minimiert. Außerdem bietet Pentaho eine
echte Workflow basierte Anwendung an, die einerseits einfach in die bestehenden
Geschäftsprozesse zu integrieren ist und andererseits an das Unternehmen und die
Bedürfnisse angepasst werden kann, da die Definitionen in den Solution
Dokumenten adaptierbar sind.
- 23 -
7 Technisches Umfeld für die Projektumsetzung
Auf Grund der Internetrecherchen in der Anfangsphase des Projekts ermittelten die
Autoren einige „Mindestanforderungen“ an die Hardware des Rechners, der sowohl
den Server für die Pentaho BI-Plattform beherbergen, als auch als DevelopmentRechner für die Erstellung der Reports eingesetzt werden sollte.
Obwohl sämtliche notwendige OpenSource-Software auch für Microsoft Windows
vorliegt, entschieden sich die Autoren bei der Durchführung des Projekts auch mit
dem eingesetzten Betriebssystem in der OpenSource-Welt zu bleiben.
Die Autoren verwendeten daher folgendes System für die Durchführung des
Projekts:
•
Intel Centrino 1,86 Ghz
•
1GB RAM
•
Linux-Distribution „Ubuntu 7.04 – Feisty Fawn“ als Betriebssystem
•
MySQL-Datenbank 5.0 (aus den repositories des Betriebssystems installiert)
•
MySQL-GUI-Tools (http://dev.mysql.com/downloads/gui-tools/5.0.html)
•
OpenOffice.org (http://www.openoffice.org/)
•
phpMyAdmin (aus den repositories des Betriebssystems installiert)
•
Java-IDE Eclipse 3.2 (http://www.eclipse.org)
•
Pentaho Business Intelligence Platform Demo (Pre-Configured Install)
(http://www.pentaho.com)
•
Pentaho Report Designer RC 2 (http://www.pentaho.com)
- 24 -
8 Schwierigkeiten beim Importieren der Daten in die
MySQL-Datenbank
Grundsätzlich waren die Autoren sowohl mit der Anwendung einer Java-IDE
(konkret: Eclipse 3.2), als auch mit diversen Management-Tools für MySQLDatenbanken (phpMyAdmin, MySQL Query Browser, OpenOffice.org v2.2 Database)
vertraut. Die Anforderungen dieses Projekts zeigten jedoch, dass der MySQL Query
Browser mit den Default-Einstellungen nicht geeignet ist, eine Datenbank inkl. der
zugehörigen Tabellen schnell und benutzerfreundlich zu erstellen. Es wurde daher
versucht mit dem Datenbank-Tool der OpenOffice.org-Produktfamilie (Version 2.2)
auf
die
MySQL-Datenbank
zuzugreifen,
was
sich
auf
Grund
zahlreicher
Programmabstürze ebenfalls als nicht praktikabel erwies.
Es existiert keine Dokumentation über die Inhalte der Files (was bedeutet welches
Attribut, usw.). Nachdem aus den Dokument-Files zu erkennen war, dass diese
selbst mit Hilfe einer Datenbank generiert wurden, hätte man auch ein csv-File für die
Portierung der Daten in die MySQL-Datenbank der Autoren verwenden können. Dies
hätte allerdings noch immer erfordert, das Java-Programm für die Log-Files zu
entwickeln.
Die Dokument-Files umfassen Dissertationen und WorkingPapers. Beide Typen
unterscheiden sich voneinander in der Namensgebung der Attribute, obwohl die
Attribute äquivalent sind, z.B. für das Institut, an dem die Arbeit verfasst wurde =>
Dissertation:
„DC.Contributor.personalName“
=>
WorkingPaper:
„DC.Publisher.corporateName“
Dies machte es erforderlich, das Java-Programm um eine separate Routine zu
erweitern, die sich mit dem Import der Daten aus den WP-Dokument-Files befasst.
Die Files enthalten unterschiedlich viele Attribute, was sich auf die Ermittlung der
max. Spaltenanzahl der Tabelle überdurchschnittlich negativ bemerkbar gemacht
hat.
Jedes File enthält nur jene Attribut-Wert-Paare, bei denen der Wert nicht NULL ist.
Es ist daher schwierig zu ermitteln, welche Attribute über die Gesamtmenge der Files
für jeden Dokument-Typ vorkommen.
- 25 -
Hier wurde Abhilfe geschaffen, indem das Java-Programm am Ende eine Liste mit
den ermittelten Attributen ausgibt.
Auch innerhalb der Files gibt es keine Konsistenz in der Namensgebung. Ein Wert
für das Attribut „DC.Date.Created“ hat das Format YYYY, ein Wert für das Attribut
„DC.Date.Submitted“ hat das Format YYYY-MM und der Wert für das Attribut
„VL.Date“ hat das Format YYYY-MM-YY.
Hier wurde ein Workaround gefunden, indem alle Datumsangaben in das MySQLTimestamp-Format YYYY-MM-DD 00:00:00 gebracht wurden. Fehlende Daten für
Monate bzw. Tage wurden mit „01“ befüllt, die Uhrzeiten mit „00:00:00“.
Es lässt sich also erkennen, dass die angeführten Inkonsistenzen den Zeitaufwand
extrem
in
die
Höhe
getrieben
und
die
vor
dem
Projekt
durchgeführte
Aufwandschätzung ad absurdum geführt haben.
Die Aufwandschätzung für die Erstellung des Java-Programms war mit 15 Std.
eigentlich schon recht großzügig bemessen, es stellte sich jedoch heraus, dass weit
über 40 Std. notwendig sein werden, um ein lauffähiges Programm zu bekommen,
das später auch flexibel auf verschiedene Ablageorte der Files reagieren kann.
- 26 -
9 Probleme beim Erstellen der Reports mit dem Pentaho
ReportDesigner (inkl. Wizard)
Um die Konnektivität zwischen MySQL-Datenbank und ReportDesigner zu testen,
wurden Teile der Daten aus der Pentaho-Datenbank (Hypersonic) in die MySQLDatenbank migriert. Hierzu wurden die Tools „Kettle“ und „Spoon“ von der PentahoPlattform heruntergeladen und erfolgreich für die Datenmigration angewendet.
Grundsätzlich war der ReportDesigner in der Version RC 1 out-of-the-box nicht für
die Verwendung der MySQL-Datenbank zu konfigurieren. Grund hierfür war, dass
der korrekt installierte Java-MySQL-Connector nicht gefunden wurde. Dass der
CLASSPATH zum Connector korrekt gesetzt war, wurde an Hand einer Installation
von Jakarta Tomcat 5.5 (aus den repositories) getestet. Nach dem Anwenden der
Anleitungen mehrerer How-Tos aus diversen Foren, wurde dann eine komplette
Neuinstallation des Betriebssystems vorgenommen und danach nochmals die
Installation von Connector und ReportDesigner vorgenommen. Wieder konnte das
Tool den Connector nicht finden, ein anderes Programm aber schon. So konnte
ausgeschlossen werden, der Fehler in der Installation (CLASSPATH setzen) lag und
die Fehlerursache war eindeutig auf der Seite des ReportDesigners zu suchen.
Nachdem zu diesem Zeitpunkt bereits feststand, dass in den nächsten Tagen ein
neuer ReleaseCandidate des ReportDesigners veröffentlicht werden wird, wurde die
MySQL-Anknüpfung
an
den
ReportDesigner
auf
einen
späteren
Zeitpunkt
verschoben und die Entwicklung des Java-Programms fortgesetzt.
Nach dem Erscheinen des ReleaseCandidate 2 und dessen Installation funktionierte
das Auffinden des Java-MySQL-Connectors ohne nennenswerte Probleme. Es
wurde Verbindung zu den migrierten Daten in der MySQL-Datenbank aufgebaut und
ein kleiner Test-Report erstellt.
Somit war die grundsätzliche Einsatzbereitschaft des ReportDesigners hergestellt
und es konnte wieder die volle Energie in die Fertigstellung des Java-Programms für
die Befüllung der Datenbank investiert werden.
- 27 -
Nachdem die Datenbank schließlich korrekt befüllt war, wurde der ReportDesigner
für die Erstellung von Reports herangezogen. Es stellte sich jedoch heraus, dass die
eingebaute Hilfestellung für das Erstellen von SQL-Abfragen unzureichend und
extrem instabil war. Das Verwenden des „QueryDesigners“ führte jedes Mal zum
Absturz des gesamten ReportDesigners. Nach mehrmaligen Versuchen und Updates
auf neuere Versionen haben sich die Autoren dazu entschieden, die SQL-Statements
manuell zu definieren. Hierzu wurde das Tool „phpMyAdmin“ aus den repositories
installiert und erfolgreich eingesetzt.
Die nächste (negative) Überraschung kam dann beim Design des Reports für die
Zugriffstatistiken. Es ist derzeit nicht möglich, mehrere SQL-Abfragen für ein und
denselben zu definieren. Die Kennzahlen wurden daher in diese Richtung angepasst,
dass nun überwiegend Ergebnislisten generiert werden, die in ihrem Ausmaß limitiert
wurden („Limit“-Befehl). Eine weitere Schwierigkeit brachte die visuelle Aufbereitung
der Reports mit sich, da der ReportDesigner bei mehreren Versuchen die Reports
mit grafischen Elementen (horizontale Linien, Hintergrundfarben für Text, usw.)
auszustatten abstürzte und sich erst nach dem „Killen“ des entsprechenden
Prozesses erneut starten ließ.
Bei den erstellten Reports wurde aus den oben angegebenen Gründen die grafische
Gestaltung so einfach wie möglich gehalten.
- 28 -
Die
Erstellung
der
Reports
war
extrem
durch
Programmabstürze
des
ReportDesigners und des zugehörigen Wizards geprägt, die den Einsatz in einer
Produktivumgebung definitiv ausschließen. Das konkrete Problem war jenes, dass
nach Abschluss aller notwendiger Schritte im Wizard, der Wizard mit Klick auf „Done“
abgeschlossen
werden
sollte,
das
Programm
häufig
abstürzte
ReportDesigner ebenfalls beendete.
Abbildung 2: Fehlermeldung („Interner Fehler aufgetreten“)
- 29 -
und
den
Das Terminal gab hierzu folgende Fehlermeldung aus:
„The program 'SWT' received an X Window System error.
This probably reflects a bug in the program.
The error was 'BadWindow (invalid Window parameter)'.
(Details: serial 47368 error_code 3 request_code 3 minor_code 0)
“
Die Internetrecherche zur Behebung dieses Fehlers bzw. Möglichkeit einer
entsprechenden Installation eines Patches blieb leider erfolglos.
Es konnten somit die Reports weder in PDF, CSV, XLS, o.ä. Format, als auch als
Pentaho-Template erstellt werden, das notwendig ist, um den Report am PentahoBusinessIntelligence-Server aufrufen zu können.
- 30 -
10 Das Erstellen eines Reports (Screenshots)
Abbildung 3: Hinzufügen der Datenquelle
In Abbildung 3 sieht man das manuelle Hinzufügen einer Datenquelle für den
Pentaho Report Designer (bei Verwendung des Wizards nicht notwendig).
- 31 -
Der Aufruf des ReportDesign Wizards über das Menü DATEI -> Report Wizard führt
zu folgendem Screen:
Abbildung 4: 1. Schritt der Report-Erstellung
In Abbildung 4 befinden wir uns in Schritt 1. Hier wird der Titel des Reports, sowie
dessen Beschreibung definiert.
- 32 -
In einem zweiten Schritt muss die Datenquelle ausgewählt bzw. erstellt werden und
das entsprechende SQL-Statement eingegeben werden.
Abbildung 5: Auswahl der Datenquelle
Abbildung 6: Bearbeitung der Verbindung zur Datenquelle
- 33 -
Nach dem erstmaligen Erstellen der Datenquellen ist sie fortan immer unter dem
Namen „ePub“ als Auswahlmöglichkeit vorhanden;
Abbildung 7: Gestaltungs- und Gruppierungsmöglichkeiten
- 34 -
In Abbildung 7 wird festgelegt, ob und wie die Daten in der Ausgabeliste gruppiert
werden sollen. Dies macht vor allem dann Sinn, wenn eine hierarchische
organisatorische Gliederung der Daten möglich ist, z.B. Ist- und Soll-Budget für
einzelne Regionen -> Länder -> Kontinente usw.; Hierbei stellt jede Gruppierung eine
Kumulierung der enthaltenen Daten dar;
Hier können das Format und die Gruppen-Funktionen (für die Berechnung) definiert
werden;
Abbildung 8: Weitere Auswahlmöglichkeiten zur Gruppierung
- 35 -
Abbildung 9: Formatierungsmöglichkeiten
In Abbildung 9 werden das Papierformat und Ausrichtung, die Seitenränder, usw.
vorgegeben;
optional kann ein Image als Wasserzeichen angegeben werden, das auf jede Seite
gedruckt wird;
- 36 -
Abbildung 10: Feintuning
In Abbildung 10 kann noch ein abschließendes Feintuning vorgenommen werden,
wie z.B. Bezeichnung der Summenzeile, Anzeige von Gitternetzlinien, usw.;
Hier wird ebenfalls festgelegt, ob ein Chart zum Einsatz kommen soll
- 37 -
Abbildung 11: Integration eines Charts
Will man ein Chart in den Report integrieren, kann man die entsprechenden
Einstellungen in dem in Abbildung 11 dargestellten Pop-Up vornehmen;
- 38 -
Abbildung 12: Vorschau des ReportDesigners
In Abbildung 12 sieht man den mit dem Wizard generierten Report in der Ansicht
„Vorschau“ des ReportDesigners.
- 39 -
Abbildung 13 zeigt die Entwurfsansicht des ReportDesigners.
Abbildung 13: Entwurfsansicht des ReportDesigners
Vorschau-Ansichten der einzelnen Reports inkl. zugehörigen SQL-Statements:
Nachdem
die
Report-Generierung
nicht
funktioniert,
sollen
die
folgenden
Screenshots zumindest eine Indikation dafür geben, welche Daten auf dem fertigen
Report dargestellt worden wären. Hierbei ist jedoch zu beachten, dass das
Hinzufügen von mehr als 5 Feldern per Drag-and-Drop das Programm zum Absturz
bringt.
Um Abstürze zu vermeiden, haben die Autoren daher die Einschränkung getroffen,
dass nur das Ergebnis der Abfrage in Form einer Liste und allenfalls ein passender
Chart pro Report vorkommen sollen.
- 40 -
Nutzungs-Stärkster Tag der Woche
Abbildung 14: Nutzungs-Stärkster Tag der Woche
SELECT DAYNAME( `date` ) AS wochentag, count( `id` ) AS useranz
FROM logs_basic
WHERE 1
GROUP BY wochentag
ORDER BY DAYOFWEEK( `date` ) ;
- 41 -
Top 10 der meistaufgerufenen WorkingPapers; gruppiert nach Institut
Abbildung 15: Meistaufgerufene WorkingPapers gruppiert nach Institut
SELECT wp_basic.dc_title AS title, wp_basic.dc_creator_personalname AS autor,
wp_basic.dc_publisher_corporatename AS institut, count( logs_views.userid ) AS
aufrufe
FROM wp_basic, logs_views
WHERE logs_views.views = ( REPLACE( wp_basic.id, '/meta', '' ) )
GROUP BY title
ORDER BY aufrufe DESC
LIMIT 0 , 10;
- 42 -
Anteile der verschiedenen Sprachen an den WorkingPapers
Abbildung 16: Anteile der verschiedenen Sprachen an den Workingpapers
SELECT dc_language_id AS sprache, count( id ) AS anzahl
FROM wp_basic
WHERE 1
GROUP BY sprache
ORDER BY anzahl DESC;
- 43 -
Die meistgesuchten Stichwörter (Top 10)
Abbildung 17: Meistgesuchten Stichwörter
SELECT keyword AS stichwort, count( userid ) AS suchen
FROM `logs_queries_keyw`
WHERE LENGTH( keyword ) > 3
GROUP BY stichwort ORDER BY suchen DESC LIMIT 0 , 10;
Die Bedingung „Länge des Stichworts > 3“ wurde gewählt, um allfällige Bindewörter,
Präpositionen, usw. überwiegend aus dem Ergebnis auszuschließen; ein manueller
Test hat ergeben, dass das einzige Bindewort, das aus Sicht der Anzahl in dieser
Liste aufscheinen müsste, das Wort „and“ ist. Somit wurde die Plausibilität der o.a.
Bedingung bewiesen.
- 44 -
Berechnung von Kennzahlen:
Es wurden noch weitere SQL-Abfragen definiert, die Informationen über das
Nutzungsverhalten der User in Form von quantitativen Kennzahlen liefern sollen.
Exemplarisch sollen die Kennzahlen, sowie die zugehörigen SQL-Abfragen im
Folgenden erwähnt werden:
durchschnittliche Log-In-Dauer in Min (exkl. 0-Sec-Log-Ins):
Ergebnis: 11,22 min
SQL-Query:
SELECT AVG( TIMESTAMPDIFF(
SECOND , `date` , `end` ) /60 ) AS 'dauer'
FROM logs_basic
WHERE TIMESTAMPDIFF(
SECOND , `date` , `end` ) <> 0;
durchschnittliche Log-In-Dauer in Min (inkl. 0-Sec-Log-Ins):
Ergebnis: 8,28 min
SQL-Query:
SELECT AVG( TIMESTAMPDIFF(
SECOND , `date` , `end` ) /60 ) AS 'dauer'
FROM logs_basic;
- 45 -
11 Fazit
Pentaho wirbt mit seiner einfachen Handhabung als Open Source Lösung für das
Einrichten einer Business Intelligence Plattform. Im Rahmen dieser Arbeit konnte
diese Behauptung nicht bestätigt werden. Begonnen mit dem Import der Daten bis
hin zur Erstellung der Reports traten unvorhergesehene Fehler auf.
Zwar bietet Pentaho alle notwendigen Funktionen um mit den kommerziellen
Business Intelligence Produkten mithalten zu können, doch stellt sich die Frage ob
die Ergebnisse der Analysen den Aufwand des Konfigurieren des Systems
rechtfertigen.
- 46 -
12 Anhang
Data Import in Java:
import java.io.*;
import java.util.*;
import java.util.Vector;
import java.sql.*;
public class dataimport {
public static Vector columns_diss = new Vector();
public static Vector columns_wp = new Vector ();
public static Vector columns_logs = new Vector ();
public static String current_id = null;
public static String url = "jdbc:mysql://localhost:3306/ePub";
public static Connection conn = null;
/**
* @param args
* Gibt dem Programm jenen (absoluten) Pfad (inkl. Dateiname und Endung) mit,
an dem das properties-file gespeichert ist.
*/
public static void main(String[] args) {
try {
DriverManager.registerDriver(new org.gjt.mm.mysql.Driver());
conn = DriverManager.getConnection(url, "ePub_user", "ePub_password");
}
catch (SQLException e) {
System.out.println("DB-Fehler: "+e);
}
String propertiesFile=args[0].trim();
//String propertiesFile = "/home/valentin/dbtest_testData/dbtest.properties";
// Reading properties file.
Properties properties = new Properties();
try {
properties.load(new FileInputStream(propertiesFile));
- 47 -
// The Folders shall be separated by commas in the properties-File or the
keyword "all" shall be stated;
// "all" means that all subfolders of logfiles.PathToFolders shall be included
String logfileFolders=properties.getProperty("logfiles.Folders");
// The PathToFolders shall contain an ending /-sign and be an absolute path
String pathToDataFolders=properties.getProperty("logfiles.PathToFolders");
String datafileFolders_diss=properties.getProperty("datafiles_diss.Folders");
String
pathToDataFolders_diss=properties.getProperty("datafiles_diss.PathToFolders");
String datafileFolders_wp=properties.getProperty("datafiles_wp.Folders");
String
pathToDataFolders_wp=properties.getProperty("datafiles_wp.PathToFolders");
handleFolders (logfileFolders, pathToDataFolders, 1);
handleFolders (datafileFolders_diss, pathToDataFolders_diss, 2);
handleFolders (datafileFolders_wp, pathToDataFolders_wp, 3);
System.out.println("\n\n\nSpalten fuer die basic Diss-DB:");
showContent(columns_diss, false);
System.out.println("\n\n\nSpalten fuer die basic WP-DB:");
showContent(columns_wp, false);
System.out.println("\n\n\nSpalten fuer die logs-DB:");
showContent(columns_logs, false);
}
catch (IOException e) {
System.out.println("Fehler beim Lesen des properties-File:" +e);
}
}
/**
*
* @param folder
* @param path
* @param typeOfFiles 1: logfiles; 2: diss; 3: wp;
*/
public static void handleFolders (String folder, String path, int typeOfFiles) {
String[] dataFolders=null;
if (folder.equals("all")==false){
dataFolders=folder.split(",");
System.out.println("Ordner wurden explizit angegeben");
}
else { // logfilesFolders=="all"
- 48 -
dataFolders=new File(path).list();
if (dataFolders!=null){
for (int i=0; i<=dataFolders.length-1;i++){
System.out.println(dataFolders[i]);
}
}
}
String fileType = "";
switch (typeOfFiles) {
case 1: fileType="logFiles"; break;
case 2: fileType="diss"; break;
case 3: fileType="wp";break;
}
// Check, if the amount of the folders is right
System.out.println(dataFolders.length + " Ordner mit "+fileType+" angegeben:");
for (int i=0;i<=dataFolders.length-1;i++) {
System.out.println("===============================================
===============");
System.out.println("Beginne mit Verarbeitung von Ordner: "+dataFolders[i]);
String concreteDataFolder=path+dataFolders[i];
switch (typeOfFiles) {
case 1: importLogFilesIntoDatabase(concreteDataFolder); break;
case 2: importDissFilesIntoDatabase(concreteDataFolder); break;
case 3: importWpFilesIntoDatabase(concreteDataFolder); break;
}
System.out.println("Verarbeitung von Ordner "+concreteDataFolder+"
abgeschlossen!");
}
System.out.println("\n\nAlle Ordner durchsucht. Programmende.");
}
public static void importLogFilesIntoDatabase (String dataFolder) {
File folder=new File(dataFolder);
File[] logFiles = folder.listFiles();
System.out.println("Im Ordner "+dataFolder+" gefundene Dateien
("+logFiles.length+"):");
if (logFiles!=null){
for (int i=0; i<=logFiles.length-1;i++){
- 49 -
System.out.println("===============================================
=============");
System.out.println(folder+"/"+((File) logFiles[i]).getName()+" hat folgenden
Inhalt: ");
readFileContent(logFiles[i]);
}
}
else System.out.println("Das Array mit den Files ist NULL");
}
public static void readFileContent (File f){
try {
String streak;
Vector insertObjects = new Vector ();
Vector vec_query_attr = new Vector();
Vector vec_query_keyw = new Vector();
Vector vec_views = new Vector();
File enterFile = f;
FileReader enterStream = new FileReader(enterFile);
BufferedReader eInput = new BufferedReader(enterStream);
while ((streak = eInput.readLine()) != null) {
String[] nameValueCouple = streak.split(" := ");
if (nameValueCouple[0].equals("query")==true) {
//
System.out.println("QUERY:");
addColumnToColumnList(nameValueCouple[0], columns_logs);
String[]
queries=nameValueCouple[1].substring(1,nameValueCouple[1].length()-1).split(";");
for (int i=0; i<=queries.length-1; i++) {
if (queries[i].contains(":=")==true) {
String[] queryCouple = queries[i].split(":=");
if (queryCouple.length==2) {
//
System.out.println("QueryAttribut: "+queryCouple[0]);
//
System.out.println("QueryWert: "+queryCouple[1]);
vec_query_attr.addElement(queryCouple);
}
}
else { // Query waren nur Stichwoerter
String[] queryKeywords = queries[i].split(" ");
for (int j=0; j<=queryKeywords.length-1; j++){
String keyword = queryKeywords[j].replace("\"", "'");
//
System.out.println("QueryStichwort: "+ keyword);
vec_query_keyw.addElement(keyword);
}
- 50 -
}
}
}
else if (nameValueCouple[0].equals("view")==true) {
//
System.out.println("VIEWS:");
addColumnToColumnList(nameValueCouple[0], columns_logs);
String[]
views=nameValueCouple[1].substring(1,nameValueCouple[1].length()-1).split(";");
for (int i=0; i<=views.length-1; i++) {
//
System.out.println(views[i]);
vec_views.addElement(views[i]);
}
}
else {
if (nameValueCouple[0].equalsIgnoreCase("userid")){ //notwendig zur
Identifikation fuer queries und views
current_id = nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1);
}
//
System.out.println("Name: "+nameValueCouple[0]);
addColumnToColumnList(nameValueCouple[0], columns_logs);
//
System.out.println("Wert: "+nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1));
insertObjects.addElement(nameValueCouple);
}
}
insertVectorInDatabase(insertObjects, "logs_basic");
insertObjects=null;
insertQueryIntoDB(vec_query_attr, vec_query_keyw);
vec_query_attr=null;
vec_query_keyw=null;
insertViewsIntoDB (vec_views);
vec_views=null;
} catch (IOException e) {
e.printStackTrace();
}
}
public static void importDissFilesIntoDatabase (String dataFolder) {
try {
//
System.out.println("===============================================
======");
- 51 -
//
System.out.println("===============================================
======");
//
System.out.println("importDissFilesIntoDatabase");
File enterFile=new File(dataFolder+"/meta.dat");
FileReader enterStream = new FileReader(enterFile);
BufferedReader eInput = new BufferedReader(enterStream);
String streak;
Vector documentDetails = new Vector ();
Vector documentKeywords = new Vector ();
Vector documentKeywords_eng = new Vector ();
String documentId = null;
while ((streak = eInput.readLine()) != null) {
String[] nameValueCouple = streak.split(" := ");
if (((nameValueCouple[0].equals("DC.Subject.Keywords")) ||
(nameValueCouple[0].equals("DC.Subject.Keywords.eng")))==false) {
if (nameValueCouple[0].equals("ID")){
documentId=nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1);
}
//
System.out.println("Name: "+nameValueCouple[0]);
addColumnToColumnList(nameValueCouple[0], columns_diss);
//
System.out.println("Wert: "+nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1)+" ==> Laenge: "+nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1).length());
if ((nameValueCouple[0].equals("DC.Date.Created")) ||
(nameValueCouple[0].equals("DC.Date.Accepted"))){
nameValueCouple[1]=nameValueCouple[1].substring(0,
nameValueCouple[1].length()-1)+"-01-01 00:00:00}";
}
if (nameValueCouple[0].equals("DC.Date.Submitted")){
nameValueCouple[1]=nameValueCouple[1].substring(0,
nameValueCouple[1].length()-1)+"-01 00:00:00}";
}
if (nameValueCouple[0].equals("VL.Date")){
String[] dateValue = nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1).split(" ");
nameValueCouple[1]="{"+buildMysqlTimestamp(dateValue)+"}";
}
if (((nameValueCouple[0].equals("DC.Description.Abstract.eng")) ||
(nameValueCouple[0].equals("DC.Description.Abstract")))==true){
nameValueCouple[1]=nameValueCouple[1].replace("'", "");
- 52 -
}
documentDetails.addElement(nameValueCouple);
}
else {
System.out.println("KEYWORDS ("+nameValueCouple[0]+"):");
Vector helpVec = new Vector();
//
String[]
keywords=nameValueCouple[1].substring(1,nameValueCouple[1].length()1).split("/");
for (int i=0; i<=keywords.length-1; i++) {
//
System.out.println(keywords[i].trim());
helpVec.addElement(keywords[i].trim());
}
//
System.out.println("=====END OF KEYWORDS=====");
if (nameValueCouple[0].equals("DC.Subject.Keywords.eng")){
documentKeywords_eng=helpVec;
}
else {
documentKeywords = helpVec;
}
}
}
insertVectorInDatabase(documentDetails, "diss_basic");
insertDocumentKeywordsIntoDB("diss_keywords", documentId,
documentKeywords, "deu");
insertDocumentKeywordsIntoDB("diss_keywords", documentId,
documentKeywords_eng, "eng");
}
catch (IOException e) {
e.printStackTrace();
}
}
public static void importWpFilesIntoDatabase (String dataFolder) {
try {
//
System.out.println("===============================================
======");
//
System.out.println("===============================================
======");
//
System.out.println("importWpFilesIntoDatabase");
File enterFile=new File(dataFolder+"/meta.dat");
FileReader enterStream = new FileReader(enterFile);
BufferedReader eInput = new BufferedReader(enterStream);
- 53 -
String streak;
Vector documentDetails = new Vector ();
Vector documentKeywords = new Vector ();
Vector documentKeywords_eng = new Vector ();
String documentId = null;
while ((streak = eInput.readLine()) != null) {
String[] nameValueCouple = streak.split(" := ");
if (((nameValueCouple[0].equals("DC.Subject.Keywords")) ||
(nameValueCouple[0].equals("DC.Subject.Keywords.eng")))==false) {
if (nameValueCouple[0].equals("ID")){
documentId=nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1);
}
//
System.out.println("Name: "+nameValueCouple[0]);
addColumnToColumnList(nameValueCouple[0], columns_wp);
//
System.out.println("Wert: "+nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1)+" ==> Laenge: "+nameValueCouple[1].substring(1,
nameValueCouple[1].length()-1).length());
if (nameValueCouple[0].equals("VL.Date")){
String[] dateValue =
nameValueCouple[1].substring(1,nameValueCouple[1].length()-1).split(" ");
nameValueCouple[1]=buildMysqlTimestamp(dateValue);
}
if (nameValueCouple[0].equals("DC.Date.Created")){
nameValueCouple[1]=nameValueCouple[1].substring(0,
nameValueCouple[1].length()-1)+"-01-01 00:00:00}";
}
if (((nameValueCouple[0].equals("DC.Description.Abstract.eng")) ||
(nameValueCouple[0].equals("DC.Description.Abstract")))==true){
nameValueCouple[1]=nameValueCouple[1].replace("'", "");
}
documentDetails.addElement(nameValueCouple);
}
else {
//
System.out.println("KEYWORDS ("+nameValueCouple[0]+"):");
Vector helpVec = new Vector();
String[]
keywords=nameValueCouple[1].substring(1,nameValueCouple[1].length()1).split("/");
for (int i=0; i<=keywords.length-1; i++) {
//
System.out.println(keywords[i].trim());
helpVec.addElement(keywords[i].trim());
}
//
System.out.println("=====END OF KEYWORDS=====");
if (nameValueCouple[0].equals("DC.Subject.Keywords.eng")){
documentKeywords_eng=helpVec;
- 54 -
}
else {
documentKeywords = helpVec;
}
}
}
showContent (documentDetails, true);
insertVectorInDatabase(documentDetails, "wp_basic");
insertDocumentKeywordsIntoDB("wp_keywords", documentId,
documentKeywords, "deu");
insertDocumentKeywordsIntoDB("wp_keywords", documentId,
documentKeywords_eng, "eng");
}
catch (IOException e) {
e.printStackTrace();
}
}
public static void addColumnToColumnList (String column, Vector columnList) {
if (columnList.contains(column)==false){
columnList.addElement(column);
}
}
public static void showContent (Vector vec, boolean containsArray){
for (int i=0; i<=vec.size()-1; i++) {
if (containsArray==true){
String[] array = ((String[])(vec.elementAt(i)));
for (int j=0; j<=array.length-1; j++){
System.out.println(array[j]);
}
}
else {
System.out.println((String) vec.elementAt(i));
}
}
System.out.println("======= Ende des Vektors ========\n\n\n");
}
public static void insertVectorInDatabase (Vector vec, String table) {
String columns = "";
String values = "'";
for (int i=0; i<=vec.size()-1;i++){
String[] nameValueCouple=((String[]) vec.get(i));
columns=columns+nameValueCouple[0]+", ";
if (nameValueCouple[0].trim().equals("ip")==true){
String[] help =
nameValueCouple[1].trim().substring(1,nameValueCouple[1].length()-1).split(" / ");
- 55 -
values=values+help[0].trim()+"', '";
} else
if (((nameValueCouple[0].trim().equals("date")) ||
(nameValueCouple[0].trim().equals("end"))) == true){
String[] dateValue =
nameValueCouple[1].substring(1,nameValueCouple[1].length()-1).split(" ");
String timestamp = buildMysqlTimestamp (dateValue);
values=values+timestamp+"', '";
}
else {
values=values+nameValueCouple[1].trim().substring(1,nameValueCouple[1].lengt
h()-1).replace("'", "")+"', '";
}
}
columns=columns.substring(0,columns.trim().length()-1);
values=values.substring(0,values.trim().length()-3);
String sqlStatement = "insert into "+table+" ("+columns.replace(".", "_")+")
values ("+values+")";
System.out.println("====> "+sqlStatement);
try {
Statement stmt = conn.createStatement ();
stmt.executeUpdate(sqlStatement);
System.out.println("\nErfassung erfolgreich.");
}
catch (Exception e) {
System.out.println("\nFehler bei Erfassung: " + sqlStatement + "\n\n" + e);
}
}
public static void insertQueryIntoDB (Vector vec_attr, Vector vec_keyw){
if (vec_attr!=null) {
for (int i=0; i<=vec_attr.size()-1; i++) {
String attr = ((String[]) vec_attr.get(i))[0];
String value = ((String[]) vec_attr.get(i))[1];
String query= "insert into logs_queries_attr values ('"+current_id+"',
'"+attr.toLowerCase().replace(".", "_")+"', '"+value.replace("\"", "").replace("'", "")+"')";
System.out.println(query);
try {
Statement stmt = conn.createStatement ();
stmt.executeUpdate(query);
System.out.println("\nErfassung erfolgreich.");
}
catch (Exception e) {
System.out.println("\nFehler bei Erfassung: " + query + "\n\n" + e);
- 56 -
}
}
}
if (vec_keyw!=null) {
for (int i=0; i<= vec_keyw.size()-1; i++) {
String keyword = ((String)vec_keyw.get(i)).replace("'", "");
String query="insert into logs_queries_keyw values ('"+current_id+"',
'"+keyword+"')";
System.out.println(query);
try {
Statement stmt = conn.createStatement ();
stmt.executeUpdate(query);
System.out.println("\nErfassung erfolgreich.");
}
catch (Exception e) {
System.out.println("\nFehler bei Erfassung: " + query + "\n\n" + e);
}
}
}
}
public static void insertDocumentKeywordsIntoDB (String table, String docID,
Vector vec, String lang) {
if (vec!=null){
for (int i=0; i<=vec.size()-1; i++) {
String keyword = ((String)vec.get(i)).replace("'", "");
String query="insert into "+table+" values ('"+docID+"', '"+keyword+"',
'"+lang+"')";
System.out.println(query);
try {
Statement stmt = conn.createStatement ();
stmt.executeUpdate(query);
System.out.println("\nErfassung erfolgreich.");
}
catch (Exception e) {
System.out.println("\nFehler bei Erfassung: " + query + "\n\n" + e);
}
}
}
}
public static void insertViewsIntoDB (Vector vec){
if (vec!=null) {
for (int i=0; i<= vec.size()-1; i++) {
String keyword = ((String)vec.get(i)).replace("'", "");
String query="insert into logs_views values ('"+current_id+"',
'"+keyword+"')";
- 57 -
System.out.println(query);
try {
Statement stmt = conn.createStatement ();
stmt.executeUpdate(query);
System.out.println("\nErfassung erfolgreich.");
}
catch (Exception e) {
System.out.println("\nFehler bei Erfassung: " + query + "\n\n" + e);
}
}
}
}
public static String buildMysqlTimestamp (String[] dates) {
String timestamp=null;
String[] months = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
"Oct", "Nov", "Dec"};
int i=0;
while (dates[1].trim().equals(months[i])==false){
i++;
}
String mm = ""+(i+1);
if (mm.length()==1){
mm="0"+mm;
}
String yyyy = dates[dates.length-1];
String dd = dates[dates.length-3];
if (dd.length()==1){
dd="0"+mm;
}
String time = dates[dates.length-2];
timestamp = yyyy+"-"+mm+"-"+dd+" "+time;
return timestamp;
}
}
- 58 -
13 Literatur
(Basi04)
Basis04 AG; Open Source Business Intelligence. Bern 2004.
(DaWa07)
Data
Warehouse
und
Data
Marts:
Erfolgskritische
Architekturkomponenten. http://bpm.iwi.unisg.ch/downloads/gi/kemper.pdf. 2007.
(GaJa05) Gajdzik Jakob; Data Mining. Methoden und Algorithmen. Zürich 2005.
(KoSt04) Kooths Stefan; Freie Software und Open Source. Definitionen, Pro und
Contra. Münster 2004.
(KöMa02)
Köster Mathais:
Business Intelligence und Data-Warehouse:
Datenfriedhof oder Schatztruhe. In: content mananger 10/2002.
(LuBe04) Luthiger, Benno: Alles aus Spaß? Zur Motivation von Open-Source
Entwicklern.2004.
(Moni05)
Monitor –
Intelligence. 10/2005.
Das
Magazin
für
Informationstechnologie.
Business
(PaKa06)
Karman Parsyae; OLAP and Data Mining: Bridging the Gap.
http://www.dbpd.com/vault/parsfeb.htm. 2006
(PlDa02) Ploch Danota et al.; Einführung in Open Source Software.
(PrTo06)
Priebe Torsten und Pernul Günther; Sicherheit in Data-Warehouse- und
OLAP-Systemen. Regensburg. 2005.
(RuJo03)
Rubin Jon: Die DB2 Architektur für Business Intelligence – Business
Intelligence-Lösungen. August 2003.
(RuJo07) Rupp Johannes; Trends in Business Intelligence und Data Warehouse.
2007
(RüWo05)
Rütter Wolfgang; Die ORACLE OLAP Option. Gummersbach. 2005.
(ScTo06)
2006.
Scheffer Tobias und Bickl Steffen; Text Mining und Web Mining. Berlin.
(WiCh06) Wieser Christian; Open Source Software. Mannheim 2006.
(WoUl03) Wollgandt Ulrike und Trefz Alexandra; Business Intelligence – Der
Prozess. Stuttgart 2003.
- 59 -