Mario Günterberg's Blog

Lange Zeit hatte ich nach einem grafischen Tool zum Datenbank entwerfen gesucht. Es sollte natürlich OSS sein, unter Linux laufen und möglichst DBMS unabhängig sein. ArgoUML kam mir dazu in den Sinn, doch irgendwie bin ich damit nicht so richtig warm geworden. Irgendwann bin ich dann über parsediasql gestolpert. Dies stellt eine Weiterentwicklung von tedia2sql dar. Dieses Script, in Verbindung mit Dia als Modellierungssoftware, gibt mir doch so ziemlich die Freiheiten, die ich haben wollte. Dia sollte bei jeder halbwegs tauglichen Linux-Distribution dabei sein und eine Windows Version gibt es auf der Projekt-Homepage auch. Parsediasql ist zumindest bei der Fedora nicht per default als Paket verfügbar. Da parsediasql sowohl ein Perl-Modul, als auch ein lauffähiges Script darstellt, ist Installation denkbar einfach; entweder über das hinlänglich bekannte CPAN oder durch:

make Makefile.PL
make
sudo make install

Installiert wird das Ganze dann nach /usr/local. Diese Script arbeitet lautet Aussage auf der Projekt-Homepage auch unter Windows, vorrausgesetzt man hat Perl installiert.

Bevor wir nun aber so richtig loslegen, will ich erst einmal ein Beispiel-Schema vorstellen, welches ich natürlich mit Dia erzeugt habe:

DB-Books-Schema

In diesem doch ziemlich simplen Entwurf ist alles enthalten, worüber ich schreiben möchte. Doch gehen wir Schritt für Schritt das Schema durch.

Als erstes wählen wir in Dia den UML-Objektbogen aus, so das unser Werkzeug-Fenster dann folgendermaßen aussieht:

Dia-Werkzeug

Hier finden wir dann auch  unsere Buttons, die wir benötigen um das oben abgebildete Modell zu erstellen. Benötigen werden wir allerdings nur 4 Buttons, nämlich Klasse, Kleines Paket, Komponente und Aggregation. Wenn ihr mit der Maus über die jeweiligen Knöpfe in Dia fahrt, seht ihr einen Tipp. Im Schema sind diese durch verschiedene Farbe dargestellt:

hellrot: Komponente

hellblau: Kleines Paket

kein Hintergrund: Tabelle

Nun nehmen wir eine Klasse und erstellen uns damit eine Tabelle, wie im Schema abgebildet. Wir klicken auf den Klasse-Button im Werkzeug-Fenster und klicken danach irgendwo in unser Diagramm-Fenster in Dia. Schon haben wir eine kleine Darstellung, in der oben Klasse steht. Nach einem Doppelklick auf diese öffnet sich ein Fenster, in dem wir die Eigenschaften dieser Klasse/Tabelle bearbeiten können.

Tab-Attribute

Unter dem Reiter Klasse vergeben wir den Namen der Tabelle. In dem Bild befinden wir uns im Attribute-Bereich. Dort legen wir die Spalten und deren Eigenschaften fest. Eine Besonderheit ist hier der Eintrag mit der Raute (#) vorne weg. Dies symbolisiert den Primär-Schlüssel. Definieren können wir ihn über die Eigenschaft Sichtbarkeit; diese sollte für den Primärschlüssel bei “protected”, anstatt “public” stehen. Ansonsten tragen wir die Parameter in die Felder Name, Type, Wert ein. Wenn ihr Längenbegrenzungen verwenden woll, so wie bei varchar(21), dann tragt ihr die auch im Typ-Feld so ein. In Wert-Feld kommen die Default Werte rein, z.B. eine Spalte vom Typ timestamp hat als Wert CURRENT_TIMESTAMP. Mit Anwenden oder OK speichert ihr die Tabelle. So verfahrt ihr dann mit jeder zu erstellenden Tabelle.

Jetzt schauen wir uns mal das Kleine Paket an. Das sind die Konstrukte mit dem hellblauen Hintergrund. Diese legt man genauso an wie eine Klasse. Nach einem Doppelklick erscheint dann folgendes Fenster.

Kleines Paket

Wir benutzen dieses kleine Paket, um sogenanntes “typemapping” zu betreiben. Das ist nichts anderes, als dafür zu sorgen, das in allen von uns zu erzeugenden SQL-Scripten, die Datentypen zu den jeweiligen DBMSsen passen. Wir wollen zum Schluß jeweils ein Script für MySQL und Postgresql haben. Da beide Systeme, unter anderem, unterschiedliche Definitionen des automatisch inkrementierten Zahlenwerten haben, benötigen wir hier eine Typen-Umschreibung. Wir legen also ein kleines Paket an und öffnen dann das Eigenschaften-Fenster, wie oben beschrieben.

Hier tragen wir beim Feld Stereotyp dann folgendes ein: Datenbank-Typ:typemap, wobei Datenbank-Typ für das jeweilige vom parsediasql unterstützte DBMS steht. Dies sind zur Zeit foldende:

MySQL mit den Engines InnoDB und MyISAM, Postgresql, DB2, SQLite3 und Oracle, um nur die wichtigesten zu nennen. Eine Besonderheit ist noch beim verwenden von MySQL zu beachten! Benutzt ihr die InnoDB Engine, muß der Eintrag im Stereotyp Feld mysql-innodb lauten, ansonsten wird’s nichts mit dem Script erzeugen.

Nach dem Klick auf den OK-Button schließt sich das Fenster und ihr wählt jetzt im Dia-Werkzeug Fenster den Textbearbeitungsbutton. Danach klickt ihr dann in das kleine Paket und tragt dort eure Datentypen ein. Also, in unserem Beispiel nehmen wir den Begriff “identity”, ist ja gleichzeitig unser Primärschlüssel, und weisen ihm unter mysql-innodb dem Typ “int unsigned auto_increment” zu, und für postgres nehmen wir dementsrechend “serial”. Für die jeweiligen Fremdschlüssel MÜSSEN wir auch ein typemapping vornehmen. Postgresql kennt keine “int(10) unsigned” Datentypen! Also fügen wir dort einfach noch fkidentity hinzu und geben bei Postgresql den Type integer an, und bei InnoDB den Typ int unsigned. Das gleich muß dann natürlich für die anderen DBMS Typen ebenso erfolgen. So das war’s auch schon hierzu. Alle anderen Eigenschaften dienen lediglich der Darstellung.

Wenden wir uns jetzt der Komponente zu. Das ist das Teil mit dem hellroten Hintergrund. Auch dieses wird so erzeugt, wie die Kalsse und das Kleine Paket. Und auch hier öffnent sich, nach einem Doppelklick, ein Eigenschaften-Fenster.

Komponente

Diese Komponente dient uns zum Befüllen der Datenbank-Tabellen mit Beispielwerten. Im Realfall kann man damit Standardwerte schon beim Anlegen der Datenbank eintragen.

Im Stereotyp-Feld tragen wir den Namen der Tabelle, gefolgt von in Klammern stehenden Spaltennamen; also ähnlich wie im SQL-Dialekt auch. Nach dem Schließen des Eigenschaften-Fensters, durch Klick auf OK, können wir wieder mit dem Textbeabeitungswerkzeug die jeweiligen Werte eintragen, äquivalent zum Kleinen Paket. Die einzutragenden Strings (nicht Integer) sollten nicht in Anführungszeichen stehen, sondern in Hochkommata, da sonst Postgresql meckert.

Zum Schluß kümmern wir uns noch um die Aggregationen. Mit Hilfe dieser erstellt parsediasql dann Fremdschlüsselbeziehungen zwischen den Tabellen her. Hier eine Eigenschaften-Fenster:

Aggregation

Erstellen kann man diese, indem man im Werkzeug-Fenster auf den Aggregation Button klickt und dann eine Verbindung zwischen den Tabellen herstellt, ähnlich wie eine Linie zeichnen in einem Malprogramm.

Bei der Aggregation sollten wir die in der Abbildung links dargestellte Parameter einstellen. Oben steht der Name, ich habe mir angewöhnt, für Fremdschlüssel immer mit dem Prefix “fk_” zu beginnen. Sollte man aus versehen die falsche Richtung beim Linie ziehen eingeschlagen haben, kann man es hier noch korrigieren. Den Typ ändern wir für unsere Zwecke nicht. In den Rolle-Feldern tragen wir die Spalten ein, zwischen denen die Beziehung besteht. Bei der Multiplizität kann man noch die optionalen “on delete” und “on update” Eigenschaften definieren.

So, das war’s auch schon, zumindest was den grafischen Teil betrifft. Wir speichern das Diagramm und wechseln mit der Konsole/dem Terminal in dieses Verzeichnis und rufen dort

parsediasql --ignore_type_mismatch --file diagramm.dia --db mysql-innodb > innodb.sql

auf. Den Parameter “–ignore_type_mismatch” brauchen wir, da die Spalte mit dem Typ “identity” nicht einer Spalte mit dem Type “int(10) unsinged” entspricht. Dies gilt allerdings nur, wenn wir Fremdschlüsselbeziehungen drin haben. Außer ein paar Warnungen, die geworfen werden, wird auch nichts weiter angestellt. Diese können in den SQL-Scripten gelöscht werden. Schon haben wir ein fertiges SQL-Script, welches wir dann über den MySQL-Prompt oder PHPMyAdmin verwenden können. Für Postgresql, oder allen anderen unterstützten DBs, verfahren wir äquivalent. Ich habe mir für diese Zwecke ein Makefile angelegt mit folgendem Inhalt:

all:
 parsediasql --ignore_type_mismatch --file books.dia --db mysql-innodb > books-mysql.sql
 parsediasql --ignore_type_mismatch --file books.dia --db postgres > books-pgsql.sql

Jetzt rufe ich nach jeder Änderung einfach nur make auf und gut ist.

Es gibt noch ein Tool, sql2dia, welches zumindest für Mysql, die DB sozusagen refaktoriert und als Dia Diagramm speichert. Allerdings geschieht dies OHNE die Schlüsselbeziehungen.

Das war’s! Spielt einfach ein wenig damit rum. Es gibt noch viel zu entdecken, z.B. kann man auf diese Art und Weise auch Views erzeugen. Schaut einfach mal auf dieser Webseite vorbei (english). Das was dort beschrieben steht, gilt ebenso für parsediasql.

Have fun!

Da ich auch im Vim immer mit einem dunklen Farbschema arbeite, dachte ich mir, es wird Zeit auch für Netbeans ein solches zu besorgen. Ich weiß, es sind schon einige Schemas bei Netbeans dabei, doch die gefallen mir alle nicht so gut. Nach einiger Suche kam ich dann auf zwei nennenswerte, jedenfalls meiner Meinung nach. Das Eine findet ihr hier, und das Andere hier. Sind beide eigentlich recht gut, basieren sie doch auf alt bekannte Themes vom gEdit oder Textmate.

Ich wollte dann aber doch noch etwas anderes, und zwar mein eigenes Schema vom Vim, soweit wie möglich, auf die Netbeans IDE übertragen. Was dabei herausgekommen ist, seht Ihr auf den folgenden Screenshots.

NetBeans IDE 6.9 Java - Poolbyte Schema

NetBeans IDE 6.9 PHP - Poolbyte Schema

NetBeans IDE 6.9 C - Poolbyte Schema

Was mich an den anderen Color Schemes, welche ich im Internet gefunden hatte, am meisten störte, war die Tatsache, das sie fast immer nur mit einer Sprache auch wirklich gut aussahen. Ich habe mir das original Dark Pastels Theme genommen, da es meinem Vim Scheme am nächsten kommt, und habe dann angefangen, die Details zu verändern. Herunterladen könnt ihr Euch das Schema hier: PoolByte-Theme. Installieren lässt es sich am einfachsten über Tools->Options->Fonts & Colors. Dort findet Ihr einen Import Button unten links.