.: vb - datenbank-programmierung II :.
 
abyter.de \\ workshops

Einführung
Die meisten werden den ersten Workshop zu diesem Thema lesen und sagen, dass doch alles wunderbar funktioniert hat und man hat mit dem schönen Steuerelement eigentlich wenig Arbeit. Eigentlich perfekt. Doch richtige Programmierer setzen bei ihren Programmen nicht das Datensteuerelement ein, da dies einige Probleme mit sich bringt. So werden mehr Dateien für eine Installation benötigt (das Steuerelement und die DAO-Dateien), außerdem ist das Datensteuerelement viel zu langsam und es funktioniert nicht in allen Fällen, so wie es der Programmier sich wünscht.
Warum also von dem Datensteuerelement einschränken lassen, wenn es alles auch selbstgemacht geht. Darum möchte ich euch in diesem Workshop in die Kunst der Datenbankprogrammierung aus der Sicht des richtigen Programmierers zeigen.

Theorie: Fertig!
Wenn du den vorherigen Workshop Theorie des Datenbankzugriffs durchgearbeitet hast, bist du theoretisch auf den nun folgenden praktischen Teil der Datenbankprogrammierung vorbereitet.
Der selbstprogrammierte Datenbankzugriff ist bedeutend schneller als der Zugriff über ein Data-Steuerelement, außerdem ermöglicht er später fortgeschrittene Methoden des Datenbankzugriffs, z.B. EmbeddedSQL in Visual Basic.
Ich habe mir vorgestellt, eine Datenbankanwendung zu erstellen, die die Daten für den eBay-Verkauf beinhalten. Also eine Tabelle die die Adresse des Käufers speichert, das Endgebot, die Versandkosten und den Namen des Produkts.

Datenbank für das Projekt anlegen
Wie bei allen Datenbankanwendungen muss zuallererst eine Datenbank erstellt werden. Ich möchte die Erstellung diesmal jedoch ganz schnell abtun, für alle, denen es jetzt zu schnell geht, sei gesagt, dass die Erstellung der Datenbank mit dem Visual Data Manager im ersten Workshop sehr ausführlich beschrieben ist.
Wir erstellen eine Microsoft Access 7.0 MDB, gib der Datenbank einen einprägsamen Namen (z.B. ebay). Erstelle dann mit einem Rechtsklick auf "Properties" und der Auswahl von "Neue Tabelle" aus dem Kontextmenü eine neue Tabelle.
Gebe der Tabelle den Namen "ebay". Erstelle dann folgende Felder: "Name" (Text), "StrasseNr" (Text), "PLZOrt" (Text), "EGebot" (Currency), "VKosten" (Currency) und "PName" (Text). Mit "Feld hinzufügen" wird das Feld jeweils in der Datenbank gespeichert und ein neues Datenfeld vorbereitet.
Das Fenster sollte unter "Felder" jetzt so aussehen:
Screenshot der Datenfeldliste

Nachdem du auf "Tabelle erstellen" geklickt hast, ist die neue Tabelle erstellt worden. Bevor du nun den Visual Data Manager schließt, wollen wir noch einen Datensatz einfügen, damit wir später sofort sehen, ob die Programmierung funktioniert hat.
Doppelklicke auf den Namen der Tabelle. Im nächsten Fenster klickst du erst einmal auf "Hinzufügen", danach erst gibst du die Daten in die Felder ein. Lasse dir irgend etwas einfallen, was ist egal, für ganz phantasielose hier mein Eintrag:
Screenshot von meinem Vorschlag

Schließe danach alles, nun geht es ans richtige programmieren!

Formulardesign
Doch bevor wir wirklich ans Werk gehen, designen wir noch unsere Form. Erzeuge für jedes erstellte Feld der Datenbank ein Bezeichnungsfeld und ein Textfeld. Die "Caption"-Eigenschaften der Bezeichnungsfelder sind die jeweiligen Namen der Felder der Datenbank, die Text-Eigenschaften der Textfelder sind leer.
Nenne Textfeld des Produktnamens txtPName, das des Namen des Käufers txtName, das mit der Straße txtStrNr, das mit PLZ und Ort txtPLZOrt, das mit dem Höchstgebot txtHGeb und das mit den Versandkosten txtVKosten. Nun brauchen wir noch 7 Buttons. Die ersten vier für das Navigieren in der Datenbank und die anderen drei für die Aktionen Hinzufügen, Ändern und Löschen. Die Beschriftungen und wie die Form jetzt aussehen könnte hier:

Formulardesign des Fensters

Den Buttons haben wir noch keine eindeutigen Namen gegeben. Nenne den ganz linken Knopf der vier Navigationsknöpfe cmdFirst, den nächsten cmdPrev, den nächsten cmdNext und den letzten der vier cmdLast. Den Hinzufügen-Button nennst du cmdAdd, den Ändern-Button cmdEdit und den Löschen-Button cmdDel.

Grundgerüst der Datenbankanwendung erstellen
Gut aussehen tut unser Programm nun schon einmal, jedoch kann es bis jetzt noch nichts machen.
Bevor wir jedoch mit dem programmieren beginnen können, müssen wir dem Programm noch einen Verweis hinzufügen. Gehe unter dem Menüpunkt Projekt auf Verweise suche dort den Eintrag "Microsoft DAO 3.6 Object Library" (eine andere Version ist auch OK!) und mache einen Hacken davor.
Als erstes wollen wir nun die Anbindung an die Datenbank realisieren. Definiere die Variablen Db und Tb:

Dim Db as Database
Dim Tb as Recordset

Gehe dann in die Prozedur Form_Load und tippe folgendes ein:

Set Db = OpenDatabase(App.Path & "\ebay.mdb")
Set Tb = Db.OpenRecordset("ebay", dbOpenDynaset)

Die Anweisung App.Path und das \ vor dem Datenbanknamen ist notwendig, dass die Datenbankanbindung auch unter der IDE von Visual Basic läuft. Ansonsten werden alle Dateien im VB-Verzeichnis gesucht. Mit App.Path wird in das Verzeichnis der Anwendungsdatei gewechselt.
So nun ist die Datenbankverbindung zum Puffer im RAM realisiert. Nun ist es noch unsere Aufgabe die Daten von dort auf unsere Form zu bekommen. In der Theorie haben wir gelernt, dass dies mit txtName = Tb!Name geht, doch es wäre umständlich bei jeder Änderung der Anzeige alle Verknüpfungen herunter zu rattern. Dieses Problem wollen wir mit einer Prozedur lösen:

Private Sub Load()
txtPName.Text = Tb!PName
txtName.Text = Tb!Name
txtStrNr.Text = Tb!StrasseNr
txtPLZOrt.Text = Tb!PLZOrt
txtHGeb.Text = Tb!EGebot
txtVKosten.Text = Tb!VKosten
End Sub

Mit der Anweisung Load wird die Prozedur nun immer dann ausgeführt, wenn man im Programm die aktuellen Inhalte des Puffers benötigt.
Damit muss also der Form_Load-Prozedur noch der Befehl:
Load

angehängt werden. Nun könntest du das Programm schon mal ausprobieren. Wenn alles funktioniert, dann wird der erste Datensatz schon jetzt angezeigt. Damit haben wir das aller gröbste Grundgerüst schon einmal erstellt. Doch wirklich viel kann das Programm noch nicht, weshalb wir im folgenden noch einige Funktionen hinzufügen werden. Schließlich haben wir noch unbelegte Buttons die noch auf Quellcode warten.

Vorbereitung für weitere Schritte
Die zunächst wichtigste Eigenschaft nach der Anzeige der Datensätze ist die Navigation in der Datenbank. Die wollen wir nun in unsere Form einbauen. Das Problem ist jedoch, dass wir bis jetzt nur einen Datensatz haben, so dass eine Navigation noch nicht möglich ist.
Gehe also wieder in den Visual Data Manager und füge noch mindestens zwei weitere Datensätze hinzu. Beende danach den Visual Data Manager wieder.

Navigation einbauen
So wo wir nun mehrere Datensätze haben, macht die Navigation auch Sinn. Nun aber wirklich zum Programmieren. Der Zum-Ersten-Springen-Button-Quelltext muss so aussehen:

Tb.MoveFirst
Load

Mit MoveFirst wird der Datensatzzeiger auf den ersten Datensatz verschoben und mit Load dann die Datenfelder vom Puffer im RAM aus auf die Form ausgegeben.
Der Zum-Vorherigen-Springen-Button-Quelltext muss so aussehen:

Tb.MovePrevious
If Tb.BOF Then
Tb.MoveFirst
End If
Load

Ich habe mal das Problem, dass sich ergeben wir vorweggenommen und gelöst, denn was ist, wenn der Datensatzzeiger sich schon am Anfang der Datenbank (=BOF; Beginn Of File) befindet? Dann kann man nicht mehr zum vorherigen gehen. Ich habe das Problem so gelöst, dass ich überprüfe, ob der Datensatzzeiger am sich am BOF befindet, falls ja, bewege ich ihn wieder auf den ersten Datensatz zurück.
Der Zum-Nächsten-Springen-Button-Quelltext muss so aussehen:

Tb.MoveNext
If Tb.EOF Then
Tb.MoveLast
End If
Load

Das gleiche Problem wie bei dem vorherigen Button besteht auch bei diesem Button: Was tun wenn man am Ende der Datenbank (= EOF; End Of File) angelangt ist? Meine Lösung ist ähnlich wie bei dem vorherigen Button, dass ich den Datensatzzeiger auf den letzten Datensatz zurücksetze.
Der Zum-Letzer-Springen-Button-Quelltext muss so aussehen:

Tb.MoveLast
Load

Mit MoveLast wird der Datensatzzeiger auf den letzten Datensatz verschoben.
Nun ist das Programm vollfunktionsfähig, man kann in den Datensätzen navigieren. Nur wenn man die Datenbasis ohne den Visual Data Manager verändern will, hat man bis jetzt noch ein Problem. Aber es sind ja auch noch drei Buttons unbelegt. Den schreibenden Zugriff wollen wir nun realisieren.

Die restlichen Buttons
Nun sollen auch die letzten drei Buttons mit Funktionen ausgestattet werden. Der erste davon ist der Hinzufügenbutton. Mit den folgenden Anweisungen wird aber nur ein leerer Datensatz gespeichert, d.h. die Eingaben werden nicht gespeichert. Darum muss man nach der Eingabe in den neuen Datensatz noch einmal den im späteren Verlauf erstellten Ändern-Button drücken. Nun aber erst einmal der Quellcode:

Tb.AddNew
Clear
txtPName.SetFocus

Das erste Kommando sollte dir aus der Theorie bekannt sein. Bei dem zweiten handelt es sich wiederum eine selbsterstellte Prozedur, die ist folgendermaßen aufgebaut:

Private Sub Clear()
txtPName.Text = ""
txtName.Text = ""
txtStrNr.Text = ""
txtPLZOrt.Text = ""
txtHGeb.Text = ""
txtVKosten.Text = ""
End Sub

Die Prozedur sorgt also dafür, dass alle Felder frei sind, mit dem SetFocus-Befehl wird der Cursor in das Textfeld PName gesetzt, so dass man gleich loslegen kann mit dem Eingeben.

Ändern-Button
Der Ändern-Button wird, wie soeben erwähnt, nicht nur zum bearbeiten bestehender Datensätze benötigt, sondern auch zum abspeichern der Eingaben in einen neuen Datensatz.
So wird die Funktion realisiert:

If Tb.EditMode = dbEditAdd Then
MsgBox ("Datensatz wurde angehängt")
Else
Tb.Edit
End If
Send
Tb.Update
MsgBox ("Datensatz erfolgreich geändert!")

Die Bedingungsabfrage überprüft, ob der Benutzer die Änderungen bei einem neuen Datensatz speichern will oder einen bestehenden Datensatz ändern will. Im letzteren Fall muss man die Tabelle noch in den Edit-Mode versetzen.
Wieder habe ich eine Prozedur vorweggenommen - Send - mit der Prozedur Send schreibe ich die Änderungen in den Puffer, analog zu der Prozedur Load beim Lesen der Datensätze.
Die Prozedur Send ist folgendermaßen aufgebaut:

Private Sub Send()
Tb!PName = txtPName.Text
Tb!Name = txtName.Text
Tb!StrasseNr = txtStrNr.Text
Tb!PLZOrt = txtPLZOrt.Text
Tb!EGebot = txtHGeb.Text
Tb!VKosten = txtVKosten.Text
End Sub

Es handelt sich ganz offensichtlich um das Gegenteil der Load-Prozedur. Nun noch zu den oberen Anweisungen: Mit Tb.Update schließlich werden die Daten gesichert, das haben wir ja schon genauer in der Theorie besprochen.

Der Löschen-Button
Nun ist es nur noch ein Button bis zur fertigen Datenbankanwendung. Dieser letzte Button ist der Löschen-Button. Der Quelltext dieses Buttons sieht so aus:

Dim OK As Integer
OK = MsgBox ("Datensatz wirklich löschen?", vbYesNo, "Löschen")
If OK = 6 Then
Tb.Delete
cmdNext_Click
End If

Zuerst mache ich eine Sicherheitsabfrage mit einer MsgBox, mit dem Attribut vbYesNo lege ich fest, dass die Knöpfe Ja und Nein zur Auswahl stehen. Wird Ja gedrückt, so ergibt sich der Rückgabewert 6 der MsgBox-Funktion. Ob als Rückgabewert 6 herauskommt, überprüfe ich mit der folgenden Bedingungsabfrage. Sollte Ja geklickt worden sein, dann wird mit Tb.Delete der Datensatz gelöscht. Der Datensatzzeiger muss noch um eins weiterverschoben werden, da er sonst ins Leere zeigt; was wäre dazu besser geeignet als die cmdNext_Click Prozedur des Springe-Zum-Nächsten-Buttons. Damit ist auch gleich sicher gestellt, dass die Ausnahmefälle mit EOF und BOF beachtet werden.

Das Menü einbauen
Das Programm ist im Grunde fertig, doch die Art das Programm zu beenden (über Schließen-Kreuzchen) ist noch etwas schlecht. Wir werden noch ein Menü einfügen mit dem man das Programm beenden kann. Also öffne den Menü-Editor (Menüeditor) aus der Symbolleiste durch einen Klick darauf. Nun gib bei Caption "&Beenden" ein. Nein, & ist kein Schreibfehler, dieses Kaufmanns-Und macht einen kleinen Strich unter den Buchstaben danach (Beenden). So kann man hier beispielsweise durch Druck von [Alt]+[B] den Menüpunkt öffnen und muss nicht erst extra darauf klicken. Gebe dann unter "Name" "mnuEnd" ein. Der Namenspräfix mnu vor "mnuEnd" bedeutet das es sich um einen Menüpunkt handelt. Mit einem Klick auf "OK" wird deinem Fenster eine Menüleiste hinzugefügt. Nun müssen wir noch dem Menüpunkt sagen, was er machen soll, wenn auf ihn geklickt wird. Klicke hierfür auf den Menüpunkt, als wolltest du ihn öffnen. Das Code-Fenster öffnet sich und wartet auf deine Quelltexteingabe. Gib ein:

Tb.Close
Db.Close
End

Zuerst wird der Recordset und dann auch die Datenbank geschlossen, danach wird das ganze Programm beendet.

Was man noch machen könnte
Nun ist dein Programm fertig, wenn du noch eine EXE-Datei aus dem Projekt machen willst gehe vor wie im Workshop "Programmieren mit VB" beschrieben.

Related Workshops:Allgemeines \\ Visual Basic Einführung \\ Die Programmierumgebung \\ Programmiergrundlagen \\ Programmieren mit VB \\ Datenbankprogrammierung \\ Datenbanktheorie \\ EmbeddedSQL \\ Steuerelemente \\ Api-Funktionen
Related Files: Quellcodedateien fertiges Programm

Workshop als pdf

<Zurück

© by www.abyter.de (Martin Monshausen)