Access mit Makros automatisieren - HomePages für Einsteiger ...

29 KnowWare PLUS
4,-
Deutschland
Access 97/2000 und 2002/XP
Access mit Makros
Access mit Makros
automatisieren
www.KnowWare.de
Deutschland: 4,- EUR Österreich: 4,60 EUR
Schweiz: 8 SFR Luxemburg: 4,70 EUR Italien: 5,50 EUR
Thomas Barkow
4 *qlrujs#b-v--b* ÊÂËÙ

Acrobat Reader - Bestellung - Autoren gesucht
Acrobat Reader: Wie ...
F5/F6 öffnet/schließt die Ansicht Lesezeichen
Strg+F sucht
Im Menü Ansicht stellst du ein, wie die Datei gezeigt wird
STRG+0 = Ganze Seite STRG+1 = Originalgrösse STRG+2 = Fensterbreite
Im selben Menü kannst du folgendes einstellen:: Einzelne Seite,
Fortlaufend oder Fortlaufend - Doppelseiten .. Probiere es aus, um
die Unterschiede zu sehen.
Navigation
Pfeil Links/Rechts: eine Seite vor/zurück
Alt+ Pfeil Links/Rechts: Wie im Browser: Vorwärts/Zurück
Strg++ vergrößert und Strg+– verkleinert
Bestellung und Vertrieb für den Buchhandel
Bonner Pressevertrieb, Postfach 3920, D-49029 Osnabrück
Tel.: +49 (0)541 33145-20
Fax: +49 (0)541 33145-33
bestellung@knowware.de
www.knowware.de/bestellen
Autoren gesucht
Der KnowWare-Verlag sucht ständig neue Autoren. Hast du ein Thema,
daß dir unter den Fingern brennt? - ein Thema, das du anderen Leuten
leicht verständlich erklären kannst?
Schicke uns einfach ein paar Beispielseiten und ein vorläufiges
Inhaltsverzeichnis an folgende Adresse:
lektorat@knowware.de
Wir werden uns deinen Vorschlag ansehen und dir so schnell wie
möglich eine Antwort senden.
www.knowware.de

Inhalt
3
Hallo....................................................................4
Wie ist das Heft aufgebaut? ..................................5
Voraussetzungen für dieses Heft......................6
Kenntnisse und Fähigkeiten..............................6
Benötigte Hardware ..........................................6
Software und Daten ..........................................7
Beispieldatenbank vorbereiten..........................7
Die Arbeit mit dem Makroeditor .....................9
Der Makroeditor ...............................................9
Das erste Makro..............................................10
Das zweite Makro ...........................................12
Aktionszeilen einfügen........................................12
Makros strukturieren ...........................................12
Aktionen kommentieren......................................12
Spaltenbreite einstellen........................................12
Aktionszeilen löschen .........................................12
Aktionszeilen umstellen ......................................13
Die gewünschte Aktion finden ............................13
Argumente für Aktionen .....................................13
Makros testen..................................................14
Eine fehlgeschlagene Aktion...............................14
Einzelschritt-Modus ............................................15
Aktionen vorübergehend stillegen ......................16
Makrogruppen.................................................16
Namensspalte ......................................................17
Makros einer Makrogruppe starten .....................17
Namenskonventionen......................................18
Namens- und Bedingungsspalte dauerhaft
anzeigen........................................................18
Das Manko an den Makros .............................18
Programmstrukturen der Makrosprache .....19
Programmverzweigung durch Bedingungen...20
Referenz auf ein Objekt, Teil 1 ...........................21
Bedingungen wiederholen...................................21
Verzweigung .......................................................21
Unterprogramm: ein Makro ruft ein
anderes auf ...................................................22
Schleifen: Aktionen mehrfach ausführen........23
Bildschirmflackern ausschalten...........................24
Makros automatisch starten...........................26
Direktstart .......................................................26
Start durch ein Ereignis ..................................26
Bearbeiten eines Wertes in einem Textfeld.........27
Referenz auf ein Objekt, Teil 2 ...........................28
Der Ausdrucks-Generator ...................................28
Ereignis und Makro verknüpfen..........................30
Alternative Ereignisse .........................................31
Nach einem Datensatz suchen.........................32
Schaltfläche und Makro verknüpfen ...................33
Datensätze filtern ............................................34
Die Struktur der Datenherkunft ...........................35
Eine Parameterabfrage.........................................35
Die Datenstruktur mit Filter ................................37
Das Makro zum Filtern........................................37
Den Filter testen ..................................................38
Der Steuerelement-Assistent ...............................38
Variablen durch die Hintertür .......................40
Mit Makros Tabellen erzeugen............................40
Ein Makro schreibt in die Tabelle .......................41
Wert einer Eigenschaft setzen .............................42
Laden einer Datenbank...................................43
Das AutoExec-Makro .....................................45
Das AutoExec-Makro umgehen......................45
Das AutoKeys-Makro .....................................46
Daten importieren und exportieren ...............47
Daten per Email senden ..................................47
Daten in eine Datei schreiben .........................48
Im- und Export mit Transfer... ........................48
Ein Arbeitsblatt transferieren...............................49
Ein Datenbank-Objekt transferieren....................49
Eine Textdatei transferieren.................................49
Und TransferSQLDatenbank? .............................51
Wohin kann Access exportieren? ........................52
Alle Makroaktionen im Detail ........................53
Liste der Makroaktionen ................................64
Makroaktionen alphabetisch sortiert ...............64
Makroaktionen gruppenweise sortiert.............66
Tipps und Tricks..............................................68
Meldungen erweitern ......................................68
Typ steuert die Schaltflächen ..............................68
Typ steuert das Symbol .......................................69
Typ steuert die Voreinstellung ............................69
Kombinationsfeld automatisch öffnen ............69
Symbol „Makro ausführen“ ............................70
Schneller arbeiten............................................71
Ordnung im Datenbankfenster ........................71
Tastenkombinationen......................................73
Register.............................................................75
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

4
Vorwort
Hallo
Arbeitest du mit Word, hast du mit einem Dokument
oft gerade mal 15 oder 30 Minuten zu tun.
Du schreibst vielleicht einen Brief, druckst und
speicherst ihn, fertig. Nur selten verwendest du
das Dokument noch ein weiteres Mal. Schon bei
einer Excel-Kalkulation kann das ganz anders
aussehen. Und mit einer Access-Datenbank
arbeitet man immer wieder. Es gibt Anwender,
die schalten an ihrem Arbeitsplatz morgens den
PC ein, laden eine Datenbank in Access, arbeiten
den ganzen Tag damit und schalten die Kiste
abends wieder aus – Tag für Tag.
Diese Anwender kennen ihre Datenbank in- und
auswendig, beherrschen sie wie im Schlaf – nur
eines stört: oft schläft man wirklich fast dabei
ein. Nicht etwa, weil Access so langsam wäre;
aber um zu einem Ergebnis zu kommen ist es
häufig ausgesprochen mühsam, immer wieder
dieselbe lange Sequenz von Arbeitsschritten auszuführen.
Wie schön wäre es, wenn das auf Knopfdruck
automatisch passieren könnte!
Bist du einer von diesen Anwendern? Wenn du
täglich die gleichen Schritte häufig wiederholen
musst, ist das zwar lästig, aber eigentlich kein
Problem; es klappt bald ohne nachzudenken.
Musst du aber regelmäßig jedes Quartal oder am
Jahresende solche Prozeduren durchführen, dann
wird das leicht zum Zitterspiel, weil du vergessen
hast, wie es genau geht, oder weil du einfach in
den Tiefen deines Schreibtisches den Zettel nicht
mehr findest, wo alles notiert ist.
Access enthält zwei Programmiersprachen, mit
denen man eine Prozedur von Arbeitsschritten
automatisieren kann: VBA (Visual Basic for
Applications) und eine einfache Makrosprache.
Um die geht es hier. VBA ist eine mächtige Sprache
mit Hunderten von Befehlen und Parametern,
und es kostet sicher einige Monate intensiver
Arbeit, um sie einigermaßen zu erlernen.
Anders sieht es mit der Makrosprache aus; je
nach Access-Version enthält sie etwa 50
Aktionen. Damit kann man sicher nicht alles das
machen, was sich mit VBA realisieren lässt; aber
für einen fortgeschrittenen Access-Anwender
auch ohne bisherige Programmierkenntnisse
bietet sie einiges.
Um die Makrosprache geht es also in diesem
Heft. Du kannst es mit vielen Übungen leicht in
drei Tagen durcharbeiten; es deckt die Makrosprache
in den zwei Versionen für Access 2000
und 2002 ab.
Hast du noch Access 97, wirst du sicher auch mit
dem Heft zurecht kommen, denn die Unterschiede
sind gering.
Willst du bei Access gerade erst einsteigen,
solltest du dieses Heft lieber wieder weglegen –
es setzt zu viel voraus und würde dich nur
frustrieren. Fang an mit dem KnowWare-Heft
172 „Access 2002 für Einsteiger“. Das kannst du
auch verwenden, wenn du noch mit Access 97
oder Access 2000 arbeitest. Es ist bereits im
September 2002 erschienen und an vielen
Kiosken nicht mehr erhältlich, aber auf Seite 2
erfährst du, wie du es noch bestellen kannst.
Informationen zu dem Heft (und eine Bestellmöglichkeit)
gibt es auf www.knowware.de.
Auch das KnowWare-Plus-Heft 18 „Access –
Formulare und Berichte“ gehört eigentlich
chronologisch vor dieses Heft. Es lässt sich für
alle Access-Versionen verwenden und stellt eine
wichtige Voraussetzung für die Übungen dieses
Heftes dar. Mehr dazu findest du unter
www.knowware.de
Zu meiner Person
Meine Haupttätigkeit besteht eigentlich im
Datenbank-Design und der Programmierung von
Office-Applikationen mit VBA – nicht nur für
Access, sondern auch für Excel und Word; ich
bin also Office-Praktiker. Aber als Entwickler
läuft man immer Gefahr, sich von den Wünschen
der Anwender zu weit zu entfernen.
Als Autor sollte man für die Bedürfnisse der
Leser ein offenes Ohr haben. Deshalb bin ich an
Anregungen und Kritik besonders interessiert.
Hier ist meine EMail-Adresse:
xsMakros@OfficeTuning.de
Bitte schreib mir, was dir gefallen hat, und vor
allem, was nicht; mich interessiert, welche Aspekte
fehlen und was vielleicht hätte entfallen können.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Vorwort
5
Und wenn du meinst, ich sollte als nächstes unbedingt
ein Heft zu einem anderen Office-Thema
schreiben, lass es mich auch wissen.
Was kannst du hier lernen?
Als erstes findest du ein ziemlich langes Kapitel
über die Arbeit mit dem Makroeditor. Hier geht
es darum, wie man sich in diesem Editor bewegt
und welche Hilfsmittel und Eigenschaften er zur
Verfügung stellt; außerdem erhältst du Hinweise
zur Programmiertechnik und zum Testen.
Im nächsten Abschnitt geht es um Programmstrukturen.
Darunter versteht man z.B. die Möglichkeit,
in einem Programm in verschiedenen
Situationen unterschiedlich zu reagieren; gemeint
sind bedingte Verzweigungen im Programm.
Eine weitere Struktur besteht im Durchlaufen von
Schleifen – in einer bestimmten Anzahl oder bis
eine bestimmte Bedingung erfüllt ist.
Das nächste Kapitel widmet sich dem Prinzip der
Ereignissteuerung in Windows. Bewegst du die
Maus oder klickst oder ziehst damit, drückst du
eine Taste ... alles wird von Access als ein sogenanntes
Ereignis aufgefasst und interpretiert.
Möglicherweise ist mit dem Ereignis eine bestimmte
Reaktion verbunden; das ist dann nichts
anderes als eine Programmroutine. Und genau
das kannst du bald selbst realisieren.
Nebenbei – oder ich sollte besser sagen: gleichzeitig
– lernst du eine ganze Reihe von Befehlen
kennen – oder Aktionen, wie sie in der Makrosprache
genannt werden. Es ist ein bisschen wie
bei der Henne und dem Ei. Ohne Kenntnis der
Befehle kannst du nicht lernen, wie man ein Programm
schreibt; und ohne Programmierkenntnisse
nutzt dir die reine Befehlssyntax nichts.
Beim Erlernen der Technik streue ich also immer
wieder kleine, möglichst allgemein gehaltene
Beispiele ein. Am Anfang sprach ich von der
„Automatisierung häufiger Arbeitsabläufe“. Da
gibt es relativ einfache Dinge, die dazu beitragen
können, dass Anwender, die sich mit dem Aufbau
einer Datenbank nicht gut auskennen, trotzdem
komfortabel und sicher arbeiten können. Gemeint
ist die Erstellung eines Verwaltungsformulars,
das quasi als Hauptmenü dient, und von dem aus
sich alle anderen Formulare und Berichte aufrufen
lassen.
Ferner geht es darum, die Suchfunktion von
Access zu verbessern. Was Access mit dem
Symbol Suchen (oder dem Befehl BEARBEITEN|
SUCHEN oder ALT-B S oder STRG-F) zur Verfügung
stellt, ist leider wenig komfortabel. Wir
schreiben ein Makro zum Suchen, und weil es
dazu noch eine Variante gibt, auch eines zum
Filtern.
Die kleinen Randbemerkungen, wie soeben in
dem Satz über die Suchfunktion, mag mancher als
oberlehrerhaft empfinden. Ich halte es aber für
sinnvoll, mit den verschiedenen Alternativen und
nützlichen Kleinigkeiten bei der Handhabung von
Access vertraut zu sein.
Ein häufiges Thema ist der Import und Export
von Daten; sei ist zum Zwecke der Archivierung,
der Datensicherung oder der Weiterverarbeitung
in Word oder Excel. Oder du bekommst Daten
von einer anderen Abteilung in einem anderen
Format geliefert und benötigst sie in deiner
Datenbank. Dazu werden wir ein paar kurze
Makros verfassen.
Wie ist das Heft aufgebaut?
Die Frage ist immer: schreibe ich einen Kursus,
den du kontinuierlich durcharbeiten musst, oder
lässt sich das Heft auch als kleines Nachschlagewerk
verwenden.
Bei diesem Heft ist es ganz klar: Der größere
erste Teil ab Seite 9 ist ein Kurs, der dir die
Technik erklärt, wie man kleine Prozeduren mit
der Makrosprache programmiert. Den musst du
auf jeden Fall durcharbeiten. Der kleinere zweite
Teil ab Seite 53 behandelt alle Makroaktionen im
Einzelnen und systematisiert sie nach Themenbereichen.
Klar ist, dass du alle Beispiele am Computer nachvollziehen
solltest. Denke daran: du lernst auch
mit den Fingern; deine Hand weiß, wo im Auto
der Rückwärtsgang ist, so soll es sein.
Hast du schon Vorkenntnisse und benötigst nur
eine schnelle Information zu einem einzelnen
Problem, sollte es dir mit Hilfe von Inhaltsverzeichnis
und Register gelingen, den entsprechenden
Abschnitt aufzusuchen. Ab Seite 64 findest
du außerdem Listen, die alle Makroaktionen
enthalten, – und zwar alphabetisch und nach
zusammengehörigen Gruppen sortiert.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

6
Voraussetzungen für dieses Heft
Voraussetzungen für dieses Heft
Kenntnisse und Fähigkeiten
Grundlegend sind zumindest gewisse Kenntnisse
darüber, wie und warum man Daten in einer relationalen
Datenbank auf verschiedene Tabellen
verteilt; hier machen Anfänger meist gravierende
Fehler. Außerdem solltest du wissen, wie eine
Tabelle angelegt wird; das ist nicht sonderlich
schwer, dennoch sind ein paar wichtige Kleinigkeiten
zu beachten. Und das Thema Abfragen ist
natürlich ganz zentral, denn dies ist das wichtigste
Werkzeug eines Datenbank-Systems; mit
Abfragen holst du aus den vielen Daten deiner
Datenbank genau die Informationen heraus, die
deine Fragen beantworten.
All diese Themen habe ich in meinem Heft für
Einsteiger diskutiert (vgl. Seite 4). Gleichwertige
Kenntnisse aus anderer Quelle sind natürlich
auch in Ordnung.
Beim Erstellen von Formularen und Berichten
helfen dir die Assistenten von Access; darüber
hinaus solltest du aber schon wissen, wie man
Steuerelemente (Textfelder, Schaltflächen etc.) in
ein Formular einbaut. Außerdem musst du dich
mit den vielen konfigurierbaren Eigenschaften
von Steuerelementen auskennen. Auch dazu gibt
es von mir ein KnowWare-Heft „Access – Formulare
und Berichte“, vgl. Seite 4, das dir alle
Techniken näher bringt. Du musst dir nicht unbedingt
die Hefte kaufen (obwohl man vier Euro
kaum profitabler in Know How investieren
kann), aber du solltest dir wenigstens auf der
Homepage von www.knowware.de einen Überblick
über den Inhalt verschaffen und überlegen,
ob deine Kenntnisse den Stoff abdecken.
Bevor du dich an die Programmierung kleiner
Makros machst, solltest du sicher sein, dass die
Struktur deiner Datenbank sauber und durchdacht
konzipiert ist.
Der Haken ist nämlich der: Hast du schon diverse
Formulare, Berichte und Makros angelegt und
bemerkst dann, dass deine Daten anders auf die
unterschiedlichen Tabellen verteilt sein müssen,
so bist du gezwungen, alle Abfragen, die auf
diesen Tabellen basieren, neu zu erstellen. Und
haben sich dann die Abfragen geändert, funktioniert
natürlich auch kein Formular mehr, das auf
diesen Abfragen beruht.
Das zieht leicht viel unnütze Arbeit nach sich, die
du dir durch ein wenig Planungsaufwand im
Vorhinein leicht hättest ersparen können.
Bevor du viel Zeit und Aufwand in ein Formular,
einen Bericht oder gar in die Programmierung von
Makros investierst, plane und prüfe die Datenstruktur,
also den Aufbau und die Verknüpfung der
Tabellen deiner Datenbank. Der Grundsatz lautet:
keine Redundanz (d.h. keine Daten doppelt)!
Benötigte Hardware
Willst du nur so nebenbei ein paar Makros anfertigen,
ist ein 17-Zoll-Monitor gerade noch hinreichend.
1024 x 768 Punkte sollte er aber schon
flimmerfrei darstellen können. Du willst es nachprüfen?
Wähle START|EINSTELLUNGEN| SYSTEM-
STEUERUNG|ANZEIGE|EINSTELLUNGEN.
Hast du aber vor, für eine auch nur etwas größere
Datenbank mit diversen Tabellen, Abfragen, Formularen
und Berichten Makros zu erstellen, die
den Ablauf häufig verwendeter Arbeitsabläufe
automatisieren, kann der Monitor bzw. die Auflösung
des Monitors gar nicht groß genug sein.
Eigentlich sollte ich sagen: kann die Arbeitsfläche
gar nicht groß genug sein. Windows
erlaubt nämlich schon seit Jahren den Anschluss
von zwei Monitoren an einen Rechner. Der benötigt
dann allerdings zwei Grafikkarten. Aber ein
zweiter 17-Zöller und eine passable Grafikkarte
kosten nur wenig mehr als 200 Euro, weniger
jedenfalls als ein 20- oder 21-Zoll-Monitor und
eine sehr gute Grafikkarte, die darauf 1600 x
1200 Punkte flimmerfrei darstellen kann. Vielleicht
steht ja im Büro nebenan ein unbenutzter
Rechner ...?
Sicher ist es günstig, zwei gleiche Karten und
gleiche Monitore zu verwenden, das muss aber
nicht sein. Umbau der Grafikkarte und Anschluss
des Monitors dauern zehn Minuten, die Konfiguration
sollte Windows normalerweise alleine
schaffen. Du musst Windows lediglich mitteilen,
welcher Monitor rechts und welcher links steht.
Bewegst du dann die Maus, springt der Mauszeiger
automatisch vom rechten Rand des linken
Bildschirms an den linken Rand des rechten Bildschirms.
Auch Fenster kannst du frei von einem
Monitor auf den anderen verschieben.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Voraussetzungen für dieses Heft
7
So kannst du auf einem Monitor ein großes Formular
so darstellen, wie es der Anwender sieht –
und auf dem zweiten das Datenbankfenster, den
Makroeditor und eventuell weitere Hilfsfenster
wie Eigenschaftenfenster oder die Feldliste.
Software und Daten
Access hast du ohnehin installiert – entweder
Access 2000 oder Access 2002.
Auch wenn du Access 97 verwendest, wirst du mit
diesem Heft zurecht kommen – die Unterschiede
sind nicht besonders groß.
Was du noch brauchst, um die hier beschriebenen
Beispiele nachvollziehen zu können, ist die Beispiel-Datenbank
NORDWIND.MDB. Du findest sie
auf deinem Rechner wahrscheinlich in dem Verzeichnis
...OFFICE\BEISPIEL“; meist heißt es
C:\PROGRAMME\MICROSOFT OFFICE\OFFICE\
BEISPIEL oder ähnlich. Lege dir ein Arbeitsverzeichnis
an, in dem du die mit diesem Heft erstellten
Beispiele speichern kannst (etwa
C:\ACCESSMAKROS) und kopiere in dieses
Verzeichnis die Originaldatei NORDWIND.MDB.
Findest du sie allerdings auch mit der Suchfunktion
des Windows-Explorers nicht, musst du sie
nachinstallieren.
Bist du mit dem Installationsprogramm nicht
vertraut, kannst du die Datei für Access 97 oder
2000 auch einfach von der Office-CD-ROM
kopieren. Das Verfahren beschreibe ich gleich.
Bei Access 2002 kommst du leider nicht um das
Installationsprogramm SETUP.EXE herum; wähle
FEATURES HINZUFÜGEN ODER ENTFERNEN, und
das Programm führt dich durch die Installation;
unter dem Zweig von Access findest du dann
auch die Nordwind-Datenbank.
1. Lege die Office-97 oder 2000-CD in das CD-
ROM-Laufwerk und brich das Setup-Programm
ab, falls es automatisch angelaufen
ist.
2. Starte den Windows-Explorer
3. Navigiere auf deinem CD-ROM-Laufwerk in
das Verzeichnis mit den Beispieldateien.
Bei Office 97 heißt das Verzeichnis etwa
D:\OFFICE\BEISPIEL.
Bei Office 2000 heißt das Verzeichnis
D:\PFILES\MSOFFICE\
OFFICE\SAMPLES. Die Datei heißt hier nur
NWIND.MDB.
Bei Office xp heißt das Verzeichnis
D:\PROGRAMME\MICROSOFT OFFICEXP\
OFFICE10\SAMPLES
1. Kopiere die Originaldatei in dein Arbeitsverzeichnis
(siehe oben).
2. Benenne sie ggf. in NORDWIND.MDB um.
Beispieldatenbank vorbereiten
Starte Access und öffne die soeben kopierte
Datenbank NORDWIND.MDB. Den Hinweis, dass
die Datei schreibgeschützt ist, bestätigst du mit
OK. Das Begrüßungsfenster mit dem Leuchtturm
schließt du ebenfalls mit einem Klick auf OK.
Verwendest du Access 2002, so schließt du auch
das Formular HAUPTÜBERSICHT mit einem Klick
auf die Schaltfläche SCHLIEßEN in der oberen
rechten Ecke.
Willst du dir einen Überblick über die Datenstruktur
verschaffen, wählst du EXTRAS|BEZIE-
HUNGEN.Du siehst, dass es hier 8 Tabellen gibt,
die wir später verwenden werden.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

8
Voraussetzungen für dieses Heft
Die Beziehungen zwischen den Tabellen sehen
wir uns später näher an. Zunächst nur so viel: Es
gibt hier eine Reihe von 1:n-Beziehungen. So
gehören z.B. zu einem Kunden mehrere Bestellungen;
bei einem Neukunden sind aber auch 0
oder 1 Bestellungen möglich. Gleiches gilt für
die Tabellen Lieferanten und Artikel.
Zwischen den Tabellen Artikel und Bestellungen
besteht eine m:n-Beziehung – denn ein
bestimmter Artikel kann Bestandteil mehrerer
Bestellungen sein, wie umgekehrt auch eine
Bestellung meist auch mehrere Artikel umfasst.
Um eine derartige Beziehung in einem relationalen
Datenbanksystem abzubilden, wird eine Verknüpfungstabelle
benötigt, die mindestens die
beiden Primärschlüsselfelder der Tabellen enthalten
muss, die in der m:n-Beziehung stehen; hier
ist es die Tabelle Bestelldetails mit den Feldern
Bestell-Nr und Artikel-Nr.
Klicke im Datenbankfenster nacheinander die
verschiedenen Register an. Du findest etliche
Abfragen, Formulare, Berichte, Makros und
Module in der Datenbank. Die wollen wir hier
nur teilweise benutzen – wenn du sie jetzt aber
löschst, wäre deine Nordwind.mdb kaputt. Also
legst du eine neue Datenbank an und importierst
bei Bedarf die benötigten Objekte.
1. Lege eine neue leere Datenbank in dem
Arbeitsverzeichnis für dieses Heft (etwa
c:\AccessMakros) an.
Das ist in den verschiedenen Versionen von
Access etwas unterschiedlich. Aber da du ja
hoffentlich kein Einsteiger mehr bist, weißt du
sicher, wie das geht.
1. Gib ihr den Namen SÜDWIND. (Access fügt
automatisch .MDB an.)
Achte darauf, dass du in deinem Arbeitsverzeichnis
bleibst – notfalls navigierst du
dorthin.
1. Wähle dann DATEI|EXTERNE DATEN|IMPOR-
TIEREN...
2. Du findest in deinem Arbeitsverzeichnis die
Datenbank NORDWIND.MDB. Markiere sie
und klicke auf IMPORTIEREN. Access importiert
aber noch nicht, sondern liest nur, welche
Objekte es in dieser Datenbank gibt.
Klicke bitte erst dann auf OK, wenn ich es dir
sage.)
1. Der Bereich für TABELLEN zeigt die acht
Tabellen von NORDWIND.MDB. Markiere sie
mit einem Klick auf ALLE AUSWÄHLEN.
Halt: Bevor du mit OK wirklich importierst,
klicke auf die Schaltfläche OPTIONEN>>.
Du siehst: Es werden normalerweise auch die
BEZIEHUNGEN zwischen den Tabellen importiert;
von den Tabellen wiederum DEFINITION
UND DATEN. Herrlich! Genau das willst du.
1. Klicke auf OK. Fertig? ... fast!
2. Wähle nochmals EXTRAS|BEZIEHUNGEN.
Leider sieht das Bild nicht ganz so schön aus
wie in der Abbildung auf der vorher gehenden
Seite, aber du kannst es leicht mit der
Maus selbst richten.
3. Wähle EXTRAS|OPTIONEN Register ALLGE-
MEIN und aktiviere die Option BEIM SCHLIEßEN
KOMPRIMIEREN. Das hält die Datenbank
immer klein, kompakt und schnell.
4. Schließlich wählst du DATEI|BEENDEN und
achtest auf den unteren Rand des Access-
Fensters: SÜDWIND.MDB wird komprimiert
und gespeichert.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Die Arbeit mit dem Makroeditor
9
Die Arbeit mit dem Makroeditor
Bevor wir zur Makrosprache selbst kommen,
müssen wir uns zunächst ein paar Dinge ansehen:
Beispielsweise, wo und wie man ein Makro
anlegt oder schreibt. Und wie man am besten
vorgeht und was es zu beachten gibt.
Der Makroeditor
1. Lade die Übungsdatenbank SÜDWIND.MDB.
2. Wechsle im Datenbankfenster auf das
Register Makros. Da es noch kein Makro
gibt, empfängt dich gähnende Leere.
3. Es gibt auch keine vordefinierten Aktionen,
wie in den Registern TABELLEN, ABFRAGEN,
FORMULARE oder BERICHTE. Also bleibt nur
ein Klick auf die Schaltfläche NEU.
Egal, ob du kleine oder große Programme mit der
Makrosprache von Access oder mit einer anderen
Programmiersprache schreibst: Mach dir immer
sofort die Mühe und kommentiere, was die Aktion
macht und warum es gemacht wird. Manchmal
lohnt es auch die Mühe zu dokumentieren, warum
es nicht anders gemacht wird.
Intuitiv ist dir vielleicht zunächst eine andere
Lösung eingefallen, nach längerem Probieren hast
du aber bemerkt, dass es aus irgendeinem Grund
so nicht realisierbar ist. Schreib es auf! Du wärst
nicht der oder die Erste, der/die nach drei
Monaten seine/ihre eigenen Makros nicht mehr
versteht.
4. Jetzt siehst du den Makroeditor: zunächst nur
zwei Spalten, überschrieben mit AKTION und
KOMMENTAR. Die einzelnen Makrobefehle
werden hier Aktionen genannt; in die
Kommentarspalte kann du beliebigen Text
schreiben, der erklärt, was warum gemacht
wird.
Kommentare bewahren dich also davor, die
gleiche mühsame Gedankenarbeit noch einmal
investieren zu müssen.
Im Editor siehst du unten einen Bereich, der mit
AKTIONSARGUMENTE überschreiben ist. Noch ist
er leer. Aber zu fast jeder Aktion gibt es eine
oder mehrere Angaben – Parameter oder hier
eben Argumente genannt – , die weitere Details
der Aktion festlegen, wie du gleich sehen wirst.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

10
Das erste Makro
Das erste Makro
Ich erwähnte schon, dass es an die 50 verschiedene
Befehle oder Aktionen gibt. Die meisten
Aktionen haben sprechende Namen, das heißt,
der Name sagt ganz gut aus, was die Aktion
macht: Meldung informiert den Anwender mit
einer wichtige Meldung, ÖffnenFormular
öffnet natürlich ein Formular. Mit den zusätzlichen
Argumenten legst du fest, wie die Meldung
denn nun lautet, ob ein Signalton erklingen soll,
der den fast eingeschlafenen Anwender wecken
soll (das bist du! Nein, dein Kollege, der später
mit der Datenbank arbeiten soll!), oder welches
Formular in welcher Darstellung zu öffnen ist.
Wenn die Schreibmarke (der Cursor) in irgendeiner
Zeile der Spalte Aktion blinkt, taucht (in
dieser Zeile) rechts in dem Feld die Schaltfläche
für eine Drop-Down-Liste auf (siehe nächstes
Bild). Die Liste zeigt dir alle zur Verfügung
stehenden Aktionen an.
1. Öffne in der ersten Zeile des Makroeditors in
der Spalte Aktion die Drop-Down-Liste.
Um eine Dropdown-Liste zu öffnen, klickst du
mit der Maus auf den abwärts gerichteten Pfeil
– bzw. Drückst F4 oder ALT-PFEIL ABWÄRTS.
1. Es wäre schön, wenn der blaue Text in der
unteren rechten Ecke jeweils schon vor der
Auswahl einer Aktion eine Erklärung zur
Funktionalität dieser Aktion anzeigen würde.
Macht er aber nicht; kommt sicher mit einer
der nächsten Versionen von Access. Und auf
den Computer-Messen wird Access dann laut
als „noch viel anwenderfreundlicher“ angepriesen.
2. Hast du die Aktion Meldung ausgewählt
und drückst die EINGABETASTE, so springst
du in die Spalte Kommentar – etwas früh
vielleicht; den Kommentar solltest du erst
schreiben, wenn die Aktion vollständig
definiert ist. Günstiger scheint mir, mit der
Maus auf die gewünschte Aktion zu klicken;
du bleibst in der Spalte Aktion, und unten
rechts wird angezeigt, was diese Aktion
macht: Bei der Aktion Meldung steht dort:
3. Egal, ob du dich in der Kommentar- oder der
Aktionsspalte befindest: Per Mausklick oder
besser mit Hilfe der Taste F6 springst du zum
ersten Argument für diese Aktion. (Vgl. auch
den Abschnitt über Tastenkombinationen auf
Seite 73.) Achte auf den blauen Hilfetext
rechts!
2. Rollst du mit dem Rollbalken in der Liste
nach unten, findest du hier die Namen aller
Makrobefehle oder Makroaktionen. Wir
suchen jetzt die Aktion Meldung.
Bald weißt du schon vorher, wie die Aktion
heißt, die du benötigst. Dann kannst du nach
dem Öffnen der Liste einfach den ersten Buchstaben
der Aktion tippen und stehst sofort auf
dem Namen der ersten Aktion, die mit diesem
Buchstaben beginnt. Diese Eigenschaft kennst
du wahrscheinlich schon von vielen anderen
Drop-Down-Listen in Windows-Programmen.
4. Einer unsinnigen, aber alten Tradition folgend
gibst du als Text der Meldung „Hallo
Welt“ ein (oder „Hallo“ und deinen Namen
oder stolz „Mein erstes Makro“ oder irgendeinen
anderen redundanten Unsinn).
5. Mit der TABULATOR-TASTE oder mit PFEIL-
NACH UNTEN gelangst du in die zweite Zeile.
Aus der Drop-Down-Liste kannst du wählen,
ob der Computer beim Anzeigen des Meldungsfensters
einen Signalton abspielen soll
oder nicht. Wenn dein PC sich weigert, hast
du Pech gehabt; im Prinzip klappt’s. Probiere
es aus!
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Das erste Makro
11
6. Das Argument Typ legt fest, ob und welches
Symbol in deiner Meldung erscheinen soll:
Entweder Ohne Symbol oder (wie hier)
Kritisch:
Bevor das Makro dann tatsächlich ausgeführt
wird, teilt Access dir mit, dass es zunächst
gespeichert werden muss: safety first ist nicht
verkehrt. Dabei muss das Kind natürlich einen
Namen bekommen. Der vorgeschlagene Name
Makro1 ist für spätere Zeiten nicht gerade
aussagekräftig. Ich habe als treffenden Namen
eingegeben:
7. Oder Warnmeldung (?):
8. Oder Warnmeldung (!):
9. Oder Information:
1.
Hast du die Aktion Meldung erforscht, so
schließt du das Makro mit DATEI|SCHLIEßEN oder
durch einen Klick auf diese
Schaltfläche in der rechten oberen
Ecke des Editor-Fensters.
Zwei Hinweise noch zur Aktion Meldung:
• Der Text kann maximal 255 Zeichen lang
sein.
• Aber viel gravierender: Andere Schaltflächen
als OK sind nicht möglich; kein JA oder
NEIN, kein ABBRECHEN. Und es gibt auch
keine andere Aktion, die einen solchen
Dialog mit dem Anwender erlaubt. Ein
ärgerlicher Nachteil der Makrosprache.
Es gibt aber einen Trick, wie du doch zu einem
Meldungsfenster mit zwei Schaltflächen kommst.
Ich muss dir aber vorher noch einige andere Dinge
erklären, damit du verstehst, wie der Trick
funktioniert. Ich komme auf das Thema zurück.
10. Das Argument Titel legt den Text fest, der in
der Titelleiste des Meldungsfensters
erscheint:
So, nun darfst du spielen. Du startest
das Makro mit Hilfe dieser
Schaltfläche.
Ein Makro unmittelbar aus dem Editor heraus zu
starten ist zu Testzwecken ganz praktisch. Aber
um den Anwender auf irgend etwas hinzuweisen,
kann das so ja wohl nicht gehen.
Richtig!
Später zeige ich dir andere Methoden, um
Makros zu starten: per Schaltfläche, auf die der
Anwender klickt (etwa aus einem Formular
heraus) oder gar automatisch, wenn irgendein
Ereignis eintritt, das der Anwender nur indirekt
ausgelöst hat (siehe Seite 26).
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

12
Das zweite Makro
Das zweite Makro
So trivial wie bisher werden deine Makros auf
Dauer wohl nicht bleiben. Wir werden nun ein
paar weitere Zeilen hinzufügen, aber ich muss
dich enttäuschen: Es bleibt noch bei der Aktion
Meldung; gleichzeitig lernst du den Editor
etwas weiter kennen.
1. Klick im Datenbankfenster, Register
MAKROS auf die Schaltfläche NEU.
2. Verwende in der ersten Zeile die Aktion
Meldung mit diesen Argumenten:
Meldung
Meldung
Shut up, Bill!
Signalton
Ja
Typ
Kritisch
Titel
Antwort
1. Wähle DATEI|SPEICHERN und vergib den
Namen Ich an Bill. Dann führe das Makro
aus. Das Ergebnis ist wie erwartet.
Aktionszeilen einfügen
Nun möchtest du aber, dass vor dieser Meldung
noch eine andere Aktion ausgeführt wird
1. Klicke in der
ersten Zeile auf
die Markierspalte ganz links. Damit wird die
Zeile markiert.
2. Dann kannst du mit der Taste EINFG über der
ersten Zeile eine Leerzeile einfügen.
3. Füge hier noch eine Meldung ein, die
besagt: Jetzt geht’s los!.
4. Lasse die dritte Zeile leer. In der vierten Zeile
soll nochmals die Aktion Meldung aufgerufen
werden. Tippe zunächst einmal nur den
Buchstaben m.
5. Access schlägt die erste Aktion mit m vor,
nämlich maximieren. Die wollen wir aber
nicht. Tippe noch ein e – na also: meldung.
Die soll’s sein!
6. Mit F6 kannst du sofort die Aktionsargumente
festlegen, nämlich als Meldungstext:
Dem hab ich’s gezeigt.
7. Access hat den Namen der Aktion orthographisch
korrekt als Meldung geschrieben.
8. Die verbleibenden Argumente kannst du nach
Belieben vergeben.
9. Führe das Makro aus; zunächst sollst du
wieder speichern. Ein Name für das Makro
ist ja schon vergeben.
Makros strukturieren
Du siehst: Die Leerzeile bleibt ohne Auswirkung,
das Makro läuft darüber einfach hinweg.
Längere Makros kannst du dadurch etwas strukturieren
und leichter lesbar machen, dass du
logisch zusammengehörige Aktionen in Blöcke
schreibst, die durch Leerzeilen optisch getrennt
werden.
Aktionen kommentieren
Spätestens jetzt solltest du auch daran denken,
die Kommentarspalte sinnvoll zu ergänzen. Bei
mir sieht das Makro jetzt so aus:
Spaltenbreite einstellen
Die Breite der Spalten kannst du durch Ziehen
mit der Maus verändern. Stelle die Maus dazu auf
den Trennstrich zwischen zwei Spalten:
Erfahrene Excel-Anwender wissen sicher, dass
man die Spaltenbreite durch einen Doppelklick
auf den Spaltentrennstrich auf die optimale Breite
einstellen kann. Probier es aus! Die Breite einer
Spalte ist dann optimal, wenn der längste Eintrag
einer Zeile gerade darin Platz findet.
Aktionszeilen löschen
Zum Löschen der aktuellen Zeile benutzt du die
Taste ENTF. Zum Einfügen oder Löschen von
Aktionszeilen kannst du natürlich auch
diese Symbole nehmen:
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Das zweite Makro
13
Aktionszeilen umstellen
Willst du die Reihenfolge deiner Aktionen
ändern, markierst du in der Markierspalte eine
Aktion (oder auch mehrere), klickst ein zweites
Mal in die Spalte und ziehst die markierte Zeile
mit der Maus an die gewünschte Stelle.
Wahrscheinlich kennst du das Verhalten von
Word oder Excel.
Die gewünschte Aktion finden
Viele Aktionen haben Namen, die wirklich
unmittelbar verständlich sind; beispielsweise:
• Drucken
• EinblendenSymbolleiste
• GeheZuDatensatz
• oder auch alle Aktionen, die mit Öffnen
beginnen
Bei anderen Befehlen hilft es, wenn du sie
einfach als Aktion auswählst und den blauen
Erklärungstext unten rechts im Editorfenster
durchliest; auch hierzu ein paar Beispiele:
AnwendenFilter
AusgabeIn
(gemeint ist
„Ausgabe in“, nicht
„Ausgabeln“)
Maximieren
Wendet Filter, Abfrage
oder SQL WHERE-
Klausel auf eine Tabelle,
ein Formular oder einen
Bericht an, um die Datensätze
... einzuschränken
oder zu sortieren.
Gibt die Daten im angegebenen
Datenbankobjekt
im Format Microsoft
Excel (:XLS), Rich-Text
(:RTF), MS-DOS-Text
(:TXT) ... aus.
Ändert das aktuelle
Fenster in ein Vollbild,
damit dieses das Microsoft
Access-Fenster
ausfüllt.
Führt das nicht zum Ziel, so solltest du im Kapitel
„Liste der Makroaktionen“ die Abschnitte
„Makroaktionen alphabetisch sortiert“ (Seite 64)
und „Makroaktionen gruppenweise sortiert“ (ab
Seite 65) zu Rate ziehen.
Argumente für Aktionen
Schwierig wird es teilweise bei den Argumenten:
• Es gibt Aktionen, die kein Argument benötigen
(AbbrechenEreignis, AnzeigenAlleDatensätze,
Maximieren,
Minimieren); da ist es einfach
• Es gibt aber auch Aktionen mit sehr vielen
Argumenten: AusgabeIn hat 7 Argumente,
SendenObjekt sogar 10; Suchen-
Datensatz, TransferDatenbank und
TransferText haben alle 7.
• Und schließlich erfordern manche Aktionen
Argumente, bei denen du sicher zuerst etwas
Zeit in Forschung investieren musst.
Ein Beispiel ist die Aktion Tastaturbefehle;
hier gibt es das Argument Tastenfolge. Zur
Erklärung bietet dir Access an: „Geben Sie die zu
verarbeitende Tastenfolge ein. Verwenden Sie
die Syntax des Visual Basic-Befehls ‘SendKeys’,
um die Tasten festzulegen. Notwendiges
Argument.“ Die Hilfe-Datei zu Visual Basic hast
du aber möglicherweise gar nicht installiert – und
selbst wenn, weißt du nicht, wie du da dran
kommst. Du siehst: Du musst erst Forschung
betreiben (oder Seiten 40 und vor allem 61f
studieren.) Eins kannst du aber von diesem
Beispiel schon ableiten:
Es gibt notwendige Argumente, die du auf jeden
Fall angeben musst, und nicht-notwendige (optionale)
Argumente. Für die nicht-notwendigen Argumente
gibt es manchmal Standardwerte – d.h.
wenn du nichts angibst, wird ein bestimmter Wert
als Standard angenommen.
Dazu ein Beispiel: das Argument Exemplare bei
der Aktion Drucken. Gibst du nichts an, wird
genau ein Exemplar gedruckt.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

14
Makros testen
Makros testen
Es gibt eine alte Ingenieur-Weisheit, die lautet:
Methodik ersetzt den Zufall durch den Irrtum.
Beim Programmieren wirst du es auch bemerken
– nicht unbedingt oft bei der Makrosprache von
Access, sicher aber, wenn du dich mit Visual
Basic oder C oder Pascal befasst: in unserem
Hirn laufen auch bei einfachen logischen Konstrukten
so viele Details automatisch ab, dass es
zunächst viel Übung kostet, all die kleinen
impliziten Schritte in einem Programm auch
explizit zu formulieren.
Anfänglich wirst du viele Fehler machen, weil du
eine Aktion anstößt, ohne geprüft zu haben, ob
auch alle notwendigen Voraussetzungen erfüllt
sind.
Leider bietet die Makrosprache von Access
überhaupt keine Möglichkeit, unerwartete Fehler
abzufangen. Du müsstest also immer vorher
prüfen, ob sämtliche Voraussetzungen für eine
Aktion auch erfüllt sind; z.B. ob ein Formular,
das mit ÖffnenFormular geöffnet werden
soll, überhaupt vorhanden ist. Aber auch dafür
stellt die Makrosprache keine Aktionen bereit.
Du musst also immer davon ausgehen, dass deine
Datenbank ständig so heil ist, wie zu dem
Zeitpunkt, als du dein Makro geschrieben hast.
Stell dir vor, in einer Applikation gibt es ein
Formular mit dem Namen Hauptmenü. Dieses
Formular enthält aber keine Daten, sondern es
handelt sich um ein Formular, das allein Verwaltungszwecken
dient. Es enthält diverse
Schaltflächen, mit deren Hilfe du verschiedene
Aktionen in der Datenbank anstoßen kannst:
• Kundendaten erfassen und ansehen
• Artikeldaten erfassen und ansehen
• Rechnungen schreiben
• Mahnungen drucken
Für viele dieser Aktivitäten wird vom Hauptmenü
aus mit einem Klick auf eine Schaltfläche
ein Formular geöffnet oder ein Bericht geöffnet
und gedruckt.
Willst du ein Formular öffnen, gibt es folgende
Aktion:
ÖffnenFormular
Formularname
Ansicht
Filtername
Bedingung
Datenmodus
Fenstermodus
Kunde
Formular
Notwendig ist die Angabe der ersten zwei Argumente,
d.h. das Makro muss wissen, welches
Formular in welcher Ansicht (Formular, Entwurf,
Seitenansicht, Datenblatt, PivotTable oder Pivotchart)
dargestellt werden soll; meist wohl in der
Formularansicht.
Stehst du in dem Eingabefeld für das Argument
Formularname, bietet dir der Editor in einer
Drop-Down-Liste die Namen aller vorhandenen
Formulare an. Nicht schlecht – ein Tippfehler
kann dir also kaum unterlaufen.
Eine fehlgeschlagene Aktion
Was passiert aber, wenn das Formular irgendwann
doch nicht mehr existiert – sei es, dass es
absichtlich oder versehentlich gelöscht wurde
oder dass es aus irgendeinem Grund später
jemand umbenannt hat? (Umbenennen ist immer
nachteilig! Vgl. Kapitel „Namenskonventionen“
auf Seite 18.) In deiner Datenbank (mit der du
arbeitest, während du dieses Heft liest) gibt es
beispielsweise kein Formular mit dem Namen
Kunde. Macht nichts, wir wollen ja gerade einen
Programmfehler provozieren. Erstellst du ein
Makro mit der Aktion ÖffnenFormular und
führst es aus, so erscheint zuerst dieser Hinweis:
Das wäre für den unbedarften Anwender (natürlich
ist dein Kollege gemeint!) noch erträglich,
aber sobald du – ähh – er auf OK klickt, sieht er
folgendes:
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

4.
Makros testen
15
5. Klicke auf das Symbol Einzelschritt.
6. Führe das Makro aus.
Vor Ausführung jeder einzelnen Aktion erscheint
ein Dialogfeld mit diesem Aufbau:.
Das ist nicht zumutbar.
Aber – wie gesagt – die Makrosprache bietet
keine Möglichkeit, ein Makro, das auf einen
Fehler stößt, vernünftig zu beenden.
Und eine Aktion, die vorher die Existenz eines
Objektes prüft, etwa diese (angenommene):
ExistiertObjekt
Objekttyp
Objektname
gibt es leider nicht.
Einzelschritt-Modus
Möglicherweise wird ein Makro normal beendet,
führt aber trotzdem nicht zu dem gewünschten
Ziel, auch ohne dass es mit einer fehlgeschlagenen
Aktion abbricht. Vielleicht hast du einen
logischen Fehler drin. Dann ist es – jedenfalls bei
einem Makro, das aus mehreren Aktionen besteht
– nicht immer leicht festzustellen, wo der Fehler
liegt.
Access bietet die Möglichkeit, ein Makro im
Einzelschrittmodus, das heißt Aktion für Aktion,
einzeln auszuführen. Da wir noch kein längeres
Makro haben, greifen wir noch einmal auf Ich an
Bill zurück:
1. Öffne das Makro Ich an Bill in der Entwurfsansicht
– Entweder so:
2. oder indem du den Makronamen mit der
rechten Maustaste anklickst:
3. Im Kontextmenü wählst du dann den Befehl
ENTWURFSANSICHT.
Du siehst den Makronamen, den Aktionsnamen
der nächsten Aktion und die Einstellungen aller
Argumente der Aktion. Was es mit dem Feld
Bedingung auf sich hat, erfährst du gleich.
Die Schaltflächen ermöglichen weitere Ausführung
des Makros schrittweise oder normal ablaufend
(Weiter). Oder du kannst die Ausführung
des Makros Anhalten.
Dieses Verfahren hilft oft weiter – aber nicht
immer: ab und zu stehst du dennoch vor einer
Situation, die dir zunächst Rätsel aufgibt. Alles
sieht sauber aus, du hast den ganzen Ablauf des
Makros überdacht, jede einzelne Aktion geprüft –
und das Ergebnis ist trotzdem nicht korrekt.
Was tun?
Manchmal möchtest du eine Aktion mitten im
Makro mal testweise still legen und das Ergebnis
dann begutachten.
Bei einer normalen Programmiersprache würde
man jetzt auskommentieren, das heißt, aus der
Befehlszeile eine Kommentarzeile machen. Dazu
verwendet man spezielle Zeichen, die dem
Compiler mitteilen, dass jetzt irgendein Text
folgt, den er nicht beachten muss, weil er nicht
zum Programm gehört. Manchmal beginnt dann
eine Zeile mit einen einzelnen Hochkomma ‘
oder man muss es so schreiben:
/* Hier steht jetzt Kommentar */.
Egal! Geht hier nicht. Leider.
Du könntest den Befehl löschen; das ist aber
nicht ökonomisch, wenn du ihn wahrscheinlich
eine Minute später wieder einbauen musst. Aber
es gibt einen Trick.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

16
Makrogruppen
Aktionen vorübergehend stillegen
Über Aktionen, die erst ausgeführt werden, wenn
eine bestimmte Bedingung erfüllt ist, werde ich
dir später etwas erzählen. Aber die Technik
brauchen wir schon jetzt.
1. Öffne das Makro Ich an Bill in der Entwurfsansicht.
2. Klicke auf dieses Symbol:
Es soll eine Verzweigung im Programm
darstellen: wenn die Bedingung erfüllt ist,
dann weitermachen, sonst abzweigen und
etwas anderes machen.
3. Links neben der Spalte Aktion wird die
Spalte Bedingung eingeblendet.
Willst du die Ausführung einer Aktion verhindern,
kannst du in die Bedingungsspalte unmittelbar
den Wahrheitswert falsch eintragen.
Faul wie Programmierer sind, schreiben sie zu
dem gewünschten Zweck oft einen Vergleich, der
sicher immer falsch ist und wesentlich kürzer als
das Wort falsch: mit 1=2 hast du einen kleinen
Teil deines Programmes um 50% gekürzt. Schön.
(Ganz coole Programmierer schreiben 9=0 oder
so etwas; rat mal, warum!)
1. Lege die Meldung Shut up, Bill still,
indem du einen immer falschen Vergleich in
die Zeile einträgst.
In diese Spalte kannst du eine Bedingung
schreiben, die entweder erfüllt ist oder nicht. Ein
Vergleich gibt als Ergebnis dann entweder den
Wert Wahr oder den Wert Falsch.
Etwa [Familienstand]=“ledig“, d.h. im
Klartext: wenn das Feld Familienstand den Wert
ledig enthält, dann führe die Aktion aus. Sonst
wird sie übersprungen und die Ausführung des
Makros mit der nächsten Aktion fortgesetzt.
Wir werden uns ab Seite 20 eingehender mit
Bedingungen bzw. der bedingten Ausführung
von Makroaktionen befassen; jetzt können wir
die Bedingungsspalte aber etwas zweckentfremden,
um Aktionen vorübergehend still zu legen.
Makrogruppen
Ich habe auf Seite 14 schon von einem Verwaltungsformular
oder Hauptmenü gesprochen. Stell
dir vor: Da gibt es 10 Schaltflächen mit denen
sich 10 verschiedene Formulare öffnen lassen.
Das ergäbe dann 10 kleine Makros mit jeweils
nur einer einzigen Aktion (ÖffnenFormular).
Zu jedem Formular gehören möglicherweise auch
noch ein paar Makros ... Die Anzahl der Makros
würde schnell sehr groß, und es entstünde die
Gefahr, die Übersicht zu verlieren.
2. Führe das Makro normal und im Einzelschrittmodus
aus und prüfe, was passiert.
Der Einzelschrittmodus zeigt, warum die Meldung
Shut up, Bill nicht angezeigt wird:
Die Bedingung 0=9 ist natürlich falsch!
Zum Glück gibt es Abhilfe: Mehrere Makros
kannst du in einer Makrogruppe zusammenfassen.
Natürlich wirst zu zweckmäßigerweise solche
Makros in eine Gruppe schreiben, die logisch
oder organisatorisch zusammengehören. Eine
Makrogruppe sieht im Datenbankfenster aus wie
ein einfaches Makro, jedes Makro einer Makrogruppe
benötigt jedoch einen spezifischen
Makronamen.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

Makrogruppen
17
Namensspalte
Dafür kann man im Makroeditor eine zusätzliche
Spalte einrichten.
1. Lege ein neues Makro an.
2. Mit einem Klick auf dieses Symbol ...
3. öffnet sich die
Spalte
Makroname:
Du hast nun die Möglichkeit, mehrere Makros
untereinander zu schreiben. Jedes Makro
bekommt einen eigenen Namen. Das Ende eines
Makros brauchst du nicht kenntlich zu machen.
Vor einem Makronamen endet automatisch das
Makro, das oberhalb davon notiert ist.
Ich habe der Einfachheit halber die beiden
Makros Bill an mich und Ich an Bill geöffnet
und durch Kopieren hier eingefügt. Die Namen
habe ich hier in der Spalte Makroname nochmals
eingetragen. Du solltest die Spalte Bedingung
einmal öffnen und etwa noch vorhandene
Bedingungen löschen. Der Makrogruppe habe ich
den Namen Konversation gegeben.
So sieht jetzt die
Makrogruppe
Konversation in
der Entwurfsansicht
aus:
Die Leerzeile kann auch entfallen, fördert aber
die Übersicht.
Makros einer Makrogruppe starten
Führst du jetzt das Makro mit Hilfe des
entsprechenden Symbols aus, so startet
immer nur das oberste Makro; hier also Bill an
mich. Es gibt aber noch den Befehl EXTRAS|
MAKRO|MAKRO AUSFÜHREN.
Damit öffnet sich dieses Dialogfeld. Du siehst:
Hier sind die beiden Makros deiner Makrogruppe
mit einem zweiteiligen Namen aufgeführt. Markierst
du hier Konversation.Ich an Bill, kannst
du auch ein Makro aus einer Makrogruppe ausführen,
das hier nicht als oberstes notiert ist.
Der oben genannte Menübefehl weist dich darauf
hin, dass es ein Symbol gibt, mit dem du den
Befehl ausführen kannst. Leider ist das Symbol
nicht in der Symbolleiste
Makroentwurf enthalten.
Wie du es hier einbauen kannst, zeige ich dir im
Kapitel „Tipps und Tricks“ auf Seite 70. Danach
sieht deine Symbolleiste so
aus:
Nun kannst du auch solche Makros bequem
starten, die in einer Makrogruppe stehen.
Es gibt noch eine andere Art, ein Makro zu
starten – die allerdings ein besonderes Risiko
birgt. Markierst du im Datenbankfenster im
Register Makros ein Makro oder eine Makrogruppe,
so kannst du sie von hier aus auf dreierlei
Art starten: mit dem Befehl AUSFÜHREN aus der
Menüleiste des Datenbankfensters, dem gleichen
Befehl aus dem Kontextmenü, das sich nach
einem Rechtsklick auf den Makronamen öffnet,
oder ganz simpel mittels Doppelklick auf den
Makronamen. Gerade die beiden letzten Vorgänge
können auch leicht passieren ohne dass
man es eigentlich will.
Stell dir vor, das Makro, das dann abläuft,
modifiziert auf irgendeine Art Daten. Das kann
manchmal eine mittlere Katastrophe für deine
Datenbank bedeuten.
Diese Gefahr lässt sich mit einem kleinen Trick
verhindern: Lege immer Makrogruppen an (also
niemals Einzelmakros), und schreibe in die erste
Zeile ein Dummymakro, das nur aus dem Makronamen
besteht,
aber keine Aktion
enthält – wie hier
gezeigt:
Aus dem Datenbankfenster
heraus wird durch die oben beschriebenen
Methoden immer nur dieses Dummymakro
ohne Aktion ausgeführt.
Eine Alternative dazu: Gib dem ersten Makro den
Namen Dummy und statte es mit einer Aktion
Meldung aus, die kurz erklärt, welchem Zweck
diese Makrogruppe dient.
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03

18
Namenskonventionen
Namenskonventionen
An einer Datenbank, die nicht im Laufe der Zeit
wächst, ist – wie die Erfahrung zeigt: fast immer
– irgend etwas verkehrt. Mit Wachsen meine ich
nicht die Anzahl der Datensätze, die in den
Tabellen gespeichert sind, sondern den Funktionsumfang.
Wünsche und Phantasie der Anwender
sind unbegrenzt. Wenn die ursprünglich
geplante Funktionalität der Datenbank zur Zufriedenheit
aller Anwender klappt, kommen
sofort Wünsche nach Erweiterung auf: Nun noch
dies oder das einbauen, können wir nicht auch
jenes damit erledigen?
Was passiert? Aus sechs oder acht Tabellen
werden bald 20, dazu gehören schnell 40 Abfragen
und ebenso viele Formulare und Berichte:
Hast du erst einmal damit begonnen, gewisse
Abläufe mit Hilfe von Makros zu automatisieren,
so kommen schnell 200 Makros zusammen.
Und jedes Kind braucht einen Namen. Jedes
Tabellenfeld, jede Abfrage, jedes Steuerelement
in einem Formular oder Bericht, jedes Makro.
Schnell hast du einige Dutzend, ja, einige Hundert
Namen zusammen.
Vorsicht!
Wenn du das Ganze nicht mit ein wenig System
angehst, besteht deine Haupttätigkeit bald nur
noch darin, herauszufinden, was die von dir
selbst vor vier Wochen vergebenen Namen LiSt
oder GKZ bedeuten. Noch schwieriger kann es
werden, wenn mehrere Leute an der Entwicklung
eine Datenbank arbeiten.
Standards sind dringend notwendig!
Schon seit einigen Jahren sind solche Namenskonventionen
international üblich. Eine ausführliche
Darstellung (vom Erfinder Gregory
Reddick selbst, deshalb leider englisch) findest
du hier:
www.xoc.net/standards/rvbanc.asp.
In dem Heft „Access 2002 für Fortgeschrittene“,
das voraussichtlich im Frühjahr 2004 erscheinen
wird, gehe ich auf das Thema ausführlicher ein.
Als kleinen Vorgeschmack verwende ich ab hier
• keine Leerzeichen mehr in Namen
• für Makros das Präfix mcr
(also etwa mcrBillAnMich)
• für Makrogruppen das Präfix mgrp (deshalb
etwa mgrpKonversation und darin
mgrpKonversation.mcrIchAnBill)
Namens- und Bedingungsspalte
dauerhaft anzeigen
Legst du ein neues Makro bzw. eine Makrogruppe
an, so musst du die Namensspalte und die
Bedingungsspalte immer wieder neu einschalten.
Das wird auf die Dauer lästig.
Mit EXTRAS|OPTIONEN|ANSICHT stehen dir zwei
Optionsfelder zur Verfügung, mit deren Hilfe du
die beiden Spalten optional dauerhaft anzeigen
oder ausblenden kannst.
Das Manko an den Makros
Wohl jede Programmiersprache kann Variablen
und Konstanten definieren und ihnen einen (vorübergehenden
oder festen) Wert zuweisen.
Eigentlich müsste ich dir jetzt zeigen, wie man
das macht. Aber: es geht mit der Makrosprache
von Access nicht.
Nun, du hast eine Datenbank vor dir und damit
alle Möglichkeiten, Werte in Tabellen zu speichern
und aus ihnen zu lesen. Damit hat man das
obige Problem gelöst, aber das Verfahren ist umständlich.
Ich werde es dir zeigen (Seite 40).
Access mit Macros automatisieren © Thomas Barkow & Knowware Verlag - 14.09.03