<\/p>\n
Das Thema Adressverwaltung kann man auf viele verschiedene Arten lösen. In vielen Fällen reicht eine einfache Tabelle, die eine Adresse speichert. Reden wir über Adressen in einer Kundenverwaltung, kann es auch vorkommen, dass der Kunde unterschiedliche Adressen für Lieferungen und Rechnungen angeben möchte. Solche Daten speichert man entweder in einer einzigen Tabelle je Kunde oder man trägt die Liefer- und Rechnungsadresse in eigene Tabellen ein, die man dann per 1:1-Beziehung mit dem Kundendatensatz verknüpft. Wir gehen noch einen Schritt weiter und wollen mit der hier vorgestellten Lösung die Möglichkeit bieten, nicht nur zwei, sondern beliebig viele Adressen je Kunde anzulegen – die dann flexibel als Rechnung- oder Lieferadresse festgelegt werden können.<\/b><\/p>\n
Eigentlich ist es kein Problem, die Adressdaten eines Kunden oder einer Person in einem Datensatz einer Tabelle zu speichern. Sie legen dann Felder für ein oder zwei Adressen an, hier Liefer- und Rechnungsadresse, und speichern den Datensatz. Aus dieser Tabelle können Sie dann ganz einfach die Lieferadresse und die Rechnungsadresse entnehmen.<\/p>\n
Nachteile herkömmlicher Kundentabellen<\/b><\/p>\n
Aber was, wenn der Kunde vorübergehend unter einer anderen Lieferadresse erreichbar ist Oder wenn er eine Rechnung zwischenzeitlich an seinen Arbeitgeber schicken lassen will, statt zu sich nach Hause<\/p>\n
Dann müssen Sie entweder zur klassischen Methode greifen und die Rechnung oder das Paket von Hand beschriften oder Sie ändern die Rechnungs- oder Lieferadresse vorübergehend, um diese anschließend wieder in den alten Zustand zu versetzen. Aber wie stellen Sie sicher, dass Sie dann nicht vergessen, die vorübergehende Adresse wieder herauszulöschen Und wo speichern Sie in der Zwischenzeit die üblicherweise zu verwendende Adresse<\/p>\n
Solche Fragen stellen sich auch, wenn Sie mit der hier vorgestellten Lösung arbeiten, aber sie macht das Leben deutlich einfacher.<\/p>\n
Datenmodell für flexible Adressen<\/b><\/p>\n
Im Datenmodell für unsere Lösung finden wir zunächst die übliche Tabelle etwa namens tblKunden<\/b>. Diese enthält einige Basisdaten wie etwa die Anrede, den Vor- und den Nachnamen des Kunden sowie das Geburtsdatum. Wir haben beispielsweise auch noch die E-Mail-Adresse und die Telefonnummer des Kunden erfasst. Sie können nach Bedarf noch weitere organisatorische Daten erfassen, wie etwa das Datum, an dem der Kundendatensatz erstellt wurde.<\/p>\n
Diese Tabelle sieht vorerst wie in Bild 1 aus. Das Feld AnredeID <\/b>ist ein Fremdschlüsselfeld zur Tabelle tblAnreden<\/b>, welche wir hier nicht abbilden. Diese Tabelle besteht lediglich aus den Feldern ID <\/b>und Anrede<\/b>.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle tblKunden<\/span><\/b><\/p>\n Die neue Tabelle zum Speichern von Liefer- und Rechnungsadressen heißt schlicht tblAdressen<\/b>. Sie sieht im Entwurf wie in Bild 2 aus. Sie enthält nochmals die Felder AnredeID<\/b>, Vorname <\/b>und Nachname<\/b> – das deshalb, weil ja auch einmal eine ganz andere Person eine Lieferung oder eine Rechnung erhalten können soll. Außerdem finden Sie hier die üblichen Felder zum Erfassen einer Adresse wie Firma<\/b>, Strasse<\/b>, PLZ<\/b>, Ort <\/b>und Land<\/b>.<\/p>\n Bild 2: Entwurf der Tabelle tblAdresse<\/span><\/b><\/p>\n Interessant wird es beim Feld KundeID<\/b>. Dabei handelt es sich um ein Fremdschlüsselfeld, mit dem Sie einen der Datensätze der Tabelle tblKunden <\/b>auswählen können. Wir haben es als Nachschlagefeld ausgelegt.<\/p>\n Außerdem finden Sie hier das Feld Bezeichnung<\/b>. Damit soll der Benutzer eine individuelle Bezeichnung für die Adresse angeben können, damit er diese später leicht identifizieren kann. Es handelt sich jedoch um kein Pflichtfeld.<\/p>\n Von der Adresse zum Kunden zur Adresse<\/b><\/p>\n Nun können wir zwar bereits für eine Adresse festlegen, zu welchem Kunden diese gehört, und auf diese Weise einem Kunden keine, eine oder auch mehrere Adressen zuweisen. Aber woher wissen wir, welche Adresse die Lieferadresse des Kunden ist und welche die Rechnungsadresse<\/p>\n Dazu müssen wir der Tabelle tblKunden <\/b>noch weitere Felder hinzufügen, was wir wie in Bild 3 erledigen. Das erste Feld heißt LieferadresseID <\/b>und ist ein Fremdschlüsselfeld zur Auswahl eines der Datensätze der Tabelle tblAdressen<\/b>. Das zweite Feld namens RechnungsadresseID <\/b>dient der Auswahl der für den Rechnungsversand zu verwendenden Adresse.<\/p>\n Bild 3: Entwurf der Tabelle tblAdresse mit Feldern zur Auswahl von Rechnungs- und Lieferadresse<\/span><\/b><\/p>\n Beziehungen zwischen den Tabellen<\/b><\/p>\n Wir haben nun verschiedene Beziehungen festgelegt, welche die Tabellen tblKunden <\/b>und tblAdressen <\/b>in beide Richtungen miteinander verknüpfen. Die Tabelle tblAdressen <\/b>wird über das Fremdschlüsselfeld Kunde-ID <\/b>mit je einem Datensatz der Tabelle tblKunden <\/b>verknüpft. Die Tabelle tblKunden <\/b>wiederum wird über kein, eines oder zwei der Felder LieferadresseID <\/b>und Rechnungsadresse-ID <\/b>mit der Tabelle tblAdressen <\/b>verknüpft (siehe Bild 4). Um die Beziehungen zwischen den ID-Feldern der Tabelle tblAdressen <\/b>und den beiden Fremdschlüsselfeldern LieferadresseID <\/b>und RechnungsadresseID <\/b>im Beziehungen-Fenster abzubilden, haben wir die Tabelle tblAdressen <\/b>unter dem Namen tblAdressen_1 <\/b>ein zweites Mal hinzugefügt. Die Beziehung zwischen dem Feld KundeID <\/b>der hier unter tblAdressen_1 <\/b>abgebildeten Tabelle und der Tabelle tblKunden <\/b>lässt sich aus technischen Gründen nicht abbilden, sie ist aber wie für die Tabelle tblAdressen <\/b>dargestellt vorhanden.<\/p>\n Bild 4: Beziehungen zwischen den Tabellen<\/span><\/b><\/p>\n Reihenfolge beim Anlegen der Daten<\/b><\/p>\n Wenn Sie einen Datensatz in die Tabelle tblAdressen <\/b>eingeben, müssen Sie auch gleich über das Feld KundeID <\/b>festlegen, zu welchem Kunden die Adresse gehört. Daher muss zu diesem Zeitpunkt bereits ein Kundendatensatz vorhanden sein. Die Reihenfolge lautet also: Erst Kundendatensatz anlegen, dann die Adressdatensätze. Um sicherzustellen, dass kein Adressdatensatz gespeichert werden kann, ohne dass ein Kundendatensatz referenziert wurde, stellen wir die Eigenschaft Eingabe erforderlich <\/b>für das Feld KundeID <\/b>der Tabelle tblAdressen <\/b>auf Ja <\/b>ein. Dies sollten Sie erledigen, bevor Sie Daten in die Tabelle tblAdressen <\/b>eingegeben haben, deren Fremdschlüsselfeld KundeID <\/b>noch leer ist. Datensätze in der Tabelle tblAdressen <\/b>ohne referenzierten Kundendatensatz sind ein Problem, denn sie befinden sich quasi im luftleeren Raum – sie sind keinem Kunden zugeordnet und so nicht zu gebrauchen.<\/p>\n Löschweitergabe bei den Verknüpfungen<\/b><\/p>\n Wenn wir mit Verknüpfungen arbeiten, müssen wir uns auch ansehen, welche Regeln wir für das Löschen von Daten festlegen. Das ist einfach: Wenn ein Kundendatensatz aus der Tabelle tblKunden <\/b>gelöscht wird, sollen natürlich auch die mit diesem Kunden verknüpften Adressdatensätze aus der Tabelle tblAdressen <\/b>gelöscht werden. Die Frage ist nur: Über welche Beziehung können wir das festlegen Die korrekte Antwort ist: Über die Beziehung der Felder LieferadresseID <\/b>und RechnungsadresseID <\/b>der Tabelle tblKunden <\/b>zum Feld ID <\/b>der Tabelle tblAdressen<\/b>.<\/p>\n Im Fenster Beziehungen bearbeiten <\/b>für diese Beziehung stellen wir die Eigenschaft Löschweitergabe an verwandte Datensätze <\/b>zusätzlich zu Mit referentieller Integrität <\/b>ein (siehe Bild 5).<\/p>\n Bild 5: Beziehung zwischen den Tabellen tblKunden und tblAdressen<\/span><\/b><\/p>\n Damit werden nun beim Löschen eines Kunden aus der Tabelle tblKunden <\/b>gleichzeitig alle mit diesem Kundendatensatz verknüpften Adressen gelöscht.<\/p>\n Auswahl der Rechnungs- und Lieferadresse<\/b><\/p>\n Wenn wir nun einige Datensätze zur Tabelle tblKunden <\/b>hinzugefügt haben und in der Tabelle tblAdressen <\/b>Adressen angelegt haben, die mit den Einträgen der Tabelle tblKunden <\/b>verknüpft sind, können wir für die beiden Fremdschlüsselfelder LieferadresseID <\/b>und RechnungsadresseID <\/b>die passenden Einträge aus der Tabelle tblAdressen <\/b>auswählen.<\/p>\n Sobald wir zum Beispiel das Nachschlagefeld LieferadresseID <\/b>der Tabelle tblKunden <\/b>aufklappen, finden wir dort nicht nur die Einträge der Tabelle tblAdressen <\/b>vor, die wir dem aktuellen Kunden über das Feld KundeID <\/b>zugewiesen haben, sondern alle Adressen. Wir müssten hier also noch einen Filter einbauen, der nur die zu diesem Kunden passenden Adressen liefert.<\/p>\n Das ist nun allerdings keine Aufgabe mehr, die wir im Datenmodell erledigen können – dazu benötigen wir entsprechende Formulare.<\/p>\n Formulare zur Eingabe von Kunden und Adressen<\/b><\/p>\n Wir starten mit einem einfachen Formular namens frmKunden<\/b>, das über die Eigenschaft Datensatzquelle<\/b> an die Tabelle tblKunden <\/b>gebunden ist.<\/p>\n Außerdem ziehen wir alle Felder dieser Tabelle über die Feldliste in den Entwurf des Formulars und ordnen die Felder wie in Bild 6 an.<\/p>\n Bild 6: Das Formular sfmKundenAdressen in der Entwurfsansicht<\/span><\/b><\/p>\n Damit haben wir zwar nun die Möglichkeit, über die beiden Kombinationsfelder, die an die Felder LieferadresseID <\/b>und RechnungsadresseID <\/b>gebunden sind, aus allen vorhandenen Adressen auszuwählen.<\/p>\n Aber genau das wollten wir ja verhindern und die dort zur Auswahl angebotenen Datensätze auf die zum Kunden gehörenden Adressen reduzieren.<\/p>\n Dazu passen wir nun die Datensatzherkunft der beiden Kombinationsfelder an, die wir übrigens vorher in cboLieferadresseID <\/b>und cboRechnungsadresseID <\/b>umbenennen.<\/p>\n Dann fügen wir dem ersten der beiden Kombinationsfelder eine Abfrage hinzu, die wir mit dem Abfrage-Generator wie in Bild 7 zusammenstellen.<\/p>\n Bild 7: Datensatzherkunft für die Kombinationsfelder zur Auswahl der Liefer- und Rechnungsadresse<\/span><\/b><\/p>\n Wir fügen der Abfrage zunächst das Primärschlüsselfeld der Tabelle hinzu. In der zweiten Spalte legen wir ein Feld namens Adresse <\/b>an, das folgenden Ausdruck, bestehend aus verschiedenen Feldern der Tabelle, liefern soll. Aber nur, wenn das Feld Bezeichnung<\/b>, das der Benutzer für jede Adresse vergeben kann, leer ist:<\/p>\n Wir stellen hier einen Ausdruck zusammen, der zunächst prüft, ob das Feld Bezeichnung <\/b>einen Wert enthält. Falls ja, liefert der Ausdruck diesen Wert zurück. Anderenfalls ist das Ergebnis ein Ausdruck mit dem Format <\/p>\n Da wir diese Abfrage für beide Kombinationsfelder nutzen können, speichern wir sie gleich unter dem Namen qryCboAdressen<\/b>, sodass sie auch im Navigationsbereich angezeigt wird.<\/p>\n Danach stellen wir diese Abfrage auch als Datensatzherkunft des zweiten Kombinationsfeldes ein. Schließlich müssen wir noch die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf die Werte 2 <\/b>und 0cm <\/b>einstellen, damit nur der aus den Feldern zusammengestellte Ausdruck angezeigt wird, nicht jedoch das Primärschlüsselfeld.<\/p>\n Nun haben wir allerdings immer noch nicht die angezeigten Einträge nach dem aktuell angezeigten Kunden gefiltert. Das erledigen wir, indem wir der Abfrage noch ein Vergleichskriterium für das Feld KundeID <\/b>zuweisen (siehe Bild 8). Dabei beziehen wir uns auf das entsprechende Feld im Formular:<\/p>\n Bild 8: Hinzufügen eines Kriteriums, das nur die zum Kunden gehörenden Adressen liefert<\/span><\/b><\/p>\n Damit erreichen wir, wenn wir bereits einen Kunden und eine Adresse für diesen Kunden über die Datenblattansicht der Tabellen angelegt haben, zumindest schon einmal die Ansicht aus Bild 9.<\/p>\n Bild 9: Auswahl einer Rechnungsadresse<\/span><\/b><\/p>\n Adressen vollständig anzeigen<\/b><\/p>\n Nun wollen wir dem Benutzer die Adressen nicht nur in Form von Vorname<\/b>, Nachname <\/b>und Firma <\/b>in einem Kombinationsfeld anzeigen, sondern er soll auch die vollständigen Daten direkt auf den ersten Blick sehen. Dazu erstellen wir zunächst ein Unterformular, das die Daten der Tabelle tblAdressen <\/b>anzeigt. Für das Unterformular stellen wir die Tabelle tblAdressen <\/b>als Datensatzquelle <\/b>ein. Außerdem ziehen wir alle Felder mit Ausnahme des Fremdschlüsselfeldes KundeID <\/b>in den Detailbereich des Entwurfs. Die Steuer-elemente positionieren wir so, dass nur wenig Platz zwischen ihnen und den Seitenrändern sichtbar ist. Allein der Abstand zum linken Rand sollte dem gleichen Abstand entsprechen, den Sie sonst zwischen Formularrand und Steuer-element lassen. Schließlich stellen wir noch die Eigenschaften Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>ein. Den Wert der Eigenschaft Datensatzmarkierer <\/b>belassen wir bei dem Wert Ja<\/b>, denn daran kann der Benutzer erkennen, ob er bereits Änderungen an einer Adresse vorgenommen hat (siehe Bild 10). Außerdem stellen wir die Eigenschaft Zyklus <\/b>noch auf Aktueller Datensatz <\/b>ein, damit der Benutzer im Unterformular nicht zwischen mehreren Datensätzen blättern kann.<\/p>\n Bild 10: Das Unterformular zur Anzeige der Adressen in der Entwurfsansicht<\/span><\/b><\/p>\n Danach speichern wir das Formular unter dem Namen sfmKundenAdressen<\/b> und schließen es. Öffnen Sie nun wieder das Formular frmKunden <\/b>in der Entwurfsansicht. Ordnen Sie dann die beiden Steuer-elemente cboLieferadresseID <\/b>und cboRechnungsadresseID <\/b>nebeneinander an und ziehen Sie das Unterformular sfmKundenAdressen <\/b>zweimal in den Entwurf des Formulars frmKunden<\/b>.<\/p>\n Löschen Sie die mit den Unterformular-Steuer-elementen automatisch angelegten Beschriftungsfelder und positionieren Sie die Unterformulare unter den beiden Kombinationsfeldern.<\/p>\n Außerdem stellen wir noch die Eigenschaft Rahmen <\/b>der beiden Unterformular-Steuerelemente auf Transparent <\/b>ein (das ist Geschmackssache – Sie können den Rand auch beibehalten).<\/p>\n Schließlich versehen wir die beiden Unterformular-Steuerelemente mit passenden Namen, also etwa sfmLieferadresse <\/b>und sfmRechnungsadresse<\/b>. Danach sollte der Entwurf des Formulars wie in Bild 11 aussehen.<\/p>\n Bild 11: Einfügen der Unterformulare zur Anzeige von Liefer- und Rechnungsadressse<\/span><\/b><\/p>\n Beziehung zwischen Haupt- und Unterformularen herstellen<\/b><\/p>\n Wenn wir nun in der Entwurfsansicht eines der beiden Unterformular-Steuerelemente markieren (was nicht gleichbedeutend mit dem Markieren des darin enthaltenen Formulars ist!), finden wir im Bereich Daten <\/b>des Eigenschaftenblatts die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>vor.<\/p>\n Access versucht automatisch, hier sinnvolle Werte einzutragen, was in unserem Fall wie üblich gelaufen ist (siehe Bild 12). Allerdings hat Access für unseren Anwendungsfall etwas übertrieben. Das Unterformular sfmLieferadresse <\/b>soll lediglich den Datensatz anzeigen, der im Kombinationsfeld cboLieferadresseID <\/b>ausgewählt ist.<\/p>\n Bild 12: Verknüpfung von Haupt- und Unterformular<\/span><\/b><\/p>\n Dazu stellen wir für das Unterformular-Steuerelement sfm-Lieferadresse <\/b>die Eigenschaft Verknüpfen von <\/b>auf den Wert ID <\/b>und Verknüpfen nach <\/b>auf LieferadresseID <\/b>ein (siehe Bild 13). Für das Unterformular sfmRechnungsadresse <\/b>stellen wir die Eigenschaft Verknüpfen von <\/b>ebenfalls auf den Wert ID <\/b>und Verknüpfen nach <\/b>auf RechnungsadresseID <\/b>ein.<\/p>\n Bild 13: Optimierte Verknüpfung von Haupt- und Unterformular<\/span><\/b><\/p>\n Wenn wir in der Tabelle tblKunden <\/b>einen Datensatz eingefügt haben und für diesen je eine Liefer- und eine Rechnungsadresse angelegt haben, können wir diese nun in den Kombinationsfeldern des Formulars frmKunden <\/b>auswählen und erhalten die Ansicht aus Bild 14.<\/p>\n Bild 14: Auswahl von Liefer- und Rechnungsadresse<\/span><\/b><\/p>\n Unterformulare nach Auswahl aktualisieren<\/b><\/p>\n Wenn Sie mit dem Formular experimentieren, werden Sie feststellen, dass nach der Auswahl eines anderen Eintrags aus dem Kombinationsfeld kein Wechsel der im Unterformular angezeigten Daten erfolgt. Der Grund ist gar nicht so einfach zu finden: Wir haben weiter oben nämlich die beiden Unterformular-Steuerelemente über die Werte LieferadresseID <\/b>und RechnungsadresseID <\/b>für die Eigenschaft Verknüpfen nach <\/b>mit dem Hauptformular verbunden.<\/p>\n Das reicht auch aus, um die Daten im Unterformular zu aktualisieren, wenn wir das Formular neu öffnen oder einen anderen Datensatz auswählen. Wenn wir allerdings nur einen neuen Wert für eines der beiden Kombinationsfelder cboLieferadresseID <\/b>oder cboRechnungsadresseID <\/b>auswählen, tut sich bei dieser Konstellation nichts.<\/p>\n Das ändert sich, wenn wir statt cboLieferadresseID <\/b>und cboRechnungsadresseID <\/b>einfach die Felder Liefer-adresseID <\/b>und RechnungsadresseID <\/b>für die Eigenschaft Verknüpfen nach <\/b>angeben.<\/p>\n Kombinationsfelder nach Auswahl aktualisieren<\/b><\/p>\n Sobald wir in einen anderen Datensatz als den beim Öffnen angezeigten wechseln, für den es auch schon Adressdatensätze gibt, sollten wir die zu diesem Kunden gehörenden Adressen über die Kombinationsfelder auswählen können. Das ist allerdings nicht der Fall – die Kombinationsfelder zeigen immer noch die Adressen des ersten Datensatzes an. Um diese zu aktualisieren, legen wir eine Ereignisprozedur für das Ereignis Beim Anzeigen <\/b>des Hauptformulars an. Die Ereignisprozedur sorgt immer beim Anzeigen eines Datensatzes dafür, dass die Datensatzherkunft der beiden Kombinationsfelder aktualisiert wird:<\/p>\n Neue Adressen anlegen<\/b><\/p>\n Wir können zwar neue Kunden über das Hauptformular anlegen, aber was ist mit neuen Adressen für den jeweiligen Kunden Normalerweise sollte es möglich sein, nach der Eingabe der Basisdaten des Kunden im Hauptformular direkt die Liefer- und die Rechnungsadresse des Kunden in den Unterformularen einzutragen. Das gelingt aber so nicht ohne weiteres. Spätestens wenn wir versuchen, einen Datensatz im Hauptformular einzutragen und dann in einem der Unterformulare fortzufahren und schließlich den Datensatz im Unterformular speichern wollen, erhalten wir den Fehler aus Bild 15.<\/p>\n Bild 15: Fehlermeldung beim Eintragen einer Adresse in das Unterformular<\/span><\/b><\/p>\n Das ist logisch, denn das Feld KundeID <\/b>der Tabelle tblAdressen <\/b>im Unterformular wird zu keinem Zeitpunkt gefüllt – es wird nicht angezeigt und kann somit nicht vom Kunden gefüllt werden und es wird auch nicht automatisch über die Verknüpfung zum Hauptformular gefüllt.<\/p>\n Also erweitern wir die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>wie in Bild 16. Danach können Sie dann auch direkt eine Lieferadresse und eine Rechnungsadresse in die Unterformulare eintragen.<\/p>\n Bild 16: Aktualisierung der beiden Eigenschaften Verknüpfen von und Verknüpfen nach<\/span><\/b><\/p>\n Das gelingt allerdings nur manchmal, denn gelegentlich erscheint bei der Eingabe des ersten Zeichens in eines der Felder einer neuen Adresse im Unterformular auch die Fehlermeldung aus Bild 17. Spannenderweise konnten wir nicht nachvollziehen, unter welchen Bedingungen dieser Fehler auftritt. Jedenfalls ist an dieser Stelle der Zeitpunkt erreicht, die Notbremse zu ziehen: Wir werden zum Anlegen der Adressen ein neues Formular erstellen, das der Benutzer über eine Schaltfläche zum Anlegen einer neuen Adresse anklicken kann. Die beiden Unterformulare wandeln wir in schreibgeschützte Formulare um – der Benutzer soll nur noch entweder eine der verfügbaren Adressen über eines der beiden Kombinationsfelder auswählen können oder eine neue Adresse über das noch zu erstellende Formular anlegen.<\/p>\n Bild 17: Fehlermeldung beim Versuch, eine Adresse anzulegen<\/span><\/b><\/p>\n Unterformular schreibschützen<\/b><\/p>\n Damit der Benutzer nicht mehr direkt in das Unterformular schreiben kann, ändern wir diese wie folgt:<\/p>\n Danach sieht das Unterformular bei fehlender Adresse wie in Bild 18 aus. Hier stören nun noch die Schaltfläche zum Aufklappen des Kombinationsfeldes, welches nun ohnehin gesperrt ist. Außerdem benötigen wir auch die Anzeige der ID <\/b>der Adresse nicht. Letztere können wir einfach entfernen. Damit die Anrede nur noch in einem Textfeld angezeigt wird, ändern wir die Datensatzquelle des Unterformulars noch wie folgt und fügen so das Feld Anrede <\/b>der Tabelle tblAnreden <\/b>hinzu:<\/p>\n Bild 18: Die ID und das die Schaltfläche des Kombinationsfeldes stören das Bild.<\/span><\/b><\/p>\n Danach liefert das Unterformular die Daten in optisch ansprechenderer Form.<\/p>\n Formular zum Anlegen neuer Adressen<\/b><\/p>\n Das Formular zum Anlegen von Adressen soll schlicht frmAdressen <\/b>heißen. Wir legen die Tabelle tblAdressen <\/b>als Datensatzquelle für dieses Formular fest. Außerdem ziehen wir alle Felder dieser Tabelle mit Ausnahme des Feldes KundeID <\/b>in den Entwurf dieses Formulars.<\/p>\n Stellen Sie die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>ein und Automatisch zentrieren <\/b>auf Ja<\/b>.<\/p>\n Außerdem fügen wir zwei Schaltflächen namens cmdOK <\/b>und cmdAbbrechen <\/b>hinzu, für die wir die folgenden Prozeduren hinterlegen:<\/p>\n Aufruf des Formulars zum Anlegen von Adressen<\/b><\/p>\n Fehlt noch die Kommunikation zwischen den Formularen, sprich die Schaltfläche, welche das Formular frmAdressen <\/b>vom Formular frmKunden <\/b>aus ausruft. Beziehungsweise zwei Schaltflächen, wenn wir diese direkt für die Liefer- und die Rechnungsadresse anlegen wollen.<\/p>\n Dann müsste die Schaltlfäche für die Lieferadresse das Formular frmAdressen <\/b>aufrufen, den Benutzer einen neuen Datensatz anlegen lassen und nach dem Schließen dieses Formulars die neue Adresse gleich als neue Lieferadresse einrichten. Das Gleiche gilt für die Rechnungsadresse.<\/p>\n Dazu statten wir das Formular frmKunden <\/b>zunächst mit den beiden Schaltflächen cmdNeueLieferadresse<\/b> und cmdNeueRechnungsadresse <\/b>aus (siehe Bild 19).<\/p>\n Bild 19: Schaltflächen zum Hinzufügen neuer Rechnungs- und Lieferadressen<\/span><\/b><\/p>\n Wenn wir das Formular frmAdressen <\/b>etwa über die Schaltfläche cmdNeueLieferadresse <\/b>öffnen, benötigen wir dazu eine Prozedur wie die folgende. Diese öffnet zunächst das Formular frmAdressen <\/b>mit der DoCmd<\/b>. Die OpenForm<\/b>-Anweisung und legt mit den Parametern fest, dass das Formular als modaler Dialog zum Anlegen eines neuen Datensatzes geöffnet wird. Der letzte Parameter OpenArgs <\/b>übergibt die ID des aktuell im Formular frmKunden<\/b> angezeigten Kundendatensatzes, damit wir die neue Adresse direkt im Kontext dieses neuen Kunden anlegen können:<\/p>\n Wenn der Benutzer die Daten der neuen Adresse im Formular frmAdressen <\/b>eingegeben hat und das Formular mit der OK<\/b>-Schaltfläche schließt, wird dieses unsichtbar gemacht und der Code der Prozedur cmdNeueLiefer-adresse_Click <\/b>läuft weiter. Dann prüfen wir mit der Hilfsfunktion IstFormularGeoeffnet<\/b>, ob das Formular noch geöffnet ist, was nur der Fall ist, wenn der Benutzer es mit der OK<\/b>-Schaltfläche unsichtbar gemacht hat. Dann ermittelt die Prozedur den Wert des Primärschlüsselfeldes ID <\/b>des neu angelegten Datensatzes und speichert diesen in der Variablen lngAdresseID<\/b>. Danach schließt die Prozedur das Formular, damit der dort eingegebene Datensatz auch gespeichert wird. Danach aktualisiert sie das Kombinationsfeld cboLieferadresseID <\/b>mit der Requery<\/b>-Methode. Dadurch listet das Kombinationsfeld nun auch den neuen Eintrag auf. Dieser wird dann als Wert des Kombinationsfeldes eingestellt und der neue Datensatz mit der Re-query<\/b>-Methode im Unterformular eingeblendet:<\/p>\n Damit der Plan aufgeht, müssen wir nun noch im aufgerufenen Formular, also frmAdressen<\/b>, beim Öffnen die übergebene ID <\/b>des Kunden ermitteln und für das Feld KundeID <\/b>einstellen. Wenn Sie sichergehen wollen, dass dieses auch übergeben und festgelegt wird, können Sie das Feld vorübergehend noch in den Entwurf des Formulars frmAdressen <\/b>ziehen.<\/p>\n Nach dem Aufruf sieht das Formular dann etwa wie in Bild 20 aus.<\/p>\n Bild 20: Anlegen einer neuen Lieferadresse<\/span><\/b><\/p>\n Oben rechts sehen Sie, dass der Kunde aus dem aufrufenden Formular für das Feld KundeID <\/b>voreingestellt wurde. Das geschieht durch die folgende Prozedur, die beim Laden des Formulars frmAdressen <\/b>ausgelöst wird:<\/p>\n Damit können Sie nun neue Adressen eingeben, die direkt als Lieferanschrift im aufrufenden Formular eingestellt werden.<\/p>\n Neue Rechnungsadresse<\/b><\/p>\n Die Schaltfläche cmdNeueRechnungsadresse <\/b>ruft eine ähnliche Prozedur auf wie cmdNeueLieferadresse<\/b>:<\/p>\n Bearbeiten einer Adresse<\/b><\/p>\n Zum Bearbeiten einer Adresse fügen wir dem Formular frmKunden <\/b>noch zwei weitere Schaltflächen hinzu – jeweils neben die beiden Neu<\/b>-Schaltlfächen über den Kombinationsfeldern. Die beiden Schaltflächen heißen cmdLieferadresseBearbeiten <\/b>und cmdRechnungsadresseBearbeiten<\/b>.<\/p>\n Für die Schaltfläche cmdLieferadresseBearbeiten <\/b>hinterlegen wir die folgende Prozedur:<\/p>\n Diese ist ähnlich aufgebaut wie die für das Anlegen einer Adresse. Allerdings verwenden wir für den Parameter DataMode <\/b>den Wert acFormEdit<\/b>, und wir übergeben auch keinen Wert für den Parameter OpenArgs<\/b>, sondern einen für WhereCondition<\/b>. Dieser erhält eine Where<\/b>-Condition, welche dafür sorgt, dass beim Anzeigen des Formulars der Datensatz angezeigt wird, dessen Feld ID <\/b>den Wert des Kombinationsfeldes cboLieferadresseID <\/b>enthält.<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_002.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_003.png\")
<\/p>\n![\"Beziehungen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_004.png\")
<\/p>\n![\"Beziehung](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_005.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_006.png\")
<\/p>\n![\"Datensatzherkunft](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_007.png\")
<\/p>\nAdresse: Nz([Bezeichnung];[Nachname] & \", \" & [Vorname] & \" (\"+[Firma]+\")\")<\/pre>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_008.png\")
<\/p>\n[Forms]![frmKunden]![ID]<\/pre>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_009.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_010.png\")
<\/p>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_011.png\")
<\/p>\n![\"Verknüpfung](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_012.png\")
<\/p>\n![\"Optimierte](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_013.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_014.png\")
<\/p>\nPrivate Sub <\/span>Form_Current()\r\n Me!cboLieferadresseID.Requery\r\n Me!cboRechnungsadresseID.Requery\r\nEnd Sub<\/span><\/pre>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_015.png\")
<\/p>\n![\"Aktualisierung](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_016.png\")
<\/p>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_017.png\")
<\/p>\n\n
![\"Die](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_018.png\")
<\/p>\nSELECT tblAdressen.ID, tblAdressen.KundeID, tblAdressen.Bezeichnung, tblAdressen.Firma, tblAnreden.Anrede, tblAdressen.Vorname, tblAdressen.Nachname, tblAdressen.Strasse, tblAdressen.PLZ, tblAdressen.Ort, tblAdressen.Land FROM tblAnreden INNER JOIN tblAdressen ON tblAnreden.ID = tblAdressen.AnredeID;<\/pre>\n
Private Sub <\/span>cmdOK_Click()\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdAbbrechen_Click()\r\n Me.Undo\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\n![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_020.png\")
<\/p>\nPrivate Sub <\/span>cmdNeueLieferadresse_Click()\r\n Dim <\/span>lngAdresseID As Long<\/span>\r\n DoCmd.OpenForm \"frmAdressen\", DataMode:=acFormAdd, _\r\n WindowMode:=acDialog, OpenArgs:=Me!ID<\/pre>\n If <\/span>IstFormularGeoeffnet(\"frmAdressen\") Then<\/span>\r\n lngAdresseID = Forms!frmAdressen!ID\r\n DoCmd.Close acForm, \"frmAdressen\"\r\n Me!cboLieferadresseID.Requery\r\n Me!cboLieferadresseID = lngAdresseID\r\n Me!sfmLieferadresse.Form.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1214_021.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Me!KundeID.DefaultValue = Me.OpenArgs\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeueRechnungsadresse_Click()\r\n Dim <\/span>lngAdresseID As Long<\/span>\r\n DoCmd.OpenForm \"frmAdressen\", DataMode:=acFormAdd, _\r\n WindowMode:=acDialog, OpenArgs:=Me!ID\r\n If <\/span>IstFormularGeoeffnet(\"frmAdressen\") Then<\/span>\r\n lngAdresseID = Forms!frmAdressen!ID\r\n DoCmd.Close acForm, \"frmAdressen\"\r\n Me!cboRechnungsadresseID.Requery\r\n Me!cboRechnungsadresseID = lngAdresseID\r\n Me!sfmRechnungsadresse.Form.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdLieferadresseBearbeiten_Click()\r\n Dim <\/span>lngAdresseID As Long<\/span>\r\n DoCmd.OpenForm \"frmAdressen\", DataMode:=acFormEdit, _\r\n WindowMode:=acDialog, WhereCondition:=\"ID = \" _\r\n & Me!cboLieferadresseID\r\n If <\/span>IstFormularGeoeffnet(\"frmAdressen\") Then<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n lngAdresseID = Me!cboLieferadresseID\r\n Me!cboLieferadresseID.Requery\r\n Me!cboLieferadresseID = lngAdresseID\r\n Me!sfmLieferadresse.Form.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n