Departement für Informatik Erweiterung des fuzzy - DIUF

 Departement für Informatik Information Systems Research Group Erweiterung des fuzzy Klassifizierung Toolkits fCQL Verfasser: Philipp Hofer 05‐212‐568 Sandacherstrasse 10 3186 Düdingen [email protected] Referent: Prof. Dr. Andreas Meier Betreuer: Daniel Fasel Ort: Düdingen Datum: 14.07.2009 1. Inhaltsverzeichnis 1. Inhaltsverzeichnis ............................................................................................................................. I 1.1. Abbildungsverzeichnis: .............................................................................................................. III 1.2. Tabellenverzeichnis: .................................................................................................................. IV 1.3. Programmcodeverzeichnis: ....................................................................................................... IV 2. Kurzfassung ....................................................................................................................................... 1 3. Abstract ............................................................................................................................................. 1 3.1. Schlüsselworte ........................................................................................................................... 1 4. Einleitung .......................................................................................................................................... 2 4.1. Ausgangslage und Motivation der Arbeit ................................................................................. 2 5. Aufbau des fCQL‐Toolkit ................................................................................................................... 3 5.1. Java, jdk 1.5 und 1.6 .................................................................................................................. 3 5.2. Metrics ....................................................................................................................................... 3 5.3. UML‐Klassen‐Diagramm und Paketübersicht ........................................................................... 4 5.3.1. Paketübersicht ................................................................................................................................ 4 5.4. Struktur Relationen‐Datenbankschema .................................................................................... 5 5.5. Architektur‐Erweiterungen ....................................................................................................... 7 6. Problemstellung und wissenschaftliche Forschungsfragen ............................................................. 8 6.1. Benutzeransprüche, Gewünschte Erweiterungen .................................................................... 8 7. Vorgehensweise ................................................................................................................................ 9 7.1. Reihenfolge, Aspekte des Projektmanagements und Methoden ............................................. 9 7.2. Lösungsansätze, Lösungswahl ................................................................................................... 11 7.2.1. Konsole (1.‐4.) ............................................................................................................................... 12 7.2.2. SQL (5.‐7.) ....................................................................................................................................... 13 7.2.3. Metatabellen (8.‐9.) ........................................................................................................................ 13 7.2.4. fCQL‐Abfragen (10.‐11.) .................................................................................................................. 14 7.2.5. Membershipfunktionen (12.‐14.) ................................................................................................... 14 7.2.6. Plugin (15.‐16.) ............................................................................................................................... 15 8. Umsetzung, Realisierung .................................................................................................................. 16 8.1. Verwendete Lösungen .............................................................................................................. 16 8.1.1. Konsole (1.‐4.) ................................................................................................................................ 16 8.1.2. SQL (5.‐7.) ....................................................................................................................................... 20 8.1.3. Metatabellen (8.‐9.) ........................................................................................................................ 21 I 8.1.4. fCQL Abfragen (10.‐11.) .................................................................................................................. 23 8.1.5. Membershipfunktionen (12.‐14.) ................................................................................................... 27 8.1.6. Plugin (15.‐16.) ............................................................................................................................... 32 8.2. Endergebnis, Vergleich Version 1.05 und 1.10 ......................................................................... 34 8.3. Angetroffene Probleme ............................................................................................................. 34 8.3.1. Übersicht bei 230 Klassen und 1000 Methoden? ........................................................................... 35 8.3.2. Tab hinzufügen, Tab erneuern, Tab entfernen… ............................................................................ 36 8.3.3. Java Probleme: Wie bitte? „KeyTyped“ reagiert nicht auf Pfeiltasten? ......................................... 36 8.3.4. PostgreSQL, JDBC und MySQL ........................................................................................................ 37 8.3.5. fCQL‐Abfragen anpassen, GUI‐Abhängigkeit .................................................................................. 40 8.3.6. Abhängigkeit zwischen dem GUI und der Verbindung ................................................................... 40 8.3.7. Wenn Eclipse nicht will… ................................................................................................................ 40 9. Benutzeranleitung ............................................................................................................................ 41 9.1. fCQL‐Toolkit einrichten ............................................................................................................. 41 9.1.1. MySQL Installieren .......................................................................................................................... 41 9.1.2. PostgreSQL installieren ................................................................................................................... 42 9.1.3. Konfiguration für Linux (Ubuntu) ................................................................................................... 43 9.1.4. fCQL‐Toolkit Konfiguration ............................................................................................................. 44 9.2. Konsole‐Anleitung ..................................................................................................................... 45 9.2.1. GUI Oberfläche: .............................................................................................................................. 45 9.2.2. fCQL‐Toolkit‐Oberfläche (7.2 User Interface) ................................................................................. 45 9.2.3. Datenbankverbindung (7.2.1 Database Connection) ..................................................................... 46 9.2.4. SQL‐Abfragen (7.2.2 Data Analysis Panels) ..................................................................................... 47 9.2.5. Abfragen und Anzeigen von Fuzzy‐Klassifikationen (neu) .............................................................. 48 9.2.6. Erstellen einer Fuzzy‐Klassifikation (7.2.3 Fuzzy Classification Definition Wizard) ........................ 53 9.2.7. Fuzzy‐Klassifikationselemente löschen (neu) ................................................................................. 58 9.2.8. fCQL‐Abfragen (7.2.4 Fuzzy Querying Process) .............................................................................. 60 9.2.9. fCQL‐Resultate (7.2.5 Results Evaluation) ...................................................................................... 61 9.2.10. Metatabellen sichern und einlesen (neu) ...................................................................................... 61 9.2.11. Konsole‐Einstellungen (neu) ........................................................................................................... 63 9.2.12. Benutzen des fCQL‐Toolkits mit Kommandozeileninterpreter ...................................................... 64 9.2.13. Erstellen einer Batch‐Datei ............................................................................................................. 64 10. Zusammenfassung ............................................................................................................................ 66 II 11. Literaturverzeichnis: ......................................................................................................................... 68 11.1. Bücher ....................................................................................................................................... 68 11.2. Webseiten ................................................................................................................................. 68 11.3. Nach Themen ............................................................................................................................ 70 12. Anhang .............................................................................................................................................. 71 12.1. Befehlsübersicht ........................................................................................................................ 71 12.2. fcql_example mittels Konsole einfügen .................................................................................... 74 12.3. Befehle detailliert ..................................................................................................................... 76 12.4. cmd Befehle ............................................................................................................................... 77 12.5. Veränderte und neue Dateien ................................................................................................... 78 12.6. Bekannte Probleme mit dem fCQL‐Toolkit ............................................................................... 80 1.1. Abbildungsverzeichnis: Abbildung 1 Aufbau Bericht ..................................................................................................................... 2 Abbildung 2 fCQL‐Toolkit UML‐Klassen‐Diagramm ................................................................................. 4 Abbildung 3 fCQL‐Toolkit Paketübersicht ................................................................................................ 5 Abbildung 4 Übersicht Metatabellen ....................................................................................................... 6 Abbildung 5 fCQL‐Toolkit Aufbau ............................................................................................................ 7 Abbildung 6 Themen Übersicht ............................................................................................................... 11 Abbildung 7 Hauptfenster, MainFrame ................................................................................................... 12 Abbildung 8 Pakete und Klassen .............................................................................................................. 16 Abbildung 9 Konsolefenster ..................................................................................................................... 18 Abbildung 10 ............................................................................................................................................ 20 Abbildung 11 fCQL Abfragen .................................................................................................................... 24 Abbildung 12 ............................................................................................................................................ 25 Abbildung 13 fclaif ................................................................................................................................... 29 Abbildung 14 linter ................................................................................................................................... 29 Abbildung 15 confun ................................................................................................................................ 29 Abbildung 17 pg_dump Fehler ................................................................................................................. 38 Abbildung 19 MySQL Schema .................................................................................................................. 42 Abbildung 20 Verbindungseinsellungen .................................................................................................. 42 Abbildung 21 PostgreSQL ......................................................................................................................... 42 Abbildung 22 ............................................................................................................................................ 43 Abbildung 23 Konsole .............................................................................................................................. 45 Abbildung 24 SQL Abfrage ....................................................................................................................... 47 Abbildung 26 fclaif ................................................................................................................................... 49 Abbildung 25 busdat ................................................................................................................................ 48 Abbildung 27 linvar .................................................................................................................................. 49 Abbildung 28 ratatt .................................................................................................................................. 49 Abbildung 29 catatt .................................................................................................................................. 49 Abbildung 30 linter ................................................................................................................................... 49 III Abbildung 31 confun ................................................................................................................................ 50 Abbildung 32 stefun ................................................................................................................................. 50 Abbildung 33 concep................................................................................................................................ 50 Abbildung 34 conval ................................................................................................................................. 50 Abbildung 35 comatt ................................................................................................................................ 50 Abbildung 36 fclass .................................................................................................................................. 51 Abbildung 37 msihp delete Befehle ......................................................................................................... 59 Abbildung 38 fclaifd ................................................................................................................................. 59 Abbildung 39 linterd ................................................................................................................................ 60 Abbildung 40 linvard ................................................................................................................................ 60 Abbildung 41 concepd ............................................................................................................................. 60 Abbildung 42 set status ............................................................................................................................ 63 Abbildung 43 CMD Fenster ...................................................................................................................... 64 1.2. Tabellenverzeichnis: Tabelle 1 fCQL‐Toolkit Metrics ................................................................................................................. 4 Tabelle 3 Metatabellen Übersicht ........................................................................................................... 6 Tabelle 4 Metrics Version 1.05 und 1.10 ................................................................................................. 34 Tabelle 5 set connect ............................................................................................................................... 46 Tabelle 6 Show Funktionen ...................................................................................................................... 48 Tabelle 7 mship show Befehle ................................................................................................................. 52 Tabelle 8 Mship set‐Befehle .................................................................................................................... 53 Tabelle 9 fclaifs ........................................................................................................................................ 54 Tabelle 10 fclaifu ...................................................................................................................................... 54 Tabelle 11 linvars ..................................................................................................................................... 55 Tabelle 12 linters ...................................................................................................................................... 56 Tabelle 13 confuns ................................................................................................................................... 56 Tabelle 14 stefuns .................................................................................................................................... 57 Tabelle 15 fclasss ...................................................................................................................................... 57 Tabelle 16 conceps ................................................................................................................................... 58 Tabelle 17 mship delete ........................................................................................................................... 58 Tabelle 18 fCQL‐Abfragen ........................................................................................................................ 61 Tabelle 19 dump ...................................................................................................................................... 62 Tabelle 20 read ......................................................................................................................................... 62 Tabelle 21 create ...................................................................................................................................... 62 Tabelle 22 set ........................................................................................................................................... 63 Tabelle 23 Hilfsanzeige ............................................................................................................................ 63 1.3. Programmcodeverzeichnis: Programmcode 1 ConsoleInterface ......................................................................................................... 17 Programmcode 2 ConsoleController ....................................................................................................... 19 Programmcode 3 SqlDump ...................................................................................................................... 22 Programmcode 4 SqlReadinLines ............................................................................................................ 23 Programmcode 5 Metaschema ................................................................................................................ 23 Programmcode 6 ExecuteFcql ................................................................................................................. 25 IV Programmcode 7 WhereSubSubCondition .............................................................................................. 26 Programmcode 8 makeQuery .................................................................................................................. 27 Programmcode 9 MemberShipShow ....................................................................................................... 28 Programmcode 10 MemberShipSet ........................................................................................................ 31 Programmcode 11 MemberShipDelete ................................................................................................... 32 Programmcode 12 Tools .......................................................................................................................... 33 Programmcode 13 Fcql ............................................................................................................................ 33 Programmcode 14 Main() ........................................................................................................................ 34 Programmcode 15 config.dat .................................................................................................................. 44 Programmcode 16 Batch‐Datei ................................................................................................................ 65 V 2. Kurzfassung Diese Arbeit beschreibt, wie das aus 24‘616 Zeilen und 283 Klassen Java Code bestehende fCQL‐Toolkit 1.05 erweitert wurde. Die bisherige Version wurde zuvor in einer Doktorarbeit [Werro 2008] stark wei‐
terentwickelt. Sie ermöglicht das Auswerten von Daten in herkömmlichen Relationen MySQL und PostgreSQL Datenbanken mit der Sprache fCQL. In das Toolkit wurde eine Konsole eingebaut. In diese Konsole wurden neue und bereits im GUI beste‐
hende Funktionen integriert, welche SQL und fCQL Abfragen mit Resultatespeicherung ermöglichen. Das Erstellen von Fuzzy‐Klassifikationen mit zugehörigen Membershipfunktionen wurde ebenfalls voll‐
ständig in die Konsole eingebaut. Neu kann das Toolkit mit Parametern in einer Konsole aufgerufen werden. Die neu eingebauten Möglichkeiten erleichtern das Auswerten von Datenbanken im Vergleich zur vor‐
hergehenden Version wesentlich. Befehle können nun in Dateien abgespeichert und beliebig oft wie‐
derverwendet werden. Aufwändige Klicks durch zahlreiche Menus der grafischen Oberfläche sind nicht mehr von Nöten. Jederzeit kann eine Sicherung der Metatabellen angelegt und später wieder zurück‐
gespielt werden. Abgespeicherte Resultate können nun miteinander verglichen werden. 3. Abstract This work describes how the fCQL‐Toolkit 1.05 consisting of 283 classes containing 24‘616 code lines has been developed further and which problems occurred during this process. The version 1.05 was strongly developed in the master thesis of Werro [Werro 2008]. The fCQL Toolkit allows the user to query data of conventional MySQL and PostgreSQL databases with the language fCQL. A console was built into the toolkit. New and already in the GUI existing functions have been build into the console. One can now make SQL and fCQL queries and save the output in files. The developing of fuzzy classifications including the membership functions have also been build into the console. It’s now possible to use the toolkit within a terminal and readin arbitrary many parame‐
ters directly from a file. The new built‐in functions make it easier to evaluate database information. Commands can be stored into files and reused infinitly often. Stored results can be compared with each other. Effortful clicks trough numerous menus of the graphicall surface are no more of needs. Any time a backup of the metatables can be made and restored. 3.1. Schlüsselworte fCQL‐Toolkit 1.05/1.10, SQL, MySQL, PostgreSQL, fCQL, Fuzzy‐Klassifikation, Membershipfunktionen, Java, JDBC 1 4. Einleitung Beim schriftlichen Teil dieser Arbeit handelt es sich um einen Bericht. Dieser beschreibt den eigentlichen Hauptteil der Bachelorarbeit, das Erstellen des Programmcodes sowie den Pro‐
grammcode selber. Der Bericht ist in 4 Haupt‐
teile gegliedert. Übersicht, Hier und in „5. Aufbau des fCQL‐Toolkit“ wird Programm‐
zuerst eine Übersicht über die Voraussetzungen struktur
sowie die bestehende Programmstruktur, gege‐
ben. Problem‐
Danach werden die eigentliche Problemstellung stellung („6 Problemstellung und wissenschaftliche For‐
Lösungs‐
schungsfragen“) und die Vorgehensweise sowie ansätze
mögliche Lösungsansätze dafür beschrieben („7. Vorgehensweise“). Lösungs‐
Benutzer‐
Im dritten Teil („8. Umsetzung, Realisierung“) beschrei‐
anleitung
bung
folgt schliesslich die Beschreibung der imple‐
mentierten Lösungen mit Erklärungen an Pro‐
Abbildung 1 Aufbau Bericht grammcode Ausschnitten. Als letztes wird in Form einer Benutzeranleitung erklärt, wie die neuen Funktionen des Programms bedient und einge‐
setzt werden („9 Benutzeranleitung“). Dieser Aufbau ist in „Abbildung 1“ grafisch dargestellt. 4.1. Ausgangslage und Motivation der Arbeit Diese Arbeit erfolgt im Rahmen einer Bachelorarbeit im Studiengang Informatik. Die Basis bildet die Doktorarbeit „Fuzzy Classification of Online Customers“ von Nicolas Werro [Werro 2008]. Sie beschreibt die mathematischen Hauptkonzepte der Fuzzy Logik und zeigt an einem Beispiel aus dem Kundenbe‐
ziehungsmanagement eine Anwendungsmöglichkeit für eine Fuzzy‐Klassifizierung auf, die ohne weite‐
res auch in anderen Bereichen eingesetzt werden kann. Basis dafür ist eine relationale Datenbank (MYSQL oder PostgreSQL). Hauptinstrument ist ein in der Programmiersprache Java erstelltes Toolkit. Dank der angewendeten Konzeption mit Metadaten wird eine Fuzzy‐Auswertung ermöglicht, ohne die Originaldaten zu verän‐
dern. Die GUI Oberfläche bietet die Möglichkeit, eine eindimensionale oder zweidimensionale Daten‐
analyse durchzuführen. Über einen Wizard kann eine Fuzzy‐Klassifizerung mit definierbaren linguisti‐
schen Variablen, linguistischen Termen mit einer Kombination aus linearen und sigmoiden Member‐
ship‐Funktionen, sowie Fuzzy‐Klassen erstellt werden. Dieses Thema war auf der Homepage der „Information Systems Research Group“ [fCQL Project 2008] aus‐
geschrieben. Es ist daher davon auszugehen, dass die implementierten Erweiterungen für die zukünfti‐
ge Forschung gebraucht werden können. Das Ziel dieser Arbeit ist es, die Vorgehensweise zur Weiterentwicklung des fCQL‐Toolkits aufzuzeigen: Warum wurde das Tool um die vorgegebenen Benutzerwünsche erweitert und wie wurde dazu vorge‐
gangen? Auf die Konzeption, Relevanz und möglichen Anwendungsgebiete der Fuzzy‐Klassifizierung wird nur soweit, wie dies für das Verständnis, die Vorgehensweise und Erweiterungen notwendig ist, 2 eingegangen. Diese Themen werden ausführlich in den Kapiteln 3, 5 und 6 von Werros Dissertation [Werro 2008] behandelt. Um ein besseres Verständnis des fCQL‐Toolkits zu erlagen, ist ebenfall das Stu‐
dium der Masterarbeit von Nançoz [Nançoz 2004] sehr empfehlenswert. Um zu verstehen, wie das Tool eingesetzt werden kann, lohnt sich ein Blick in die Masterarbeit Zumstein [Zumstein 2007], in welcher ein mögliches Anwendungsfeld am Beispiel des „Customer Performance Measurement“, ausführlich analy‐
siert und bewertet wird. Vertiefende Information bieten Zadeh [Zadeh 1965], Zimmerman [Zimmer‐
mann. 2001], Schindler [Schindler 1998], und Silberschatz [Silberschatz 2005]. Diese Literatur beschreibt die grundlegenden Ideen und Konzepte der Fuzzy‐Klassifikation. 5. Aufbau des fCQL‐Toolkit 5.1. Java, jdk 1.5 und 1.6 Das fCQL‐Toolkit wurde in Java 5 implementiert, eine der führenden, wenn nicht die führende objekt‐
orientierte Programmiersprache. Dies ermöglicht eine relativ einfache Verbindung des Toolkits mit einem Relationalen Datenbank Management System, da RDBMS meistens mit einer passenden Java Database Connectivity (JDBC) Schnittstelle ausgeliefert werden. So ist der MySQL‐ sowie PostgreSQL‐
Connector in der Version 5.1.6 bzw. 8.3.604 in das Toolkit integriert. Das Programm wurde mit einem MySQL‐Server der Version 5.0.67 und dem PostgreSQL‐Server 8.3.7.1 getestet. Ein weiterer Vorteil von Java ist seine Betriebssystem‐Unabhängigkeit. Das Programm sollte also prob‐
lemlos auf Betriebssystemen, welche Java 5 und 6 unterstützen, funktionieren. 5.2. Metrics Damit man sich ein genaueres Bild von der eigentlichen Programmgrösse machen kann, beschreibt dieser Abschnitt in „Tabelle 1 fCQL‐Toolkit Metrics“ einige wichtige Metrics‐Angaben der Ausgangsver‐
sion „fCQL‐Toolkit 1.05“. Die hier aufgeführten Angaben wurden mit der Freeware SourceMonitor 2.5 [Campwood 2009] ermittelt. Es folgt eine knappe Erklärung der verschiedenen Begriffe. Detailliertere Erklärungen können im „Sour‐
ceMonitor Help“‐Menu unter „Explanation of Language Metrics“, „Java Metrics“ nachgelesen werden. fCQL‐Toolkit 1.05 Metrics Checkpoint: fCQL 1.05 Name des SourceMonitor Schemas Anzahl Dateien Files: 103 Anzahl physikalisch vorhandener Codezeilen Lines: 24‘616 In Java werden Anweisungen, mittels Semikolon „ ; “ getrennt. „If“, Statements 12‘745 „for“ und „while“ Schlaufen sowie beim Errorhandling verwendete (Anweisungen): % Branches: 9.9 % Calls: % Comments: Classes: Methods / Class: 8‘921 15 % 238 5.54 „try“, „catch“ und „finally“ zählen ebenfalls als Statements. Attri‐
bute wie z.B. „int Anzahl = 0“ werden ebenfalls mitgezählt. Dazu zählen „if”, „else”, „for”, „do”, „while”, „break”, „continue”, „switch”, “case und „default”. Sowie die exception Statements „try”, „catch and finally throw”. Alle Methoden Aufrufe in Anweisungen und Ausdrücken Prozentualer Anteil an Kommentar Codezeilen welche mit „/*“, „/**“ oder „//“ beginnen. Ohne Dateikopf Kommentar. Beschreibt die Anzahl vorhandener Klassen und Interfaces. Durchschnittliche Anzahl Methoden je Klasse 3 Avg. Statements per 7.49 Method: Max Complexity: 84 Beschreibt die durchschnittliche Anzahl Anweisungen pro Metho‐
de. Angenäherter Wert, welcher die komplexeste Methode beschreibt, nach [McConnell 1993]. Avg. Depth: Beschreibt anhand des Arithmetischen Mittels aller obigen Komplexitätswerte jeder Datei die durchschnittliche Komple‐
xität. 2.24 5.3. UML‐Klassen‐Diagramm und Paketübersicht Damit nicht nur ein ungefährer Eindruck gewonnen werden kann, aus wie vielen Codezeilen das Toolkit besteht, sondern auch wie die einzelnen Klassen zusammenhängen und miteinander interagieren, kann im UML‐Ordner ein mit NetBeans automatisch generiertes UML‐Klassendiagramm angeschaut werden. Die „Abbildung 2“ zeigt eine Übersicht dieses Diagramms. Darin sind die Pakete für die JDCB‐
Verbindung sowie die mathematischen Pakete „edu.rit“ nicht mit inbegriffen. Tabelle 1 fCQL‐Toolkit Metrics Abbildung 2 fCQL‐Toolkit UML‐Klassen‐Diagramm
5.3.1. Paketübersicht In einer vereinfachten Übersicht, welche alle Pakete (mit gelb hervorgehobener Main Funktion) zeigt, ergibt sich die Struktur in „Abbildung 3“. 4 Abbildung 3 fCQL‐Toolkit Paketübersicht
Die grünen Rechtecke stellen die unterschiedlichen Pakete des fCQL‐Toolkits dar. Das „src“‐Paket (Source) umfasst alle Pakete. In ihm befinden sich die beiden Hauptpakete „fcql“ und „edu.rit“. Die „edu.rit“‐Pakete enthalten fremde Programmdateien und dienen zum Berechnen und Darstellen der Fuzzy‐Funktionen. Sie wurden, wie dem Sourcecode zu entnehmen ist, durch Alan Kaminsky am „Ro‐
chester Institute ofTechnology“ erstellt. Im „fcql“‐Paket sind alle anderen Java‐Klassen und Java‐Pakete enthalten, welche zur Entwicklung des fCQL‐Toolkits erstellt wurden. Die Mainfunktion befindet sich in der Datei „Fcql.java“ in diesem Paket, dargestellt durch das gelbe Rechteck „Fcql“. „Fclass“ enthält wichtige konzeptionelle Elemente der Fuzzy‐Klassifizierung. Dabei enthält „functions“ die für eine Fuz‐
zy‐Klassifizierung benötigten Funktionen, denen die „edu.rit“‐Pakete als Grundlage dienen. In „que‐
ries“ schlussendlich befinden sich sämtliche Elemente zum Auswerten und Berechnen der Resultate. Das „db“‐Paket enthält abgesehen von den „JDBC“‐Paketen sämtliche Informationen, um die Mysql‐ und PostgreSQL‐Verbindung aufzubauen. Im „dbWrapper“ sind grundlegende Getter enthalten, um Parameter für einen Verbindungsaufbau zu erstellen. Das „util“‐Paket enthält grundlegende Funktio‐
nen, unter anderem für die grafische Darstellung (Swing), mathematische Berechnungen, Verbindung‐
sauf‐ und ‐abbau und Fehlermeldungen. Im „gui“‐Paket sind schlussendlich die meisten für die grafi‐
sche Oberfläche benötigten Klassen mit Haupt‐, Dialog‐ und Resultatefenster enthalten. 5.4. Struktur Relationen‐Datenbankschema Durch das fCQL‐Toolkit werden bestehende Daten in einem Relationen‐Datenbankschema erweitert. Die vorhandenen Daten werden durch zusätzliche Informationen in Form von Metatabellen in einen bestehenden Systemkatalog eingebunden. Diese sind in untenstehender „Tabelle 2“ und „Abbildung 4“ zu überblicken. 5 Tabellennamen: Tabelle enthält: fcql_example die ursprüngliche Datenbankwerte fcql_meta_fc Fuzzy Klassifikation mit Namen und Grundwerten (fclaif) fcql_meta_lv Linguistische Variablen (LinVar) fcql_meta_ra zusätzliche Werte eines numerischen rationalen LinVar. Attributes (ratAtt)
fcql_meta_ca zusätzliche Werte numerischer composed LinVar. Attribute (comAtt) fcql_meta_cat zusätzliche Werte eines categoric LinVar. Attributes (catAtt) fcql_meta_lt Linguistische Terme (LinTer)
fcql_meta_cf Funktionstyp (Linear, S‐Shaped) mit Funktionsbereich (conFun) fcql_meta_p Funktionswerte zu conFun, Start‐, End‐, sowie Inflexions‐ und Slopewerte fcql_meta_sf Treppenfunktion (steFun) zu entsprechender LinTer. des Typs catAtt fcql_meta_c Konzeptnamen der entsprechenden fclaif (conCep) fcql_meta_cv Konzeptwerte der entsprechenden (conVal) fcql_meta_fcl Fuzzy Klassen Namen und Beschrieb (fclass) fcql_meta_fcd Informationen zum Zusammenhang zwischen linTer und fclass Tabelle 2 Metatabellen Übersicht Abbildung 4 Übersicht Metatabellen 6 Die Metadaten‐Tabellen und die eigentlichen Business‐Daten (hier „fcql_example“) sind unabhängig voneinander. Dies hat den Vorteil, dass die ursprünglichen Daten unverändert bleiben und somit deren Konsistenz garantiert werden kann. Abbildung 5 fCQL‐Toolkit Aufbau In der bisherigen Version 1.05 musste der direkte Zugriff auf Datenbankwerte mit SQL‐Befehlen über ein vom fCQL‐Toolkit unabhängiges Programm wie den MySQLQueryBrowser, pgAdmin oder phpmy‐
admin erfolgen (1.a in „Abbildung 5“). Über das grafisches Userinterface können eine „Data Distribution Analysis“, eine „Data Space Analysis“ sowie mit der Hilfe eines Assistentenprogramms (Wizard) Fuzzy‐Klassifikationen erstellt und mittels fCQL‐Abfragen ausgewertet werden (2. und 3.). Diese Abfragen greifen auf die vorhandenen Business‐
Daten sowie Meta‐Tabellen zu und berechnen die entsprechenden Membership Grade der klassifizier‐
ten Elemente in den Fuzzy‐Klassen. 5.5. Architektur‐Erweiterungen Die neue Version 1.10 ergänzt das oben beschriebene Programm mit einigen zusätzlichen Interakti‐
onsmöglichkeiten (4.). Eine wichtige Neuerung ist die in das GUI integriere Kommandozeilen‐
Oberfläche. Sie ermöglicht die direkte Eingabe von SQL‐Befehlen (1b) und Befehlen zum Erstellen von Fuzzy‐Klassifikationen. Zudem können Resultate von SQL‐ und fCQL‐Abfragen in einer Datei abgespei‐
chert werden. (SQL‐, fCQL‐Resultate) Dies hat den wesentlichen Vorteil, dass Resultate nun einfacher miteinander verglichen werden können. Zudem ist es dank der neuen Schnittstelle möglich, Befehle direkt aus einer Batdatei zu übergeben und mehrmals auszuführen. So können zum Beispiel in einer Batdatei verschiedene fCQL‐Abfragen ausge‐
führt werden und danach mit den Resultatedateien verglichen werden. 7 Die Metatabellen können mittels Backup über die Konsole unabhängig von der Datenbank in einer hundertprozentig MySQL oder PostgresSQL standardisierten Sicherungsdatei gespeichert werden und jederzeit wieder eingelesen werden. Das Toolkit in der Version 1.10 wurde auf den Betriebsystemen Windows Xp Sp3, Ubuntu 8.04 sowie Windows 7, auf seine Funktionalität überprüft. Für letzteres konnte PostgreSQL nicht verwendet wer‐
den, da bisher keine Version existiert, die vollständig funktioniert [Postg Win7 2009]. Zum Testen wurde jeweils die neuste Version von Java 1.5 verwendet. Unter Win Xp und Windows7 wurde auch mit der neusten Java Version 6 Update 14 [Java 6.14 2009] getestet. Das Programm sollte aber auch auf anderen Plattformen problemlos funktionieren. Die folgenden Abschnitte zeigen auf, welche Lösungen für die oben aufgeführten Neuerungen in Be‐
tracht gezogen wurden, wie sie realisiert wurden, welche Forschungsfragen sich dabei stellten und zu letzt welche Probleme dabei angetroffen wurden. 6. Problemstellung und wissenschaftliche Forschungsfragen In den letzen Jahrzehnten haben sich Informationssysteme und die Methoden, wie Daten verarbeitet und gespeichert werden können, enorm weiterentwickelt. Dadurch ist jedoch die Schwierigkeit ent‐
standen, riesige Datenvolumen adäquat auszuwerten und daraus entsprechende Managementent‐
scheidungen zu treffen. Die heutigen Informationssysteme basieren auf der binären Logik und beste‐
hen grösstenteils aus Relationalen Datenbankmodellen mit scharfen Abfrage‐ und Ausgabewerten. Dies widerspiegelt jedoch kaum die menschliche Denkweise. Wie an unscharfen Ausdrücken unserer Sprache einfach zu erkennen ist, spielen indiskrete Übergänge und verschwommene Überschnei‐
dungsbereiche eine wichtige Rolle. Die grundlegende Problemstellung, welche hier behandelt wird, ist das Auswerten von Datenbankin‐
formationen mittels der Fuzzy‐Logik‐Theorie. Der Fuzzy‐Klassifizierungsansatz bietet eine Möglichkeit von der dichotomen Einteilung wegzukommen und Datensätze realitätsnaher auszuwerten. Durch das Erstellen von Fuzzy‐Klassen und die Zuhilfenahme von linguistischen Termen und linguistischen Variab‐
len entsteht ein detaillierteres, flexibleres und verständliches Abfragesystem. In der vorliegenden Ar‐
beit soll das fCQL‐Toolkit, welches auf dieser Theorie basiert, um untenstehende Bereiche erweitert werden. 6.1. Benutzeransprüche, Gewünschte Erweiterungen Die gewünschten Veränderungen wurden in der Projektausschreibung [fCQL Project 2008] wie folgt be‐
schrieben: „The fCQL Toolkit is a framework that provides the possibility to analyze in a fuzzy manner the data in a Relational Database Management System (see Fuzzy Classification). The application is Java based. In the moment it provides a GUI to the user, where he/she can construct the fuzzy concepts per different dialog boxes. In order to be able to use the fCQL Toolkit as plugin to other applications, we indend to extend it. The following minimum extensions should be included: A console in the GUI of the fCQL Toolkit Save into and read out the Meta Tables of the fCQL Toolkit Data Manipulation (read in/out files, writing pure SQL / fCQL statements in the console) Free definition of the membership functions in the console An interface to interconnect the fCQL toolkit with other application.” 8 Zusammengefasst bedeutet dies, dass folgende Veränderungen in den jeweiligen Bereichen gefordert wurden: Grafische Oberfläche: GUI‐Konsole Daten Manipulation: SQL‐Befehle, fCQL‐Befehle, Fuzzy‐Klassifikationen (Membershipfunktionen) Datenspeicherung: Resultaten‐Speicherung für SQL‐ und fCQL‐Abfragen Sicherung: Metatabellen, einlesen und abspeichern Schnittstelle: Verbindung zwischen dem fCQL‐Toolkit und anderen Anwendungen ermöglichen Dokumentation: Beschreiben der implementierten Funktionen und vor allem der Klassen Ein weiteres persönliches Ziel ist zudem das Erstellen einer möglichst vollständigen Dokumentation, zumindest des von mir abgeänderten benutzten oder neu erstellten Programmcodes. Eine vollständige Übersicht mit allen veränderten oder neu erstellten Javaklassen bietet „12.5 Veränderte und neue Da‐
teien“ im Anhang. Die geplanten Ergänzungen des bestehenden Toolkits werfen verschiedene Forschungsfragen auf: Zum einen sind dies Projektmanagementfragen, wie vorzugehen sei, um diese Ergänzungen möglichst optimal zu implementieren, zum anderen programmiertechnische Aspekte zu den fünf verschiedenen Erweiterungen: Wie wird eine Konsole in den bestehenden Programmcode integriert und erstellt? Welche SQL‐ und fCQL‐Befehle werden benötigt, wie werden sie in der Konsole eingegeben? Reicht ein vorhandener SQL‐Interpreter aus, wie soll der fCQL‐Interpreter aufgebaut sein? Wie sieht die Syntax, die Struktur der Befehle aus? Welche Funktionalität kann direkt übernommen werden, was muss neu implementiert werden? Welche Form haben die Input‐ und Outputdateien? Wie werden Membership‐Degrees beschrieben und integriert? Auf welche Art werden beliebige Membershipfunktionen in die Konsole eingegeben? Wie wird die Kohärenz der Daten garantiert? Wie werden bereits im GUI bestehende Probleme und Bugs bezüglich der Editierung von Fuzzy‐
Klassifikationen in der Konsole möglichst Vermieden? Wie wird der Zugriff auf die Metatabellen ermöglicht und wie werden neue Werte erstellt? In welcher Form werden die Metatabellen gelesen, angezeigt und geschrieben? Wie wird der Zugriff mit anderen Programmen auf das fCQL‐Toolkit ermöglicht? Welche Funktionen sollten dabei zur Verfügung stehen? 7. Vorgehensweise 7.1. Reihenfolge, Aspekte des Projektmanagements und Methoden Die Konzeption und das Vorgehen zum Lösen der oben beschriebenen Ziele und Erweiterungen folgt abgesehen von den in „Hinweise für Seminar‐, Bachelor‐ und Masterarbeiten“ [wiss. Arbeit. 2009] gege‐
benen Richtlinien keinen für dieses Projekt spezifischen Vorgaben. Da es sich hierbei um ein Einperso‐
9 nen‐Projekt handelt, musste es nicht in verschiedene Arbeitsteile unterteilt werden. Die Implementa‐
tionsreihenfolge der verschiedenen Erweiterungen wurde daher einzig von den verschiedenen Abhän‐
gigkeiten und Zusammenhängen untereinander vorgegeben. Es war naheliegend, mit der grafischen Konsolenoberfläche zu beginnen (1.‐4. „Abbildung 6“). Auf der Konsole bauen nämlich alle anderen Erweiterungen auf. Sämtliche neuen Befehle werden über dieses Interface eingegeben. Besonders praktisch war dabei, dass die darauf folgenden Erweiterungen sofort getestet werden konnten. So konnte sofort festgestellt werden, wie ein neuer Befehl eingegeben wer‐
den muss. Wenn schon nach wenigen Werteeingaben der Überblick verloren ging, welcher Wert wofür steht, fiel dies sofort auf und konnte angepasst werden. So entstand zum Beispiel die Idee für den Kon‐
solenverlauf. Als nächstes wurde der SQL‐Interpreter integriert (5.‐7.), da die SQL‐Sprache sowohl für die Metatabel‐
len wie für die fCQL‐Sprache und die Membershipfunktionen die Grundlage bildet. Die Metatabellen wurden als dritte Erweiterung implementiert (8.‐9.). Es erschien als praktisch, die Sicherungs‐ und Backupfunktion vor den eigentlichen Erweiterungen, den Membershipfunktionen, zu implementieren. So konnten diese später gleichzeitig mit der eigentlichen Arbeit ausführlich getestet werden. Zudem hatte man den grossen Vorteil, dass jederzeit ein Abbild des aktuellen Datenbankzu‐
standes gemacht werden konnte. Neu implementierte Funktionen konnten danach problemlos aus‐
probiert und mit einem Backup wieder rückgängig gemacht werden. Dies war besonders praktisch, da das Toolkit bisher keine einfach bedienbare und immer funktionierende Löschfunktion besass. Die Implementation der Löschfunktion in der Konsole erleichterte aber auch das Verständnis für die Mem‐
bershipfunktionen. Durch fleissiges Ausprobieren konnte besser verstanden werden, wie die einzelnen Elemente zusammenhängen und abgespeichert werden. Damit wurde auch klarer, welche Elemente der Metatabellen wann entfernt werden durften oder unverzichtbar waren. Anschliessend wurden die beiden Teile implementiert, welche direkt im Zusammenhang mit der Fuzzy‐
Logik stehen: die fCQL‐Sprache (10.‐11.) und die Membershipfunktionen (12.‐14.). Als letzte Erweiterung erfolgte schlussendlich die Veränderung der Hauptklasse und der darin enthal‐
tenen Mainfunktion, so dass die Befehle direkt über Kommandozeilen an das Tool weitergegeben wer‐
den können (15., 16.). Anschliessend wurden mehrere Unregelmässigkeiten, welche durch das Zusammenspiel der neuen Erweiterungen neu auftauchten, korrigiert. So mussten zahlreiche Fehlermeldungen auf eine andere Art ausgegeben werden, damit diese auch in einem Terminal angezeigt werden. Zudem waren die gra‐
fischen Teile des Programms und die restlichen Funktionen, insbesondere die Datenbankverbindung miteinander verbunden. Dieses Problem konnte erst nach längerem Verschieben und Umschreiben von Funktionen korrigiert werden(17., 18.). Nach diesen Schritten wurde der Grossteil dieses Berichtes erstellt (19.). Danach wurde die eigentliche Programmcode‐Kommentierung vervollständigt (20.). Schlussendlich erfolgte im verbleibenden Zeitraum eine Testphase, in welcher möglichst viele Fehler, natürlich längst nicht alle, im Programm entdeckt und korrigiert werden sollten (21.‐22.). Zu guter letzt wurde eine Benutzeranleitung in diesen Bericht integriert, welche Anleitungen zur Instal‐
lation der Datenbanken unter Linux (Ubuntu) und Windows (XP) enthält und alle neuen Funktionen beschreibt (23.). 10 7.2. Lösungsansätze, Lösungswahl Konsole
SQL
• 1. Konsolen Oberfläche
• 2. Konsolen Integration
• 3. Konsolen Funktionen, Befehle
• 4. Fehlermeldungen integrieren
• 5. SQL‐, JCDB‐Verbindung
• 6. SQL‐Integration in die Konsole
• 7. Interpreter und Dateiausgabe (SQLresults.txt)
Meta Tabellen
• 8. Mysql‐Sichernung und Backup der Metatablellen
• 9. Postgresql‐Sichernung und Backup der Tabellen
fCQL Abfragen
• 10. Integration von fCQL‐Abfragen in die Konsole
• 11. Erstellen der fCQL‐Resultateausgabe FCQLresults.html
Membership
Plugin
Korrekturen
Bericht
• 12. Eingabe von Fuzzy‐Klassifizierungsdaten
• 13. Löschen von Fuzzy‐Daten
• 14. Editieren von Fuzzy‐Klassifizierungsdaten • 15. Befehlsübergabe in cmd‐Fenster
• 16. Ausführen von Befehlen in Batdatei
• 17. Funktionen und Meldungen konsolenkonformer machen
• 18. Graphische Oberfläche von funktionallem Teil möglichst trennen
•19. Erstellen und Schreiben des Berichts
•23. Erstellen einer Benutzeranleitung
• 20. Vervollständigen der Dokumentation
Dokummentation
Fehlerbehbung
• 21. Dürchführen von Tests, Anwendungsversbesserung
• 22. Fertigstellen des Berichts
Abbildung 6 Themen Übersicht Bei der Implementierung der verschiedenen Erweiterungen wurde also versucht, möglichst logisch und systematisch vorzugehen. Es folgt nun ein Beschrieb der jeweiligen Lösungsansätze zu den in „Abbildung 6“ unter 1.‐16. aufgeführten Themen. 11 7.2.1. Konsole (1.‐4.) Ein Grundsatz der Programmiersprache Java ist es, möglichst plattformunabhängige Softwareentwick‐
lung zu ermöglichen. Deshalb muss die Sprache eine eigene Bibliothek zur Gestaltung von grafischen Oberflächen beinhalten. In Java heisst das dafür am besten geeignete Paket „javax.swing“. Ein guter Überblick, welche gestalterischen Möglichkeiten dieses Paket bietet, erhält man im Java‐
Installationsordner „jdk“ unter „demo\jfc“ (z.B. C:\Programme\Java\jdk1.6.0\demo\jfc). Noch um eini‐
ges Interessanter ist die Browserdemo von Sun [Java Swing 2009], vorausgesetzt man benutzt mindestens Java 6 Update 10 im Browser. Eine andere Möglichkeit, grafische Oberflächen zu gestallten, bietet das „java.awt“‐Paket. Dieses bietet aber nur sehr eingeschränkte Möglichkeiten und ist sehr einfach gehal‐
ten. Professionelle und moderne Oberflächen lassen sich damit kaum erstellen. (Statt „Abstract Win‐
dow Toolkit“ wird es deswegen häufig auch „Awful Window Toolkit“ oder ähnlich genannt.) Tabs
ResultDisplay Mainframe Abbildung 7 Hauptfenster, MainFrame
Da die Version 1.05 des Toolkits, wie weiter oben beschrieben, bereits eine grafische Oberfläche be‐
sitzt, waren die eigentliche Grundstruktur, die Auswahl des Hauptpakets sowie die grundlegenden Elemente vorgegeben. Auf die Codestruktur wird im Teil 8.1.1 Konsole (1.‐4.) genauer eingegangen. Wie „Abbildung 7“ zeigt, besteht das Toolkit aus drei Hauptelementen, nämlich aus den verschiedenen Tabs, welche jeweils ein ResultDisplay (Panel) beinhalten, und darüber im Mainframe einer Iconbar und einem Menu. Die grundlegende Herausforderung war es, herauszufinden, ob die Konsole in die bestehende Oberflä‐
che eingegliedert oder doch besser und auf einfacher Weise in einem eigenen Fenster angezeigt wer‐
den sollte. Wie sich später herausstellte, waren der bisherige Code und sämtliche Funktionen, welche auch nur im Entferntesten mit einem der Tabs zu tun haben, auf maximal 3 Tabs ausgelegt. Dadurch 12 wurde dies ein ziemlich langwieriger Prozess. Ein weiterer Knackpunkt war die eigentliche Gestaltung der Konsole selber: Welche Art von Swing‐Element benutzt man am besten für eine Konsole und wie wird das Ausgabefeld und vor allem das Eingabefeld erstellt? Zudem beschäftigen sich die meisten PC Benutzer unter Windows kaum je mit Kommandozeilen. Folglich hat dieses Thema nur eine sehr einge‐
schränkte Zielgruppe und ist nicht besonders attraktiv, um mehr darüber zu schreiben. Entsprechend wenig Information, welche in dieser Richtung weiterhelfen würden, findet man in sehr ausführlichen Bücher über Java [Ullenboom 2009] oder auch im Internet. Die Java‐Hompage [Javaworld 2001] allerdings beschreibt sehr ausführlich eine eigenständige Konsole mit Kommandozeileeingabe. Die dortigen Er‐
klärungen und diese Grundstruktur bilden hier die Basis, was die Konsolenoberfläche betrifft. Für die Integration der Konsole in das Programm erschien ein eigenständiges Frame im fCQL‐Toolkit ziemlich unpraktisch. Wenn irgend möglich, sollte also die Konsole als eigenständiger Tab integriert werden. Dies hatte zur Folge, dass von der oben erwähnten Vorlage einzig die Anordnung und die Swing‐Elemente Kommandozeilenausgabe und Kommandozeile („JTextArea“, „JTextField“) übernom‐
men werden konnten. Wie genau schlussendlich die Konsole erstellt wurde, kann in 8.1.1 Konsole (1.‐
4.) nachgelesen werden. Auch welche zusätzlichen Einstellungen an der Konsole vorgenommen wer‐
den können und mit welchen weiteren Funktionalitäten sie ergänzt wurde, wird dort erklärt. 7.2.2. SQL (5.‐7.) Die Möglichkeit, SQL‐Abfragen direkt über die Konsole, also das fCQL‐Toolkit, zu ermöglichen, war rela‐
tiv rasch gefunden. Dazu musste nur die entsprechende JDBC‐Verbindung zur MySQL‐ respektive PostgreSQL‐Datenbank aufgebaut werden und die entsprechenden Befehle von der Kommandozeile korrekt an einen SQL‐Interpreter weitergegeben werden. Beim Anzeigen der Abfrageresultate stellte sich jedoch das Problem, dass es unpraktisch ist, die eventuell grossen Resultatetabellen im selben Fenster wie die restlichen Ausgabewerte der Konsole anzuzeigen. Deshalb wird ein mehrzeiliger Rück‐
gabewert im Gegensatz zu leeren einzeiligen Meldung, nicht im Panel der eigentlichen Konsole ange‐
zeigt, sondern in einem zusätzlichen in die Konsole integrierten Fenster. Die Formatierung der Rückga‐
bewerte wurde aus dem Interpreter von Java2s [Java2s 2000] übernommen und entsprechend ange‐
passt. Zudem wurde direkt in diese Klasse eine Dateispeicherung eingebaut, um die Abfrageresultate in einer Textdatei zu sichern. So kann jederzeit auf das Resultat einer Abfrage zugegriffen werden. Eine andere Möglichkeit wäre gewesen, die Abfrageresultate in mehreren Tabs anzeigen zu können. Da jedoch das Ziel war, einen vom GUI unabhängigen Vergleich zu ermöglichen, erschien das Abspeichern der Daten in einer Datei der bessere Weg. Im Gegensatz zur fCQL‐Resultateausgabe (fCQL Abfragen (10.‐11.)) wurde hier einfachheits‐ und übersichtshalber auf das HTML‐Format verzichtet. 7.2.3. Metatabellen (8.‐9.) Die Metatabellen sind, wie in „Abbildung 4“ ersichtlich, dreizehn SQL‐Tabellen. Das Ziel war es nun, diese Tabellen mit den darin enthalten Daten absichern und später wieder einzuspielen zu können. Grundsätzlich erschienen zwei relativ unterschiedliche Möglichkeiten naheliegend, um dieses Ziel zu erreichen. Die eine Version wäre, die jeweiligen Daten jeder Tabelle einzeln mit Java über die JDBC abzufragen und mit einer entsprechenden Formatierung der Daten und einem FileWriter direkt in Java zu schreiben. Später könnten die Daten dann auch wieder durch einen InputStreamReader auf ähnli‐
che Weise eingelesen werden. Dabei müsste nur für den Verbindungsaufbau zwischen MySQL und PostgreSQL unterschieden werden. Die zweite Version hat einen ganz anderen Ansatz und baut anhand der durch die Datenbanksoftware zur Verfügung gestellten Sicherungsprogramme eine indirekte Verbindung zwischen der Javaoberflä‐
13 che und der Datenbank auf. Durch das Ausführen von „mysqldump“ bei MySQL und „pg_dump“ im Falle einer PostgreSQL‐Datenbank wäre garantiert, dass die Sicherungsdatei so genau wie nur möglich der jeweiligen Sprachsyntax entspricht. Bei Betriebssystemen mit restriktiven Benutzerrechten, insbe‐
sondere bei WinXp mit unausgereiftem Benutzerrechtemanagement, hat diese Version jedoch den Nachteil, dass nicht nur die eigentliche Verbindung hergestellt und konfiguriert werden muss, sondern dass zusätzlich die nötigen Zugriffsrechte für das „dump“‐Programm sichergestellt werden müssen. Vor allem „pg_dump“ erschien diesbezüglich nicht gerade einfach und benutzerfreundlich ansprechbar zu sein. Schlussendlich wurde ein Kompromiss zwischen beiden Ansätzen gewählt, nämlich ein Abspei‐
chern über die oben erwähnten Sicherungsprogramme, das Einlesen der Sicherungsdateien jedoch unabhängig von diesen direkt über das fCQL‐Toolkit. Damit wird garantiert, dass die Sicherungsdateien korrekt gespeichert werden und dem Datenbankanwender in einer bekannten und leserlichen Form vorliegen. Beim Einlesen kann im Fall von MySQL gut auf das zusätzliche Programm und die damit ver‐
bundenen Komplikationen verzichtet werden, um die Veränderungen direkt über die JDBC und das Toolkit vorzunehmen. Leider stellte sich später heraus, dass diese Umsetzung mit PostgreSQL nicht korrekt funktionierte und die zugehörige JDBC total überforderte (8.3.4 PostgreSQL, JDBC und MySQL). 7.2.4. fCQL‐Abfragen (10.‐11.) Nachdem im GUI eine Fuzzy‐Klassifizierung erstellt wurde, kann diese geöffnet werden. Danach ist es möglich, im „Fuzzy Classification Query Panel“ mittels fCQL‐Sprache, welche von Werro ausführlich beschrieben wird [Werro 2008], Abfragen durchzuführen. Diese sollten nun neu auch durch die Eingabe in die Kommandozeile ermöglicht werden. Um diese Anforderung umzusetzen, kamen zwei verschiedene Ansätze in Frage. Zum einen könnten möglichst die bereits vom GUI benötigten Funktionen benützt werden. Sie müssen dazu so abgeändert werden, dass sie auch für die Konsole benutzbar werden. Zum anderen könnte eine eigene unabhängi‐
ge Implementierung erstellt werden, welche eine effizientere Abfrage ermöglicht. Dies würde eine bessere Anpassung an fCQL‐Eingaben in Form von Strings ermöglichen. Vor allem fällt dabei die Einga‐
bekontrolle ins Gewicht, welche nun, da der Benutzer eine beliebige Zeichenreihenfolge eingeben kann, wesentlich aufwendiger ausfallen muss. Abfragen mit falschen oder sinnlosen Abfragewerten, zum Beispiel mit Werten, welche gar nicht in der Datenbank existieren, oder mit Abfragen, welche sich gegenseitig widersprechen, müssen erkannt und angezeigt werden. Bei der GUI Eingabe besteht dieses Problem nicht, da man hier dem Benutzer nur die gültigen Werte in einer „JComboBox“ zur Auswahl anzeigen kann. Natürlich wäre es möglich, eine solche Auswahl auch in der Kommandozeile vor‐
zugeben. Dies wäre jedoch sehr aufwendig zu implementieren und vor allem für die später ergänzte Parameterübergabe schwer umsetzbar. Einen Mittelweg zu suchen, schien darum in diesem Teil den besten Erfolg zu versprechen. So sind ei‐
nige grundlegende Teile aus der „fclass.queries“‐Klasse mit kleinen Veränderungen oder neuen Funkti‐
onen benützt worden, so dass sie auch ohne GUI ihre Resultate ohne Fehlermeldung zurückgeben. Zudem erschien das bestehende Abfragesystem ziemlich kompliziert aufgebaut und die spärliche, und teilweise sogar fehlende Kommentierung erschwerte die Wiederverwendung und das Verständnis stark. Deswegen sind einige Funktionen komplett neu implementiert worden. Welche Aufgabe diese haben und wie sie implementiert wurden, kann im 8.1.4 fCQL Abfragen (10.‐11.) nachgelesen werden. 7.2.5. Membershipfunktionen (12.‐14.) Die Membershipfunktionen erwiesen sich als die langwierigste Erweiterung des Programms. Die Imp‐
lementierung einer Fuzzy Klassifikation basiert auf den bereits erwähnten 13 SQL‐Metatabellen. Die 14 ungefähr 40 unterschiedlichen Tabellenspalten müssen ähnlich wie bei den fCQL‐Abfragen überprüft werden. In diesem Fall ist ihre korrekte Form noch wichtiger, da es sich dabei nicht nur um Abfragen handelt, sondern auch um in der Datenbank verbleibende Einträge. Wenn man diese Einträge über das grafische Interface erstellt und daran verschiedene Editier‐ und Löschmöglichkeiten ausprobiert, stellt man rasch fest, dass dies häufig die gesamte Fuzzy Klassifikation durcheinanderbringen kann und das Laden nur noch mit einer Fehlermeldung abbricht, oder, schlim‐
mer noch, ohne sich bemerkbar zu machen abstürzt. Eine Übersicht zu einigen solchen Fehlern gibt „12.6 Bekannte Probleme mit dem fCQL‐Toolkit“. Zum Beispiel geschieht dies, sobald man eine Fuzzy Klasse (fCQL example) editiert und mit dem Klicken auf das letzte Fenster neu abspeichert. Dann werden alle Einträge in der Datenbank verdoppelt. Man hat also nach jedem Editieren statt einer geänderten Fuzzy Klassifikation eine neue mit geänderten Einträgen, plus die alte unveränderte. Solange das Toolkit geöffnet bleibt, führt dies, abgesehen von einem rasch wachsenden Datenmüll, auf welchen mit dem Toolkit nicht mehr zugegriffen werden kann, zu keinem Fehler. Wird jedoch das Toolkit neu gestartet, müssen die Datenbankwerte neu in Javaobjekte geladen werden. Aus diesen Gründen wurde bei den Membershipfunktionen komplett auf die bestehenden Funktionen verzichtet. Die Konsoleoberfläche hat nun ihre eigenen, unabhängigen Funktionen und schreibt alle Einträge jedes einzelnen Elements sofort in die Datenbank. Im Gegensatz dazu wird beim grafischen Interface nur am Ende alles auf einmal abgespeichert. Dabei scheint es auch zum oben beschriebenen Fehler der Fuzzy Klassifikation Duplizierung zu kommen. Die Konsoleversion ist zwar etwas weniger effizient, da jede Funktion einzeln eine Verbindung aufbaut und wieder schliesst, ermöglicht aber eine bessere Kontrolle darüber, was wann genau passiert. Auf diese Weise kann auch sichergestellt werden, dass eine Fuzzy‐Klassifizierung wieder entfernt wer‐
den kann. So muss man nicht wie bisher passende SQL‐Befehle finden oder mit „phpmyadmin“ oder „pg_admin“ alle überflüssigen Einträge einzeln über die jeweiligen ID’s aufspüren und löschen. Diese Probleme bestehen im bisherigen Teil mit MySQL nicht nur beim Editieren: auch wenn man eine Fuzzy‐
Klassifizierung löschen will, wird nur der Fuzzy Klassifikation Haupteintrag gelöscht. Alle anderen Ein‐
träge bleiben bestehen und können über das Toolkit nicht mehr erreicht werden, da es nicht möglich ist, nur einen neuen Haupteintrag zu erstellen. Ein Nachteil durch die neuen Funktionen ist natürlich, dass sie weitere neue Fehler enthalten können und bisher bewährte Teile im bestehenden Aufbau un‐
genutzt bleiben. Wie dieser Ansatz umgesetzt wurde, ist genauer im Abschnitt 8.1.5 (Membershipfunktionen (12.‐14.)) beschrieben. 7.2.6. Plugin (15.‐16.) Als letzte Erweiterung erfolgte schlussendlich die Implementation einer Parameterübergabe. Diese wurde nach dem Vorschlag des Assistenten implementiert. Beim Start eines Java‐Programms, in die‐
sem Fall bei der Ausführung der „fCQL1.10.jar“‐Datei, können Parameter an die Main‐Funktion über‐
geben werden. Diese können dann im weiteren Programmcode als normale Parameter genutzt wer‐
den. Eine andere relativ einfache Art, welche die Parameterübergabe aus einem Terminal an die Java‐
Applikation ermöglicht, konnte ich nicht ausfindig machen. Welche Möglichkeiten alle diese Erweiterungen bieten, kann im Abschnitt 9.2 (Konsole‐Anleitung) nachgelesen werden. 15 8. Umsetzung, Realisierung 8.1. Verwendete Lösungen In diesem Abschnitt werden die einzelnen Bereiche 1.‐16. genauer beschrieben. Es wird aufgezeigt, welche Schritte notwendig waren, um sie umzusetzen. Zur Realisierung wurden folgende Themenge‐
biete, Konzepte und Programmiersprachen benutzt: Einige wenige Projektmanagement‐Aspekte aus Descloux [Descloux 2008], dann Relationale Datenbanken, Data Mining, Objektorientierte Programmie‐
rung, SQL, fCQL, Java 5 und 6, Java Swing, UML, JDBC, SQL, MySQL, PostgreSQL, Batch‐Befehle, CSS und HTML. Sämtliche Klassennamen, welche zur Lösung des jeweiligen Bereichs neu erstellt wurden, werden je‐
weils erwähnt. Die Zahl in Klammern nennt deren ungefähre Codezeilenanzahl. Die Codeausschnitte zeigen einige wichtige Teile der entsprechenden Klasse. Sie wurden auf das Nötigste gekürzt. Fehlende Codezeilen sind an der Zeilennumerierung zu erkennen. Die „Abbildung 8“ bietet einen Überblick über die wichtigsten dieser Klassen. Der hervorragende Converter „Highlight Code Converter“ [HCodCon. 2009] erlaubt nicht nur das Drucken der Zeilennummerierung, sondern kann diese auch beim Kopieren bzw. bei einer Ausgabe mit Format‐
übernahme aus Eclipse angeben. So konnten einfach unwichtige Zeilen herausgelöscht werden, ohne dass sich die Zeilennummerierung vom originalen SourceCode unterscheidet. Andere Editoren wie UltraEdit, Eclipse, Scite, Notepad++, Emacs oder Linux‐Editoren scheitern an dieser Aufgabe, oder zu‐
mindest ist eine solche Möglichkeit nicht auffindbar. Abbildung 8 Pakete und Klassen
8.1.1. Konsole (1.‐4.) Dieser Teil beschreibt die Konsoleoberfläche und die Grundstruktur für spätere Kommandoeingaben. Hier wird auch entschieden, wie eingegebene Befehle ausgeführt bzw. an andere Klassen weitergege‐
16 ben werden. Wie im vorhergehenden Teil beschrieben wurde die Konsole so gut wie möglich in das bestehende Programm eingebaut. Das Ziel war es, möglichst den Still und die Konzeption der vorhan‐
denen Oberfläche weiterzuführen. Die Konsole wurde dazu in zwei Hauptklassen aufgeteilt, den „ConsoleInterface.java“ und den „Conso‐
leController.java“. Das Interface wird, wenn benötigt, in die Controller‐Klasse geladen. Der Controller und das Interface wurden so integriert, dass nur eine Instanz gleichzeitig existieren kann. Der Nutzen davon wurde von Gamma [Gamma 2001] ausführlich beschrieben und im Beispiel von Javaworld [Java‐
world 2001] verwendet. Das ConsoleInterface beinhaltet alle Information und Funktionen, welche benötigt werden, um die Konsole grafisch anzuzeigen. Dazu gehört das Aktualisieren der Ansicht, die Befehlseingabe oder das Laden und Schliessen des Konsole‐Tabs. Im ConsoleController andererseits befinden sich alle Funktionen, welche unabhängig vom grafischen Interface funktionieren. Dies ist zum Grossteil ein „CommandHandler“, welcher sämtliche durch den Benutzer oder eine Batchdatei eingegebenen Befehle parst und die entsprechenden Funktionen aus‐
führt. Zudem sind im Controller auch die für die Konsoleeinstellungen benötigten Funktionen vorhan‐
den. Struktur ConsoleInterface.java (450): 28 public class ConsoleInterface extends JFrame {
30
private static final long serialVersionUID = 5376015143479068580L;
33
public ConsoleInterface() {
34
}
36
//interface
37
private
JTabbedPane tabs = new JTabbedPane();
38
private static JPanel consolePanel = new JPanel();
39
private JTextArea jtaDisplay = new JTextArea();
40
private static JTextField jtfCommand = new JTextField(32);
41
private JScrollPane jspDisplay = new JScrollPane(jtaDisplay);
42
private final String CONSOLE_NAME = "Console";
44
//Displays to show SQL and FCQL Results
45
private static JTextArea jtaSQLDisplay = new JTextArea();
46
private static JTextPane jepfCQLDisplay = new JTextPane();
Programmcode 1 ConsoleInterface Für den grafischen Teil wurden die in „Abbildung 9“ ersichtlichen und farbig umrandeten Swing‐
Elemente neu erstellt. Die Konsole wurde als neues Frame in das bestehende „MainFrame“ integriert. Darin wurden verschiedene weitere Elemente integriert. Die normalen Rückgabewerte der Konsole werden in einer JTextArea „jtaDisplay“ (Z. 39) dem Consoleinterface angezeigt. Dieser Oberflächentyp hat den grossen Vorteil, dass Text effizient und ohne grossen Aufwand der bestehenden Anzeige hin‐
zugefügt werden kann. Er verträgt jedoch keine formatierten Texte, sondern nur genau einen Textyp. Alternative Swing‐Elemente, wie ein JEditorPane stellten sich als wesentlich schwerfälliger heraus. So ist kein simples Anfügen einer neuen Textzeile möglich, wie dies über „jtaDisplay.append(„Text“)“ bei einer TextArea ohne Probleme funktioniert [JText.‐Pane. 2009]. In das Frame wurden später zwei weitere Oberflächen eingefügt, da es sich als ziemlich unpraktisch herausstellte, Abfrageresultate von SQL‐ und fCQL‐Queries in demselben Fenster wie die anderen Kon‐
solenrückmeldungen darzustellen. Zudem ist das bestehende fCQL‐Resultat in HTML formatiert, was als normale Textausgabe unleserlich dargestellt würde. Für die SQL‐Abfragen wird eine zusätzliche Tex‐
tarea „jtaSQLDisplay“(Z. 45) eingeblendet, die fCQL‐Resultate werden in einem JTextPane „jepfCQLDisplay“ (Z. 46) Element angezeigt, welches problemlos HTML Formatierungen akzeptiert. Ist 17 das Resultat einmal erstellt, muss es nicht mehr verändert werden. Das im vorherigen Abschnitt be‐
schriebene Problem tritt hier also nicht auf. Unterhalb des Consoleinterface wurde ein TextField „jtfCommand“ angefügt, welches die Eingabe von Befehlen ermöglicht. Während dem Programmieren und Testen stellte sich rasch heraus, dass eine simple Kommandozeile zur Eingabe von Befehlen zwar funktioniert, aber nach jeder Eingabe sämtliche Information über die ausgeführte Eingabe verloren ging. Um nicht jedesmal den gesamten Befehl neu eingeben zu müssen, wurde eine Speicherfunktion eingebaut, welche die letzten 20 Befehle sichert. So kann, vergleichbar mit einem normalen Terminal oder dem Windows‐Comandline‐Fenster, durch das Benutzen der Pfeiltasten ein bereits eingegebener Befehl angezeigt, verändert und wiederbenutzt werden. Abbildung 9 Konsolefenster Dieses TextField und die verschiedenen Displays wurden in ein JPanel „consolePanel“ (Z. 40) (grün) verpackt. Dieses wird dann wie die bestehenden „Data Analysis 1D“‐, „Data Analysis 2D“‐ und „Fuzzy Classification“‐Tabs in einem neuen Console‐Tab (blau) angezeigt. Eigentlich würde man annehmen, dass dies eine einfache Aufgabe ist, da ja bereits 3 Tabs genau auf dieselbe Art und Weise in die Oberfläche eingebaut wurden, wenn auch mit anderem Inhalt. Leider waren aber sämtliche Funktionen, vom Aufbau der Verbindung bis hin zur Aktualisierung der Ansicht, wenn zum Beispiel eine neue Daten Analyse durchgeführt wird, statisch programmiert. Es wurde ein‐
fach überprüft ob alle drei Tabs geöffnet waren, da zwei sowieso immer offen sind und der dritte Tab einmal geöffnet nicht mehr geschlossen werden konnte. So hat der zusätzliche vierte Tab dieses auf maximal drei Tabs ausgelegte System komplett durcheinander gebracht. Dieses Problem und die ge‐
wählte Lösung ist genauer im Abschnitt 8.3.2 (Tab hinzufügen, Tab erneuern, Tab entfernen…) be‐
schrieben. 18 Die Iconbar wurde mit den neuen Funktionen für die Konsole ergänzt (rot) und die entsprechenden Einträge in den Menus hinzugefügt. Damit kann die Konsole geöffnet und geschlossen sowie zurückge‐
setzt werden. Ein neuer Eintrag ermöglicht es nun, einen geöffneten Fuzzy‐Klassifikations Tab zu schliessen (orange). Dies ist vor allem in der Hinsicht auf Probleme, welche beim Laden der Klassifikati‐
onen auftreten, und auch für die Effizienz bei fCQL‐Abfragen mit der Konsole von Vorteil. Struktur ConsoleController.java (1650): Der „ConsoleController“ wird bei jeder Befehlseingabe in die Konsole benutzt. Das Herz dieses Conrol‐
lers ist ein „String Scanner“. Dieser wurde an Stelle des StringTokenizers [Scan.‐Tok. 2009] im oben er‐
wähnten Beispiels von Javaworld [Javaworld 2001] verwendet. Der Scanner hat vor allem den Vorteil, ganze Zeichenreihenfolgen erkennen zu können und nicht nur einzelne Zeichen, wie der Tokenizer. Der Scanner ist auch in anderen Bereichen wesentlich flexibler, wie unter anderem an der Anzahl aufgelis‐
teter Funktionen in der API von Java erkennbar ist. Der untenstehende Programmcode 2 ConsoleController zeigt eine typische Verwendung des Scanners. In diesem Fall wird der Befehl „quit“ erkannt (Z. 239). 212
213
233
234
238
239
240
241
242
243
244
245
246
248
249
250
251
//start scanner to get entered commands from command input line
Scanner scannerCommands = new Scanner(sCommandLine);
//handle all non empty commands
String firstCommand = scannerCommands.next();
//close console
if (firstCommand.equalsIgnoreCase("quit")) {
if (Tools.isGUI()){
consoleInterface.closeConsole();
return "console closed"+ "\r\n";
}else{
return "the command \"quit\" is only valid in GUI mode"+
"\r\n";
}
}
//handel help command:
else if (firstCommand.equalsIgnoreCase("help")) {
return HELP_COMMANDS;
}
Programmcode 2 ConsoleController Ein anderes einfaches Beispiel ist der Befehl „help“, welcher die verschiedenen Hilfe‐Texte zu allen gültigen Eingaben anzeigt. Im Verlaufe der Programmierung wurden immer mehr Befehle in den Cont‐
roller eingefügt, am Ende erkennt der Controller nun 57 unterschiedliche Kommandos (siehe 12.1 Be‐
fehlsübersicht). Die meisten Befehle bestehen nicht nur aus einem String wie „quit“ und „help“, sonder im Extremfall aus bis zu 16 Stringteilen (z.B. zum Setzen einer Verbindung: „set connect ‐h localhost ‐p 3306 ‐d fcql ‐u root ‐pw admin ‐dr MySQL ‐ac true“), welche einzeln erkannt, kontrolliert und an die passende Funkti‐
on übergeben werden müssen. Dies hat dazu geführt, dass die Übersicht in den zahlreichen „if“‐ und „else“‐Schleifen sehr erschwert wurde. Deswegen wurde der Scanner in verschiedene untergeordnete Scanner‐Funktionen nach den verschiedenen Befehlstypen aufgeteilt. Dies sind „commandHandler“ „sqlCommandHandler“ „fCQLCommandHandler“ „metaCommandHandler“ „setCommandHandler“ und „mshipCommandHandler“. In diesen verschiedenen CommandHandler wird jeweils der entsprechende Befehlstyp in die richtige Form gebracht und an die jeweils zuständige Funktion in einer anderen Klasse weitergegeben. Zum Beispiel wird im „fCQLCommandHandler“ der eingegebene Abfrage‐String in die 19 einzelnen Grundelemente einer solchen Abfrage getrennt (FROM, WHERE, WITH und ALPHA) und dann an die Klasse „ExecuteFcql“ weitergegeben. An der Konsole können ein paar Einstellungen vorgenommen werden (Exception, Warnungen und Speicherung). Die verschiedenen dazu benötigten Parameter werden im Controller gespeichert. Zudem sind hier auch die unterschiedlichsten allgemeineren Fehlermeldungen abgespeichert. In die Konsole wurden als erstes SQL‐Abfragen integriert. Wie diese aufgebaut sind und welche Mög‐
lichkeiten sie bieten, wird im nächsten Abschnitt erklärt. 8.1.2. SQL (5.‐7.) Für die spätere Integration der SQL Abfragen in die Konsole wurde zuerst eine eigenständige Klasse erstellt, mit welcher es möglich war, eine Verbindung aufzubauen und SQL Abfragen zu machen. Da bereits zahlreiche solche SQL‐Interpreter existieren, wurde für diesen Teil auf einen solchen zurückge‐
griffen [Java2s 2000]. Struktur ExecuteSQL.java: (400): Zahlreiche Strukturen wie der Verbindungsaufbau wurden komplett umgebaut. Zuerst wurde eine ei‐
genständige Verbindung zur fCQL‐Datenbank hergestellt, was sich im Verlauf der Arbeit jedoch als Res‐
sourcenverschwendung herausstellte, da eine identische Verbindung bereits im GUI aufgebaut wurde und auch benutzt werden kann. Dies war jedoch nicht einfach zu erkennen, wenn man sich vorher noch nicht mit einer JDBC‐Verbindungen und einem Programm dieser Grösse beschäftigt hatte. Die Verbindung ist über mehrere Klassen, „dbWrapper“, „dbMySQLWrapper“, „Fcql“, „MainFrame“ und „DBConnection“, verteilt und wird nicht genauer kommentiert. Schlussendlich wird nun aber die bestehende Verbindung verwendet. Es sind jedoch noch einige Überbleibsel vom langen Werdegang bis hin zum aktuellen Zustand im Programmcode vorhanden. Zum Beispiel wird die Verbindung in „Tool connectSQL()“ mit einzelnen Strings aufgebaut und nicht mit Hilfe des passenden MySQL‐ oder PostgreSQL‐Wrappers. Zudem wurde die Verbindung beim Start des Toolkits direkt an das MainFrame übergeben, was natürlich zu einer Abhängigkeit zwischen dem grafischen Teil und der Verbindung führte, doch dazu mehr in 8.3.6 (Abhängigkeit zwischen dem GUI und der Verbindung). Damit ohne grossen Aufwand und Probleme mit dem GUI eine Verbindung erstellt bzw. auf diese jederzeit zuge‐
griffen werden kann, wurde die Funktion „connectSQL()“ in „Tools.java“ ausgelagert. Nachdem die Verbindung zur Datenbank in der ausgelagerten Klasse funktionierte, wurde der SQL‐
Interpreter in den „ConsoleController“ integriert. So dass nun alle SQL‐Abfragen, welche durch den jeweiligen JDBC‐Connector unterstützt werden, über die Konsole erfolgen können. Um SQL‐Abfragen mit Rückgabewerten übersichtlich darstellen zu können, werden diese wie in 7.2.2 SQL (5.‐7.) erwähnt in einem eigenen Bereich dargestellt. Die Darstellung der Resultate wurde unverändert aus dem Origi‐
nal‐Interpreter übernommen. Rückmeldungen von SQL‐Befehlen welche leere Resultate zurückgeben und nur Datenbankwerte verändern, werden im normalen Konsolefenster ausgegeben. Die Spaltenbreite wird, sofern die Datenbank auf die entsprechende Anfrage einen korrekten Wert zurück gibt, an die jeweiligen Inhalte angepasst (was sowohl bei MySQL und PostgreSQL bisher ohne Ausnahme funktionierte). Die angezeigten Resultate werden mit der entsprechenden Konsoleeinstellung in einer Textdatei abgespeichert. So können später unterschiedliche Abfragen einfach verglichen werden. Die Textdatei „SQLresultsX.txt“ wird auf dem Desktop gespei‐
chert. Wobei „X“ eine Zahl ist, die automatisch an die Anzahl an diesem Ort bereits Abbildung 10 vorhandener Resultate‐Dateien angepasst wird. 20 8.1.3. Metatabellen (8.‐9.) Nachdem nun die Möglichkeit besteht, SQL‐Queries direkt in der Konsole einzugeben und damit die Tabelleninhalte direkt zu verändern, sollten nun diese Tabellen auch gesichert und wiederhergestellt werden können. Dazu wurden zwei neue Klassen erstellt: zum Sichern „Sqldump.java“ (vormals „Mysqldump.java“) und zum Wiederherstellen „SqlreadinLines.java“ (vormals „MysqlreadinSqlt.java“). Struktur SqlDump.java (300): Mit dieser Klasse wird auf die externen Programme „mysql_dump.exe“ und „pg_dump.exe“ zugegrif‐
fen. Diese werden bei jeder normalen MySQL‐ oder PostgreSQL‐Installation mitinstalliert. Sie dienen, wie an ihrem Namen „dump“ unschwer zu erkennen ist, zum Sichern der Daten des jeweiligen Daten‐
banktyps. Das grundlegende Problem bestand darin, die externen Programme korrekt anzusprechen. Zum einen funktioniert die Kommunikation zwischen Java und den beiden Programmen nicht immer so, wie wenn man die Programme direkt über die Kommandozeilen aufruft. Die Fehlermeldungen sind schwierig abzufangen, wenn überhaupt welche entstehen. Bis die Übergabe der benötigten Parameter korrekt funktionierte und nicht nur leere Dateien erzeugt wurden, verging viel Zeit (siehe 8.3.4 PostgreSQL, JDBC und MySQL). Ein kleiner Codeausschnitt zeigt, wie dieser Schritt mit „mysqldump“ erfolgt. Es wird sichergestellt, dass es sich um eine MySQL‐Datenbank handelt (Z. 188), danach wird ein „runtime“‐Prozess ausgeführt (Z. 191), welcher die benötigten Parameter an „mysgldump“ übergibt (Z. 191), die Rückgabewerte werden in einer Datei „backupFile“ mit Hilfe eines InputStreamReader „irs“ abgespeichert (Z. 195‐202). 162 //do a mysqldump with mysqldump.exe
163 if(DBConnection.getDriver().equalsIgnoreCase("MySQL")){
164
Process process = runtime
165
//.exec("c:\\xampp\\mysql\\bin\\mysqldump --user="+user+" --password="+pw+" -lock-all-tables --opt "+database+"");
166
.exec(""+sqlDumpProgrammLocation+"
--host="+host+" --user="+user+" -password="+password+
167
" --lock-all-tables --opt "+database+" "+tables+"");
168
FileWriter fw = new FileWriter(backupFile);
169
if (process != null){
170
InputStreamReader
irs
=
new
InputStreamReader(process.getInputStream());
171
BufferedReader br = new BufferedReader(irs);
173
String line;
174
while ((line = br.readLine()) != null) {
175
if (line.length() > 0){
176
isOK = true;
177
}
187
188
189
191
192
194
195
196
198
//do a mysqldump with mysqldump.exe
if(DBConnection.getDriver().equalsIgnoreCase("MySQL")){
Process process = runtime
.exec(""+sqlDumpProgrammLocation+"
--host="+host+"
-user="+user+" --password="+password+
"
--lock-all-tables
--opt
"+database+"
"+tables+"");
if (process != null){
InputStreamReader
irs
=
new
InputStreamReader(process.getInputStream());
BufferedReader br = new BufferedReader(irs);
String line;
21 199
200
201
202
205
208
while ((line = br.readLine()) != null) {
if (line.length() > 0){
isOK = true;
}
}
}
Programmcode 3 SqlDump Mit PostgreSQL muss zudem eine Datei konfiguriert werden (siehe 9.1.2 PostgreSQL ), da komischer‐
weise das Passwort nicht als Parameter übergeben werden kann sondern erst nachträglich abgefragt wird, was mit der Java‐runtime nicht wirklich funktioniert, wie zahlreichen Forumseinträge bei der Su‐
che zu diesem Thema veranschaulichen [pg_du. Pw. 2009]. Es wurden verschiedenen Parameter eingebaut, mit welchen der Pfad zum externen Programm ange‐
geben werden kann, der Speicherort festgelegt wird, der Dateiname beliebig geändert werden kann und neben den Standardtabellen zusätzliche Tabellen angegeben werden können. Wie diese Befehle genau benutzt werden, zeigt Abschnitt 9.2.10 (Metatabellen sichern und einlesen (neu)). Struktur SqlReadinLines.java (350): Da sich das Einbinden der externen Sicherungstools als wenig stabil und fehleranfällig herausgestellt hat, wurde beim Einlesen möglichst auf diese verzichtet. Gesicherte und SQL konforme Dateien kön‐
nen unabhängig von „mysql_dump“ eingelesen werden. Mit PostgreSQL ist dies jedoch nicht möglich, da die aktuelle JDBC längst nicht alle benötigten SQL‐Befehle unterstütz. Deshalb musste hier trotz mehreren Versuchen auf „pg_dump.exe“ zurückgegriffen werden. Da diese Dateien möglichst leserlich abgespeichert werden sollen, sind die Statements nicht auf einer Zeile angeordnet, sonder erstrecken sich über mehrere Zeilen. Dies führt dazu, dass beim Einlesen die einzelnen Statements‐Stücke zuerst erkannt und zu einem Ganzen zusammengefügt werden müssen. Danach kann jedes Statement mit Hilfe der MySQL JDBC‐Verbindung eingelesen werden. Diese Aufteilung wurde mittels der Erkennung von Klammern erreicht: Solange eine ungleiche Anzahl rechte Klammern „(“ zu linken Klammern „)“ vorhanden ist, wird das Statement erweitert (Z. 298‐334). Sobald gleich viele rechte und linke Klammern vorhanden sind, wird das Statement ausgeführt (Z. 341). Dies ist in folgendem Code realisiert. 296 //sort one sql statement per line
297 while ((line = inputsql.readLine()) != null) {
298
for (int i = 0; i < line.length(); i++) {
299
char chara = line.charAt(i);
301
// avoid --comment, brackets
302
if (i == 0) {
303
if (chara == '-') {
304
chara = line.charAt(i + 1);
305
if (chara == '-') {
306
jump = true;
307
break;
308
}
309
}
310
} else
jump = false;
313
if (chara == '(') {
314
++right;
317
}
319
if (chara == ')') {
320
++left;
322
}
22 324
}
329
if (left == right && right == 0) {
330
// Ignore comments
331
if (jump) {
332
continue;
333
}
334
// Ignore blank lines
335
if (line.length() == 0)
336
continue;
341
boolean status = statement.execute(line);
342
}
343 }
Programmcode 4 SqlReadinLines Auch zum Einlesen wurden verschiedene Parameter integriert. So kann der Pfad mit Dateinamen zur einzulesenden Datei angegeben werden (‐rl) oder nur der Dateiname (‐fn). Zwei Dateien, von denen die eine das Metaschema mit dem fCQL‐example enthält und die andere in leerer Form, wurden ebenfalls in den Code integriert (Programmcode 5 Metaschema) und können ein‐
gelesen werden. 731 //meta create
732 else if (secondCommand.equalsIgnoreCase("create")) {
733 if (scannerCommands.hasNext()) {
734
// create -"something"
735
if (DBConnection.getDriver().equalsIgnoreCase("MySQL")){
736
return
"creating
"+SqlReadinLines.doMysqlReadinSqlt
("fcql_example_metaschema.sql", "fcql_example_metaschema.sql","")+"\r\n";
737
}
738
else{DBConnection.createMetaSchema();
739
return "pgsql Metaschema created\r\n";
740
}
741 }
742 else{
743
if (DBConnection.getDriver().equalsIgnoreCase("MySQL")){
744
return "creating empty "+SqlReadinLines.doMysqlReadinSqlt ("emptymetaschema.sql", "emptymetaschema.sql","")+"\r\n";
745
}
746
else{DBConnection.createMetaSchema();
747
return "pgsql Metaschema created\r\n";
748
}
749 }
750 }
Programmcode 5 Metaschema Die eigentliche Datenbankinformation wurde absichtlich nicht in den Code integriert. Auf diese Art kann durch das Erstellen einer neuen Sicherungsdatei mit demselben Namen „fcql_example_‐
metaschema.sql“ oder „emptymetaschema.sql“ ein eigenes, neues, angepasstes Metaschema erstellt werden, ohne den Programmcode verstehen oder abändern zu müssen. 8.1.4. fCQL Abfragen (10.‐11.) Als nächstes wurden die fCQL‐Abfragen in die Konsole integriert. Diese Abfragen können wie in der grafischen Oberfläche in „Abbildung 11“ ersichtlich unterteilt werden. 23 Abbildung 11 fCQL Abfragen Struktur ExecuteFcql.java (1450): Die Klasse beinhaltet alle Grundelemente, welche für eine fCQL‐Abfrage benutzt werden. Dazu wird die Verbindung „Connection conn“ (Programmcode 6 Z. 40) zur Datenbank benutzt. Des Weiteren wird eine Fuzzy Klassifikation „fClassification“ (Z. 41) benötigt, welche später mit Hilfe der „FClassification‐
Query“ (Z. 42)‐Klasse und den durch den Benutzer eingegebenen Werte die eigentliche fCQL‐Anfrage beinhalten. Eine solche Abfrage beinhaltet ebenfalls ein CLASSIF‐„Attributes“‐Element (Z. 49), und je nach Abfrage eine Kombination von „whereCondition“, „withCondition“ und „alphaCondition“ (Z. 52‐54). Diese Ele‐
mente werden in der „FClassificationQuery“ gesetzt (Z. 1275, 1295, 1307 und 1318). Es wird also zwischen folgenden Abfrage‐Elementen unterschieden: CLASSIFY Welche Tabellenspalten und oder Linguistische Terme sollen in das Resultat miteinbezogen und schlussendlich im Resultat einer separaten Spalte angezeigt werden? FROM Welche Tabelle wird abgefragt, vergleichbar mit dem FROM in SQL? WHERE … formuliert Bedingungen anhand von Werten und den Operatoren =, > und <, vergleichbar mit SQL WHERE. WITH … formuliert ebenfalls Bedingungen, jedoch anhand der Linguistischen Variablen und deren unterschiedlicher Linguistischer Terme und oder Fuzzy‐Klassen. ALPHA … kann eine Bedingung mit den vorhandenen Fuzzy‐Klassen oder Fuzzy‐Konzepten verbin‐
den. Wird ALPHA mit einer WITH Bedingung benutzt, entsteht eine benutzerdefinierte Klasse „Customized Class“, welche ebenfalls den Abfragebereich einschränkt. 24 Die Abfrage wird anschliessend mit der Klasse „FClassificationResults“ (Z. 1327) und der dazugehörigen Funktion „analyse()“ ausgewertet (Z. 1330). Die ausgewerteten Daten werden schlussendlich an das ResultDisplay übergeben, welches das grafische Endresultat berechnet und in Form eines Strings zu‐
rückgibt (Z. 1346). 40
41
42
43
45
46
48
49
51
52
53
54
private Connection conn = null;
private FClassification fClassification = null;
private FClassificationQuery fClassificationQuery = null;
private FClassificationResults fClassificationResults = null;
// containing the answer
private String sFCResult = "";
// containing vector with Ling Var names of FClass
Vector<String> attributes = new Vector<String>();
//containing whereCondition with and subsubconditions and or subconditions
WhereCondition whereCondition = null;
WithCondition withCondition = null;
WhereCondition alphaCondition = null;
1275 fClassificationQuery.setAttributes(attributes);
1295 fClassificationQuery.setWhereCondition(whereCondition);
1307 fClassificationQuery.setWithCondition(withCondition);
1318 fClassificationQuery.setAlphaCondition(alphaCondition);
1327 fClassificationResults = new FClassificationResults(fClassificationQuery);
1330 fClassificationResults.analyse();
1316 //create the result Table
1346 sFCResult = ResultDisplay.createResultTable (fClassificationResults, fClassification);
Programmcode 6 ExecuteFcql Ist der Konsoleparameter „SaveToFile“ auf „true (on)“ gestellt, wird dieses Resultat in ein fCQLResults.html gesichert. Solange der „Fuzzy Classification“‐
Tab geöffnet ist, wird in diesem das Resultat in herkömmliche Weise mit allen grafischen Elementen angezeigt. Damit das in der Datei gespeicherte Resultat die ursprüngliche Form beibehält, mussten die HTML‐ und CSS‐
Formatierungen abgeändert werden. Abbildung 12 Die oben erwähnten Klassen wurden je nach Inhalt mehr oder weniger an die Konsoleabfragen angepasst. „FClassification.java“ wurde kaum abgeändert. Die anderen Klassen je‐
doch mussten stark an die neue Eingabe angepasst werden. Es wurden neue Setter erstellt, welche es ermöglichen, „Attributes“, „WhereCondition“, „WithCondition“ und „AlphaCondition“ auch von aus‐
serhalb des GUI‐Teils zu erstellen und später auszuwerten. Häufig enthalten die Funktionen Elemente, welche in Zusammenhang mit dem GUI stehen und bei einer nicht grafischen Eingabe zu Abstürzen oder unnötigem Ressourcenverbrauch führten, oder ohne grafische Oberfläche gar keine Werte zur Auswertung entgegennehmen konnten. Um dies zu verbessern, wurden Funktionen angepasst oder neu erstellt. Diese sind im Sourcecode jeweils mit „changed“ oder „new“ gekennzeichnet. Die CLASSIF‐Attribute wurden soweit angepasst, dass möglichst auf dieselbe Art und Weise vorgegan‐
gen werden kann wie im grafischen Interface. Deswegen werden standardmässig alle linguistischen Terme als Attribute verwendet, also dieselben Attribute, welche im GUI automatisch selektiert sind. Es ist jedoch auch möglich, selber Attribute zu setzen und wieder zu entfernen, genauso wie im GUI mit der Maus Attribute selektiert und deselektiert werden können. Die Grundstruktur der unterschiedlichen Condition wurde beibehalten. In den Klassen, welche die je‐
weiligen Abfragebedingungen enthalten („WhereSubSubCondition“, „WithSubSubCondition“ etc.), 25 mussten jedoch neue Funktionen erstellt werden. Die entsprechenden Werte werden im GUI direkt aus der Datenbank ausgelesen und danach durch den Benutzer in der entsprechenden JComboBox gesetzt. Bei der Konsole Eingabe werden die Werte durch den Benutzer eingetippt, deshalb kann die‐
ser Wert ungültig sein. Der Wert kann also nicht wie bisher direkt aus der vorhandenen „JCombox“ übergeben werden, sonder der Eingabestring muss zuerst überprüft werden. Da die gültigen Werte bereits alle in den JComboboxes vorhanden sind, konnten diese dazu genutzt werden. Trotzdem war die korrekte Überprüfung dieser Werte eine der aufwendigsten Aufgaben, da jedes Element aus min‐
destens drei Unterelementen besteht, welche alle einzeln mit unterschiedlichem Vorgehen überprüft werden müssen. Die Überprüfungen mussten komplett neu erstellt werden, da das GUI immer nur gültige Werte zur Auswahl anbietet, also gar keine falschen Werte ausgewählt werden können. Im untenstehenden Codebeispiel für die „WhereSubSubCondition“ ist eine solche Überprüfung zu se‐
hen. Die durch den Benutzer eingegebenen Werte „where“ (enthält einen Linguistischen Term, Attri‐
bute) (Z. 355‐361), der „whereOperator“ (enthält <=, =, >=, >, <) (Z. 370‐376) und die „whereValue“ (enthält einen gültigen Datenbankintegerwert) (Z. 378‐384) werden jeweils mit Hilfe der in jeder Con‐
dition bereits vorhandenen JComboBox (whereSubSubCondition.getWhereBox()) validiert. Dieselben JComboBoxes werden im grafischen Teil für die Anzeige der gültigen Werte gebraucht. 362
363
364
365
366
367
368
369
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
// set where arguments
whereSubSubCondition.setWhere(where);
JComboBox whereJComboBox = whereSubSubCondition.getWhereBox();
// check where
if (isValidArgumentIgnoreCase(whereJComboBox, where) == false) {
throw new IllegalArgumentException("the WHERE argument \"" + where
+ "\" is not valid \r\n");
}
// set where operator
whereSubSubCondition.setWhereOperator(" " + whereOperator);
JComboBox operatorJComboBox = whereSubSubCondition.getOperatorBox();
// check valid whereOperators
if (isValidArgumentIgnoreCase(operatorJComboBox, " " + whereOperator) == false)
{
throw new IllegalArgumentException("the WHERE operator \"" + whereOperator
+ "\" is not valid \r\n");
}
// set where value
whereSubSubCondition.setWhereValue(whereValue);
JComboBox valueJComboBox = whereSubSubCondition.getWhereValueBox();
// check valid whereValues
if (isValidArgumentIgnoreCase(valueJComboBox, whereValue) == false) {
throw new IllegalArgumentException("the WHERE value \"" + whereValue
+ "\" is not valid \r\n");
}
// add + set subsub
vWhereSubSubConditions.add(whereSubSubCondition);
Programmcode 7 WhereSubSubCondition Damit die Benutzer einsehen können, welche Werte Gültigkeit haben, können mit den entsprechenden fCQL‐Kommandos Abfragen gemacht werden. So können Werte, welche relevant für eine fCQL‐Abfrage sind, angezeigt werden (siehe 9.2.8 fCQL‐Abfragen (7.2.4 Fuzzy Querying Process). Damit gültige Anfragen mit den unterschiedlichsten Attributen und Conditions schliesslich in der kor‐
rekten Reihenfolge ausgewertet werden, wird bereits im „ConsoleController“ zwischen den verschie‐
denen Conditions unterschieden. Diese werden dann getrennt an die Funktion „makeQuery“ in der 26 ExecuteFcql‐Klasse weitergegeben und dort, wie weiter oben beschrieben und im Programmcode 6 ExecuteFcql gezeigt, in die „FClassificationQuery“ eingefügt. ConsoleController:
500 fcqlResult = executeFcql.makeQuery(fromCommand, whereCommand, withCommand, alphaCommand);
Programmcode 8 makeQuery 8.1.5. Membershipfunktionen (12.‐14.) Nachdem fCQL‐Abfragen nur von mit dem GUI erstellten Fuzzy‐Klassifikation durchgeführt werden konnten, sollte es nun auch möglich sein neue Fuzzy‐Klassifikationen über die Konsole zu erstellen. In diesem Bereich mussten zu allererst neue, etwas ausführlichere Abfragen geschrieben werden. Dies, damit man für die Eingabe von Fuzzy Klassifikationswerten den Überblick behält und jederzeit sehen kann, welche Membershipfunktionen, Linguistischen Variablen etc. bereits vorhanden sind. Die dafür benötigten Funktionen befinden sich in „MemberShipShow“. Danach wurden die Funktionen, mit wel‐
chen es möglich ist, neue Fuzzy Klassifikationen zu erstellen, in „MemberShipSet“ erstellt. So konnten nun neue Werte geschrieben werden und anschliessend mit den Funktionen aus „MemberShipShow“ angezeigt und überprüft werden. Als letztes mussten noch Funktionen erstellt werden, welche diese Werte auch wieder löschen können („MemberShipDelete“). Struktur MemberShipShow.java (1250): Die Funktionen, um Membershipwerte anzuzeigen, sind alle nach demselben Prinzip aufgebaut. Ein typisches Beispiel soll diesen Aufbau veranschaulichen („Programmcode 9“): Die Funktion „getClassifi‐
cationValues“ (Zeile 34) zeigt Grundwerte einer Fuzzy Klassifikation an. Mithilfe eines Suchwertes „searchVal“ wird durch ein „ResultSet“ und die Verbindung „conn“ auf die Datenbank zugegriffen und mit einer Query die nötige Information in dieses ResultSet abgespeichert. Dabei wird zwischen drei Fällen unterschieden: 1. Der Benutzer gibt eine ID (fc_id) an (Z. 45) und es wird die entsprechende Klassifikation angezeigt. 2. Der Benutzer gibt einen Fuzzy Name (fc_name) an (Z. 51) und die entspre‐
chende Klassifikation wird angezeigt. 3. Der Benutzer gibt keinen Fuzzy Klassenwert an (Z. 57) und es werden alle vorhandenen Fuzzy Klassifikation Werte angezeigt. Für die jeweiligen Rückgabefelder wird eine Grösse festgelegt (Z.68‐87), damit eine übersichtliche ta‐
bellenartige Struktur entsteht. Mit (Z.87‐90) wird der String mit den Spaltennamen erstellt und später (Z.98‐123) werden die Werte aus dem ResultSet hinzugefügt. Der dadurch entstandene String wird schlussendlich zurückgegeben (Z.128). 34 public
String getClassificationValues(String searchVal) {
35
ResultSet rs = null;
36
37
String fClassValues = "\r\n";
38
try {
39
Statement s;
40
conn = Tools.connectSQL();
41
s = conn.createStatement();
42
43
//make correct result set, find all, with name or with id
44
//with id
45
if (Tools.isInt(searchVal)){
46
rs = s.executeQuery(" SELECT * FROM fcql_meta_fc
WHERE
id
=
27 '"+searchVal+"' ORDER BY name ASC");
47
//System.out.println("Mit Id suchen");
48
}
49
//with name
50
else{
51
if (searchVal != ""){
52
//System.out.println("Mit fclass suchen");
53
rs = s.executeQuery(" SELECT * FROM fcql_meta_fc WHERE name =
'"+searchVal+"' ORDER BY name ASC");
54
}
55
//all
56
else{
57
rs = s.executeQuery("SELECT * FROM fcql_meta_fc ORDER BY name
Asc");
59
}
60
}
67
//defines standard size of values
68
int ID_SIZE = 5;
69
int FC_NAME_SIZE = 20;
70
int RELATION_NAME_SIZE = 15;
77
int FC_SPACE_SIZE = 8;
78
int FC_SIZE = ID_SIZE + FC_NAME_SIZE + RELATION_NAME_SIZE + RELATION_ID_SIZE +
79
AND_OP_SIZE
+
AND_ARG_SIZE
+
OR_OP_SIZE
+
OR_ARG_SIZE
+
FC_SPACE_SIZE;
81
//get actual Width
82
widthInChars = getWidthInChars();
84
int restCharSize = widthInChars - FC_SIZE-1;
87
fClassValues += calculateWordWidth("fc_id", ID_SIZE)+
88
" "+calculateWordWidth("name", FC_NAME_SIZE)+
89
"
"+calculateWordWidth("relation_name",
RELATION_NAME_SIZE)+
90
"
"+calculateWordWidth("relation_id",
RELATION_ID_SIZE)+
98
while (rs.next()) {
99
String id = (rs.getString("id"));
100
String name = (rs.getString("name"));
101
String description = (rs.getString("description"));
102
String relation_name = (rs.getString("relation_name"));
109
" "+calculateWordWidth(name, FC_NAME_SIZE)+
110
"
"+calculateWordWidth(relation_name,
RELATION_NAME_SIZE)+
123
}
124
//if no query result display standard message
125
if (fClassValues.length()== widthInChars+4){
126
fClassValues = "no query result to display (invalid fc_value)\r\n";
127
}
128
return fClassValues;
129 }
Programmcode 9 MemberShipShow Insgesamt befinden sich 11 solche Funktionen in dieser Klasse. Damit in der Konsoleanzeige die Übersicht über die verschiedenen Werte bewahrt werden kann, wird die aktuelle Grösse des Konsolefensters miteinbezogen. Diese Anpassung geht von einer Mindestgrös‐
se der Konsole von 140 Zeichen aus, was in etwa einer Fensterbreite von 980 Pixeln entspricht. Wer‐
den im aktuellen Fenster nicht genügend Zeichen angezeigt, entsteht ein Durcheinander, da die Werte nicht mehr in strukturierter Form untereinander dargestellt werden können. Jeder Ausgabewert be‐
28 sitzt nun eine Maximalgrösse. Diese wird nur selten und bei besonders langen Inhalten wie der Fuzzy‐
Klassifikations‐Beschreibung überschritten. Ist dies der Fall, wird der Wert auf die entsprechende Län‐
ge gekürzt und mit einem „*“ gekennzeichnet (siehe „Abbildung 13“). Abbildung 13 fclaif Die Anzeige entspricht nicht immer der wirklichen Struktur in der Datenbank sondern versucht, wenn möglich zusammengehörige Werte übersichtlich darzustellen. So werden bei einer Abfrage eines lingu‐
istischen Terms, wie in „Abbildung 14“ gezeigt, Werte aus drei unterschiedlichen Tabellen zusammen‐
gesucht. Abbildung 14 linter Es kann jedoch auch eine weitere Abfrage gemacht werden, hier können die Werte der linguistischen Terms detaillierter abgefragt werden (siehe „Abbildung 15“). Sämtliche implementierten Abfragen werden in „9.2.5 Abfragen und Anzeigen von Fuzzy‐Klassifikationen (neu)“ ausführlich beschrieben. Abbildung 15 confun Struktur MemberShipSet.java (1500): Diese Klasse wurde sehr ähnlich aufgebaut wie die vorhergehende, nur enthält sie nicht Funktionen zur Anzeige, sondern insgesamt acht zum Schreiben von Fuzzy Klassifikation‐Werten. Es wird wiederum eine Verbindung benötigt, welche das Schreiben der Werte zulässt. (Z. 18, 37). Zusätzlich wird eine „DBConnection“ verwendet, welche einen einfachen Zugriff auf bereits vorhandene Funktionen zu Ab‐
frage von Datenbankwerten ermöglicht (Z. 34). Die Eingabewerte müssen vor dem Schreiben in die Datenbank überprüft werden, ähnlich wie bei der Eingabe von fCQL‐Abfragen. Dadurch werden Inkon‐
sistenzen in der Datenbank möglichst vermieden, wie zum Beispiel, dass mehrere Fuzzy Klassifikation gleich heissen oder dass die eingegebenen Werte auch im gültigen Wertebereich einer Members‐
hipfunktion liegen. Beim „relation_name“ wird zum Beispiel kontrolliert, ob dieser korrekt geschrieben ist und in der Da‐
tenbank auch wirklich eine Tabelle mit diesem Namen existiert (Z. 73‐78). Ein anderes Beispiel ist die Validierung des „and‐operators“. Hier wird gesprüft, ob es sich um einen der beiden gültigen Eingabe‐
werte „Gamma“ oder „Maximum“ handelt (Z. 92 ‐102). In diesem Fall geschieht dies für insgesamt acht verschiedene Werte (1.fc_name, 2.+relation_name, 3.+relation_id, 4.+and_operator, 29 5.+and_argument, 6.+or_operator, 7.+or_argument, 8.+description). Sind alle Werte validiert, werden diese zu einem String zusammengesetzt (Z. 135‐137) und in die Datenbank geschrieben (Z. 140‐142). Am Ende wird ein Rückgabestring „result” erstellt und zurückgegeben (Z. 154/155/161). 29 public String setFuzzyClassification(String[] commands) throws IllegalArgumentException {
30
ResultSet rs = null;
31
int rRCount = 0;
32
String result = "";
33
try {
34
dbConn = Fcql.getDBConnection();
36
Statement s;
37
s = conn.createStatement();
44
//get start fc_id
45
int fc_id = 0;
46
rs = s.executeQuery(" SELECT MAX(`id`) FROM `fcql_meta_fc` ");
47
if (rs.next()) {
48
String idS = "";
49
idS = rs.getString(1);
50
if (idS == null) {
51
idS = "0";
52
}
53
fc_id = Integer.parseInt(idS);
54
++fc_id;//first id = 1
55
}
61
Vector<String> fc_names = new Vector<String>();
62
rs = s.executeQuery("SELECT name FROM `fcql_meta_fc`");
63
while (rs.next()) {
64
fc_names.add(rs.getString("name"));
65
}
73
// validate relation_name with database table names
74
String relation_name = commands[1];
75
Vector<String> tables = Tools.getSorted(dbConn.getAvailableTables());
76
if (Tools.isValidMshipCommand(relation_name, tables) == false) {
77
throw new IllegalArgumentException("relation_name \"" + relation_name + "\" is not valid");
78
}
92
//validate and_operator
93
String and_op = commands[3];
94
if (and_op.equalsIgnoreCase("g")) {
95
and_op = "Gamma";
96
}
97
if (and_op.equalsIgnoreCase("m")) {
98
and_op = "Maximum";
99
}
101
if
((and_op.equalsIgnoreCase("Gamma")
||
and_op.equalsIgnoreCase("Maximum")) == false) {
102
throw
new
IllegalArgumentException("and_operator
\""
+
and_op + "\" has to be Gamma or Maximum");
132
}
134
//append all commands
135
String commandsS = "'" + fc_id + "', " + "'" + name + "', " + "'"
+ description + "'," + "'"
136
+ relation_name + "'," + "'" + relation_id + "', " +
"'" + and_op + "', " + "'" + and_arg
137
+ "', " + "'" + or_op + "', " + "'" + or_arg + "'";
139
//ececute SQL Insert
30 140
141
142
154
155
161
162
rRCount = s.executeUpdate("INSERT INTO `fcql_meta_fc` ("
+ " `id` ,`name` , `description` , `relation_name` ,
`relation_id` ,"
+ " `and_op` , `and_arg` , `or_op` , `or_arg` ) VALUES
(" + commandsS + ")");
result = "Fc-Insert Ok. " + rRCount + " row affected" + "\r\n";
result += commands[0] + " with id " + fc_id + " inserted" +
"\r\n";
return result;
}
Programmcode 10 MemberShipSet Sämtliche Werte, welche in der Datenbank überprüft werden, können in „Tabellenübersicht.pdf“ ein‐
gesehen werden. Des Weitern kann in den Tabellen „Tabelle 8 fclaifs“ bis „Tabelle 15 conceps“ ein ge‐
nauer Überblick gewonnen werden, welche Bedingungen jeder Eingabewert erfüllen muss, damit er gültig ist. Wie mit diesen Funktionen eine neue Fuzzy‐Klassifikation erstellt werden kann, wird ausführ‐
lich in der Anleitung 9.2.6 (Erstellen einer Fuzzy‐Klassifikation (7.2.3 Fuzzy Classification Definition Wi‐
zard)) erklärt. Einige Eingriffe in der Datenbank werden automatisch ausgeführt. Der Benutzer merkt im Normalfall nichts davon und muss auch keine Werte dafür eingeben. So werden die Tabellen „fcgl_meta_fcd“ vollständig und „fcql_meta_fcl“ teilweise aktualisiert, wenn eine linguistische Variable oder ein linguis‐
tischer Term hinzugefügt oder entfernt wird. Struktur MemberShipDelete.java (550): Damit Werte einer Fuzzy‐Klassifikation oder die gesamte Fuzzy‐Klassifikation wieder entfernt werden können, mussten die Funktionen der Klasse „MemberShipDelete“ geschrieben werden. Da wie oben erwähnt darauf verzichtet wurde, das Löschen jedes einzelnen Eintrags eines Elements zu erlauben, ist diese Klasse nur ein Drittel so gross wie die Klasse zum Setzen dieser Werte. Wie das untenstehende Beispiel zeigt, wird beim Löschen der gesamten Fuzzy‐Klasse jede Tabelle, wel‐
che Werte im Zusammenhang mit dieser Fuzzy Klassifikation enthalten, auf zu löschende Werte über‐
prüft. Dazu werden jeweils bestehende Funktionen, welche mit entsprechenden Befehlen auch einzeln aufgerufen werden können, benutzt. Zuerst werden die Werte der Fuzzy‐Klassen entfernt (Z. 54), da‐
nach die Linguistischen Variabeln (Z. 57). Das Entfernen einer LinVar. beinhaltet sowohl alle damit in Verbindung stehenden Categories, Composed Attributes oder Rational Attributes sowie dazugehörige Linguistische Terme mit den entsprechenden Membershipfunktionen. Danach werden die Fuzzy‐
Concepts entfernt (Z. 60). Schlussendlich folgt der Fuzzy‐Klassifikations‐Eintrag, welcher in dieser Funk‐
tion als einziges direkt ausgeführt wird. (Z. 63‐75) Jede indirekt aufgerufenen Funktion gibt eine Erfolgsmeldung oder Fehlermeldung zurück. Diese wer‐
den im „result“‐String gesammelt und dann angezeigt (Z. 38, 54, 57, 60, 70, 74, 79 und 82). 35
36
37
38
39
48
53
54
55
public String deleteFuzzyClassification(String[] commands) throws IllegalArgumentException {
ResultSet rs = null;
int rRCount = 0;
String result = "";
try {
//find fc_id, if fc_name, and validate fc_id, throws exception's
//1.b delete all fcl (fuzzy classes) with fc_id function deleteFuzzyClassesClassDefinition
result += MemberShipDelete.deleteFuzzyClassesClassDefinition(command);
31 56
//1.a delete all lv
with fc_id
function
deleteLinguis-
ticVariable
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
82
83
result += deleteLinguisticVariable(command);
// 3. delete concepts with fc_id
result += deleteFuzzyClassConcepts(command);
//0. delete fuzzy classification
rs = s.executeQuery(" SELECT name FROM fcql_meta_fc WHERE id = '"
+ fc_id + "'");
String fc_name = "";
if(rs.next()){
fc_name = rs.getString("name");
}
rRCount = s.executeUpdate("DELETE FROM fcql_meta_fc WHERE `id` =
'" + fc_id + "'");
if(rRCount != 0){
result += "Fuzzy Classification \""+fc_name+"\" and all corresponding values have been deleted\r\n";
}
//should never be reached
else{
result += " no Fuzzy Classification \""+fc_name+"\" has been
found\r\n";
}
rs.close();
s.close();
} catch (Exception e) {
result +=Tools.createDetailedException(e);
}
return result;
}
Programmcode 11 MemberShipDelete 8.1.6. Plugin (15.‐16.) Als letzte Erweiterung wurde ermöglicht, dass Befehle direkt über eine Batchdatei oder ein Komman‐
dofenster in das fCQL‐Toolkit eingegeben werden können. Hierfür wurden keine neuen Klassen benö‐
tigt. Damit das fCQL‐Toolkit von aussen angesprochen werden kann, mussten einige bestehende Funk‐
tionen abgeändert und zusätzliche in den entsprechenden Klassen integriert werden. Diese Verände‐
rungen wurden hauptsächlich in den Klassen „Fcql.java“ und „Tools.java“ vorgenommen. „Fcql.java“ enthält die Main‐Funktion und folglich einige grundlegende Elemente wie das Mainframe, die Verbin‐
dung, das „ConsoleInterface“ und den „ConsoleConroller“. „Tools.java“ enthält viele Funktionen, wel‐
che zur Berechnung von Werten im „ResultDisplay“ dienen. Andere Funktionen wurden hierhin ausge‐
lagert, da sie mehrmals von verschiedenen Klassen mit derselben Priorität benutzt werden. Sie sind hier zentral überblickbar anstatt in unterschiedlichen Klassen versteckt zu sein. Diese Veränderungen hatten zum Ziel, dass der grafische Teil nicht zwingend mitgeladen werden muss, wenn das Tool im Konsolemodus aufgerufen wird. Dies führte nämlich zu zahlreichen Problemen. Da die Verbindung ei‐
ner der am häufigsten benutzten Bestandteile ist, mussten sehr viele Zugriffe darauf neu angepasst werden, nachdem die Verbindung aus dem „MainFrame.java“ in „FCQL.java“ verschoben worden war. Zudem wurden in den vorhergehenden Bereichen einige Funktionen in diesem Zusammenhang un‐
überlegt implementiert, so dass sie ohne grafischen Teil nicht fehlerfrei funktionieren konnten (siehe 8.3.6 Abhängigkeit zwischen dem GUI und der Verbindung). 32 Struktur Tools.java (850*): „Tools.java” enthält den Boolean „isGUI“ (Z. 56), um die im oberen Abschnitt beschriebenen Fehler zu umgehen. Dieser wird in 37 verschiedenen Funktionen überprüft und verhindert dort jeweils, dass auf fehlende grafische Elemente zugegriffen wird, oder führt eine alternative, neu implementierte Funkti‐
on aus, welche keine grafischen Elemente benötigt. Hier befinden sich zudem zwei neue Funktionen, welche die Sicherung der Einstellungen der Konsole, Resultateausgabe, Warnungsausgabe, Fehlermeldungsausgabe und Dateispeicherung übernehmen (Z. 165, 171). Beim ordnungsgemässen Schliessen des Programms werden diese Einstellungen des Toolkits in der "config.dat" Datei abgespeichert. Der Klasse wurden weiter einige Funktionen zur String‐Überprüfung für Membershipbefehle sowie Funktionen zur Fehlererzeugung und Datenbankerstellung hinzugefügt. 51 public class Tools {
56
public static boolean isGUI = true; //new
149
/**changed loads the Console Configuration **/
150
public static void loadConsoleConfig (){
151
ConsoleController consoleController = Fcql.getConsoleController();
152
consoleController.setShowResult(Boolean
.parseBoolean(config.getProperty("fcql.console.result")));
153
consoleController.setShowWarning(Boolean
.parseBoolean(config.getProperty("fcql.console.warning")));
154
consoleController.setShowException(Boolean
.parseBoolean(config.getProperty("fcql.console.exception")));
155
consoleController.setSaveToFile(Boolean
.parseBoolean(config.getProperty("fcql.console.save")));
156
} catch (NumberFormatException e) {
177
e.printStackTrace();
158
}
159
}
162
/**changed retrieve console configuration**/
163
public static void saveConsoleConfig (){
164
ConsoleController consoleController = Fcql.getConsoleController();
165
config.setProperty("fcql.console.result",
Boolean.toString(consoleController.isShowResult()));
173
}
Programmcode 12 Tools Struktur Fcql.java (300*): Der wichtigste neue Teil in dieser Klasse ist die Funktion „cmdRun“. Diese ruft das Toolkit ohne GUI auf (Z. 198‐203) und setzt den Boolean „isGUI“ auf „false“ (Z. 205). 190
191
192
198
199
200
201
202
203
205
206
/**new, optimized run for cmd interface
* load Config.dat parameters, Connection, start Message**/
public void cmdRun() throws Exception {
System.out.println("Loading...");
Tools.loadConfig();
System.out.println("Connecting database...");
dbConnection = new DBConnection();
Tools.loadDBConfig(dbConnection);
dbConnection.autoInit();
Tools.setIsGUI(false);
}
Programmcode 13 Fcql 33 Damit Befehle aus der Konsole überhaupt im Toolkit erkannt werden, musste die „main“‐Funktion neu angepasst werden, so dass die Befehle im eingegebenen String Array „args“(Z. 69) getrennt erkannt werden konnten. 70
public static void main(String[] args) throws Exception {
Programmcode 14 Main() 8.2. Endergebnis, Vergleich Version 1.05 und 1.10 Im oberen Teil wurden sämtliche neuen oder veränderten Java Klassen erwähnt und teilweise mit ei‐
nem kurzen Codeauschnitt aufgeführt. Diese Art von Beschreibung ermöglicht es zwar, nachzuvollzie‐
hen, was wie und wieso programmiert wurde, über das gesamte Ausmass der Veränderung gibt dies allerdings keine guten Überblick. Ein detaillierterer Einblick kann natürlich im SourceCode (fCQL1.10_Source.zip) gewonnen werden. Einen guten und vor allem rasch überblickbaren Eindruck der Veränderungen vermittelt der Metrics‐Vergleich zwischen der Ausgangs‐ und der Endversion in der Tabelle 3 Metrics Version 1.05 und 1.10). Einen noch gröberen Überblick gibt die „Abbildung 8“ mit der Paketübersicht und neu hinzugefügten Klassen der Version 1.10. fCQL‐Toolkit Metrics fCQL 1.05 fCQL 1.10 Differenz Checkpoint fCQL 1.05 fCQL 1.10 ‐ +10 Files 103
113
+10‘433 Lines 24‘616
35‘049
+5097 Statements 12‘745
17‘842
+4.2% % Branches 9.9 %
14.1%
+3293 Calls 8‘921 12‘214 +3% % Comments 15 % 18 % +16 Classes 238 254 +0.27 Methods / Class 5.54 5.81 +2.36 Avg Statements / Method 7.49 9.85 +70 Max Complexity 84 154 ‐ Max Depth 9+ 9+ +0.42 Avg Depth 2.24 2.66 +0.83 Avg Complexity 2.24 3.07 Tabelle 3 Metrics Version 1.05 und 1.10 8.3. Angetroffene Probleme Natürlich wurde dieser zusätzliche Code nicht genau in der beschriebenen Reihenfolge und problemlos aus dem Ärmel geschüttelt, wie die bisherige Darlegung suggerieren könnte. Einige Abschnitte und Bereiche mussten mehrmals komplett abgeändert, andere mit Workarounds umschifft werden. Manchmal war es für mich auch nach stundenlangen herumpröbeln schlicht nicht möglich, zu verste‐
hen, wieso ein Fehler immer noch oder immer wieder auftritt. Das liegt wohl daran, dass meine Erfah‐
rung mit grossen Javaprojekten klein ist. Der Aufbau der einzelnen Klassen und das Zusammenspiel der Funktionen erschien mir in einigen Bereichen des ursprünglichen Programms zu komplex und zu wenig ausführlich kommentiert, um diese auch mit Erfolg verändern zu können. Die interessantesten Prob‐
leme und ‐ wenn vorhanden deren Lösungen ‐ werden im Folgenden beschrieben. 34 8.3.1. Übersicht bei 230 Klassen und 1000 Methoden? Nach dem vollständigen Studium von Werros Arbeit [Werro 2008] und dem Begreifen der Toolkit‐
Grundlagen war das grundlegendste Problem, die Programmstruktur sowie die einzelnen Klassen und Methoden zu verstehen. Da Programmieren ein kreativer Prozess ist, bei dem jeder Programmierer seinen individuellen Still und Lösungsansatz wählt, war das erste Ziel, den bisher benutzen Still zu er‐
fassen und zu verstehen. Danach musste das Programm in seiner Struktur verstanden werden, was dank den aussagekräftig gewählten Paketnamen in den meisten Fällen offensichtlich war. Auf der Ebene der einzelnen Klassen jedoch war es ziemlich anspruchsvoll, herauszufinden, welche Klasse zu welchen Zwecken dient, und vor allem, welche Funktion darin wozu wiederbenutzt werden konnte. Wieso befindet sich zum Beispiel die Klasse „InfoBox“, welche verschiedene Funktionen für das grafische Interface enthält, vorwiegend für die Ausrichtung der einzelnen Elemente, im Paket „Tools“? Es handelt sich dabei um Funktionen, welche einzig mit dem grafischen Teil in Verbindung stehen und nur mit Klassen aus dem „gui“‐Paket benutzt werden. Die Klasse also in dieses Paket mit einzubinden, würde logischer erscheinen. Oder wieso gibt es in „Tools“ die getrennten Klassen „Error“ und „Swing‐
Tools“, beide nicht länger als 100 Zeilen, deren Funktionen direkt miteinander in Verbindung stehen und alleine nicht benutzt werden können, da sie mit den grafischen Elementen „MainFrame“ direkt in Verbindung stehen? Zudem brachte die fehlende Kommentierung das Problem mit sich, dass Funktionen mit vermeintlich eindeutigen Namen wie „checkConnection“ zu Fehlschlüssen über deren wirkliche Aufgabe führten. Eigentlich sollte man davon ausgehen können, dass ein Funktion mit dem Namen „checkConnection“ eine Verbindung (Connection) überprüft (check), also einfach erfasst, welche Parameter eingegeben wurden, um eine Verbindung aufzubauen, und diese auf ihre Korrektheit überprüft, oder vielleicht ein‐
fach prüft, ob eine Verbindung besteht oder nicht. Nur leider ist in diesem Fall die Sache etwas komplizierter. Die erwähnte Funktion macht zwar genau das, was man erwarten würde, überprüft die Parameter und gibt einen Boolean zurück, welcher an‐
zeigt, ob die Parameter gültig sind oder nicht. In der letzten Zeile ruft die Funktion dann aber eine wei‐
tere Funktion „init“ auf. Schaut man dann in der entsprechenden Klasse, was diese Funktion macht (in Eclipse am einfachsten mit der „F3“ Taste), stellt man fest, dass eine weitere Funktion „initConnection“ aufgerufen wird. Diese baut erstaunlicherweise die eigentliche Verbindung auf! Die Verbindung kommt also über eine Funktion zustande, welche die eigentliche Aufgabe der Funktion nicht erwähnt, sondern wird indirekt über 2 andere Funktionen initialisiert. Es erscheint mangels Kommentierung unlogisch und für Personen, die den Code wiederverwenden sollten, nicht nachvollziehbar, wieso in diesem Fall die Überprüfungs‐Funktion (check) zwei weitere Funktionen aufruft, welche die eigentliche Arbeit ver‐
richten. Man würde eher erwarten, dass die Initialisierungs‐Funktion „initConnection“ eine Überprü‐
fungs‐Funktion „checkConnection“ aufruft und dann die Initialisierung durchführt „init“. Dieses Bei‐
spiel soll veranschaulichen, welche Probleme ab und an angetroffen wurden, in vielen Fällen waren aber die Funktionen nachvollziehbar strukturiert und verständlich angeordnet. Es war also nicht immer ganz einfach herauszufinden, wo sich welche Teile befanden, und warum dort. Weder die Klassen noch die meisten Funktionen beinhalteten neben ihrem Namen weiter Information, was mit diesen gemacht werden kann bzw. wozu diese dienen. Deswegen war es sehr schwer, sich zu orientieren und in den jeweiligen Bereichen festzustellen, welche Funktion weiter benutzt werden konnte oder gar nicht existiert und somit neu geschrieben werden musste. Bis zuletzt wurden immer mal wieder Funktionen, welche zuvor zu kennen sehr praktisch gewesen wäre entdeckt. Sie hätten oft wiederverwendet werden können, waren jedoch zum entsprechenden Zeitpunkt irgendwo unentdeckt in einer Klasse, in der man nie danach gesucht hätte, verborgen 35 geblieben. Es werden also bestimmt einige vergleichbare Funktionen unnötig neu implementiert wor‐
den sein. Es erschien in manchen Fällen aufwendiger und inefizzient, noch länger nach entsprechenden bereits existierenden Funktionen zu suchen, als selber eine neue zu schreiben. 8.3.2. Tab hinzufügen, Tab erneuern, Tab entfernen… Wie bereits im Abschnitt über die Konsole‐Implementierung erwähnt, entstanden bei der Integration eines vierten Tabs, dem Konsole‐Tab, in das bestehende Programm grössere Probleme. Das Haupt‐
problem war, dass alle Funktionen im Programm auf maximal 3 Tabs ausgelegt waren. Sie überprüften einfach, ob ein dritter Tab offen ist, und entschieden aufgrund des Ergebnisses, ob A oder B auszufüh‐
ren sei. Da der dritte Tab, einmal geöffnet, nicht mehr geschlossen werden konnte, führte dies auch nicht zu weiteren Problemen. Durch den vierten Tab jedoch wurde dieses statische System durchein‐
ander gebracht. Plötzlich funktionierten viele Funktionen des Programms nicht mehr richtig, obwohl nur ein einziger Tab, welcher ansonsten nichts am Programm veränderte, hinzugefügt wurde. Zudem wurden bei jeder Veränderung an den Einstellungen, wie zum Beispiel der Verbindung oder der aktuel‐
len Fuzzy‐Klassifikation, alle Tabs neu geladen, was natürlich bei einer davon unabhängigen Konsole sinnlos und einer praktischen Konsolebenutzung hinderlich ist. Deshalb musste das gesamte System für die Tabs und alle Funktionen, die damit in Verbindung standen, angepasst werden. Jeder Tab hat nun einen eindeutigen Namen und wird über diesen identifiziert und die Funktionen überprüfen nun, wel‐
che Tabs offen sind und nicht wie viele. Die drei bisherigen Tabs funktionieren wie bisher, der Fuzzy‐Klassifikations‐Tab kann nun jedoch auch wieder geschlossen werden, wenn man eine geladene Fuzzy‐Klassifikation nicht mehr benötigt. Der neue Konsole Tab ist nun so integriert, dass er automatisch mitgeladen wird, wenn eine der Einstellun‐
gen vorgenommen wird, welche die gesamte Anzeige erneuert. Dabei kamm es jedoch zu einem Feh‐
ler: statt dem Inhalt der Konsole wird der Inhalt des ersten Tabs anzeigt. Dieser Fehler konnte leider nicht vollständig behoben werden, tritt aber dank eines Workarounds nicht mehr in dieser Form auf. Der Workaround selektiert beim Erneuern der Anzeige automatisch den ersten Tab und nicht den zu‐
letzt angewählten Tab. Wenn man danach auf den Konsole‐Tab klickt, zeigt dieser wieder den korrek‐
ten Inhalt an. Wieso es zu diesem Problem kommt, dass der „viewport“ des einen Konsole‐Tab falsch ist, solange nicht der erste Tab einmal ausgewählt wurde, bleibt nicht nachvollziehbar. 8.3.3. Java Probleme: Wie bitte? „KeyTyped“ reagiert nicht auf Pfeiltasten? Einige Java spezifische Probleme führten immer wieder zu kürzeren oder langwierigen Verzögerungen im Programmierprozess. Das beste Beispiel hierzu trafen wir im Verlauf der „ConsoleInterface“ Imple‐
mentierung an: Damit die gespeicherten Kommandozeilen‐Befehle wieder angezeigt werden konnten wurde dem „jtfCommand“‐Element ein KeyListener angefügt. Dieser beinhaltet die drei Erkennungs‐
möglichkeiten „keyTyped“ „keyReleased“ und „keyPressed“. Liest man in der API den Beschrieb zu „KeyListener“ [KeyListen. 2009] steht dort im Hauptbeschrieb: “A keyboard event is generated when a key is pressed, released, or typed.” Auf Deutsch: „Ein Tastaturerreignis wird generiert, wenn eine Taste gedrückt, losgelassen oder getippt wird.“ Der Listener sollte also reagieren, wenn eine beliebige Taste gedrückt, losgelassen oder gedrückt gehalten wird. Für die gewünschte Funktion erscheint die Ver‐
wendung des Typs „keyTyped“ am naheliegendsten, da bei jedem Tastendruck der nächst ältere oder neuere Befehl aufgerufen werden sollte. Dazu wurden also die passenden „KeyEvents“ in den entspre‐
chenden Erkennungstyp eingebaut, was in diesem Fall bedeutet das die Pfeiltasten UP (KeyE‐
vent.VK_UP ) und DOWN (KeyEvent.VK_DOWN ) integriert werden mussten. 36 Nachdem die gut 100 Zeilen Code dazu fertig geschrieben waren, geschah, wenn man die Pfeiltasten drückte, erstaunlicherweise nichts. Die Speicherung funktionierte einwandfrei, nur das Aufrufen war fehlerhaft. Nachdem die Fehlersuche nach einiger Zeit auf das KeyEvent eingegrenzt war, musste diese auseinandergenommen werden. Eigentlich gab es kaum Fehlermöglichkeiten, der Aufbau des „Key‐
Listener“ mit den „KeyEvents“ ist wirklich nicht besonders komplex. Nach langer Fehlersuche (Key‐
Listener weg, „KeyEvents“ weg, andere „KeyEvents“, Umbau der Zusammenhänge zwischen dem Ar‐
rayspeicher und dem „jtfCommand“‐Element) stellte sich heraus, dass der „KeyListener“ auf fast alle „KeyEvents“ problemlos reagiert und die Anzeige funktioniert, nur Pfeiltasten führten zu keinerlei Re‐
aktion. Schliesslich wurde dann einfach die „keyPressed“‐Erkennung verwendet, da hier das Problem mit den Pfeiltasten nicht auftritt. Es stellte sich später heraus, dass „keyTyped“ nur auf Tasten reagiert, welche einen Unicode zurückge‐
ben. Dies kann unter anderem hier [KeyTyped 2009] oder in der API („No key typed events are generated for keys that don't generate Unicode characters (e.g., action keys, modifier keys, etc.).”) nachgelesen werden. Nur leider steht dies nicht etwa bei der Funktion „KeyTyped“ [KeyTyped 2009] selber, obwohl es nur diese betrifft, sondern im Beschrieb der Klasse „KeyEvent“ [KeyEvent 2009]… 8.3.4. PostgreSQL, JDBC und MySQL Die Sicherung der Datenbanken erfolgt über externe Programme, an welche Parameter übergeben werden. Diese Funktion zu implementieren hat viel Mühe gekostet, da die Fehlermeldungen, wenn überhaupt eine erzeugt wird, nicht in jedem Fall an Java weitergegeben werden und somit häufig un‐
klar blieb, wieso etwas nicht funktionierte. Bis dann jeweils ein Tippfehler, falsche Gross‐
/Kleinschreibung, ein fehlender Leerschlag, ein falscher Parameter oder eine falsche Parameterreihen‐
folge entdeckt werden konnte, brauchte es einige „trial and error“‐Versuche… Die externen Program‐
me reagieren zudem nicht konsequent auf den Aufruf mit Java. Einige Befehle funktionierten direkt im Terminal ohne Problem, aber über einen identischen Aufruf mit Java nicht. Mit MySQL funktionierten Übergabe und Ausführung für das Passwort, die Verbindungsparameter so‐
wie beliebige Tabellen am Ende schlussendlich problemlos. PostgreSQL angeblich „The worlds most advanced opensource database“, wie auf der Herstellterweb‐
seite versprochen wird [PostgreSQL 2009], fiel dagegen eher negativ auf. Bereits bei der Installation unter Windows wird man dazu gezwungen, einen Benutzeraccount ohne Administrationsrechte einzurichten, was ziemliche Mühe bereiten, da das WinXP Rechtemanagement unausgereift ist. Des Weitern stellt einem „pg_dump.exe“ nicht die Möglichkeit zur Verfügung, das Passwort in einem Parameter direkt beim Programmaufruf zu übergeben. Es wird erst nach dem Start abgefragt. Wie man es mit einem Java‐Aufruf nachträglich zum richtigen Zeitpunkt übergibt, konnte weder im PostgreSQL‐eigenen Fo‐
rum noch in anderen Foren zu diesem Problem schlüssig geklärt werden [pg_du. Pw. 2009]. Folglich bleibt das fCQL‐Toolkit hängen, da es darauf wartet, dass der pg_dump‐Prozess zu einem Ende kommt, dieser aber seinerseits nie beendet wird, da er endlos auf eine Passworteingabe wartet. Das Problem kann umgangen werden, indem in einer entsprechenden Konfigurationsdatei (siehe 9.1.2 PostgreSQL und Datei „pgpass.conf“) ein Eintrag mit dem Passwort erstellt wird. Ein häufiges Problem war auch, dass der Aufruf zwar auf den ersten Blick problemlos zu funktionieren schien, jedoch nur leere Files ohne Sicherungsinhalt erstellt wurden. Besonders nervig war, dass „pq_dump“ nicht zuerst den Parameter „database“ und danach die gewünschten tabelname(s) über‐
geben werden konnten. Macht man dies, bekommt man eine Fehlermeldung „too many command‐line arguments (first is „‐t“), obwohl diese beiden Parameter in der Hilfe in dieser Reihenfolge aufgelistet werden (siehe Abbildung 16). 37 Abbildung 16 pg_dump Fehler Übergibt man entgegen den Hilfeangaben zuerst die tablenames und danach den „database“‐Wert, funktioniert die Sicherung. Auch bei der Form der tabelname‐Übergabe ist die Hilfe irreführend: Ob‐
wohl dort („pg_dump ‐‐help“) ausdrücklich steht „–t tablename(s)“ (und nicht etwa „–t tablename“) funktioniert die Übergabe nur in der Form „–t tablename –t tablename“. Weiter PosgreSQL Eigenheiten wurden beim Einlesen der Sicherungsdateien angetroffen. Standard‐
mässig übernimmt die Datenbank die unter Windows benutzten Spracheinstellung „WIN1253“ (für „Deutsch‐Schweiz“). Will man eine solche Sicherung über die JDBC einlesen scheitert dies kläglich: „Der Parameter 'client_encoding' wurde auf dem Server auf WIN1252 verändert. Der JDBC‐Treiber setzt für korrektes Funktionieren die Einstellung UNICODE voraus.“ Also muss man erst den Server auf „UTF‐8“ umstellen, was wiederum nur funktioniert wenn man die Datenbank neu erstellt und dabei alle vorgenommenen Veränderungen an den Metadaten verloren gehen. Interessant ist auch zu sehen was passiert, wenn man mit seinem normalen Benutzeraccount mit Administrationsrechten auf die Idee kommt die Standarteinstellungen für den Zeichensatz des Ser‐
vers, welcher ja dem postgres Benutzer gehört, neu einzustellen. Das funktioniert nicht auf Anhieb, Windows XP besitzt bekanntlich nicht die beste Benutzer‐ und Rechteverwaltung, PostgreSQL benutzt diese ohne auf diese Schwächen zu achten. Wieso sich PostgreSQL hier so widerspenstig zeigt bleibt angesichts der Tatsache das es MySQL, auch ohne mit der Rechteverwaltung in Konflikt zu kommen, schaft ähnliche Sicherheit zu erreichen [Pos.vs. My. 2005] unverständlich. Hat man diese Hürden genommen und die Sicherung noch einmal abgespeichert, nun mit dem UTF‐8 Zeichensatz wird man beim Einlesen von neuen Fehlermeldungen überhäuft. Die ersten paar Befehle zum erstellen der Tabellen in der Datenbank wie „CREATE“ funktionieren tadellos, aber danach wird man von Fehler überhauft. ERROR: COPY from stdin failed: The JDBC driver currently does not support COPY operations.:57014 org.postgresql.util.PSQLException: ERROR: syntax error at or near "WITH 1" org.postgresql.util.PSQLException: ERROR: syntax error at or near "INCREMENT"
org.postgresql.util.PSQLException: ERROR: syntax error at or near "NO" org.postgresql.util.PSQLException: ERROR: syntax error at or near "CACHE"
org.postgresql.util.PSQLException: „ERROR: syntax error at end of input“
etc.!
Wie man in den obenstehenden Fehlermeldungen unschwer erkennen kann, sind zudem die Fehleran‐
gaben von PostgreSQL zu wenig präzise für eine rasche Fehlerbehebung und zeigen manchmal sogar einen falschen Ausschnitt des fehlerhaften Befehls. Zuerst muss dann jeweils der gesamte betroffene Befehl gesucht werden, um dann herauszufinden, was genau den Fehler verursacht hat. In der Regel liegt der Fehler dann nicht am in der Meldung genannten Parameter, sonder an den vorangehenden Elementen. Dass die Fehlermeldungen Ausschnitte zurückgeben, die wenig oder gar nichts mit dem auftretenden Fehler zu tun haben, verwirrt mehr als es zur Fehlerfindung beiträgt! Nützlicher wäre, 38 wenn PostgreSQL den gesamten Befehl zurückgäbe, da die Fehlererkennung offenbar nicht in der Lage ist, den Fehlerbereich innerhalb des Befehls genau einzugrenzen. MySQL gibt solche Fehler viel genauer an, in phpMySQL sieht man sogar noch exakter, welcher Be‐
fehlsteil das Problem verursacht hat. Dies hat die Fehlersuche mit PostgreSQL spezifischen Problemen, also solche Abfragen, welche nicht rasch im praktischen phpMysqladmin Queryfenster eingegeben und überprüft werden konnten, unnötig in die Länge gezogen. Da das Einlesen über den „JDBC Connector“ mit PostgreSQL nicht funktioniert, wurde es bei PostgreSQL in den passenden externen Prozess ausgelagert. Dieser heisst „psql“ und funktioniert in der Konsole problemlos. Zum Beispiel mit „psql ‐d fcql ‐U postgres ‐f „C:\Dokumente und Einstellun‐
gen\Administrator\Desktop\metaBackup.sql““ wird die „metaBackup“ Datei vollständig eingelesen. Kopiert man genau diesen Befehl in einen passenden Aufruf, dessen Aufbau zum Sichern von PostgreSQL und MySQL problemlos funktioniert, und passt ihn mit den entsprechenden Java‐
spezifischen Eigenheiten wie „\““ korrekt an, bleibt das Programm beim Ausführen des Befehls trotz‐
dem hängen. Es produziert nicht einmal Fehlermeldung, auch nicht wenn man einen Prozess‐
Errorstream erstellt, welcher bei anderen Aufrufen mit MySQL die Fehler korrekt weitergibt. Interes‐
santerweise wird der Befehl teilweise korrekt ausgeführt und einige der Tabellen werden sogar erstellt, dann geschieht aber, auch nach langem Warten, nichts mehr. Der Prozess bleibt unbeendet. Bricht man den Prozess manuell nach einer gewissen Zeit ab und liest die Rückmeldungen aus, bleiben diese meistens leer, oder enthalten einige Rückmeldungen, wie das einige Tabellen und Tabelleneinträge bereits bestehen. Jedoch kann nicht der kleinste Hinweis gefunden werden wieso der Prozess nicht zu Ende ausgeführt wird. Deswegen funktioniert in der vorliegenden Version das Einlesen von Siche‐
rungsdateien in eine PostgreSQL‐Datenbank nicht. Ohne Fehlermeldung und ohne neue Idee wie man diesen Fehler auf einem anderen Weg umgehen könnte, war es leider unmöglich, dieses Problem zu beheben. PostgreSQL‐Sicherungsdateien müssen also im Moment über „psql“ eingelesen werden. Dazu kommt weiter, dass PostgreSQL viel empfindlicher auf SQL‐Queries reagiert. So wird zwischen Gross‐ und Kleinschreibung unterschieden und insbesondere das Zeichen „`“, welches nicht nur die Leserlichkeit des SQL‐Syntaxes wesentlich verbessert, sondern auch in „phpMySQL“ im automatischen Abfrageneditor angezeigt wird, führt bei PostgreSQL zu einem Syntax‐Error. Gibt es tatsächlich Daten‐
bankadministratoren, die ihre Datenbankparameter und Tabellennamen nur anhand der Gross‐ oder Kleinschreibung unterscheiden? Desweitern verweigert PostgreSQL jede Ausführung von Queries mit Fremdschlüssel, welche nicht in der logischen (bzw. von PostgreSQL verlangten) Reihenfolge ablaufen. Zum Beispiel wird mit MySQL die Funktion zum Erstellen einer kategorischen linguistischen Variabel problemlos ausgeführt. Dabei wurden die kategorischen Werte überprüft in die Datenbank geschrieben, dann erfolgte der neue Ein‐
trag für die linguistische Variabel. PostgreSQL beschwert sich beim Befehl zum Schreiben der kategori‐
schen Werte darüber, dass der entsprechende Schlüssel der linguistischen Variablen noch nicht existie‐
re und bricht ab. Was mit MySQL kein Problem ist, bereitet bei PostgreSQL Komplikationen und erfordert langwierige Lösungssuche: Auswahl eines möglichst allgemeingültigen Zeichensatzes, verständliche und die Rei‐
henfolge einhaltende Parameterübergabe, Kompatibilität der JDBC mit den wichtigsten Datenbankbe‐
fehlen. Bei der Vorführung des Programms durch Nicolas Werro wurde MySQL benutzt und auch in der Source wurde die MySQL‐Datenbank mitgeliefert. Ausserdem ist mein Wissen über MySQL wesentlich grösser. Deshalb wurde MySQL zum Erstellen dieses Programms verwendet. Leider mussten wegen dem ei‐
genwilligen und restriktiven Verhalten von PostgreSQL in allen in den Code implementierten SQL‐
39 Befehlen alle „`“ entfernt werden, alle Abfrageparameter mit Grossbuchstaben versehen werden so‐
wie zahlreiche „INSERT“‐Funktionen in ihrer Reihenfolge neu strukturiert werden. Jedenfalls ist unter diesem Aspekten klar, wieso MySQL bei vielen Datenbankbenutzern beliebter ist als der wesentlich restriktivere Konkurrent PostgreSQL [Mysql pop. 2008]. 8.3.5. fCQL‐Abfragen anpassen, GUI‐Abhängigkeit Die fCQL‐Abfragen in die Konsole zu integrieren war ein langwieriges Unterfangen. Viele der Funktio‐
nen für fCQL‐Abfragen sind in die grafischen Elemente des Fuzzy‐Klassifikation‐Tabs direkt integriert und die Werte werden häufig direkt in die grafischen Elemente eingelesen. Deswegen mussten viele Funktionen zuerst von den grafischen Elementen getrennt oder so abgeändert werden, dass diese zwar benutzt werden, zum Beispiel zur Überprüfung von Werten, aber nur dann angezeigt werden, wenn auch ein Fuzzy‐Klassifikation‐Tab geöffnet ist. Die grösste Herausforderung stellte die Abfrage‐
kombination von WITH‐ und ALPHA‐Bedingungen dar. Diese funktionierten alleine problemlos und berechneten die korrekten Resultate, eine WITH‐Bedingung gefolgt von einer ALPHA‐Bedingung ergab jedoch nur Resultate, als ob die ALPHA‐Bedingung nicht existierte. Es ist bisher nicht klar wieso es fälschlich dazu kommt, basiert doch die gesamte neue Berechnung auf den bisherigen Funktionen. Es wird mit der höchstmöglichen Priorität versucht dieses Problem noch zu beheben. 8.3.6. Abhängigkeit zwischen dem GUI und der Verbindung Als besondere Herausforderung stellte sich der Umgang mit der Verbindung zwischen der Datenbank und dem Toolkit heraus. Eigentlich ist diese ja einfach aufgebaut und dank den Wrapper‐Klassen ein‐
fach zu erstellen. Die Verbindung wurde jedoch wie nur wenige andere Funktionen und Parameter aus nicht ersichtlichem Grund direkt in die grafische Oberfläche übergeben. Dies hatte zur Folge, dass am Ende alle Funktionen, welche auf die Verbindung im „MainFrame“ zugreifen wollten, im Terminal‐
Modus ins Leere zeigten und nicht mehr funktionierten. Oder das Programm vollständig geladen wur‐
de und nur die grafische Oberfläche ausgeblendet wurde, was natürlich alles andere als effizient war. Deshalb mussten all diese Funktionen umgeschrieben und die Verbindung in die vom grafischen Teil unabhängige Klasse „Tools“ verlagert werden. Der Umbau erforderte die Anpassung der Einträge in 41 Fällen. Die integrierte Suchfunktion von Eclipse hat dabei zum Glück weitergeholfen. Sie ist enorm praktisch, sobald man begriffen hat, dass die Grundeinstellungen des zu suchenden Typs („FileSearch“, „Java‐
Search etc.) bei jeder Suche, erneut eingestellt werden müssen. Wenn man nicht auf „FileSearch“ um‐
stellt, werden unnütze Sachen zusammensucht und auf von den anderen Suchtypen nicht unterscheid‐
barer Ansicht angezeigt. Allerdings führte diese Umstellung zum neuen Problem, dass neue Verbindungen zwar aufgebaut wur‐
den, aber für die Abfragen weiterhin die alte benutzt wurde. Dieser Fehler fiel erst ziemlich spät auf, da nämlich bei einem Neustart alle Einstellungen problemlos übernommen wurden und die Rückga‐
bewerte beider Datenbanken dieselben sind. Eigentlich wäre das Problem ziemlich einfach zu lösen gewesen. Wie im nächsten Abschnitt beschrie‐
ben wird, hat dabei leider Eclipse nicht mitgespielt. 8.3.7. Wenn Eclipse nicht will… Das für diese Arbeit verwendete quelloffene Programmierwerkzeug Eclipse [Eclipse 2009] war im Gros‐
sen und Ganzen sehr hilfreich und erleichterte die Programmierarbeit sehr. Jedoch führte vor allem ein Problem dazu, dass unter anderem der oben erwähnte Verbindungsumbau nicht korrekt verlief. 40 Damit Eclipse den Javacode zuerst kompilieren und dann korrekt ausführen kann, muss Eclipse ein so‐
genannter Path angegeben werden, welcher auf mindestens eine auf dem Computer installierte Javabibliothek zeigt. Anscheinend hat Eclipse hier einen gravierenden Bug. Jedenfalls kommt es ab und zu vor, dass Eclipse die Javabibliothek verliert, ohne dass irgendwelche klaren Ursachen oder vorherige Ereignisse zu erkennen wären. Diesen Verlust bemerkt man als Anwender nicht direkt. Eclipse führt weiterhin den Code aus ohne eine Warnung oder Fehlermeldung anzuzeigen. Mit der Zeit stellt man aber fest, dass der veränderte Code nicht neu kompiliert wird, sondern einfach die alten Klassen ver‐
wendet werden. Je auffälliger die aktuellen Veränderungen am Programm sind, umso rascher erkennt man dies, im Falle der Verbindung, wo sich nur die Verbindungseigenschaften selbst ändern, aber erst nach ziemlich langer Zeit. Denn wenn eine Verbindung nicht richtig funktioniert und nach einer ver‐
suchten Korrektur immer noch genau die gleichen Probleme aufweist, interpretiert man dies eher da‐
hin gehend, dass man etwas noch nicht richtig korrigiert hat, und nicht, dass das benutzte Program‐
mierwerkzeug ausstieg. Kommt man dann irgendwann auf die Idee, dass gar nicht das Problem, wel‐
ches man schon seit Stunden zu lösen versucht, das eigentliche Problem ist, sonder Eclipse selber, so stellt sich als nächstes die Frage, wie man die Kompilierung wieder in Gang bringt. Ob nun das Umko‐
pieren des gesamten „Workspace“ geholfen hat oder das neu Setzten der Javabibliotheken bleibt un‐
klar. Jedenfalls funktionierte danach das Kompilieren wieder korrekt. Wie mir andere Eclipse Benutzer bestätigen konnten, ist es kein lokales, nur auf den zwei für diese Arbeit verwendeten Computern be‐
schränktes Problem sondern ein grundsätzliches Problem von Eclipse. 9. Benutzeranleitung 9.1. fCQL‐Toolkit einrichten Zuerst muss für das Toolkit eine Java‐Umgebung der Version 1.5 oder neuer installiert werden. Dazu kann die Datei „jre‐6u13‐windows‐i586‐p‐s.exe“ im Installationsordner „fCQL Installation“ benutzt werden. Sofern man die Batch‐Dateien, wie in „9.2.13 Erstellen einer Batch‐Datei“ gezeigt, mit dem Java‐Home‐Verzeichnis verlinkt, braucht auch beim Benutzen einer Batch‐Datei keine Umgebungsvari‐
able JAVA_HOME gesetzt zu werden. Danach muss dem Toolkit eine „MySQL“‐ oder „PostgreSQL“‐Datenbank zur Verfügung gestellt wer‐
den. Es gilt sicherzustellen, dass die benutzte Java‐Version mit der im Toolkit verwendeten „JDBC“‐
Version kompatibel ist (5.1.6 bzw. 8.3.604). 9.1.1. MySQL Installieren In „mysql‐5.0.67‐win32.zip“ befindet sich die Installationsdatei, um einen MySQL‐Server zu installieren. Damit eine praktische grafische Oberfläche zur Verfügung steht, sollen ebenfalls die GUI‐Tools „mysql gui‐tools‐5.0‐r17‐win32.msi“ installiert werden. Während der Installation sollen „Detailed Configuration“ und bei den Einstellungen bevorzugt „Deve‐
loper Machine“, „Multifunctional Database“, „Decision Support“ ausgewählt werden. 41 Am Ende der Installation werden Be‐
nutzername und Passwort gesetzt. Standartmässig sind dies für die ver‐
wendete Datenbank, bzw. für die be‐
reits gesetzten Einstellungen „root“ und „admin“. Es können aber natür‐
lich beliebige Benutzernamen und Passwörter verwendet werden. Da‐
nach muss nur noch im Query‐
Browser ein neues Schema (Daten‐
bank) angelegt werden. Standardmäs‐
sig wird der Name „fcql“ verwendet. Wie anschliessend eine Verbindung aufgebaut wird, ist ausführlich in 9.2.3 Datenbankverbindung (7.2.1 Database Abbildung 17 MySQL Schema Connection) erklärt. Eine Beispielskon‐
figuration für die Standartwerte ist in „Abbildung 18“ zu sehen. Danach ist das Toolkit vollständig ein‐
gerichtet und einsatzbereit. 9.1.2. PostgreSQL installieren Etwas umständlicher ist das Einrichten der PostgreSQL‐
Datenbank. Die Probleme beginnen mit der Auswahl der Installationsdatei für Windows XP auf der Herstellerwebseite [Pg.SQL.win 2009]. Dort kann zwischen einem „One Click installer“ und einem „pgInstaller“ gewählt werden. Die „One Click“ Version mag verlockender klingen, ist aber leider ziemlich instabil und bringt oft keine brauchbare Installation zustande. Jedenfalls funktionierte die Installation durch den „One Click Installer“ auch nach mehreren Versuchen und ziemlich viel mehr als ei‐
nem Klicken auf zwei unterschiedlichen Windows XP Rechnern nicht. Es ist daher zu empfehlen, den „pginstaller“ zu benut‐
Abbildung 18 Verbindungseinsellungen zen, auch wenn ein paar Einstellungen mehr vor‐
genommen werden müssen. Dies geschieht mit „postgresql‐8.3.msi“. Es wird ein neuer Benutzeraccount angelegt, welcher nicht immer automatisch einwandfrei konfiguriert ist. Der Benutzer wird hier aus Sicherheitsgründen dazu gezwungen‐ einen Benutzeraccount ohne Administrationsrechte anzulegen. Gegebenenfalls muss in der Computerverwaltung von Windows unter „Lokale Benutzer und Gruppen“ der Account mit dem Namen „postgres“ manuell konfiguriert werden. Abbildung 19 PostgreSQL 42 In meinem Fall wurde das Passwort nicht korrekt übernommen, so dass dieses zu‐
erst neu gesetzt werden muss. Nachdem man diese Hürden genommen hat kann wiederum eine neue Datenbank erstellt werden, am einfachsten über das „pgAdmi‐
nIII“‐GUI (siehe „Abbildung 19“). Danach können das Toolkit gestartet und die Ver‐
bindung konfiguriert werden. Es besteht jedoch das Problem, dass PostgreSQL kei‐
Abbildung 20 nen Parameter für das Passwort kennt, so dass die Metatabellensicherung nur funk‐
tioniert, wenn in der „pgpass.conf“‐Datei die folgenden passende Werte gespeichert wurden: „host:port:*:user:passwort“ zum Beispiel „localhost:5432:*:postgres:1234“. Unter Windows XP befin‐
det sich diese Datei im Verzeichnis „C:\Dokumente und Einstellungen\User \Anwendungsdaten\postgresql“. Wird die entsprechende Datenbank gelöscht, werden gleich auch die entsprechenden Informationen aus der Datei mitgelöscht. Am besten fertigt man davon immer eine Kopie an, damit die „pgpass.conf“‐Datei nicht jedes Mal neu erstellt werden muss! Eine ausführliche deutsprachige Installationsanleitung ist unter „pg install.“ [pg install. 2006] zu finden. 9.1.3. Konfiguration für Linux (Ubuntu) Ein Mysql Server wir unter Ubuntu mit folgenden Befehlen eingerichtet: „sudo apt‐get install mysql‐server sudo /usr/bin/mysqladmin“ “sudo apt‐get install mysql‐server” “sudo apt‐get install apache2” “sudo apt‐get install php5” “sudo apt‐get install php5‐mysql” “sudo apt‐get install phpmyadmin” “sudo ln ‐s /usr/share/phpmyadmin/ /var/www/phpmyadmin” (benötig da ansonsten phpmyadmint im Browser nicht gefunden wird) Eine detailierte Anleitung mit Problemlösungen ist unter [mysql Ubu. 2009] zu finden. Unter Ubuntu erfolgt die Installation des Postgresql Servers wie folgt: Mit dem Befehl „sudo apt‐get install postgresql“ wird das passende Packet installiert. Danach muss der Apache‐Server neu gestartet werden: „sudo /etc/init.d/apache2 restart“. Danach sollte ein Datenbankadministrator festelegt werden. Dies geschieht mit den Befehlen „sudo su postgres ‐c psql template1“ und „ALTER USER postgres WITH PASSWORD '1234'“. Damit pgsql aktiviert wird muss zusätzlich der Befehl „sudo ‐u postgres createlang ‐d datenbankname plpgsql“ benutzt werden. Um das praktische pgadmin Interface nutzen zu können muss mit „sudo apt‐get install phppgadmin“ dieses zusätzlich installiert werden und in der Datei „/usr/share/phppgadmin/conf/config.inc.php“ muss ''$conf['extra_login_security'] = true;“ gesetzt werden. Damit schlussendlich das Interface über den localhost über die Adressleiste aufgerufen werden kann muss noch „sudo ln ‐s /usr/share/phppgadmin /var/www/phppgadmin“ benutzt werden. Danach muss auch unter Ubuntu die Zeile „host:port:*:user:passwort“ zum Beispiel „local‐
host:5432:*:postgres:1234“ in die pgpass.conf Datei eingefügt werden. 43 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Häufig muss zudem die Konfiguration in der Datei „pg_hba.conf“ in „/etc/postgresql/8.3/main” abge‐
ändert werden. Wie dies genau geschieht kann unter [pg. Ubuntu 2009] nachgelesen werden. In meinem Fall, für eine Lokale Installation reichten folgende neue Einträge, damit der Zugriff funktionierte: local all all md5 local all all ident sameuser 9.1.4. fCQL‐Toolkit Konfiguration Bei jedem Start des Toolkits werden Einstellungen aus der Datei „config.dat“ gelesen, sofern diese am Ausführungsort des Tools existiert. Diese kann mit einem Texteditor abgeändert und so konfiguriert werden, dass bereits beim ersten Start alle Einstellungen wie gewünscht vorhanden sind. Natürlich können diese aber auch im Programm selber vorgenommen werden. Sofern das Programm korrekt beendet wird, werden diese dann automatisch gespeichert. #config.dat #Tue Apr 21 15:02:10 CEST 2009 fcql.db.database=fcql fcql.db.login=postgres fcql.db.password=1234 fcql.db.driver=PostgreSQL fcql.db.hostName=localhost fcql.db.port=5432 fcql.db.autoConnect=true fcql.gui.console.exception=false fcql.gui.console.warning=true fcql.gui.console.save=true fcql.gui.console.result=true fcql.gui.geometry.width=993 fcql.gui.geometry.height=770 Programmcode 15 config.dat Die ersten beiden Zeilen enthalten den Dateinamen sowie das Datum der letzten Veränderung. In den Zeilen 3 bis 9 können die in „set connect“ verwendeten Parameter angegeben werden. Danach können die Konsoleeinstellung gesetzt werden. Die Zeilen 14 und 15 erlauben es schlussendlich, die Auflösung der Breite und Höhe des Hauptfensters festzulegen. Zusammengefasst: 1. Java Umgebung installieren 2. MySQL mit Tools oder PostgreSQL installieren 3. Datenbank erstellen und Zugriffsrechte einstellen 4. Verbindung konfigurieren und Firewall‐Policy erstellen 6. gegebenenfalls config.dat anpassen 5. Programm starten Will man lokal einen einfachen und vor allem gut überblickbaren Zugriff auf die Datenbank haben, ist die Installation von xampp zu empfehlen („xampp‐win32‐1.6.8.exe“). Damit können im Browser per 44 phpmyadmin die Datenbankinhalte einer MySQL‐Datenbank angezeigt und vor allem sehr einfach und übersichtlich überprüft und korrigiert werden. Eine vergleichbare Funktion bietet pgphpadmin, dieser kann einfach in xampp integriert werden [pPg. Xampp 2008]. 9.2. Konsole‐Anleitung Die Konsole‐Anleitung ist von der Struktur her nahezu identisch aufgebaut wie die Erklärungen zur gra‐
fischen Oberfläche bei Werro [Werro 2008]. Die entsprechenden Kapitel werden jeweils in Klammern bei einem entsprechenden Abschnitt angegeben. Für alle aufgeführten Beispiele von Befehlseingaben wurde soweit möglich das fcql_example‐Beispiel verwendet. Die Werte dieses Beispiels können mit dem entsprechenden Befehl zusammen mit den grundlegenden Metatabellen geladen werden. So können die Beispiele einfach selber ausprobiert und verstanden werden. Wie das Beispiel nur mittels Konsolebefehle erstellt wird, zeigt Anhang 12.2 (fcql_example mittels Konsole einfügen). 9.2.1. GUI Oberfläche: Einen Überblick über die grafische Oberfläche das Kapitel 7.2 in Werros Doktorarbeit [Werro 2008]. 9.2.2. fCQL‐Toolkit‐Oberfläche (7.2 User Interface) Den bestehenden drei Haupttabs wurde ein vierter Tab hinzugefügt. Neben den beiden Data‐Analysis‐
Tabs, welche immer angezeigt werden, können nun die Fuzzy Klassifikation‐ und ein Konsole‐Tab in beliebiger Abfolge ein und ausgeblendet werden. Der neue Konsole‐Tab, gezeigt in „Abbildung 21“, enthält ein grosses Ausgabefenster (grün) und eine Eingabezeile (orange), in welche die Befehle einge‐
geben werden können. Abbildung 21 Konsole 45 9.2.3. Datenbankverbindung (7.2.1 Database Connection) Nachdem das Programm gestartet wurde, muss zuerst eine Verbindung hergestellt werden. Ein beson‐
deres Augenmerk sollte dabei der Firewall gelten. Diese blockiert häufig solche Verbindungen und muss je nach Produkt mit einer neuen Policy zugelassen werden. Die Parameter für eine Verbindung brauchen nur einmal eingegeben zu werden. Die Verbindungsin‐
formationen werden beim Schliessen des Programms gesichert und später automatisch (sofern „auto‐
connect“ aktiviert wurde) oder nach der Eingabe des Kennwortes wiederverwendet. Falls noch keine Datenbank mit dem spezifizierten Namen existiert, wird diese bei MySQL automatisch erstellt, sofern die erforderlichen Zugriffsrechte auf die Datenbank vorhanden sind. Der Benutzer wird im Gegensatz zur grafischen Version nicht automatisch auf die Metatabellen hinge‐
wiesen. Es wird hier davon ausgegangen, dass sich der Benutzer bewusst ist, dass diese zu Beginn noch nicht existieren, oder er dies sofort bemerkt, da ohne sie überhaupt nicht weiter gearbeitet werden kann. Zudem kann dies über eine beliebige SQL‐ oder fCQL‐Abfrage ohne Aufwand festgestellt werden. Möchte man die Metatabellen erstellen benutzt man den entsprechenden Metabefehl 9.2.10 (Metatabellen sichern und einlesen (neu)). Um eine Verbindung aufzubauen, muss der Befehle „set connect“ benutzt werden. Dieser Befehl ver‐
steht verschiedene Parameter: „connect ‐h host ‐p port ‐d database ‐u user ‐pw password ‐dr driver ‐ac autoconnect“ Dies sind:  „‐h host“ den Hostname der Datenbank an  „‐p port“ den für die Verbindung verwendeten Port (Bei MySQL meist 3306, bei PostgreSQL 5432)  „‐d database“ den Datenbanknamen.  „‐u user“ und „‐pw password“ den Benutzernamen und das dazu passende Benutzerkennwort  „‐dr driver“ ob es sich um eine MySQL‐ oder PostgreSQL‐Datenbank handelt  „‐ac autoconnect“ gibt an ob das Loginpasswort gespeichert und bei einem Neustart des Pro‐
gramms die Verbindung automatisch wiederhergestellt wird oder nicht. Das Passwort wird in diesem letzten Fall in Klartext in der „config.dat“ Datei abgespeichert. Dieser Si‐
cherheitsaspekt sollte beim Verwenden von „–ac“ beachtet werden! Ist „–ac” deaktiviert, kann mit „set connect ‐pw admin” das Passwort für die aktuelle Sitzung angegeben oder mit „set connect ‐pw admin ‐ac true” nachträglich eingestellt werden, dass es beim nächsten Schliessen des Programms ab‐
gespeichert wird. Es müssen also nicht alle Parameter gleichzeitig angegeben werden. Solange aber nicht alle Parameter gesetzt wurden, funktioniert die Verbindung natürlich nicht. Darauf wird jeweils mit einer Rückmel‐
dung in der Konsole hingewiesen: „Warning!: check your connect syntax, not all values have been set”. In der untenstehenden Tabelle sind alle gültigen Parameter‐Werte aufgelistet. set connect Parameter
Gültiger Typ, Werteinhalt ‐h String, IP oder Hostname ‐p Integer, Port ‐d String, Datenbankname ‐u String, Benutzername ‐pw String, Passwort ‐dr String, MySQL/PostgreSQL Tabelle 4 set connect 46 Ein vollständiger Verbindungsaufbau kann also folgendermassen aussehen: „set connect ‐h localhost ‐p 3306 ‐d fcql ‐u root ‐pw admin ‐dr MySQL ‐ac on” für MySQL bzw. „set connect ‐h localhost ‐p 5432 ‐d fcql ‐u postgres ‐pw 1234 ‐dr PostgreSQL ‐ac true” für PostgreSQL. Wurde die Verbindungsinformation erfolgreich gesetzt, wird dies mit folgender Rückmeldung bestä‐
tigt: „new connection information has been set“. 9.2.4. SQL‐Abfragen (7.2.2 Data Analysis Panels) Die Information der Data‐Analysis‐Panels kann über die Konsole nicht direkt angezeigt werden. Es kann jedoch mit der neu integrierten Möglichkeit, SQL‐Abfragen zu machen, auf dieselben Werte zugegrif‐
fen werden. Eine beliebige SQL‐Abfrage kann mit dem Befehl „sql“ eingegeben werden. Es erfolgt dann eine Ausgabe des Resultats im geöffneten Konsoletab oder dem geöffneten Terminal. Mit einem neu‐
en Befehl oder dem Drücken von „Enter“ in der Kommandozeile der Konsole kann zur normalen Konso‐
leansicht zurück gewechselt werden. Zudem wird das Resultat zusätzlich in einer Textdatei abgespei‐
chert, sofern „SaveToFile“ (siehe 9.2.11 Konsole‐Einstellungen (neu)) aktiviert ist. Ein Beispiel für einen SQL‐Befehl ist „sql SELECT * FROM `fcql_example` WHERE `id` >990“. Diese Ab‐
frage erzeugt das in „Abbildung 22“ ersichtliche Resultat und eine entsprechende Resultatedatei mit dem Namen „SQLResults.html“. Abbildung 22 SQL Abfrage 47 Wird ein SQL‐Befehl benutzt, der keine Rückgabewerte hat sondern Dateneinträge verändert oder hin‐
zufügt, wird angegeben wie viele Zeilen der Befehl verändert hat: "Ok. 2 row(s) affected." Bei einem leeren Rückgabewert dagegen erscheint die Meldung „Empty query result“. 9.2.5. Abfragen und Anzeigen von Fuzzy‐Klassifikationen (neu) Damit auf bequeme Weise eine Fuzzy‐Klassifikation erstellt werden kann, muss der Benutzer jederzeit sehen können, was für Werte bereits in seiner (auch unvollständigen) Fuzzy‐Klassifikation gesetzt wur‐
den und welche Werte zur Verfügung stehen. Dafür sind verschiedene Befehle in die Konsole integriert, welche ausführliche Abfragen sämtlicher Werte ermöglichen. Die untenstehende „Tabelle 4“ enthält diese Befehle. Bei allen Abfragen können alle vorhandenen Werte angezeigt werden, indem kein zusätzlicher Parameter angegeben wird. Alter‐
nativ können nur die Werte eines einzelnen Elementes angezeigt werden, wenn die Abfrage mit dem passenden Parameter gemacht wird. Zum Beispiel werden bei der Abfrage mit „mship fclaif“ alle vor‐
handenen Fuzzy‐Klassifikationen aufgelistet, mit „mship fclaif fCQL example“ nur die „fcql_example“‐
Klassifikation. Befehl: Zeigt an: busdat tablename Spalten mit Maximal‐ und Minimalwert der Business Daten. fclaif fc_value Fuzzy‐Klassifikation (Fuzzy Classification) mit Namen und Grund‐
werten linvar fc_value Linguistische Variablen mit zugehörigen Termen ratatt lv_value Werte einer LinVar. mit Rattionallen Attributen catatt lv_value Werte einer LinVar. mit Kategorischen Attributen linter lv_value Linguistische Terme mit Membershipfunktions‐Werten confun lt_value Membership‐Funktion (Continuous Function) mit Intervall, Start‐ und Endpunkten stefun lt_value Treppenfunktion (Step Function) und zugehörige Werte concep fc_value Konzeptnamen (Concept) conval c_value Werte des Konzepts (Concept Values) comatt c_value Werte einer LinVar. des Typs Composed Attribute fclass fc_value Fuzzy‐Klassen‐Namen und Beschrieb (Fuzzy Class) Tabelle 5 Show Funktionen Um die vorhandenen „Business Daten“, auf welchen die Fuzzy Klassifikation basieren zu überblicken, kann der Be‐
fehl „busdat tablename“ benutzt werden. Dann wird, wie in „Abbildung 23“ zu sehen, eine Übersicht sämtlicher Tabellenspalten angezeigt. Abbildung 23 busdat 48 Mit „fclaif fc_value“ kann die Grundinformation einer Fuzzy‐Klassifikation abgerufen werden. Abbildung 24 fclaif Mit „linvar fc_value“ können alle vorhandenen oder die linguistischen Variabeln einer Fuzzy Klassifika‐
tion angezeigt werden. Abbildung 25 linvar Mit „ratatt lv_value“ können die benutzten ratio‐
nalen Attribute mit ihren zugehörigen Tabellenna‐
men sowie dem Attributtyp angezeigt werden. Abbildung 26 ratatt Ist ein kategorisches Attribut vorhanden, können die verschiedenen Katego‐
rienamen und IDs per „catatt lv_value“ abgefragt werden. Abbildung 27 catatt Mit „linter lv_value” werden linguistische Terme samt zugehörigen Membershipfunktionen angezeigt. Abbildung 28 linter 49 Die Membershipfunktionen können mit „confun lt_value“ genauer angezeigt werden. Abbildung 29 confun Um kategorische Attribute mit deren Kategorien und Membershipdegree anzuzeigen kann „stefun lt_value“ benutzt werden. Abbildung 30 stefun Um erstellte Konzepte anzuzeigen wird der Befehl „concep fc_value“ verwendet. Abbildung 31 concep Zum Anzeigen der Konzeptwerte kann „conval c_value“ benutzt werden. Abbildung 32 conval Mit „comatt c_value” können die Verbindungen zu Konzepten von Composed‐
Attributen angezeigt werden. Abbildung 33 comatt Mit „fclass fc_value” schlussendlich werden alle Fuzzy‐Klassen zusammen mit den zugehörigen linguis‐
tischen Termen und linguistischen Variabeln angezeigt. 50 Abbildung 34 fclass Nachstehende „Tabelle 6 mship show Befehle“ bietet eine detaillierte Übersicht zu allen Befehlen für die Anzeige aller FK.‐Werte. Links stehen alle möglichen Eingabearten jedes Befehls. In der rechten Tabellenhälfte wird jeweils ein Beispiel dafür gegeben und beschrieben, welche Bedingungen erfüllt werden müssen, damit die Abfrage Werte zurück gibt bzw. gültig ist. 51 //MSHIP********************************************** Membership show commands
mship: (show)
fclaif
fc_name / fc_id fclaif
Example:
‐/ fCQL example / 1 fclaif
fc_id
Restrictions:
‐/ existing fc_name / fc_id fclaif
fc_name
linvar
linvar
linvar
ratatt
ratatt
ratatt
catatt
catatt
catatt
linter
linter
linter
stefun
stefun
stefun
confun
confun
confun
fclass
fclass
fclass
concep
concep
concep
comatt
comatt
comatt
conval
conval
conval
fc_id
fc_name
lv_id (id)
lv_name
lv_id (id)
lv_name
lv_id (id)
lv_name
lt_id (id)
lt_name
lt_id (id)
lt_name
fc_id
fc_name
fc_id
fc_name
c_id
c_name
c_id
c_name
linvar
Example:
Restriction:
ratatt
Example:
Restriction:
fc_name / fc_id ‐/ fCQL example / 1 ‐/ existing fc_name / fc_id lv_name* / lv_id ‐/ Turnover / 1 ‐/ existing lv_name / lv_id catatt
Example:
Restriction:
lv_name* / lv_id
‐/ Turnover / 1
‐/ existing lv_name / lv_id linter
Example:
Restriction:
lv_name* / lv_id
‐/ Turnover / 1
‐/ existing lv_name / lv_id stefun
Example:
Restriction:
lt_id
‐/ 1
‐/ existing lt_id
confun
Example:
Restriction:
lt_id
‐/ 1
‐/ existing lt_id
fclasss
Example:
Restriction:
(fc_name / fc_id)
fcql example / 5
existing fc_name / fc_id concep
Example:
Restriction:
fc_name / fc_id
‐/ fcql example / 1
‐/ existing fc_id / fc_name conatt
Example:
Restriction:
c_name / c_id
‐/ Discount / 1
‐/ existing c_id / c_name conval
Example:
Restriction:
c_name / c_id
‐/ Discount / 1
‐/ existing c_id / c_name Tabelle 6 mship show Befehle 52 9.2.6. Erstellen einer Fuzzy‐Klassifikation (7.2.3 Fuzzy Classification Definition Wizard) Der eigentliche Hauptteil des Programms bildet der Fuzzy‐Klassifikations‐Tab. Mit dem damit verbundenen Wizard kann eine Fuzzy‐Klassifikation erstellt werden. Der Wizard führt den Benützer Schritt für Schritt durch den Prozess. In der Konsole gibt es Funktionen, welche genau dieselben Aufgaben erfüllen wie der Wizard. Dort muss man allerdings selber die kor‐
rekte Reihenfolge beachten und einhalten. Dies geschieht mit den „mships“ (membership set) Funktionen. Es ist empfehlenswert zuerst einige Beispiele über den GUI auszuprobieren und sich über den genauen Aufbau einer Fuzzy‐Klassifikation im Klaren zu sein, bevor man über die Konsole selber Hand anlegt. Ausserdem sollte man vorher das Beispiel im Anhang 12.2 (fcql_example mittels Konsole einfügen) konsultieren und verstehen. Eine Fuzzy‐Klassifikation wird über insgesamt sechs verschiedene Schritte erstellt. In der Konsole werden der erste und der sechste Schritt vom GUI in Schritt 1 zusammengefasst. Es ist jedoch jederzeit möglich, die Werte des bisherigen sechsten Schrittes nachträglich mit „fclaiu“ zu verändern. (siehe „Tabelle 7 Mship set‐Befehle“). Befehl: Setzt: fclaifs fc_value Fuzzy‐Klassifikation (Fuzzy Classification) mit Namen und Grund‐
werten fclaiu fc_value Aktualisiert beliebige Werte der Fuzzy‐Klassifikation (Fuzzy Classi‐
fication) mit Namen und Grundwerten linvars fc_value Linguistische Variablen ratatts lv_value Werte einer LinVar. mit Rattionallen Attributen catatts lv_value Werte einer LinVar. mit Kategorischen Attributen linters lv_value Linguistischer Term confuns lt_value Membership Funktion (Continuous Function) mit Intervall, Start‐ und Endpunkten stefuns lt_value Treppenfunktion (Step Function) und zugehörige Werte conceps fc_value Konzept mit Konzeptwerten (Concept) fclasss fc_value Fuzzy‐Klassen‐Namen und Beschrieb (Fuzzy Class) Tabelle 7 Mship set‐Befehle Fuzzy‐Klassifikation (fclaifs) Der Befehlsaufbau entspricht „fclaifs fc_name +relation_name +relation_id +and_operator +and_argument +or_operator +or_argument”. Dabei enthält:  „fc_name“ den Namen der Fuzzy Klassifikation für späteres Ansprechen der Fuzzy Klassi‐
fikation  „+relation_name“ den Tabellennamen der gewünschten Business‐Daten  „+relation_id“ die Relations‐Identifizierung, welche zur Kombination von Relationalen Attributen und „Composed“‐Attributen benötigt wird, um eine FK.‐Hierarchie zu erstel‐
len  „+and_operator“ den Aggregations‐Operator für die Intersektion. $„+and_argument“ den passenden Aggregations‐Operator‐Wert der Intersektion  „+or_operator“ den Aggregations‐Operator für die Vereinigung (Union).  „+or_ argument“ den passenden Aggregations‐Operator‐Wert der Vereinigung.  „+description“ die Beschreibung der Fuzzy‐Klassifizierung Nachfolgende „Tabelle 7“ enthält eine Übersicht über alle Parameter und beschreibt, wann ein Wert gültig ist. 53 mships fclaifs Parameter Gültiger Typ, Werteinhalt fc_name String, Fuzzy Klassenname +relation_name String, Gültiger Tabellenname +relation_id String, Gültige Identifizierung +and_operator String, Gamma/g, Minimum/m +and_argument Integer, [0,1] +or_operator String, Gamma/g, Maximum/m +or_ argument Integer, [0,1] +description String/ε, Beschreib/ (192 80 77) Tabelle 8 fclaifs Ein konkretes Beispiel des Befehls ist: mship fclaifs fCQL example +fcql_example +id +Gamma+0.5 +Maximum +0 +This
is small…”
Fuzzy‐Klassifikations‐Update (fclaifu) Mit dem „fclaifu“‐Befehl kann nach dem Erstellen jederzeit eine beliebige Anzahl der Para‐
meter einer bestehenden Fuzzy Klassifikation abgeändert werden. Einziger Unterschied zum ursprünglichen Befehl ist der zusätzliche Parameter „fc_value“, welcher die zu verändernde Fuzzy Klassifikation mit Name oder ID angibt. mships fclaifu Parameter Gültiger Typ, Werteinhalt fc_value String, fc_id oder fc_name +fc_name/ε String, Fuzzy Klassenname +relation_name/ε String, Gültiger Tabellenname +relation_id/ε String, Gültige Identifizierung +and_operator/ε String, Gamma/g, Minimum/m +and_argument/ε Integer, [0,1] +or_operator/ε String, Gamma/g, Maximum/m +or_ argument/ε Integer, [0,1] +description/ε String/ε, Beschreib/ Tabelle 9 fclaifu Ein Beispiel für den Update‐Befehl ist: mship fclaifu id +name fCQL example +and_arg 0.5 54 Linguistische Variabeln (linvars) Als zweiter Schritt können die linguistischen Variablen definiert werden. Dazu dient der Be‐
fehl „linvar“. Gültiger Typ, Werteinhalt mships linvars Parameter Relationales Attribut Composed Attribut fc_value String, fc_id oder fc_name +lv_name String, beliebiger linguistischer Variablen Name +lv_type String, Relation Attribute String, Composed Attribute +domain_min Integer, sinnvolles Intervallminimum +domain_max Integer, sinnvolles Intervallmaximum +ra_name gültiger Spaltennamen ‐ +ra_attribute_type +Numeric/+Categoric ‐ +c_ids ‐ Integer, existierende con‐
cept IDs 




Tabelle 10 linvars „fc_value“ gibt mit ID oder dem Namen, die zugehörige Fuzzy‐Klassifikation an. „+lv_name“ bestimmt den Namen der neuen linguistischen Variabeln. „+lv_type“ Dabei wird zwischen den linguistischen Variabeln‐Typen „Relational Attribu‐
te“ und „Composed Attribute“ in „+lv_type“ unterschieden. „+ra_name“ gibt die passende Spalte der Tabelle an, welche mit der Variable in Verbin‐
dung gebracht werden soll. Genau wie im GUI kann jedes Attribut (jede Spalte) nur ein‐
mal ausgewählt werden. „+ra_attribute_type“: Beim einem Relationalen Attribut muss zudem zwischen dem nu‐
merischen (Numeric) und dem kategorischen (Categoric) Typ unterschieden werden. Bei Attributen mit numerischen Werten müssen jeweils ein Intervall sowie eine Ober‐ und eine Untergrenze angegeben werden. Dazu dienen „+domain_min“ und „+domain_max“. Der vorhandene Intervallbereich kann mit „busdat“ nachgeschaut werden, es können jedoch beliebige Werte verwendet werden. Das Intervall kann also, wie im GUI, kleiner oder grösser gewählt werden als diese vorhandenen Intervallgrenzen. Bei Composed‐Attributen werden die IDs der gewünschten Kategorien nacheinander eingegeben („+c_ids +1 +2 …“) linvars fc_value +lv_name +lv_type +domain_min +domain_max
+ra_attribute_type
linvars fc_value +lv_name +lv_type +domain_min +domain_max +c_ids
+ra_name
Beispiele: mship linvars 0 +Turnover +Relation Attribute +0 +800 +turnover +Numeric
mship linvars 0 +Turnover +Relation Attribute +turnover +categoric
mship linvars fcql example +Test +Composed Attribute +0 +800 +1 2 4
Linguistische Terme (linters) Im dritten Schritt werden den linguistischen Variabeln linguistische Terme hinzugefügt. Jede Variable muss mindestens einen Term enthalten. Jede Term‐Definition beginnt mit dem Be‐
fehl „linters lv_value +lt_name“. 55 mships linters Parameter lv_value +lt_name Gültiger Typ, Werteinhalt String, lv_id oder lv_name String, beliebiger linguistischer Term Name 255 204 0 Tabelle 11 linters Der Parameter „lv_value“ beschreibt entweder mit dem Variabeln‐Namen oder der passen‐
den Variabeln‐ID die entsprechende Variable. „+lt_name“ ist ein beliebiger Name für den neu erstellten linguistischen Term. Ein Beispiel einer Term‐Definition ist: mship linters 0 +Low Bei Termen muss ebenfalls zwischen numerischen und kategorischen Werten unterschieden werden. Numerische Terme können mit Membershipfunktionen beschrieben werden, das geschieht in der Konsole mit dem Befehl „confuns“. Gültiger Typ, Werteinhalt mships confuns Parameter Lineare Funktion Sigmoide (S‐Shaped) Funktion lt_id String, vorhandene lt_id +function type Linear Function/l S‐Shaped Function/s +from_value Zahl, Intervall x‐Achse Startwert +to_value Zahl, Intervall x‐Achse Endwert +startvalue Zahl, Intervall y‐Achse Startwert +endvalue Zahl, Intervall y‐Achse Startwert +slope ‐ Zahl, Slope‐Wert [2‐20] +inflexion point ‐ Zahl, Infelxions‐Wert 0.00‐1.00 Tabelle 12 confuns Dabei wird zwischen den sigmoiden und linearen Funktionstypen unterschieden. Lineare Funktionen enthalten im Gegensatz zu den sigmoiden keinen „+slope“‐ und „+inflexion point“‐Parameter. Alle restlichen Parameter “lt_id, +Function type”, “+from_value”, “+to_value”, “+startvalue” und “+endvalue” besitzen beide Typen.  „lt_id” beschreibt über die passende LinTer. ID den linguistischen Term, welchem die Membershipfunktion hinzugefügt werden soll. Es ist nicht möglich LinTer. direkt über den Namen anzusprechen, da mehrere gleichnamige LinTer. pro Fuzzy Klassifikation vor‐
handen sein können. Somit wäre unklar, welchen man ausgewählt hat, ausser man wür‐
de mit einem zusätzlichen Parameter auch die gewählte LingVar. angeben. Die ID dage‐
gen ist unverwechselbar.  „+function type“ gibt an, ob es sich um eine „S‐Shaped Function“ oder „Lineare Functi‐
on“ handelt, und kann mit „s“ und „l“ abgekürzt eingegeben werden.  „+from_value“ und „+to_value“ geben den Start‐ und Endwert des Intervalls an. Es ist sinnvoll und empfehlenswert mehrere zusammenhängende Membershipfunktionen in der aufsteigenden Reihenfolge ihrer Intervall Start‐ und Endwerte einzufügen.  „+startvalue“ und „+endvalue“ schlussendlich geben den y‐Wert zwischen 0‐1 bei Start und Ende der Funktion an. 56 Bei einer sigmoiden Funktion müssen zusätzlich ein Slope‐Wert „+slope“ von 2 bis 20 und einen Inflexionspunkt „+inflexion point“ von 0.00 bis 1.00 angegeben werden. Beispiel einer linearen Funktion: confuns lt_id +Function type +from_value +to_value +startvalue +endvalue
mship confuns 1 +Linear Function +2 +777 +0 +1
oder vereinfacht: mship confuns 1 +l +2 +777 +0 +1
Beispiel einer sigmoiden Funktion: confuns lt_id +Function type +from_value +to_value +startvalue +endvalue
+slope +infelxion point
mship confuns 0 +S-Shaped Function +0 +777 +0 +1 +2 +1.00
oder vereinfacht: mship confuns 1 +s +2 +777 +0 +1 +2 +1.00
Kategorische Werte werden mit Hilfe des Befehls „stefuns“ gesetzt. Dabei wird mit dem Pa‐
rameter „lt_id“ ebenfalls der zugehörige LinTer. angegeben und mit „+cat_name“ mit einer beliebigen Anzahl von Membership‐Werten, in Verbindung gebracht. Dabei beschreiben die ungeraden Werte jeweils den Kategorienamen und die geraden Werte den dazugehörigen Membership‐Wert zwischen 0.00 und 1.00. mships stefunsParameter Gültiger Typ, Werteinhalt lt_id String, vorhandene lt_id +cat_id String, vorhandener Kategorie‐ID degree String, Membership Wert der Kategorie 0.00‐1.00 cat_name degree* Zahl, Intervall x‐Achse Endwert *Beliebige Anzahl Tabelle 13 stefuns Beispiel eines kategorischen linguistischen Terms: stefuns lt_id +cat_name degree (cat_name degree)
mship stefuns 5 +1 0.3 2 0.4
Fuzzy‐Klassen, (Fuzzy Classes, fclasss) Nachdem alle linguistischen Terme und linguistischen Variabeln gesetzt wurden können im vierten Schritt die automatisch generierten Fuzzy Klassen bearbeitet werden. Sie enthalten bereits einen automatisch generierten Namen sowie eine passende Beschreibung. Dazu wird der Befehl „fclasss“ benutzt. Über die „id“ wird die gewünschte Klasse ausgewählt und mit „+fcl_name“ sowie „+description“ umbenannt und neu beschrieben. mships fclasss Parameter Gültiger Typ, Werteinhalt id String, vorhandene Klassen ID +fcl_name String, gewünschter Klassenname +description (optional) String, Beschreibt die gewählte Klasse Tabelle 14 fclasss Beispiel: fclasss id +fcl_name +description
mship fclasss 5 +C5-NewClassName +Very important text about this fclass!
Konzept (Concept conceps) 57 Als fünfter und letzter Schritt können Konzepte erstellt werden. Diese können unter ande‐
rem mit Composed‐Attributen verwendet werden. Dazu dient der Befehl „conceps“. Damit klar ist, zu welcher Klassifikation das Konzept gehört, gibt „fc_value“ die passende „fc_id“ oder den passenden „fc_name“ an. Danach werden die gewünschten Konzeptwerte jeder zugehörigen Klasse mit „+concept_id“ angegeben. mships conceps Parame‐
Gültiger Typ, Werteinhalt ter fc_value String, vorhandene fc_id oder fc_name +fcl_name String, gewünschter Klassenname +concept_id* String, Beschreibt Gewichtung jeder Klasse * der vorhandenen Fuzzy‐Klassenen entsprechende Anzahl Tabelle 15 conceps Beispiel: conceps fc_value +concept_id (+concept_ids)
mship conceps fcql example +Discount +20 +10 +5 +0
Nachdem diese sechs Schritte abgearbeitet wurden, kann die Fuzzy‐Klassifikation zur Aus‐
wertung mit fCQL‐Abfragen verwendet werden. 9.2.7. Fuzzy‐Klassifikationselemente löschen (neu) Damit existierende Werte wieder entfernt werden können, wurden weitere Befehle imple‐
mentiert. Sie sollen ein Fuzzy‐Klassifikationselement mit den jeweiligen zugehörigen Werten löschen. So soll möglichst vermieden werden, dass es zu Datenmüll und Inkonsistenz in der Datenbank kommt (vor allem bei MySQL). Mit „mshipd“ gefolgt von den Befehlen in „Tabelle 16 mship delete“ können die verschiedenen Elemente‐Typen gelöscht werden. Befehl: Löscht: fclaifd fc_value die gesamte Fuzzy Klassifikation (Fuzzy Classification) linvard fc_value die gesamte Linguistische Variablen mit Termen linterd lv_value den gesamten Linguistische Term mit Funktionen concepd fc_value das Konzep (Concept) mit Konzeptwerten Tabelle 16 mship delete Es können jedoch nicht alle Elemente bzw. Tabelleneinträge direkt gelöscht werden, da viele Einträge voneinander abhängig sind und nur automatisch mit dem Haupteintrag gelöscht werden dürfen. Die untenstehende „Abbildung 35“ verdeutlicht im groben Überblick diese Abhängigkeiten. Einen detaillierten Überblick über alle Tabelleneinträge und Zusammenge‐
hörigkeiten, welche beim Löschen eine Rolle spielen, bietet die zweite Seite von „Tabellen‐
übersicht.pdf“. 58 mship (delete): fclaifd fc_name / fc_id Example: fCQL example / 1 Restrictions: existing fc_name / fc_id linvard fc_name / fc_id Example: fCQL example / 1 Restriction: existing fc_name / fc_id
+(lv_name) / +(lv_id)
+Turnover / +2
existing lv_name / lv_id
fcql_ra fcql_cat fcql_ca fcql_fcd fcql_fcl confound/stefund
linterd lv_id +lt_name / +lt_id
Example: margin / 1 +Low / +2
Restriction: existing lv_id existing lt_name / lt_id
fclassd
concepd fc_name / fc_id +concept_name / +concept_id
Example: fcql example / 1 +Discount / 1
Restriction: existing fc_id / fc_name existing concept_name / concept_id
Abbildung 35 msihp delete Befehle fclasss Der Befehl „fclaifd“ löscht die gesamte Fuzzy‐Klassifikation auf einmal. Wie das Beispiel in „Abbildung 36“ zeigt, gibt die Rückgabe an, wie viele Tabelleneinträge bei jeder Aktion ge‐
löscht wurden. Im Beispiel wurden zwei linguistische Terme mit jeweils sieben weiteren Ein‐
trägen in den von linguistischen Termen abhängigen Tabellen gelöscht. Weiter wurden zwei linguistische Variablen so wie zwei Konzepte gelöscht. Ist das Löschen ohne bekannte Fehler erfolgt, wird eine abschliessende Rückmeldung angezeigt. Abbildung 36 fclaifd MySQL gibt bei „row(s)“ den exakten Wert zurück, wie es die entsprechende Javafunktion auch erwartet [executeUp. 2009]. PostgreSQL dagegen zeigt an Stelle der wirklich gelöschten Anzahl Zeilen jeweils nur eine 1 an. Statt alle Werte auf einmal zu löschen, können auch einzelne Terme und Variabeln gelöscht werden. Zum Löschen von Termen dient der Befehl „linterd“. Auch hier wird wiederum die Anzahl der gelöschten Zeilen angezeigt. Im Beispiel von „Abbildung 37“ wird zweimal ein linguistischer Term gelöscht; dies löscht insgesamt vier Einträge, nämlich den eigentlichen Term‐Eintrag, einen Membershipfunktionswert‐Eintrag (in der Tabelle „fcql_meta_cf“) und die zwei dazugehörigen Zeilen der Membershipfunktion („fcql_meta_p“). Wird der letzte Term einer Variable gelöscht, wird dies beim Löschen des zweiten Terms angezeigt, wie in diesem Beispiel vorgeführt. 59 Abbildung 37 linterd Zum Löschen der linguistischen Variabeln wird der Befehl „linvard“ benutzt. Hierbei werden ebenfalls alle zugehörigen Terme gelöscht. Sind, wie im Beispiel von „Abbildung 38“, keine Terme in der LinVar. Vorhanden, wird man darauf hingewiesen. Abbildung 38 linvard Mit der letzten Löschfunktion „concepd“ kann man die vorhandenen Konzepte löschen. Wiederum erfolgt eine Rückmeldung. Abbildung 39 concepd 9.2.8. fCQL‐Abfragen (7.2.4 Fuzzy Querying Process) Nachdem eine Fuzzy‐Klassifikation erstellt wurde, kann diese mit fCQL‐Abfragen analysiert werden. Standardmässig findet im GUI eine Abfrage der Membership‐Werte der finalen Fuz‐
zy‐Klassen sowie den damit in Verbindung stehenden Konzeptwerte aller Elemente mit allen Fuzzy‐Klassen statt. Dabei müssen weder „where“‐ noch „with“‐ oder „alpha“‐Bedingungen gebraucht werden. Auch „CLASSIF“ wird nicht benötigt. Standardmässig werden alle linguis‐
tischen Terme aufgelistet. Damit man mit einer Konsolen‐fCQL‐Abfrage dasselbe Resultat erzielt, muss nur die „FROM“,Bedingung mit der Angabe der entsprechenden Klassifikations‐
tabelle benutzt werden. Dabei werden automatisch die richtigen LingTer.‐Spalten ausge‐
wählt und dann angezeigt. Soll eine andere Kombination von LinTer.‐Spalten angezeigt werden, kann mit den Befehlen „addlv“ und „removelv“ ein beliebiger Term hinzugefügt oder entfernt werden, genauso wie im GUI mit der Maus Attribute selektiert und deselektiert werden können. Es muss bei die‐
sem Befehl unbedingt die Gross‐ und Kleinschreibung beachtet werden (auch bei MySQL). Sämtliche Abfragekombinationen sind in „Tabelle 16“ aufgelistet. 60 Befehl: addlv/removelv (CLASSIF) getlv FROM WHERE WITH ALPHA AND/OR or Beschrieb: Setzt die LinTer.‐Spalten, welche im Resultat angezeigt werden Zeigt momentan in CLASSIF ausgewählte Spaltennamen an Wählt die passende Fuzzy‐Klassifikations‐Tabelle aus Zusätzliche Bedingungen vergleichbar mit SQL WHERE WITH Bedingung mit Klasse oder LinTer. Attributten ALPHA Bedingung mit Klasse oder Konzept AND oder OR Bedingungen in WHERE, WITH und ALPHA Bedin‐
gungen or Bedingungen für WITH Term Tabelle 17 fCQL‐Abfragen Beispiel: fcql FROM fCQL example
Zum Setzten zusätzlicher Bedingungen muss einfach der entsprechende Befehl mit der rich‐
tigen Syntax nach der „FROM“‐Bedingung ausgeschrieben werden. Untenstehende Beispiele zeigen einige Möglichkeiten. Einige Beispiele mit zusätzlichen Bedingungen: fcql
fcql
fcql
FROM
fcql
fcql
ment
FROM fCQL example where turnover < 3 or id < 1 or id = 2
FROM fCQL example alpha FClass - C4 - Don't Invest < 0.02
FROM fCQL example alpha Concept - Discount < 2
fCQL example with Turnover High or Low
FROM fCQL example with class is C1 - Commit Customer
FROM fCQL example with class C1 - Commit Customer OR class C2 - AugMargin OR class C3 - Augment Turnover
9.2.9. fCQL‐Resultate (7.2.5 Results Evaluation) An der Anzeige der Resultate wurden keine wesentlichen Änderungen vorgenommen. So‐
lange der „Fuzzy Classifications“‐Tab geöffnet ist wird weiterhin dasselbe Resultat wie bisher angezeigt, sogar wenn die Abfrage über die Konsole erfolgt. In der Konsole wird bis auf die Diagramme ein identisches Resultat angezeigt. Genauere Erklärungen dieser Werte findet man in Werro ([Werro 2008] Chapter 7.2, S. 130). 9.2.10. Metatabellen sichern und einlesen (neu) Eine gänzlich neue Möglichkeit bieten die „meta“‐Befehle, welche in die Konsole integriert wurden. Mit diesen Befehlen können die Metatabellen gespeichert und wiedereingespielt werden. Über die „meta“‐Befehle ist es zudem möglich, beliebige Tabellen zu sichern und später wieder einzulesen. Mit dem Befehl „meta dump“ werden alle Metatabellen in einer MySQL‐ oder PostgreSQL‐konformen Textdatei (automatisch je nach aktiver Datenbank) ge‐
speichert. Diesem Befehl können wiederum verschiedene Parameter übergeben werden. Jeder dieser Parameter kann bei Bedarf in beliebiger Reihenfolge benutzt werden. Mit „‐dl“ kann ein Speicherort sowie ein Name für die Sicherungsdatei angegeben werden. Diese Angabe ersetzt den standardmässigen Dateiname und Pfad. Mit „‐fn“ kann der Dateiname verändert werden. 61 Mit „‐mdl“ kann der Pfad zum Datenbank‐eigenen Sicherungsprogramm MySQLdump.exe oder pg_dump.exe angegeben werden. Diese werden für das Sichern verwendet und sind Bestandteil jeder herkömmlichen MySQL‐ oder PostgreSQL‐Installation. Zusätzliche Tabellen werden mit Hilfe des Parameters „‐t“ angegeben. dump Parameter: Gültiger Typ, Werteinhalt: ‐dl String, Pfad und Dateiname (Dump location) ‐fn String, Dateiname (File name) ‐mdl String, Pfad zu MySQLdump.exe/pg_dump.exe (Mysqldump location)
‐t String, Tabellennamen (table) Tabelle 18 dump Beispiele: meta
meta
meta
meta
dump
dump
dump
dump
-dl C:\Dokumente und Einstellungen\User\desktop\backup.sql
-mdl C:\Programme\PostgreSQL\8.3\bin\pg_dump
-fn fileName.sql
-t fcql_example fcql_meta_c
Um diese Dateien später wieder einzulesen, wird der „meta read“‐Befehl benutzt. Auch hier kann der Pfad angepasst werden. Mit „‐rl“ gibt man den Pfad wie beim Sichern mit „‐dl“ und Dateinamen an und „‐fn“ gibt wiederum nur den Dateinamen an. (Hier fehlt im Moment der Eintrag zur Angabe des Pfades zu psql, da diese Aufgabe bisher nicht wirklich zuverlässig funktioniert.) read Parameter: Gültiger Typ, Werteinhalt: ‐rl String, Pfad und Dateiname (Read location) ‐fn String, Dateiname (File name) Tabelle 19 read Beispiele: meta read -rl D:\Privat\metaBackup.sql
meta read -fn metaBackupTest.sql
Mit dem „‐meta create”‐Befehl können die leeren Metatabellen in die Datenbank geladen werden. Folgt dem Befehl ein beliebiger Parameter, wird das fcql_example‐Beispiel mit in die Datenbank geladen. Möchte man diese Tabellen verändern, können die Dateien „emptymetaschema.sql“ (ent‐
spricht den leeren Metatabellen) und „fcql_example_metaschema.sql“ (mit fcql_example Beispiel) durch eine beliebige, gleichnamige Sicherungsdatei ersetzt werden. create Beschrieb create liest leere Metatabellen ein create x liest Metatabellen mit fcql_example Werten ein Tabelle 20 create Beispiele: meta create x
meta create
62 9.2.11. Konsole‐Einstellungen (neu) Neben dem „set connect“‐Befehl, welcher bereits weiter oben in „9.2.3 Datenbankverbin‐
dung (7.2.1 Database Connection)“ erklärt wurde, bietet die Konsole ein paar zusätzliche Anzeige‐ und Einstellungsmöglichkeiten. Die „set exception, warning“‐ und „saveFile“‐Befehle geben jeweils zurück, in welchen Zu‐
stand der Wert gesetzt wurde. „set status“ zeigt diese Werte in einer Übersicht an. Mit „set result“ kann, das letzte berechnete fCQL‐Resultat angezeigt werden. set Befehl
Beschrieb connect MySQL oder PostgreSQL Verbindung erstellen exception schaltet die Anzeige von Fehlermeldungen an oder aus warning schaltet die Anzeige von Warnmeldungen an oder aus saveFile schaltet das Speichern der Resultate an oder aus status zeigt aktuelle Einstellungen der Konsole an result zeigt das letzte berechnete fCQL Resultat an Tabelle 21 set Beispiele: set
set
set
set
connect -h localhost -p 3306 -d fcql -u root -pw admin -dr MySQL -ac on
warning
exception
saveFile
Abbildung 40 set status Sämtliche hier erklärten Befehle können über die Eingabe von „help“ in der Konsole ange‐
zeigt werden. Jeder Befehlsbereich kann auch einzeln abgefragt werden indem jeweils der Bereich angegeben wird, gefolgt von „help“, z.B. „mship help“, „set help“ etc… Befehl Hilfeinhalt: help Zeigt alle Hilfeinformationen an sql help Zegt SQL Abfrage Hilfe fcql help Zeigt fCQL Abfrage Hilfe meta help Zeigt Metatabellen Sicherungs Hilfe set help Zeigt Konsolleeinstellungen Hilfe mship help Zeigt alle Membership Hilfe mshipsh help Zeigt Hilfe für die Membership Anzeige mships help Zeigt Membership Hilfe für das Erstellen mshipd help Zeigt Membership Hilfe für das Löschen Tabelle 22 Hilfsanzeige Die Konsole kann mit dem Befehl „quit“ geschlossen werden, im Terminal‐Modus bedeutet dies so viel, wie dass das gesamte Programm beendet wird. 63 9.2.12. Benutzen des fCQL‐Toolkits mit Kommandozeileninterpreter Nachdem im vorhergehenden Teil sämtliche Konso‐
lenbefehle beschrieben wurden, soll in diesem Teil erklärt werden, wie diese Befehle über ein Terminal, zum Beispiel das cmd‐Terminal von Windows, be‐
nutzt werden können. Das Programm kann über die Jar‐Datei mit dem Namen „fcql1.10.jar“ direkt im Terminal gestartet werden. Übergibt man beim Star‐
ten einen beliebigen Parameter, wird das fCQL‐
Toolkit im Terminal‐Modus gestartet und kann über das Terminal gesteuert werden. Wird kein Parameter übergeben, startet das Programm im bisherigen GUI‐
Modus. Nach dem Start‐Parameter kann sofort eine beliebige Abfolge von Konsolenbefehlen folgen. Mit „quit“ wird das Programm geschlossen. Abbildung 41 CMD Fenster Starten des Programms mittels der Jar Datei: java –jar fcql1.10.jar GUI‐Modus‐Start java –jar fcql1.10.jar start Terminal‐Modus‐Start, Danach Befehlseingaben java –jar fcql1.10.jar start [Befehl] [Befehl] Terminal‐Modus‐Start mit Befehlsübergabe Das CMD Fenster (Kommandozeileninterpreter) hat standardmässig eine Auflösung von 80 Zeichen in der Breite. Das ist natürlich für viele Eingaben und Rückgaben schlicht zu wenig. Die Grösse kann jedoch temporär geändert werden mit dem Befehl „mode“ in der Form „mode Breite, Höhe“, zum Beispiel „mode 140, 50“. Eine andere Möglichkeit die Auflösung nachhaltig zu ändern ist: Rechtsklick auf „Eigenschaften“, „Layout“, dort unter „Fenstergrös‐
se“ die gewünschten Werte eingeben (siehe obige „Abbildung 41 CMD Fenster“). 9.2.13. Erstellen einer Batch‐Datei Die Befehle müssen nicht unbedingt im Terminal eingetippt werden, sondern können auch zuerst in einer Batchdatei gespeichert werden und dann in einem Zug in das Programm gela‐
den und ausgeführt werden. Diese Befehle müssen jeweils in eckigen Klammern stehen, z.B. [fcql FROM fCQL example] [meta dump ‐mdl C:\\Programme\\PostgreSQL\\8.3\\bin\\pg_dump] [quit]. Dazu wird eine Batchdatei mit folgender Struktur erstellt: 64 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 REM -----------------------------------------------------------REM Name:
.BAT
REM Autor: Hofer Philipp
REM Datum: 6. Juni 2009
REM -----------------------------------------------------------@ECHO OFF
REM WINXP
REM set CDJRE=C:\Programme\Java\jre1.5.0_16\bin
REM WINDOWS 7
REM set CDJRE="C:\Program Files (x86)\Java\jre6\bin"
set CDJRE=C:\Programme\Java\jre6\bin
C:
CD C:\Dokumente und Einstellungen\Administrator\Desktop
@ECHO ON
call %CDJRE%\java.exe -jar fcql1.10.jar start [fcql FROM fCQL example] [meta dump -mdl C:\\Programme\\PostgreSQL\\8.3\\bin\\pg_dump] [quit]
Pause
Programmcode 16 Batch‐Datei In Zeile 11 werden unnötige und unerwünschte Rückgabewerte der darauffolgenden Befehle ausgeschaltet. In „CDJRE“ wird der Pfad zur installierten Javabibliothek angegeben. Danach wird der Pfad zur fCQL‐Toolkit‐jar‐Datei angegeben. In Zeile 19 werden die Rückgabewerte wieder eingeschalten. In der darauffolgenden Zeile wird schlussendlich das Programm mit dem „start“‐Parameter im Terminal‐Modus aufgerufen. Dabei werden sämtliche Befehle, welche in der Form „[Be‐
fehl] [Befehl]“ folgen, ausgeführt. Schlussendlich wird das Programm mit „quit“ beendet. Mit „Pause“ wird verhindert, dass sich das Terminal Fenster von selber schliesst. So können nach dem Ausführen der mit der Batdatei übergebenen Befehle wie oben beschrieben belie‐
bige weitere Befehle direkt im Terminal eingegeben werden, solange das Programm nicht mit dem Befehl „quit“ oder „close“ beendet wird. Einige Beispiel‐Batdateien sind im Ordner „Beispieldateien“ zu finden. 65 10.
Zusammenfassung Zu Beginn dieser Bachelorarbeit bestand das fCQL‐Toolkit aus insgesamt 24‘616 Zeilen Code verteilt auf 283 Java Klassen. Dieses wurde um verschiedene Benutzer‐Requirements erwei‐
tert. Im Bereich der grafischen Oberfläche wurde eine Konsole in das Programm integriert. Neue SQL Befehle und die Integration der fCQL‐Abfragen in die Konsole ermöglichen, im Zu‐
sammenspiel mit der neuen Schnittstelle, vereinfachte und reproduzierbare Abfragen mit dem Toolkit, über herkömmliche Terminals oder Batchdateien. Fuzzy‐Klassifikationen kön‐
nen nun ebenfalls über eine Konsole erstellt werden. Aufwendige Klicks durch zahlreiche Menus der grafischen Oberfläche bleiben einem ersparrt. Die Resultaten‐Speicherung ermöglicht es mehrere unterschiedliche Ergebnisse miteinander vergleichen, auswerten und aufbewahren zu können. Die neue Sicherungsfunktion ermög‐
licht es jederzeit ein Abbild des aktuellen Metatabellen‐Zustandes zu machen und wieder‐
einzuspielen. Um diese Veränderungen zu realisieren musste die Struktur des bestehenden Programmco‐
des verstanden und vor allem überblickt werden. Ein Überblick hierzu wird in „5 Aufbau des fCQL‐Toolkit gegeben“. Die verschiedenen Erweiterungen wurden in eine möglichst prakti‐
sche und logische Reihenfolge gebracht, damit später weniger Probleme zwischen den ver‐
schiedenen Neuerungen entstehen sollten. Diese Reihenfolge ist im „7 Vorgehensweise“ genauer beschrieben. Beim Programmieren wurde mit der Implementierung der Konsole (siehe 7.2.1 Konsole (1.‐
4.)) gestartet. Die Integration der Konsole in das bestehende Programm‐Mainframe führte zu einem unerwarteten Problem. Dieses konnte nicht vollständig behoben werden, aber soweit umgangen werden, dass nur ein zusätzlicher Mausklick bei bestimmten Vorgängen nötig ist (siehe 8.3.2 Tab hinzufügen, Tab erneuern, Tab entfernen…). Die Integration von SQL Befehlen in die Konsole dagegen führte zu keinen grösseren Prob‐
lemen und war relativ rasch umgesetzt. Die Sicherung der Mettatabellen dagegen brachte wieder einige Eigenheiten und Schwierig‐
keiten mit sich. Die Interaktion zwischen Java, JDBC und der Datenbank MySQL und insbe‐
sondere PostgreSQL war eine grosse und langwierige Geduldsprobe (siehe 8.3.4 PostgreSQL, JDBC und MySQL). Die darauffolgende Integration der fCQL Abfragen führte auch immer mal wieder zu kleinen oder grösseren Überraschungen, diese hielten sich jedoch mit einer Ausnahme im zu erwar‐
tenden Bereich. Abgesehen vom Problem mit der Kombination von WITH und ALPHA Para‐
meter (siehe „8.3.5 fCQL‐Abfragen anpassen, GUI‐Abhängigkeit“), welches erst ziemlich spät beim ausführlichen Testen und Vergleichen der Resultate festgestellt wurde, war dieser Be‐
reich reine Fleissarbeit, um die zusätzlich benötigten Überprüfungen einzubauen, siehe „8.1.4fCQL Abfragen (10.‐11.)“. Die noch grössere Fleissarbeit stellte die darauffolgende Implementation der Fuzzy‐
Klassifikation‐Abfragen und ‐Erstellung dar. Unzählige Felder mussten auf eine ähnliche, aber nicht identische Weise, mit Funktionen überprüft und danach abgespeichert bzw. gelöscht werden können. Abgesehen davon, dass bis zum Ende nicht ganz sicher gestellt werden konnte, dass die Composed Attribute korrekt in die Klassifikation eingebaut wurden stellte dieser Bereich kaum Schwierigkeiten dar. Einzig die SQL Syntax, vor allem die diesbezügli‐
chen PostgreSQL Eigenheiten führten, wie in „8.3.4 PostgreSQL, JDBC und MySQL“ beschrie‐
ben zu stundenlangem Fehlersuchen. Als letztes wurde die Schnittstelle zu Terminaleingaben und Batchdateien erstellt. Abgese‐
hen vom Aufheben der Abhängigkeit zwischen der Konsole und der grafischen Oberfläche, 66 konnte dieser Bereich ohne grösseren Probleme realisiert werden (siehe „8.3.6 Abhängigkeit zwischen dem GUI und der Verbindung“). Ein ziemlich unangenehmes Problem wurde im Verlaufe der Arbeit zweimal mit Eclipse ange‐
troffen (siehe „8.3.7 Wenn Eclipse nicht will…“). In „9 Benutzeranleitung“ werden alle neuen Bedien‐Möglichkeiten erklärt. Der Abschnitt „12 Anhang“ bietet weiter interessante und hilfreiche Information zur Bedienung des fCQL‐
Toolkits. Diese Veränderungen vergrössern das Programm um 10‘433 Zeilen auf insgesamt 35‘049 Zeilen Programmcode und 254 Klassen. Hoffentlich können diese Neuerungen dank der detaillierten Benutzeranleitung für möglichst zahlreiche interessante Fuzzy‐Klassifikations Analysen verwendet werden. Das fCQL‐Toolkit kann, dank einer möglichst vollständigen Dokumentation, einfacher weiterentwickelt und verbessert werden. Sicher gibt es einige Verbesserungsmöglichkeiten, instabile Stellen und Bugs in den neuen erstellten Teilen des Programms. Trotz dem Anspruch möglichst wenig neue Fehler und Schwachstellen einzubauen, was immer wieder zu langwieriger Fehlersuche (und viereckigen Augen vom ewigen auf den Monitor starren) führte, wird während dem Benützen sicher die eine oder andere Unregelmässigkeit entdeckt werden. Natürlich sind auch bereits während dem Schreiben des Berichts Stellen aufgefallen, welchen eine Verbesserung oder Ergänzung gut täte. Die Fuzzy‐Klassifikationen Erstellung sind nicht immer wirklich stabil und vor allem das Laden führt häufig zu Fehlermeldungen. Dieses Problem bestand bereits in Version 1.05. Einige diesbezügliche Fehler konnten zwar behoben werden, andere bestehen aber weiterhin. Eine zusätzliche Steigerung der Stabilität in diesem Bereich wäre wünschenswert, aber nicht ein‐
fach zu realisieren. Die Resultatedateien enthalten im Moment nur die Resultate. Die Abfrage, welche zu diesem Resultat geführt hat, wird aber nicht darin abgespeichert. Abfragen in die Resultatedateien zu integrieren würde sicher das Vergleichen der Resultate weiter vereinfachen. Das Einlesen von Sicherungsdateien in eine PostgreSQL Datenbank funktioniert nur sehr sel‐
ten, ist ziemlich Fehleranfällig und instabil. Hier scheint eine neue bessere Lösung, wenn man den eine findet, angebracht. Die Weiterentwicklung des fCQL‐Tools, war sehr Interessant und Stellenweise ziemlich for‐
dernd. Die Beschäftigung mit dem für mich ganz neuen Gebiet der Fuzzy‐Klassifizierung fas‐
zinierend. Vor allem hat diese Arbeit aber meinen Java‐Wissen, auch dank der hervorragen‐
den 1474 seitigen Java‐Bibel von Ullenboom [Ullenboom 2009], stark erweiter. 67 11.
Literaturverzeichnis: 11.1. Bücher 1. [100% Java 2000] 100% Pure Java Cookbook Guidelines for achieving the 100% Pure Java Standard, Sun Microsystems, Inc., Palo Alto 2000 2. [Descloux 2008] Descloux J.‐F., Gestion de projets informatiques, Faculté des SES Fribourg 2008, Support de cours 3. [Ellis 2001] Ellis J., Ho L., Fisher M., JDBC™ 3.0 Specification, Microsystems, Inc., Palo Alto 2001
4. [Gamma 2001] Entwurfsmuster, Gamma E., Helm R., Johnson R. , Vlissides J., Programmer's Choi‐
ce, Entwurfsmuster Elemente wiederverwendbarer objektorientierter Software, Addison Wesley Verlag, Übersetzung aus dem amerikanischen Original, Bonn 2001. 5. [Horstman 2005a] Horstman Cay S., Cornell G., Core Java 2 Volume I‐Fundamentals, seventh edition, Sun Microsystems, Press, Santa Clara 2005. 6. [Horstman 2005b] Horstman Cay S., Cornell G., Core Java 2 Volume II‐Advanced Features, seventh edition, Sun Microsystems, Press., Santa Clara 2005. 7. [McConnell 1993] McConnell S., Code Complete, Microsoft Press 1993, p. 395 8. [Meier 2007] Meier A., Relationale und postrelationale Datenbanken, 6. Auflage, Springer, Berlin 2007 9. [Nançoz 2004] Nançoz C., mEdit membership function editor for fCQL‐based architecture, Univer‐
sity of Fribourg 2004, Master Thesis. 10. [Pawlan 2000a] Pawlan M., Essentials of the JavaTMProgramming Language Part I: A Hands‐On Guide, Sun Microsystems, Inc., 2000, PDF Tutorial 11. [Pawlan 2000b] Pawlan M., Essentials of the JavaTMProgramming Language Part II: A Hands‐On Guide, Sun Microsystems, Inc., 2000, PDF Tutorial 12. [Schindler 1998] Schindler G., Fuzzy Datenanalyse durch Kontextbasierte Datenbankanfragen, Deut‐
scher Universitäts‐Verlag, Wiesbaden, 1998. 13. [Silberschatz 2005] Silberschatz A., Henry F. Korth, Sudarshan S., Korth: Database System Concepts, 5th ed. International Edition, MC Graw Hill, 2005. 14. [Ullenboom 2009] Ullenboom C., Java ist auch eine Insel, Galileo Computing, 7. aktualisierte Auflage, 2007. 15. [Werro 2008] Werro N.: Fuzzy Classification of Online Customers, University of Fribourg 2008, Dissertation. 16. [Zadeh 1965] Zadeh L. A.: Fuzzy Sets, In: Information and Control 8, University of California 1965, PDF. 17. [Zimmermann. 2001] Zimmermann H.‐J., Fuzzy Sets Theory and its Applications. Kluwer Academic, Dor‐
drecht, 4th edition, 2001. 18. [Zumstein 2007] Zumstein D.: Customer Performance Measurement, University of Fribourg 2007, Master Thesis. 11.2. Webseiten In der ersten Spalte wird jeweils das Jahr angegeben, in welchem der Inhalt der Hompage erstellt wurde, wenn kein Datum angegeben ist, wird das aktuelle Jahr angegeben. 19. [Campwood 2009] Name und Link Campwood Software, The freeware program SourceMonitor lets you see inside your software source code http://www.campwoodsw.com/sourcemonitor.html 20. [Eclipse 2009] Eclipse http://www.eclipse.org/ 21. [executeUp. 2009] Java.SQL http://java.sun.com/j2se/1.5.0/docs/api/java/sql/Statement.htm
l#executeUpdate(java.lang.String) 22. [fCQL Project 2008] fCQL Toolkit extension
http://diuf.unifr.ch/is/project_fcql_console 23. [HCodCon. 2009] Highlight Code Converter
http://www.andre‐simon.de/index.html Letzter Besuch:
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
68 24. [Java 6.14 2009] 25. [Java Swing 2009] 26. [Java2s 2000] 27. [Javaworld 2001] 28. [JText.‐Pane. 2009] 29. [KeyEvent 2009] 30. [KeyListen. 2009] 31. [KeyTyped 2009] 32. [MySQL 2009] 33. [Mysql pop. 2008] 34. [mysql Ubu. 2009] 35. [pg install. 2006] 36. [pg. Ubuntu 2009] 37. [Pg.SQL.win 2009] 38. [pg_du. Pw. 2009] 39. [Pos.vs. My. 2005] 40. [Postg Win7 2009] Java SE Downloads
http://java.sun.com/javase/downloads/index.jsp Java Swing Demo 6.10
http://download.java.net/javadesktop/swingset3/SwingSet3.jnlp Java2s SQL Interpreter, A general‐purpose SQL interpreter pro‐
gram http://www.java2s.com/Code/Java/Database‐SQL‐
JDBC/AgeneralpurposeSQLinterpreterprogram.htm Javaworld Resources
http://www.javaworld.com/javaworld/jw‐11‐2001/jw‐1130‐
j2ee.html?page=4 Java 6 JTextArea und JTextPanel
http://java.sun.com/javase/6/docs/api/javax/swing/JTextArea.ht
ml http://java.sun.com/javase/6/docs/api/javax/swing/JEditorPane.
html Java 6 KeyEvent http://java.sun.com/javase/6/docs/api/java/awt/event/KeyEven
t.html Java 6 KeyListener
http://java.sun.com/javase/6/docs/api/java/awt/event/KeyListe
ner.html Java 6 KeyTyped http://www.java‐forum.org/awt‐swing‐swt/54317‐pfeiltasten‐
fuer‐keyevent.html http://java.sun.com/javase/6/docs/api/java/awt/event/KeyListe
ner.html#keyTyped(java.awt.event.KeyEvent) MySQL http://dev.mysql.com/downloads/mysql/5.1.html#downloads Why is MySQL more popular than PostgreSQL?
http://www.xaprb.com/blog/2008/05/18/why‐is‐mysql‐more‐
popular‐than‐postgresql/ Mysql mit Ubuntu
http://ubuntuforums.org/showthread.php?t=114129&page=3 http://ubuntuforums.org/showthread.php?t=841173&page=2 PostgreSQL Installation
http://www.pg‐forum.de/h‐ufig‐gestellte‐fragen‐faq/918‐
installation‐von‐postgresql‐unter‐windows.html PostgreSQL Ubuntu
http://forum.ubuntuusers.de/topic/postgresql‐8.2‐::‐probleme‐
beim‐einrichten.../#post‐1171616 http://linuxdesk.wordpress.com/2008/10/10/ident‐
authentication‐failed‐for‐user‐postgresql/ http://www.pg‐forum.de/installation‐von‐postgresql/3060‐
postgres‐unter‐ubuntu‐8‐10‐a.html PostgreSQL http://www.postgresql.org/download/windows PostgreSQL Passwort http://www.administrator.de/Postgre_mit_einem_Batch_sicher
n_aber_wie%3F.html http://archives.postgresql.org/pgsql‐novice/2006‐
07/msg00160.php http://www.pg‐forum.de/allgemeines/567‐postgresql‐8‐
backup.html PostgreSQL vs. MySQL
http://www‐css.fnal.gov/dsg/external/freeware/pgsql‐vs‐
mysql.html PostgreSQL mit Windows 7
06.07.2009 06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
06.07.2009
69 http://archives.postgresql.org/pgsql‐general/2009‐
01/msg00783.php 41. [PostgreSQL 2009] PostgreSQL http://www.postgresql.org/ 42. [pPg. Xampp 2008] How to install PostgreSQL and phpPgAdmin Support in Xampp http://practicalfoss.blogspot.com/2008/09/how‐to‐install‐
postgresql‐and.html 43. [Scan.‐Tok. 2009] Java 6 Scanner und Tokenizer
http://java.sun.com/javase/6/docs/api/java/util/Scanner.html http://java.sun.com/javase/6/docs/api/java/util/StringTokenizer.
html 44. [wiss. Arbeit. 2009] Richtlinien wissenschaftliches Arbeiten
http://diuf.unifr.ch/is/userfiles/file/studentprojects/Richtlinien_
wissenschaftliches_Arbeiten_IS.pdf 06.07.2009
06.07.2009
06.07.2009
06.07.2009
11.3. Nach Themen Zu Java‐Programmierung: [100% Java 2000], [executeUp. 2009], [Gamma 2001], [Horstman 2005a], [Java 6.14 2009], [Java Swing 2009] [Java2s 2000], [Javaworld 2001], [JText.‐Pane. 2009], [KeyEvent 2009], [KeyListen. 2009], [KeyTyped 2009], [McConnell 1993], [Pawlan 2000a], [Pawlan 2000b], [Scan.‐Tok. 2009], [Ullenboom 2009] Über das fCQL‐Toolkit: [fCQL Project 2008], [Nançoz 2004], [Werro 2008], Über die Fuzzy Logik: [Schindler 1998], [Silberschatz 2005], [Zadeh 1965], [Zimmermann. 2001], [Zumstein 2007] Datenbank: [Ellis 2001], [Meier 2007] PostgreSQL und MySQL: [MySQL 2009], [Mysql pop. 2008], [mysql Ubu. 2009], [pg install. 2006] [pPg. Xampp 2008], [pg_du. Pw. 2009], [pg. Ubuntu 2009], [Pos.vs. My. 2005], [Postg Win7 2009], [PostgreSQL 2009], [Pg.SQL.win 2009] Sonstige: [Descloux 2008], [Horstman 2005b], [wiss. Arbeit. 2009] Für diese Arbeit verwendete Programme: [Campwood 2009], [Eclipse 2009], [HCodCon. 2009] 70 12.
Anhang 12.1. Befehlsübersicht description
close console
command:
quit
sql:
sqlquery
help
make sqlquery
fcql help information
//fCQL********************************************************************fCQL functions
fclaif
show all existing Fuzzy Classification with id
linvar
fc value
show all existing Linguistic Variables of the selected Fuzzy Classification
linter
fc value
show all existing Linguistic Terms of the selected Linguistic Variables
addlv
lv name
CLASSIFY
set Linguistic Variables (all lv)
getlv
show selected Linguistic Variables (Linguistic Variables in CLASSIFY)
removelv
remove last set Linguistic Variable
result
to display the last stored Query result
FROM
tablename WHERE WITH ALPHA
lingtermname AND / OR lingtermname(s), WITH ALPHA
classname OR conceptname/classname ALPHA
conceptname AND / OR conceptname/classname ALPHA
ALPHA
customisedclass AND / OR
-example: fcql FROM fCQL example
use Fuzzy Classification
-example: fcql FROM fCQL example where turnover < 3 or id < 1 or id = 2
-example: fcql FROM fCQL example alpha FClass - C4 - Don't Invest < 0.02
-example: fcql FROM fCQL example alpha Concept - Discount < 2
-example: fcql FROM fCQL example with class is C1 - Commit Customer
-example: fcql FROM fCQL example with class C1 - Commit Customer OR class C2 Augment Margin OR class C3 - Augment Turnover
-example: fcql FROM fCQL example with Turnover High or Low
result
display the last stored FCQL Query result
help
this help information
WHERE
WITH
clear
help
reset fcql query
fcql help information
//META********************************************************************Metatable
tions
meta:
dump:
save all metatables
-dl dumpLocation
set location for dumpfile ()
-mdl mysqldumpLocation set location of mysqldump.exe ()
-fn filename
set and use filename
-t tabelnames
dump custom tables
read:
-rl
-fn filename
read in SQL tables
set read location of file
set and use filename
create
create
delete
help
create empty meta tables
create meta tables with example
delete meta tables
display meta help information
-xx
func-
71 //SET
tings
set:
************************************************************************Console
connect
result
warning
exception
saveFile
status
help
set-
set a new connection (connection of GUI)
-h hostname set hostname (hostname of GUI)
-p port
set port (port of GUI)
-d database
set database (database of GUI)
-u user
set user (user of GUI)
-pw password set password (password of GUI)
-dr drivertype set drivertype (drivertype of GUI)
-ac yes / no set autoconnect (autoconnect of GUI)
enable / disable result of query in console (on)
enable / disable warnings in console (on)
enable / disable exceptions in console (on)
enable / disable file save (on)
display connection state: connected/set state: no connection
display set help information
//MSHIPSHOW************************************* Membership show commands
Command:
Description:
mship show
find membership information and values
busdat tablename
show all Business Data with interval values
-example: mship busdat fcql_example
fclaif fc_value
show all Fuzzy Classification or from Fuzzy Classification with fc_id/fc_name
-example: mship fclaif 0
-example: mship fclaif fcql example
linvar fc_value
show all Linguistic Variable or from F. Classification with fc_id/fc_name
-example: mship linvar fcql example
ratatt lv_value
show all Rational Attribute Values or from Ling. Variable with lv_id/lv_name
catatt lv_value
show all Category Values or from Linguistic Variable with lv_id/lv_name
linter lv_value
show all Linguistic Term Values or from Linguistic Variable with
lv_id/lv_name
confun lt_value
show all Continuous Function or from Linguistic Variable with lt_id/lt_name
stefun lt_value
show all Step Function or from Linguistic Variable with lt_id/lt_name
fclass fc_value
show all Fuzzy Classes or with fc_id/fc_name and Fuzzy Class Definition
concep fc_value
show all Fuzzy Concepts or from Fuzzy Classification with fc_id/fc_name
comatt c_value
show all Composed Attribute Values or from Concept with c_id/concept name
conval c_value
show all Concept Values or from Concept with c_id/concept name
-example: mship conval discount
mshipsh help
this help information
//MSHIPSET************************************** Membership set commands
Command:
Description:
mship set
define Fuzzy Classification, values
fclaifs fc_name +relation_name +relation_id +and_operator +and_argument +or_operator
+or_argument
-example: mship fclaifs fCQL example
+fcql_example +id +Gamma +0.5 +Maximum +0
+This small example ...
fclaifu fc_value +name
+description +relation_name +relation_id +and_op +and_arg +or_op
+or_arg...
-example: mship fclaifu id +name fCQL example +and_arg 0.5
linvars fc_value +lv_name +lv_type +domain_min +domain_max +ra_name +ra_attribute_type
linvars fc_value +lv_name +lv_type +domain_min +domain_max +c_ids
-example: mship linvars 0 +Turnover +Relation Attribute +0 +800 +turnover +Numeric
-example: mship linvars fcql example +Test +Composed Attribute +11 +22 +1
linters lv_value +lt_name
-example: mship linters 0 +Low
confuns lt_id +Function type +from_value +to_value +startvalue +endvalue (+slope) (+infelxion
point)
-example: mship confuns 0 +l +0 +654 +0 +1
72 -example: mship confuns 0 +S-Shaped Function +0 +777 +0 +1 +2 +1.00
stefuns lt_id +cat_name degree (cat_id degree)
-example: mship stefuns 5 +1 0.3 2 0.4
fclasss id +fcl_name +description
-example: mship fclasss 5 +C5-testclassname +very important text about a very important fclass!
conceps fc_value +concept_id (+concept_ids)
-example: mship conceps fcql example +Discount +20 +10 +5 +0
mships help
this help information
//MSHIPDELETE*********************************** Membership delete commands
mship delete
define Fuzzy Classification, values
fclaifd fc_value
-example: mship fclaifd fcql example
linvard fc_id +lv_value
-example: mship linvard fcql example +turnover
linterd lv_id +lt_value
-example: mship linterd turnover +low
concepd fc_id +concept_id (+concept_ids)
-example: mship concepd 1 +Customer Lifetime Value
mshipd help
this help information
73 12.2. fcql_example mittels Konsole einfügen in leeres metaschema mit fcql_example Rohdaten mit dem Befehl „meta create“ (command, >> console Ausgabe) 1. mship fclaifs fCQL example +fcql_example +id +Gamma +0.5 +Maximum +0 + This small example shows how to define a fuzzy classification and how the results look like. >> Fc‐Insert Ok. 1 row affected >> fCQL example with id 1 inserted 2. mship linvars 1 +Turnover +Relation Attribute +0 +800 +turnover +Numeric >> Lv‐Insert Ok. 1 row affected >> Turnover with id 1 inserted >> Ra‐Insert Ok. 1 row affected >> turnover with id 1 inserted 3. mship linvars 1 +Margin +Relation Attribute +0 +80 +margin +Numeric >> Lv‐Insert Ok. 1 row affected >> Margin with id 2 inserted >> Ra‐Insert Ok. 1 row affected >> margin with id 2 inserted 4. mship linters 1 +High >> Lt‐Insert Ok. 1 row affected. >> High with id 1 inserted >> Fuzzy Classes and Fuzzy Class Definition have been updated 5. mship linters 1 +Low >> Lt‐Insert Ok. 1 row affected. >> Low with id 2 inserted >> Fuzzy Classes and Fuzzy Class Definition have been updated 6. mship linters 2 +High >> Lt‐Insert Ok. 1 row affected. >> High with id 3 inserted >> Fuzzy Classes and Fuzzy Class Definition have been updated 7. mship linters 2 +Low >> Lt‐Insert Ok. 1 row affected. >> Low with id 4 inserted >> Fuzzy Classes and Fuzzy Class Definition have been updated 8. mship confuns 1 +Linear Function +0 +800 +0 +1 >> Lt Interval is completely covered after this insert >> Cf‐Insert Ok. 3 rows affected. >> Linear Function with id 1 for Linguistic Term "High" inserted (Linguistic Variable: "Turnover") 9. mship confuns 2 +Linear Function +0 +800 +1 +0 >> Lt Interval is completely covered after this insert 74 >> Cf‐Insert Ok. 3 rows affected. >> Linear Function with id 2 for Linguistic Term "Low" inserted (Linguistic Variable: "Turnover") 10. mship confuns 3 +Linear Function +0 +80 +0 +1 >> Lt‐Interval is completely covered after this insert >> Cf‐Insert Ok. 3 rows affected >> Linear Function with id 3 for Linguistic Term "High" inserted (Linguistic Variable: "Margin") 11. mship confuns 4 +Linear Function +0 +80 +1 +0 >> Lt‐Interval is completely covered after this insert >> Cf‐Insert Ok. 3 rows affected >> Linear Function with id 4 for Linguistic Term "Low" inserted (Linguistic Variable: "Margin") 12. mship fclasss 1 +C1 – Commit Customer +This fuzzy class holds the best customers of the company. They should be treated in a special way in order to keep them loyal and profitable as long as possi‐
ble. >> Fcl‐Insert Ok. 1 row affected 13. mship fclasss 2 +C2 – Augment Margin +This fuzzy class holds customers having a high turnover but a low margin. The objective is to propose them premium products or services (up‐selling) in order to augment the margin. >> Fcl‐Insert Ok. 1 row affected 14. mship fclasss 3 +C3 – Augment Turnover +This fuzzy class holds customers having a high margin but a low turnover. The objective is to propose them additional products or services (cross‐selling) in order to augment the turnover. >> Fcl‐Insert Ok. 1 row affected 15. mship fclasss 4 +C4 – Don’t Invest + This fuzzy class holds customers having a low turnover as well as a low margin. The company should not invest in that segment. >> Fcl‐Insert Ok. 1 row affected 16. mship conceps fCQL example +Customer Lifetime Value +100 +66 +33 +0 >> C‐Insert Ok. 5 rows affected 17. mship conceps fCQL example +Discount +20 +10 +5 +0 >> C‐Insert Ok. 5 rows affected catecoric attribute with stefuns: mship linvars 1 +CategoricTest +Relation Attribute +0 +777 +cluster +Categoric >> Lv‐Insert Ok. 2 row affected >> CategoricTest with id 3 inserted >> Ra‐Insert Ok. 3 row affected >> cluster with id 3 inserted mship linters 3 +CategoricLtTest >> Lt‐Insert Ok. 18 row affected >> Categoric Step Functions table has been build >> CategoricLtTest with id 5 inserted 75 >> Fuzzy Classes and Fuzzy Class Definition have been updated mship stefuns 5 +1 0.3 2 0.4 >> Sf‐Insert Ok. 2 Membership degrees have been updated //mship stefuns 5 +* 0 (set all lt 0) 12.3. Befehle detailliert Console settings: set connect ‐h localhost ‐p 3306 ‐d fcql ‐u root ‐pw admin ‐dr MySQL ‐ac true >> new connection information has been set set warning >> show warning off / on set exception >> show exception off / on set saveFile >> save to file off / on set status >> connection state: connected with MySQL >> Show result is enabled >> Show warning is disabled >> Show exception is enabled >> SaveFile is disabled SQL: sql INSERT INTO `fcql`.`fcql_meta_lt` ( `id` , `lv_id` , `name` ) VALUES ( '20', '14', 'test' ); >> connected to database: fcql >> Ok. 1 row(s) affected.executeSQL succesfully finished >> queryCommand used: INSERT INTO `fcql`.`fcql_meta_lt` ( `id` , `lv_id` , `name` ) VALUES ( '20', '14', 'test' ); sql SELECT * FROM `fcql_example` WHERE `id` >900 >** Table and SQLresults.txt outputfile Meta Tabellen: meta dump >> Warning!: file already exists new file name has been generated >** metaBackup1.sql dump file >> MySQL dump file sucesfully created in: "C:\Dokumente und Einstellun‐
gen\Administrator\desktop\metaBackup1.sql" / >> PostgreSQL dump file sucesfully created in: "C:\Dokumente und Einstellun‐
gen\Administrator\desktop\metaBackup1.sql" meta read ‐rl C:\Dokumente und Einstellungen\Administrator\desktop\metabackup1.sql >> meta read (metaBackup.sql) and insert successfully finished meta create >> meta read (create empty meta tables, emptymetaschema.sql*) and insert succesfully finished meta create x 76 >> meta read (create meta tables, fcql_example_metaschema.sql*) and insert succesfully finished * Emptymetaschema.sql enthält leere Metatabellen, fcql_example_metaschema.sql enthält Metatabellen mit fCQL_example Werten aus Version 1.05, diese Dateien können beliebig angepasst werden, meta delete >> Meta tables have been deleted fCQL: fcql fclaif >> ID Name >> 0 fCQL example fcql linvar 0 >> "fCQL example" is set >> 0 Margin >> 1 Turnover >> 2 cluster >> 3 name fcql linter margin >> lv_id name >> 2 High >> 2 Low fcql FROM fCQL example where turnover < 3 or id < 1 or id = 2 >> default attribute Margin >> default attribute Turnover >** Result Table, fCQLResult.html outputfile >> fCQL result FROM "fCQL example" has been created and stored 12.4. cmd Befehle Starten des Programms mittels der Jar Datei: CD C:\Dokumente und Einstellungen\Administrator\Desktop Auflösung ändern (temporär) mode 140,50 (oder für Immer Anleitung) empfohlene Fenstergrösse 890 pixel = 140 Zeichen java –jar fcql1.10.jar normaler GUI Start java –jar fcql1.10.jar start start cmd Start C:\Dokumente und Einstellungen\Administrator\Anwendungsdaten\postgresql\pgpass.conf localhost:5432:*:postgres:1234
FClassificationQuery: withSubConditionTestValidSize
withSubConditionTestSize
ES IST DIE KONSOLE!
meta dump ‐fn filename‐t test meta read ‐fn metaBackup.sql bat‐Dateien: REM ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ REM Name: .BAT 77 REM Autor: Hofer Philipp REM Datum: 20. April 2009 REM ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ @ECHO OFF REM WINXP REM set CDJRE=C:\Programme\Java\jre1.5.0_16\bin REM WINDOWS 7 REM set CDJRE="C:\Program Files (x86)\Java\jre6\bin" set CDJRE=C:\Programme\Java\jre6\bin C: CD C:\Dokumente und Einstellungen\Administrator\Desktop @ECHO ON call %CDJRE%\java.exe ‐jar fcql1.10.jar start Pause 12.5. Veränderte und neue Dateien edu.rit.numeric (17) edu.rit.numeric.plot (16) edu.rit.numeric.plot.test (1) fcql (2) v Fcql (main!) v StrModel.java fcql.console: n ConsoleControlle.java n ConsoleInterface.java n ExecuteFcql.java n*1 ExecuteSQL.java n MemberShipDelete.java n MemberShipSet.java n MemberShipShow.java fcql.db: v DBConnection.java fcql.db.dbWrapper (3) fcql.fclass: Condept.java v Fclass.java FClassElement.java FClassification.java Interval.java LingTerm.java LingVar.java MFunction.java fcql.fclass.functions (5) fcql.fclass.queries (16): v FClassificationQuery.java v RClassificationResults.java v WhereSubSubCondition.java v WithCondition.java 78 v WithSubCondition.java v WithSubSubCondition.java v WithSubSubSubCondition.java fcql.gui: v MainFrame.java v ResultDisplay.java SplashScreen.java StatusBar.java fcql.gui.dialogs (24) minimale Dialognummerierungs‐änderungen fcql.metadata: n MysqlDump.java n MysqlDumpLines.java n MysqlReadinSqlt.java fcql.util: ConditionalAction.java v Error.java InfoBox.java SwingTools.java v Tools.java 79 12.6. Bekannte Probleme mit dem fCQL‐Toolkit Tool Allgemein: Auflösung des Toolkits wird auf 0 gestellt, das Fenster ist unauffindbar config.dat Werte löschen Konsole Anzeige bewegt sich selten nicht nur teilweise und nicht um vollständige Länge wei‐
ter.  Befehl nochmals ausführen und gegebenenfalls Fenstergrösse leicht verändern (ver‐
grössern) Probleme mit der Anzeige‐Aktualisierung. In einigen Fällen kommt es vor, dass neue Einstel‐
lungen wie Verbindung und neue Fuzzy Klassifizierung nicht angezeigt werden obwohl sie erfolgreich verbunden bzw. erstellt wurden.  benutzen einer Funktion, welche die Tabs neu lädt, z.B. Verbindungsfenster aufrufen und wieder schliessen (egal ob „ok“ oder „can‐
cel“). Eingabe von Werten in GUI: Problem bei den neuen Linguistischen Termen lässt sich eine unbrauchbare Funktion kreie‐
ren, durch nachträgliches ziehen (verstellen der Werte)!  in logischer Reihenfolge Funktio‐
nen aufbauen möglichst wenig nachträglich verändern Problem bei den neuen Linguistischen Termen lässt sich eine S‐shape funktion nicht mehr entfernen, sowohl mit remove, wie mit remove all nicht  löschen des Linguistischen Terms. Interval 0 0 null division exception! Wird nicht abgefangen. Editieren: Mit MySQL: Jegliches Editieren über GUI verdoppelt die Datenbankeinträge!  Datenbanktyp ändern auf INNODB oder nur Konsoleeingabe benutzen. Und führt in vielen Fällen zur Blockierung von Fuzzy Class open (Fehlermeldung siehe ganz unten in diesem Teil). Edit FClassification ist also eigentlich ein „new Klassifikation“! (auch in der Datenbank!) Wird das Intervall neu definiert, wird eine neue lt_v erstellt und die id der meta_fc geän‐
dert… Editieren von Termen führt zu Abstürzen, wenn die FC neu geladen werden möchte (in co‐
py()) Absturz bei zwei identischen Werten! Exception (bei termen?) Absturz bei fehlerhafte Analyseeingaben (sql) exception Es werden immer alle Felder überprüft auch wenn sie inaktiv sind und gar nicht eingegeben werden…. (and or operatoren von fc zum beispiel) Löschen: Mit MySQL: 80 Wird eine Klassifikation erstellt und später über das Programm gelöscht, löscht dies nur der Eintrag im Menu und im fc (dantenbankteil `fcql_meta_fc`) aber nicht die dazugehörigen Werte in den restlichen Datenbank Tabellen, (später werden aber die Atributte und Mem‐
bershipfunktionen nicht mehr erkannt!) FCQL: Wenn keine Fuzzy Klassifikation vorhanden, geschieht einfach mal nichts, ohne Fehlermel‐
dung… Where values sind nicht sortiert finden eines Wertes total mühsam! Fuzzy Classifikation enthält im WITH Feld ab und an unbrauchbare Einträge WITH Box enthält plötzlich weniger Einträge, nur durch neu laden behebbar. Bei fcql with Abfragen verschwindet der Eintrag class nach auswahl von Ling var terme un‐
wiederruflich! (nach Deselektion) . Die Ling Var werden nicht in der Reihenfolge angezeigt wie sie in der Tabelle vorkommen sondern umgekehrt,* was sich dann auch in der Resultate Tabelle widerspiegelt! *bzw. wohl so wie sie in fcql example erstellt wurden (und dies entspricht nicht der Reihen‐
folge wie sie in der Tabelle vorkommen) Keine Reaktion wenn Metatabellen existieren aber Programm versucht diese zu erstellen…. Manchmal verschwindet das ganze with in der fCQL Abfrage Inkonsistenz in der Datenbank bei Namensgebungen: fcql_meta_ra: id ‐ lv_id Fuzzy Klasse in Metatabellen beginnt mit 0 statt mit 1, wie alle anderen Werte auch! (korri‐
giert) Datenbank Login Passwort geht teilsweise verloren wenn Server abgestellt wird! (korrigiert) DBConnection: Fehler dass auch auf cancel der aktuelle Fuzzy Tab geschlossen wird! aber die menu icons nicht deaktiviert werden (korrigiert) Probleme mit der Kombination von WITH und ALPHA Abfragen. ALPHA Bedingungen werden ignoriert und nicht nach den angegebenen Bedingungen aussortiert. 81 Neue Probleme: 
Problem mit Gross‐ und Kleinschreibung 
Problem mit with condition  verändert Alpha in customized class (nur noch diese) Probleme mit namen mit leerzeichen!! In where und with from? (behoben) 
fcql FROM fcql example with Margin is High or Low OR Turnover is Low (behoben) 
Führt zu total Absturz: fcql from fcql example alpha Concept ‐ Discount < 2 with Con‐
cept ‐ Discount < 2 (behoben) 
Problem mit Postgresdump, das alles blockiert max dump im Moment auf 20s! 
Konflikte mit Konsole neue SQL Befehle und nicht aktualisieren der ResultDisplays 
äöü Ausgabe (System.out.println) in Konsole Fehlerhaft! 
ist bei einer Konsolen fCQL Query der Fuzzy Tab offen, sind in CLASSIF die Default Werte Schattiert und nicht die korrekten gesetzten Werte! 82 FACULTE DES SCIENCES ECONOMIQUES ET
SOC IALES / WIRTSCHAFTS- UND
SOZIALWISSENSCHAFTLICHE FAKULTÄT
ERKLAERUNG
Ich versichere, dass ich die vorstehende Arbeit selbständig angefertigt und
entsprechend den Grundsätzen wissenschaftlicher Ehrlichkeit abgefasst
habe.
Es ist mir bekannt, dass andernfalls die Abteilung gemäss dem Fakultätsrat
vom 09.11.2004 das Recht hat, den auf Grund dieser Arbeit verliehenen
Titel zu entziehen.
……………………………..…………, den .………….………………20…….
...……................................…
(Unterschrift)