Mobile Times Business Club
Startseite : Mobility : OPL Kurs
OPL OPL Kurs, Teil 5 Aktualisierung
2007-03-01
01: Einführung
02: Menüs und mehr
03: Basics, Zufall & Mathetrainer
04: Spielend lernen - Würfel, Bandit & Lotto
05: Datenbanken - Neu/Ändern/Löschen
06: Datenbanken - Suchen/Gehen Zu
07: Gezielte Textausgabe
08: Fensterl'n mit dem Psion
09: Zeichnen mit Grips
Datenbanken - Neu/Ändern/Löschen
Unser bisheriger Exkurs in die OPL-Welt war eher einem spielerischen Thema gewidmet. Heute nähern wir uns dem "Ernst des Lebens" mit dem Thema "Datenbanken". Die allerdings finden sowohl in privater als auch geschäftlicher Umgebung Anwendung. Haben Sie vor, endlich Ihre CD Sammlung (oder was auch immer) zu katalogisieren, sind Sie hier und heute in diesem Kurs richtig und der Begriff vom "Ernst des Lebens" ist damit auch schon wieder relativiert.
    Klären wir zuerst den Begriff Datenbank, der immer wieder zu Mißverständnissen zwischen Gesprächspartnern führt. (Computer-)"Datenbank" meint eigentlich eine oder mehrere Dateien, in denen in kontrollierter Art Daten abgelegt sind. Im lockeren Sprachgebrauch wird heute aber auch schon mal das zugehörige Verwaltungsprogramm als "Datenbank" bezeichnet. Da das Datenbankformat, also die Art, wie die Daten in der Datenbankdatei abgelegt werden, meist an ein bestimmtes Programm gekoppelt ist, ist die Begriffsverwischung verständlich. Nur: Man sollte im Zweifelsfall wissen wovon man eigentlich redet.
    Bei unserem Beispiel-Programm handelt es sich um den Typ "schlichter Merker", das weniger Ansprüche an das Einarbeiten stellt - und irgendwo muß man ja schließlich anfangen. Eine derartige Datenbank stellt man sich am besten als Tabelle vor, der man in Vorbereitung kommender Einträge zuerst einmal Spaltenüberschriften verpaßt, z.B.: Für ein schlichtes Telefonbuch NAME und NUMMER. Damit ist geregelt, daß alle folgenden Einträge einem festen Schema unterliegen. So wird bei einem ersten Eintrag "Franz" in die Spalte NAME geschrieben, "01/31322-30030" landet in der NUMMER Spalte. Damit ist schon ein Datensatz komplett.
    Datensatz in der Tabellen-Analogie ist also die Zeile, die alle zusammengehörenden Daten zusammenfaßt. Die Einordnung der Einzelkomponenten des Datensatzes erfolgt über "Felder" - in der Tabelle sind das die Spalten. Um zu wissen, um welches Feld des Datensatzes es gerade geht, benutzt man den "Feldbezeichner" - die Spaltenüberschrift der Tabelle. NAME in Datensatz 1 verweist als wieder auf den Eintrag "Franz".
    Um es noch anders zu verdeutlichen: Nehmen Sie einen Karteikasten. Der steht als Synonym für die "Datenbank". Wenn Sie ihn öffnen, finden Sie jede Menge Karteikarten - die "Datensätze". Besehen Sie sich eine Karte näher, zeigt sie in unserem Beispiel zwei "Felder": NAME: Franz und NUMMER: 01/31322-30030. Jeder, der neue Karteikarten beschreibt, wird sich an dieses Schema halten müssen. Ansonsten wird man wohl nicht lange Freude an seiner Adreß-Sammlung haben.

Datenbankbefehle
Die entscheidenden Befehle für eine Datenbank sind:
CREATE:
Sorgt in der Stunde Null dafür, daß überhaupt eine Datenbank-Datei angelegt wird.
OPEN:
Öffnet eine bestehende Datenbank.
USE:
Benennt die Datenbank-Datei, mit der gerade gearbeitet werden soll, denn es ist erlaubt mit mehreren Dateien gleichzeitig zu arbeiten.
CLOSE:
Schließt die aktuelle Daten-Datei.
APPEND:
Fügt einen neu einzutragenden Datensatz an eine bestehende Datei an.
UPDATE:
Hilft beim Ändern eines aktuellen Datensatzes.
FIRST, LAST, POSITION:
Da die Datenbank-Datei im Prinzip nur eine Art Tabelle ist, zeigt das Programm gewissermaßen mit dem Finger auf die Zeile (den Datensatz), die die aktuelle sein soll. Diesen Zeiger kann man selber setzen, um mit einem ganz bestimmten Datensatz zu arbeiten - entweder auf den ersten oder letzten Datensatz, oder auf einen ganz bestimmten anderen.
POS:
Ermittelt die gerade aktuelle Datensatznummer.
COUNT:
Zählt, wieviele Datensätze die aktuelle Datenbank-Datei überhaupt enthält. "0" steht für "keine Datensätze".
NEXT, BACK:
Setzt den Zeiger des aktuellen Datensatzes auf den nächsten bzw. vorhergehenden Datensatz.
    Nachdem Sie die grundlegenden Befehle kennengelernt haben, werden wir überlegen müssen, was wir eigentlich erreichen wollen und wie wir das tun. Halten wir uns also zuerst vor Augen, was nötig ist.
    OK. Wir nehmen uns also vor, eine Datenbank mit dem Namen "KUNDEN.ODB" zu erstellen und zu verwalten. Dies soll der Übersichtlichkeit halber lediglich zwei Felder (Name und Telefonnummer) enthalten.
    Klar ist, daß wir die Datenbank-Datei am Beginn anlegen oder öffnen müssen, sonst läßt sich wohl schlecht mit ihr arbeiten. Es folgt die Darstellung des Inhaltes der Datei auf dem Bildschirm. Wir möchten nur den jeweils aktuellen Datensatz anzeigen. Weil nach dem Öffnen der Datenbank immer der erste Datensatz der aktuelle ist, muß man die anderen irgendwie sichtbar machen können. Das Durchstöbern soll mit den Pfeiltasten [rechts] bzw. [links] realisiert werden ("rollen").
    Der angezeigte aktuelle Datensatz soll bearbeitet werden können; wir beschränken uns in dieser Folge des Workshops auf NEU hinzufügen, ÄNDERN und LÖSCHEN. Die Einleitung der entsprechenden Unterprogramme soll über ein Menü oder Tastaturkürzel erfolgen. Auch die Beendigung des Programms, mit dem auch das Schließen der Datenbank-Datei verbunden sein soll, muß natürlich gezielt möglich sein. Das wird ebenfalls über ein Menü oder Tastaturkürzel erfolgen.
    Unsere Wünsche ordnen wir nun in eine Programmstruktur ein.
    Ganz wie beim Schachspiel, bei dem man zuerst die Figuren auf dem Brett aufstellen muß, richtet man bei Programmen in einer ersten Phase einige Dinge vor - man initialisiert Variablen etc... In unserem Programm veranlaßt die allererste Prozedur "startup:" den Aufruf der (in unserem Beispiel) einzigen Initialisierungs-Prozedur "iniFile:". Die legt die Datenbank-Datei an oder öffnet sie und nimmt die Bildschirmdarstellung vor. Unmittelbar danach überträgt sie die Programmlast an die Hauptprozedur "main:".
    Wie schon in den vorhergehenden Folgen praktiziert, wird in "main:" in einer Schleife die Tastatur abgefragt, je nach Tastatureingabe werden dann die verschiedenen Unterprogramme angesteuert, die die "Knechtsarbeit" gemäß unsere oben skizzierten Vorstellungen zu leisten haben. Die Einzelheiten lernen wir anhand der Programm-Module kennen.
    In OPL ist es erlaubt, mehrere Befehle in eine Zeile zu schreiben, wenn man sie durch Leerzeichen und Doppelpunkt voneinander trennt. Am Ende der Zeile jedoch ist eine derartige Trennung nicht mehr erforderlich. Findet man dort dennoch einen Doppelpunkt, handelt es sich um einen Unterprogrammaufruf! Der Doppelpunkt folgt in diesem Falle ohne Leerzeichen unmittelbar auf den Unterprogramm-Namen.

Das große Sezieren...
Gehen wir nun munter ins Praktikum
DB 1
PROC startup:
   global filenam$(130), basenam$(10), name$(20), tel$(20)
   FONT 268436068,1
   inifile:
   main:
endp

proc inifile:
   basenam$="\MEINE_DB"
   trap mkdir(basenam$)
   filenam$ = basenam$ + "\" + "KUNDEN.ODB"
   if not exist(filenam$)
      trap create filenam$, A, name$, tel$
   else
      trap open filenam$, A, name$, tel$
   endif
   showknd:
endp

proc main:
   global taste%, mod%
   do
      taste%=get : mod%=KMOD
      if taste%=290
         showmen%:
      elseif (mod% AND 4)
         taste%=taste% + 96
         DoMenu:(taste%)
      elseif (taste% AND $FF00)
         if taste%=259
            rollen:(taste%)
         elseif taste%=258
            rollen:(taste%)
         endif
      endif
   until 0
endp

proc showmen%:
   local keycode%
   minit
   mcard "Datei","Beenden",%e
   mcard "Kunden","Neu",%n,"Ändern",%a,"Löschen",%l
   keycode% = menu
   domenu:(keycode%)
endp

proc domenu:(k%)
   local k$(1)
   local menuops$(10)
   menuops$="enal"
   k$=chr$(k% and $FF)
   if loc(menuops$,k$)
      @%("wahl"+k$):
   endif
endp

proc wahln%:
   local erg%
   use a
   delkndva:
   erg% = ediknd%:("Kunden anlegen")
   if erg% = 0
      delkndva:
   elseif erg% = 13
      a.name$ = name$ : a.tel$ = tel$
      append : giprint "Hinzugefügt"
      showknd:
   endif
endp

proc wahla%:
   local erg%
   use a
   erg% = ediknd%:("Kundedaten ändern")
   if erg% = 0 or erg%=27
      delkndva:
   elseif erg% = 13
      a.name$ = name$ : a.tel$ = tel$
      update : giprint "Gändert"
      last : showknd:
   endif
endp

proc ediknd%:(title$)
   local erg%
   do
      dinit title$
      dedit name$,"Kundenname:"
      dedit tel$,"Telefonnummer:"
      dbuttons "Nicht speichern",27,"Speichern",13
      erg% = dialog
   until erg% = 0 or erg%=13
   return erg%
endp

proc wahll%:
   local erg%
   use a
   if count > 0
      dinit "Kunden löschen"
      dtext "","Wirklich löschen"
      dbuttons "Ja",%j,"Nein",%n
      erg% = dialog
      if erg%=%n
         return
      elseif erg% = %j
         erase : position 1 : showknd:
      endif
   endif
endp

proc wahle%:
      use a : close : stop
endp

proc delkndva:
   name$ = "" : tel$ = ""
endp

proc showknd:
   local c%
   cls : db2knd:
   print " K U N D E N D A T E N"
   print "----------------------"
   print "Kundenname: "+chr$(9)+name$
   print "   Telefon: "+chr$(9)+tel$
   do
      print
      c% = c% + 1
   until c% = 9
   if count <> 0
      print "Datensatz ";pos;"/";count
   else
      print "Datensatz 0/0"
   endif
   print
   print "<-" + " Zurück/Vor " + "->" + " od.Menü-Taste"
   gborder 0
endp

proc db2knd:
   use a : name$ = a.name$ : tel$ = a.tel$
endp

proc rollen:(keycode%)
   if count > 1
      if taste% = 259
         if pos = 1
            giprint "1. Datensatz"
         else
            back : showknd:
         endif
      elseif taste% = 258
         if pos = count
            giprint "Letzter Datensatz"
         else
            next : showknd:
         endif
      endif
   endif
endp
    Die Startprozedur "startup:" dürfte Ihnen wohl keine Rätsel aufgeben. Spannender wir es aber bereits in der Datei-Initinalisierungs-Prozedur "iniFile:". Sie prüft zuerst indirekt, ob das Verzeichnis MEINE_DB existiert, indem sie mit MKDIR (make directory, Verzeichnis erstellen) veranlaßt, ein Verzeichnis zu erstellen. Wenn dieses bereits existiert - und das ist spätestens beim zweiten Start des Programmes der Fall, gäbe das normalerweise eine Fehlermeldung. Die wird jedoch clever mit der Anweisung TRAP unterdrückt. Aufgrund von TRAP kommt Fehlerbehandlungsroutine nicht zum Zuge - das Programm wird einfach fortgesetzt.
    Im nächsten Schritt wird geklärt, ob die Datei "KUNDEN.ODB" bereits existiert. Im Bedarfsfall wird sie neu mit CREATE erstellt, andernfalls eine vorhandene mit OPEN lediglich geöffnet. TRAP wird diesmal lediglich verwendet, um eine Fehlermeldung für den Fall zu verhindern, daß die Datei bereits irgendwie in Gebrauch ist. In der hier verwendeten Schreibweise für den Dateinamen ohne Nennung des Laufwerke befindet sich die angelegte Datei immer auf dem Laufwerk "C:".
    Die erforderlichen Parameter hinter CREATE bzw. OPEN sind:
* der vollständige Dateiname,
* ein Buchstabe, der im Zusammenhang mit USE erlaubt, offene Datenbankdateien anzusprechen (es können mehrere gleichzeitig benutzt werden, die Befehle können aber immer nur auf eine angewandt werden),
* die Variablen, die für die Feldbezeichner der Datensätze stehen. Letztere benötigen im Gegensatz zu der üblichen Verfahrensweise keine vorherige Deklaration!

showknd:
Den Abschluß von "iniFile:" bildet die Bildschirmdarstellung der geöffneten Datenbank durch das Unterprogramm "showknd:". Daß wir uns hier laufend mit verkrüppelten Namen für die Prozeduren abgeben müssen, hängt einfach mit den Festlegungen für OPL zusammen und ist häufig der Grund, sich mit kurzen Anglismen zu behelfen.
    Die gleich zu Anfang von "showknd:" angesprungene Hilfsprozedur "dbk2knd:" besorgt die notwendigen Daten, die auf dem Bildschirm dargestellt werden sollen. Sie holt sie aus dem aktuellen Datensatz. Wenn die Datei gerade erst geöffnet wurde, ist das der allererste. Dabei sorgt USE A für Klarheit, welche der offenen Dateien zu verwenden ist. In unserm Programm ist das der reine Luxus, da ja nur mit einer einzigen Datei gearbeitet wird, dienst aber bereits der Vorbereitung auf Programmerweiterungen.
    Auf die Daten in der Datenbank greift man mit ihren Feldbezeichnern und dem vorangestellten "Verwaltungsbuchstaben" (engl. handle) zu und weist sie einer allgemeinen Variablen gleichen Typs zu, beispielsweise "name$ = A.name$". Die gleichen Bezeichnungen ("name$") beißen sich hier nicht, das vorangestellte "A" und der Punkt sorgen für den kleinen Unterschied.
    Anschließend macht "showknd:" Gebrauch davon, Sonderzeichen (mit einem ASCII-Wert unter 32) auf dem Bildschirm auszugeben, indem die Funktion CHR$() verwendet wird. Der als Argument verwendete Wert sorgt dafür, daß ein Tabulator (ASCII-Wert 9) ausgegeben wird. Wenn es überhaupt einen Datensatz in der Datenbank-Datei gibt, sagt die Bildschirm-Routine sogar, wieviele Datensätze insgesamt vorhanden sind (COUNT) und zeigt, welchen Satz man gerade bearbeitet (POS). Enthält die Datenbank keinen Datensatz, heißt es dann natürlich "0/0".

main:
Das Programm hat schon einen recht langen Weg zurückgelegt, bevor es so richtig in Tritt kommt. Aber durch den Aufruf von "main:" geht es nun so richtig los! Sie werden feststellen, daß sich einige Buttons und Bildschirm-Elemente mit dem Stift bedienen lassen, ohne extra programmiert worden zu sein - ein Service von EPOC32!
    In einer ewigen Schleife wird die Tastatur mit GET auf bestimmte Werte hin abgefragt. Um entscheiden zu können, ob auch die [Strg] - Taste mitgedrückt wurde, wird die Funktion KMOD sofort nach jedem GET abgefragt. Die Variable "mod%" merkt sich das Ergebnis, bis es benötigt wird. Danach wird umgehend über die Entscheidungsstruktur IF / ELSE / ENDIF geprüft, ob die Menütaste, eine andere Taste zusammen mit der Strg - Taste oder eine Sondertaste mit einem Rückgabewert größer als 255 (z.B.: Pfeiltasten) gedrückt wurde. In jedem dieser Fälle setzt das Programm mit einer separaten Unterroutine fort, alles andere fällt unter den Tisch und die Schleife beginnt von vorn.

Die Unterroutinen im einzelnen:
showmen%
...sorgt dafür, daß das Psion-typische Menü aufgeblendet wird. Wenn Sie das Programm laufen lassen, kommen sie am Beispiel recht schnell dahinter, wie es zu programmieren ist. Die grundsätzliche Anordnung beginnt immer mit dINIT, stellt das Menü mit mCARD zusammen und endet mit der Aktivierung durch den Befehl MENU. Wichtig zu wissen ist, welche Werte wie in der Variable "keycode%" kommen. Hinter jedem Menüeintrag finden Sie eine Zahlenangabe (in einer quasi-Konstanten versteckt, z.B.: %a für 97). Dieser Wert wird nach dem Drücken einer Taste durch den MENU-Befehl übernommen und kann dort auf verschiedene Art verwendet und zu Entscheidungen benutzt werden. Ein [Esc] (das Verlassen des Menüs ohne eine Auswahl getroffen zu haben) liefert eine Null zurück. Wir nutzen hier die Zuordnung zur Variablen "keycode%", mit der dann das Unterprogramm "DoMenu:()" aufgerufen wird.
DoMenu:()
...bietet gleich mehrere "Spitzfindigkeiten". Wird die Routine von "showmen%:" aus aufgerufen, kann der übergebene Parameter k% die Werte von %x, %n, %a, %l oder Null annehmen. Das ist der einfache Fall. Ruft aber "main:" von der Stelle "ELSEIF (mod% AND 8)" die Routine mit dem Übergabewert "taste%" auf, gibt es ein Problem. "taste%" enthält nämlich nicht den reinen Code der gedrückten Taste! Durch das Mitdrücken der Strg - Taste wird dem ursprünglichen Wert ein Wert von 512 hinzuaddiert, der das korrekte Verhalten der Unterroutine verhindern würde.
    Durch den Rechenoperator AND (UND) wird die zusätzliche 512 wieder abgestreift und der reine Tasten-Code wieder "sichtbar". Man stelle sich das wie ein digitales Sieb vor. Da der Wert einer Zahl von ihrem Platz der Einsen und Nullen in der digitalen Darstellung abhängt, kann man sie dadurch verändern, daß man nur an den Stellen ein Loch in das digitale Sieb bohrt, die man weiterverwenden will (man spricht auch von "Maskieren").
    Ist in einem Sieb über dem Loch etwas, kann es durch das Loch fallen und kann darunter weiterverwendet werden. Ist aber erst garnichts über dieser Stelle im Sieb, kann auch nichts darunter ankommen. Es kann aber auch nichts unter dem Sieb ankommen, wenn an der betreffenden Stelle im Sieb kein Loch ist, egal ob darüber etwas ist oder nicht.
    Der Programmautor benutzt hier hexadezimale Zahlen, weil diese nach Eingewöhnung eine bessere Übersicht gewährleisten. Durch die UND-Verknüpfung des Wertes k% mit dem hexadezimalen Wert $FF (dez. 255) werden alle Zahlen auf Werte unter 255 beschnitten.
    Das Ergebnis wird durch die inzwischen bekannte Funktion CHR$() in einen String verwandelt und der Variablen "k$" zugeordnet. Die Funktion LOC sucht nun in dem Inhalt des Strings "menuops$", ob darin irgendein Zeichen mit dem Inhalt von "k$" übereinstimmt. Das ist immer der Fall, wenn die Strg -Taste zusammen mit der x-, a-, n- oder l-Taste gedrückt wurde oder eine entsprechende Auswahl in der Menüansicht mit [Enter] bestätigt wurde. Alles andere wir wegen der "IF" -Bedingung nicht verfolgt.
    Ein besonders Verfahren ermöglicht es, Prozeduren über Strings aufzurufen. Genau davon machen wir Gebrauch. Beim ersten Mal ist das Verfahren recht schwer zu durchschauen. Kopieren Sie es einfach! Mit Hilfe des "@-Operators" kann man so in Abhängigkeit vom Ergebnis einer String-Operation, die wir uns gerade angesehen haben, das Programm steuern. In unserem Beispiel ist das Programm deshalb in der Lage, wahlweise die Routinen "wahlx%:", "wahln%:", "wahla%:" oder "wahll%:" anzuspringen.
rollen: (taste%)
Nur wenn die Datenbank mehr als einen Eintrag enthält, macht es Sinn, sich in der Datenbank zu bewegen (zu "rollen"). Durch gezielte Abfragen findet das Unterprogramm heraus bei welchem Datensatz es sich befindet und ob überhaupt Veränderungen möglich sind - über Beginn und Ende hinaus geht es nämlich nicht, zumindest nicht in unserem Beispiel.
    Am Ende jeder Veränderung wird mit "showknd:" der Bildschirm mit aktualisierten Werten wieder aufgebaut. Gibt es keine Veränderung, glaubt "GIPRINT", eine kurzzeitig am Bildschirm erscheinende Meldung zur Information abzusetzen. Den Rest können Sie mit dem Wissen aus obigen Vorspann inzwischen selber interpretieren. Was treibt nun das Programm, wenn die einzelnen Menüpunkte aufgerufen werden?
wahle%:
Besonders einfach ist das für den Programmausstieg zu beantworten. Die Routine "wahle% ist schön kurz. Als erstes wird die aktuelle Datenbank mit CLOSE geschlossen. "USE A" ist wiederum nur Vorbereitung auf Kommendes und könnte hier eingespart werden. Mit einem lässigen "STOP" endet das Programm im wohlverdienten Ruhestand. So einfach ist das, keine Geheimnisse!
    Umfangreicher sind die anderen Routinen. Tragen wir zuerst neu einen Namen und Telefonnummer ein: "wahln%:".
wahln%:
Damit keine Verarbeitungsfehler mit den allgemeinen Variablen "name$" und "tel$" geschehen, werden ihre Inhalte zuerst vorsorglich gelöscht. Das übernimmt die Prozedur "delkndva:". In unserem Beispiel müßte das nicht unbedingt ein Unterprogramm machen, aber in Hinsicht auf Erweiterbarkeit lohnt sich der Aufwand schon. Folgt der Aufruf von "ediknd%:", inklusive der Übergabe eines Textes. Wechseln wir dorthin und sehen, was passiert.
ediknd%:()
In "ediknd%: (TEXT)" wird ein Psion-Dialog benutzt, um Eingaben zu realisieren. Dialoge beginnen immer mit dem einleitenden Befehl "dINIT". "dINIT" kann man einem String zuordnen, der dann im Kopf des Dialoges angezeigt wird.
    Das Ende wird grundsätzlich durch den Befehl "DIALOG" gebildet. Dazwischen kann es recht unterschiedlich aussehen. Konkret haben wir es bei "dEDIT" mit einer Eingabemöglichkeit für Strings zu tun. Die hier auf den Befehl folgenden Parameter sind:
* die Variable, die die Eingabe aufnehmen soll, und
* ein Text, der den Nutzer informiert, was er eingeben ("editieren") soll.
    Die Eingaben werden erst übernommen, wenn der Dialog regelrecht beendet wird (drücken von [Enter]). Im Falle von [Esc] werden die verwendeten Variablen nicht in ihrem Wert verändert - bei uns bleiben sie also leer.
dBUTTONS
bietet eine Button-Ansicht, die über die Art informiert, wie der Dialog verlassen werden kann. Das ist keine Pflicht - sieht aber gut aus. und ist äußerst benutzerfreundlich. Die Zahlen-Angaben hinter en einzelnen Texten werden vom Psion automatisch in einen Beschriftungstext umgesetzt: 27 als "Esc" und 13 als "Enter". So wird die Benutzung optisch unterstützt. Aber aufpassen! Wenn der Dialog durch [Enter] beendet wird, ist der Rückgabewert in die lokale Variable "erg%" auch "13" (wie bei dBUTTONS" angegeben), [Esc] gibt aber "0" zurück, nicht etwa "27"! Das Ergebnis des Dialoges wird schließlich an das aufrufende Programm "wahln%:()" mittels "RETURN erg%" zurückgegeben.
Noch einmal wahln%:
Das verhält sich nun je nach dem zurückgegebenen Ergebnis:
    Die allgemeinen Variablen "name$" und "tel$" werden erneut geleert und letztendlich zu "main:" zurückgekehrt, oder
    der Eintrag durch Übertragen der Variableninhalte auf die Datenbankvariablen "A.name$" und "A.tel$" der Datenbank zur Verfügung gestellt und endgültig mit APPEND dort eingebracht. Am Ende wird wieder einmal der Bildschirm mit den neuen Ergebnissen aufgefrischt.
    Nachdem wir nun etwas in der Datenbank stehen haben, können wir die Inhalte auch ändern oder löschen. Bevor wir jedoch alles wieder durch Löschen vernichten, werden wir es zuvor mit "wahla%:" ändern.
wahln%:
Nach der langen Erläuterung zu "wahln%:" sind Sie gut gewappnet, um sich diese Routine selber zu Gemüte zu führen. Der einzige Unterschied: Der Befehl "UPDATE" löscht den aktuellen Datensatz und ersetzt ihn durch die frische Eingabe.
wahll%:
Ähnlich sollte Ihnen auch die Löschroutine "wahll%:" verständlich sein. Der neue Befehl, der für das Öffnen und Schließen des Mülleimerdeckels und den lautlosen Tod des aktuellen Datensatzes verantwortlich zeichnet, lautet hier "ERASE". Achten Sie einmal darauf, wie hier die Buttons im Dialog beschriftet sind und wie die Auswertung vorgenommen wird. Damit haben Sie es für heute einmal mehr geschafft. War doch alles garnicht so schwierig, oder? Sie haben nun alle Kenntnisse, um die Datenbank auf Ihre speziellen Belange zuzuschneiden. Versuchen Sie eine Ergänzung der Felder durch Hinzufügen von Vornamen, Straße, PLZ und Ort. Sie werden sehen, es ist garnicht so kompliziert.
    Die Möglichkeit, die die Datenbanken so effektiv verwenden läßt -das Suchen- , lernen Sie im nächsten Workshop kennen.


OPL am Psion von Rudolf Pöchacker (http://members.xoom.com/poechacker/)
Valid HTML 4.01! Copyright © 2002-2007 Mobile Times Business Club
Zurück zum Menü
Nach Oben