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:
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:
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:
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 ( )
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 ( ).
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.
|
Zurück