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!

Ich habe mir mal die GoogleCL Tools runtergeladen und unter der Fedora 13 installiert.

Als erstes erst mal die Abhängigkeiten studiert. Okay, wir brauchen die Python-Gdata-Bibliothek. Also

sudo yum install python-gdata

aufgerufen. Die Version, die bei der Fedora 13 dabei ist (2.0.9), passt. Danach das googlecl-0.9.7.tar.gz entpackt und in dem neu entstandenen Verzeichnis beherzt

sudo python setup.py install

aufgerufen. Nach ein paar Sekunden ist auch alles schon vorbei. Jetzt haben wir die GoogleCL Tools auch schon installiert. Ein kleiner Test mit

google contacts list

zeigt uns, das unter $HOME/.googlecl/ eine config Datei erzeugt wurde. Dort könnt ihr unter [global] euren Google Usernamen eintragen: user = euerusername. Damit erspart ihr euch das jeweilige angeben des Usernamens beim Aufruf der Tools. Beim ersten Aufruf eines der angebotenen Service (contacts, picasa usw.) wird euer Browser gestartet, um eine Authentifizierung durchzuführen. Ihr findet danach unter $HOME/.googlecl/ eine Datei mit dem Access Token für genau den Service, den ihr gerade das erste Mal aufgerufen habt. Beachtet, das diese Prozedur bei jedem erstmaligen Aufruf eines Services stattfindet.

Fazit: Ich finde diese CommandLine-Tools genial. Jetzt kann ich aus Scripts heraus schnell und unproblematisch auf von mir genutzte Dienste zugreifen. Zwei Szenarien fallen mir jetzt schon ein: automatische Synchronisation meiner E-Mail Adresse aus mutt heraus und vim nutzen, um einmal am Tag mein diary zu synchronisieren. Schon jemand ein Script fertig?

Nachtrag: Seit ein paar Tagen gibt’s die aktuellen GoogleCL Tools auch als fertiges RPM in updates für Fedora 13. Also einfach

sudo yum install googlecl

aufgerufen und gut ist.

Ich arbeite zur Zeit zwar mit dem Vim, habe aber damals, als ich Linux für mich entdeckte, den Emacs benutzt und geliebt. Irgendwann wurde mir das Ding dann doch zu sehr Dinosaurier, nicht mehr zeitgemäße GUI (Lucid), Font-Rendering war auch nicht der Brüller, usw.; es paßte einfach nicht mehr auf meinen schönen Ubuntu/Debian Desktop. So kam ich dann zum Vim mit nativem GTK-Tookit für die GUI; passt ja auch besser zu Gnome. Die Tastatur-Bedienung war kein großes Problem, da die vom Emacs auch nicht unbedingt so intuitiv ist. Ich meine, CUA ist bei beiden nicht der default Zustand.

So nu issa da, der Emacs 23.1, seit gestern nämlich! Hat native GTK-Unterstützung, kann UTF-8, rendert Schriften mit Fontconfig und Xft, und hat noch ein paar Modes spendiert bekommen. Nachlesen kann man das Ganze in der NEWS Datei.

Da ich nun mal zu der Sorte “extrem ungeduldiger Mensch” gehöre, habe ich mir die Sourcen mal eben rundergeladen. Bis bei Ubuntu die fertigen Pakete auftauchen, wird es wohl noch ne Weile dauern. Also den alten Emacs Kram aus dem System gepurged und ./configure –prefix=/usr/local && make und dann noch sudo make install. Fertig! Kein rumgemecker und gezicke. Achso, vor dem build-Lauf habe ich sicherheitshalber noch sudo apt-get build-dep emacs aufgerufen, um die vielleicht noch fehlenden Abhängigkeiten auf die Platte zu bekommen.

So nun an die Arbeit und die noch fehlenden modes installiert. Dazu unter ~/.emacs.d noch ein Verzeichnis erstellt (elisp). Hier die Dateien reinkopiert (php-mode.el, inf-ruby.el, snippet.el, find-recursive.el, das rails-mode Geraffel ). Dann wie üblich mit require ‘XXXXX-mode in der ~/.emacs die Modes geladen und schon hats nicht mehr getan wie es soll. Es kam immer ne nette Meldung im Emacs:

Warning (initialization): An error occurred while loading `/home/guenti/.emacs':
 
error: `c-lang-defconst' must be used in a file
 
To ensure normal operation, you should investigate and remove the
cause of the error in your initialization file.  Start Emacs with
the `--debug-init' option to view a complete error backtrace.

Was nun? Also Google angeworfen und folgenden Hinweis gefunden. Also statt require dann (autoload ‘php-mode …) genommen und alles ist sowas von Schick!

Was mir in der kurzen Zeit auch noch positiv aufviel, ist die vorhandene Unterstützung von git. Da ich alle meine Projekte seit kurzem mit git verwalte, freut mich dies um so mehr.

Aussehen tut der neue Emacs jetzt so:

Emacs 23.1

So nun will ich das Teil aber mal weiter ausprobieren. So wie ich greade gesehen habe, ist Speedbar jetzt auch per default dabei, super. Wer ne Alternative zu den manchmal doch etwas gigantisch wirkenden IDEs sucht, hat mit dem neuen Emacs vielleicht ne gute Wahl getroffen. Auch so, CUA kann man per Mausklick aktiviren