Es gibt verschiedene Möglichkeiten, eine m:n-Beziehung zwischen zwei Tabellen in Formularen abzubilden: Mit zwei Listenfeldern, mit einem Haupt- und einem Unterformular und viele weitere. In diesem Beitrag schauen wir uns eine Kombination aus Listenfeld und Datenblatt an. Dabei betrachten wir das Beispiel von Fahrzeugen und Ausstattungsmerkmalen. Eigentlich sollte man meinen, das wäre eine reine m:n-Beziehung, in der die Verknüpfungstabelle nur die Zuordnung der Merkmale zu den Fahrzeugen vornimmt. Allerdings liefert einer unserer Kunden ein Beispiel, bei dem es etwas aufwendiger wird: Zusätzlich zur reinen Zuordnung soll auch noch festgelegt werden können, welche Ausstattungsmerkmale mit auf das Preisschild sollen und welche Serien- und welche Sonderausstattungen es gibt. Kein Problem: Dann bauen wir einfach eine ergonomische Lösung für diesen Fall, wie dieser Beitrag zeigt.<\/b><\/p>\n
Man könnte annehmen, dass die Zuordnung von Ausstattungen zu Fahrzeugen über eine einfache m:n-Verknüpfungstabelle zu realisieren ist, welche jeweils ein Fremdschlüsselfeld zum Herstellen einer 1:n-Beziehung zur Tabelle der Fahrzeuge enthält und eines zum Herstellen einer 1:n-Beziehung zur Tabelle der Ausstattungsmerkmale. Doch einer unserer Kunden hatte eine Anforderung, die darüber hinausgeht: Er möchte nicht nur festlegen, ob ein Ausstattungsmerkmal zu einem Fahrzeug gehört oder nicht, sondern auch noch angeben können, ob dieses auf dem Preisschild gelangen soll.<\/p>\n
Falls Sie sich fragen, warum man nicht einfach alle Ausstattungen dort unterbringt: Manchmal hat ein Fahrzeug einfach so viele Ausstattungsmerkmale, dass diese nicht alle auf das Preisschild passen, dass im Fahrzeug hinter die Windschutzscheibe gelegt wird. Dann heißt es aussortieren! Bisher hat der Kunde dies manuell erledigt.<\/p>\n
Das heißt, er hat auf Basis der m:n-Beziehung zwischen den Fahrzeugen und den Ausstattungen eine Komma-separierte Liste generiert, die er zunächst in einem Memofeld gespeichert hat. Dann hat er diesen Text in ein zweites Memofeld kopiert und die Merkmale, die am wenigsten Kaufanreiz bieten oder so selbstverständlich sind, dass sie nicht aufgeführt werden müssen, aus der zweiten Liste entfernt – solange, bis diese auf das Preisschild passte.<\/p>\n
Das ist allerdings etwas umständlich und auch fehleranfällig:<\/p>\n
Also mussten wir uns zwei Dinge überlegen:<\/p>\n
Bevor wir starten, schauen wir uns das aktuelle Datenmodell an. Eigentlich hatte der Kunde die Fahrzeuge und Ausstattungen in jeweils einer Tabelle gespeichert und die Zuordnung der Ausstattungen zu den Fahrzeugen über eine 1:n-Beziehung mit Mehrfachauswahl realisiert. Dies haben wir in einem ersten Schritt, den wir im Beitrag m:n-Daten wie im mehrwertigen Feld selektieren <\/b>(www.access-im-unternehmen.de\/1424<\/b>) erläutern, in eine echte m:n-Beziehung umgewandelt.<\/p>\n
Die Ausgangssituation sieht also wie in Bild 1 aus. Wir sehen zwei Tabellen namens tblFahrzeuge <\/b>und tblAusstattungen<\/b>. Diese werden über die Tabelle tblFahrzeugeAusstattungen <\/b>über jeweils ein Fremdschlüsselfeld verbunden. <\/p>\n
![\"Ausgangsdatenmodell\"](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_001.png\")
<\/p>\n
Bild 1: Ausgangsdatenmodell<\/span><\/b><\/p>\n Wir haben außerdem einige Beispieldatensätze hinzugefügt. Diese sehen in den Tabellen in der Datenblattansicht wie in Bild 2 aus.<\/p>\n Bild 2: Beispieldaten und Zuordnung über die m:n-Verknüpfungstabelle<\/span><\/b><\/p>\n Der erste Teil der Aufgabe besteht darin, folgende Informationen in das Datenmodell aufzunehmen:<\/p>\n Wenn wir davon ausgehen, dass es nur die beiden Kategorien Serienausstattung oder Sonderausstattungen gibt, könnten wir in einem ersten Schnellschuss zwei Ja\/Nein<\/b>-Felder in der Tabelle tblFahrzeugeAusstattungen <\/b>unterbringen, die beispielsweise die Namen Serienausstattung <\/b>und Sonderausstattung <\/b>tragen.<\/p>\n Aber meistens kommen dem Kunden im Verlauf immer noch weitere Kunden, was sich mit der neuen Funktion noch so alles anstellen lässt – in diesem Fall vielleicht noch eine weitere Kategorie. Außerdem hat die aktuelle Idee einen Haken: Wir können theoretisch festlegen, dass ein Ausstattungsmerkmal gleichzeitig zur Serienausstattung und zur Sonderausstattung gehört, indem wir beide Ja\/Nein<\/b>-Felder anhaken (siehe Bild 3).<\/p>\n Bild 3: Erster Entwurf für die zusätzlichen Informationen<\/span><\/b><\/p>\n Wir müssten schließlich bereits im Formular verhindern, dass beide Felder angekreuzt werden.<\/p>\n Zusammengefasst mit der Idee, dass neben Serienausstattung oder Sonderausstattung noch eine weitere Kategorie hinzukommen könnte, die im Bericht für das Preisschild aufgeführt werden soll, sollten wir diesen ersten Entwurf also verwerfen.<\/p>\n Die nächste Frage ist: Wird ein Ausstattungsmerkmal in mehr als einer Kategorie auf dem Preisschild erscheinen? Das hört sich wenig sinnvoll an. Ausgehend davon, dass eine Ausstattung nun entweder<\/p>\n können wir den folgenden Entwurf ins Auge fassen: Wir erstellen eine neue Tabelle namens tblAusstattungskategorien <\/b>mit den Feldern AusstattungskategorieID <\/b>und Ausstattungskategorie <\/b>und mit Werten wie Serienausstattung <\/b>oder Sonderausstattung<\/b>. Diese sieht in der Entwurfsansicht wie in Bild 4 aus.<\/p>\n Bild 4: Entwurf der Tabelle tblAusstattungskategorien<\/span><\/b><\/p>\n Der m:n-Verknüpfungstabelle tblFahrzeugeAusstattungen <\/b>fügen wir ein neues Feld namens PreisschildAusstattungskategorieID<\/b> hinzu. Warum nennen wir dieses Feld nicht einfach AusstattungskategorieID<\/b>? Weil wir flexibel bleiben wollen und es vorkommen kann, dass der Kunde noch für eine andere Ausgabeart als Preisschilder festlegen möchte, ob die Ausstattung dort ausgeben werden soll und unter welcher Kategorie.<\/p>\n Das Feld legen wir als Nachschlagefeld an, die ihre Werte aus der Tabelle tblAusstattungskategorien <\/b>entnimmt. Warum als Nachschlagefeld? Weil so später, wenn wir das Feld in ein Formular ziehen, direkt ein Kombinationsfeld auf Basis dieses Nachschlagefeldes erstellt wird. <\/p>\n Außerdem fügen wir der Tabelle noch ein Ja\/Nein<\/b>-Feld namens Preisschild <\/b>hinzu. Die Tabelle sieht im Entwurf nun wie in Bild 5 aus.<\/p>\n Bild 5: Entwurf der Tabelle tblFahrzeugeAusstattungen mit den neuen Feldern<\/span><\/b><\/p>\n Wir stellen außerdem noch die Eigenschaft Beschriftung <\/b>der Felder wie folgt ein:<\/p>\n Diese Beschriftungen werden später bei der Übernahme in das Formular übernommen, sodass wir diese dort nicht nochmals anpassen müssen.<\/p>\n Im Datenmodell spiegeln sich die Erweiterungen nun wie in Bild 6 wieder.<\/p>\n Bild 6: Das Datenmodell mit der Tabelle für die Ausstattungskategorien<\/span><\/b><\/p>\n Schließlich wandeln wir das Feld AusstattungID <\/b>noch in ein Nachschlagefeld um. Da wir dafür bereits im oben genannten Beitrag eine Beziehung angelegt haben, fügen wir die Nachschlagefeld-Eigenschaften kurzerhand manuell hinzu.<\/p>\n Dazu aktivieren wir im Tabellenentwurf für das Feld AusstattungID <\/b>in den Eigenschaften die Registerseite Nachschlagen<\/b>.<\/p>\n Hier stellen wir als Erstes den Wert der Eigenschaft Steuerelement anzeigen <\/b>auf Kombinationsfeld <\/b>ein. Dadurch blendet Access einige weitere Eigenschaften ein, die wir wie in Bild 7 anpassen.<\/p>\n Bild 7: Einstellen des Feldes AusstattungID als Nachschlagefeld<\/span><\/b><\/p>\n Wichtig ist hier, dass die nachzuschlagenden Daten aus der Tabelle tblAusstattungen <\/b>nach dem Namen der Ausstattungen sortiert ausgegeben werden.<\/p>\n Wie aber wollen wir die Benutzeroberfläche gestalten? Wenn wir schon eine m:n-Verknüpfungstabelle verwenden, wie sie auch beispielsweise bei Bestellungen, Bestellpositionen und Artikeln verwendet wird, können wir diese dann nicht auch so abbilden? Also so, dass wir in einem Hauptformular das Fahrzeug abbilden und im Unterformular in der Datenblattansicht die zugeordneten Ausstattungen? Mit den weiteren Steuerelementen, mit denen wir angeben, ob die Ausstattung auf dem Preisschild erscheinen soll und ob es sich um eine Serien- oder eine Sonderausstattung handelt?<\/p>\n Das wird auf jeden Fall Bestandteil der Lösung sein, aber nicht allein. Wie beginnen jedoch erst einmal mit diesem Teil.<\/p>\n Wir beginnen mit dem Unterformular namens sfmFahrzeugeAusstattungenPreisschild<\/b>, dem wir die Tabelle tblFahrzeugeAusstattungen <\/b>als Datensatzquelle <\/b>zuweisen. Den Namen sfmFahrzeugeAusstattungen <\/b>verwenden wir nicht, weil dieser in der Beispieldatenbank bereits für ein anderes Objekt vergeben ist.<\/p>\n Wir ziehen die drei Felder AusstattungID<\/b>, PreisschildAusstattungskategorieID<\/b> und AufPreisschild<\/b> in den Formularentwurf und stellen die Eigenschaft Standardansicht <\/b>auf den Wert Datenblatt <\/b>ein (siehe Bild 8). Danach speichern und schließen wir das Formular.<\/p>\n Bild 8: Das Unterformular sfmFahrzeugeAusstattungenPreisschild<\/span><\/b><\/p>\n Das Hauptformular erstellen wir direkt im Anschluss. Es soll den Namen frmFahrzeugeAusstattungenPreisschild <\/b>erhalten und verwendet die Tabelle tblFahrzeuge <\/b>als Datensatzquelle<\/b>. Wir ziehen lediglich die beiden Felder FahrzeugID <\/b>und Fahrzeug <\/b>in den Detailbereich des Formularentwurfs.<\/p>\n Außerdem ziehen wir dort das Formular sfmFahrzeugeAusstattungenPreisschild <\/b>aus dem Navigationsbereich als Unterformular hinein.<\/p>\n Wenn wir das Unterformular-Steuerelement markieren und im Eigenschaftenblatt die Seite Daten <\/b>aktivieren, sollten die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>jeweils den Wert FahrzeugID <\/b>enthalten (siehe Bild 9).<\/p>\n Bild 9: Haupt- und Unterformular in der Entwurfsansicht<\/span><\/b><\/p>\n Wechseln wir nun in die Formularansicht, sind wir eigentlich schon fertig: Das Hauptformular zeigt die Fahrzeuge an und im Unterformular können wir komfortabel die Ausstattungen auswählen. Die übrigen beiden Steuerelemente erlauben es uns, die Kategorie auszuwählen und ob die Ausstattung auf dem Preisschild erscheinen soll (siehe Bild 10).<\/p>\n Bild 10: Das Formular in Aktion<\/span><\/b><\/p>\n Allerdings haben wir ein Problem: Die Liste der Ausstattungsmerkmale enthält mehr als 150 Einträge. Das heißt also, dass das Zusammenstellen eines Fahrzeugs, das durchschnittlich vielleicht 30-50 Ausstattungen enthält, ungefähr so viel Spaß macht wie die Steuererklärung.<\/p>\n Selbst wenn Mitarbeiter die Anfangsbuchstaben aller Ausstattungsmerkmale kennen und diese eingeben, dauert es doch noch eine Weile, bis man alle Daten eingegeben hat.<\/p>\n Also müssen wir hier noch nachlegen, um dem Benutzer ein schnelleres und effizienteres Arbeiten zu ermöglichen. Wir wollen dazu zunächst ein Listenfeld hinzufügen, das alle aktuell nicht ausgewählten Ausstattungsmerkmale anzeigt und mit dem wir per Doppelklick weitere Elemente zur Auswahl hinzufügen können.<\/p>\n Also verschieben wir das Unterformular in der Entwurfsansicht etwas nach rechts und fügen links davon ein Listenfeld namens lstAusstattungen <\/b>hinzu. Dieses soll einfach nur die Ausstattungen in alphabetischer Reihenfolge anzeigen und den Wert des Feldes AusstattungID <\/b>der Tabelle tblAusstattungen <\/b>als unsichtbare erste Spalte liefern.<\/p>\n Die anzuzeigenden Ausstattungen hängen jedoch, da wir nur die noch nicht zugeordneten Ausstattungsmerkmale ausgeben wollen, von den Einträgen der Tabelle tblFahrzeugeAusstattungen <\/b>ab, die mit dem aktuell im Hauptformular angezeigten Fahrzeug verknüpft sind.<\/p>\n Die Datensatzherkunft wollen wir daher per VBA zuweisen. Die dazu verwendete Prozedur heißt AusstattungslisteFuellen<\/b>. Wir rufen diese zu verschiedenen Gelegenheiten auf – zum Beispiel beim Anzeigen eines neuen Datensatzes im Hauptformular oder nach dem Hinzufügen eines der Ausstattungsmerkmale <\/b>zur Tabelle tblFahrzeugeAusstattungen<\/b>.<\/p>\n Da die Abfrage, um die im Listenfeld anzuzeigenden Datensätze zu ermitteln, etwas komplizierter zu formulieren ist, nutzen wir den Abfrageeditor dazu. Wir wollen mit dieser Abfrage alle Datensätze der Tabelle tblAusstattungen <\/b>liefern, die noch nicht mit einem Datensatz der Tabelle tblFahrzeugeAusstattungen <\/b>verknüpft sind.<\/p>\n Dazu benötigen wir erst einmal eine Abfrage, die uns alle Ausstattungen liefert, die mit dem aktuellen Fahrzeug verknüpft sind.<\/p>\n Diese enthält die Tabelle tblAusstattungen <\/b>als Datenquelle. Wir ziehen beide Felder der Tabelle in das Entwurfsraster. Für das Feld AusstattungID <\/b>legen wir ein Kriterium fest, dass alle Datensätze liefert, deren Wert im Feld AusstattungID <\/b>noch nicht über die Tabelle tblFahrzeugeAusstattungen <\/b>mit einem Fahrzeug verknüpft sind. Um welches Fahrzeug es sich handelt, geben wir zunächst über den Parameter [prmFahrzeugID]<\/b> an (siehe Bild 11).<\/p>\n Bild 11: Abfrage zur Ermittlung der noch nicht verwendeten Ausstattungen<\/span><\/b><\/p>\n Wechseln wir in die Datenblattansicht, erscheint eine Inputbox für die Eingabe der FahrzeugID <\/b>des zu untersuchenden Fahrzeugs. Geben wir hier für unsere Beispieldaten den Wert 1 <\/b>ein, was dem Fahrzeug entspricht, dem wir die Ausstattungen mit den Bezeichnungen Ausstattung 1 <\/b>und Ausstattung 2 <\/b>zugeordnet haben, erhalten wir das Abfrageergebnis aus Bild 12.<\/p>\n Bild 12: Die Abfrage qryLstAusstattungen<\/span><\/b><\/p>\n Die Abfrage funktioniert also schon einmal. Nun wollen wir diese in die Funktion AusstattungslisteFuellen <\/b>integrieren. Dazu wechseln wir in die SQL-Ansicht der Abfrage und kopieren den SQL-String in die Zwischenablage (siehe Bild 13).<\/p>\n Bild 13: SQL-Ausdruck der Abfrage<\/span><\/b><\/p>\n Von hier fügen wir die SQL-Anweisung in den VBA-Code der Prozedur AusstattungslisteFuellen <\/b>ein, die wir im Klassenmodul des Formulars frmFahrzeugeAusstattungenPreisschild <\/b>einfügen.<\/p>\n Die SQL-Anweisung erleichtern wir um einige unnötige Elemente wie vorangestellte Tabellennamen und Klammern und erhalten dann eine Prozedur wie die folgende:<\/p>\n Hier ermitteln wir die ID des aktuell im Formular angezeigten Fahrzeugs und fügen diese dann dort in den SQL-Ausdruck ein, wo sich zuvor der Parameter [prmFahrzeugID] <\/b>befunden hat.<\/p>\n Schließlich weist die Prozedur die so zusammengesetzte SQL-Anweisung der Eigenschaft Datensatzherkunft <\/b>des Listenfeldes zu.<\/p>\n Diese Prozedur rufen wir nun beispielsweise in der Ereignisprozedur auf, die durch das Ereignis Form_Current <\/b>ausgelöst wird:<\/p>\n Danach brauchen wir nur noch für das Listenfeld lstAusstattungen <\/b>die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>einzustellen, damit nicht der Inhalt des Feldes AusstattungID<\/b>, sondern der des Feldes Ausstattung <\/b>angezeigt wird.<\/p>\n Damit erhalten wir erst einmal die Ansicht des Formulars aus Bild 14.<\/p>\n Bild 14: Das Listenfeld zeigt die verbleibenden Ausstattungen an.<\/span><\/b><\/p>\n Damit kommen wir zu dem Schritt, der dem Benutzer die Arbeit massiv erleichtern soll: Das Hinzufügen von Ausstattungen aus dem Listenfeld per Doppelklick. Dazu fügen wir dem Listenfeld eine Ereignisprozedur hinzu, die durch das Ereignis Beim Doppelklicken <\/b>ausgelöst wird (siehe Listing 1).<\/p>\n Listing 1: Anpassung der Prozedur für das Vergrößern und Verkleinern<\/span><\/b><\/p>\n Diese Prozedur ermittelt zunächst die Werte für die FahrzeugID <\/b>und die AusstattungID <\/b>für die Kombination aus Fahrzeug und Ausstattung, die zur Tabelle tblFahrzeugeAusstattungen <\/b>hinzugefügt werden soll. Dann stellt sie eine SQL-Abfrage wie die folgende zusammen und arbeitet dabei die FahrzeugID <\/b>und die AusstattungID <\/b>ein:<\/p>\n Danach führt sie diese Abfrage mit der Execute<\/b>-Methode des Database<\/b>-Objekts für die aktuelle Datenbank aus. Anschließend aktualisiert sie das Unterformular, sodass dieses nun die neu hinzugefügte Ausstattung anzeigt. Außerdem ruft es die Prozedur AusstattungslisteFuellen <\/b>auf, damit das Listenfeld mit den neuen Daten aktualisiert wird.<\/p>\n Das Ergebnis eines Doppelklicks auf einen Eintrag im Listenfeld sehen wir in Bild 15. Allerdings wurde noch keine Kategorie <\/b>angelegt und auch das Feld Auf Preisschild <\/b>wurde noch nicht aktualisiert. Hier haben wir nun folgende Möglichkeiten:<\/p>\n Bild 15: Eine frisch hinzugefügte Ausstattung<\/span><\/b><\/p>\n Die erste Variante würde vielleicht bei 50% der hinzugefügten Ausstattungen die richtigen Werte vorgeben.<\/p>\n Bei der zweiten Variante könnte der Benutzer beispielsweise zuerst die Serienausstattungen hinzufügen und dann die Sonderausstattungen. Die Option Auf Preisschild <\/b>könnte man einfach aktiviert lassen und jeweils übernehmen und diese dann bei Bedarf nachträglich für die betroffenen Ausstattungen einstellen.<\/p>\n Wir zeigen, wie das mit der zweiten Variante funktioniert und fügen dem Hauptformular zwei Steuerelemente hinzu:<\/p>\n Diese legen wir wie in Bild 16 an.<\/p>\n Bild 16: Steuerelemente zum Festlegen der Standardwerte<\/span><\/b><\/p>\n Für das Kombinationsfeld cboStandardkategorie <\/b>hinterlegen wir die Tabelle tblAusstattungskategorien <\/b>als Datensatzherkunft<\/b>. Außerdem stellen wir die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf die Werte 2 <\/b>und 0cm <\/b>ein.<\/p>\n Um diese Einstellungen zu speichern, benötigen wir allerdings noch eine Optionentabelle. Diese nennen wir tblOptionen <\/b>und fügen ihr die drei Felder OptionID<\/b>, StandardkategorieID <\/b>und AufPreisschild <\/b>hinzu (siehe Bild 17).<\/p>\n Bild 17: Die Tabelle tblOptionen<\/span><\/b><\/p>\n Für das Feld StandardkategorieID <\/b>legen wir ein Nachschlagefeld an, das die Daten der Tabelle tblAusstattungskategorien <\/b>enthält. AufPreisschild <\/b>ist ein einfaches Ja\/Nein<\/b>-Feld.<\/p>\n Wir können die Steuerelemente cboStandardkategorie <\/b>und chkAufPreisschild <\/b>in diesem Formular leider nicht an die Felder dieser Tabelle binden, da das Formular bereits an die Tabelle tblFormulare <\/b>gebunden ist.<\/p>\n Daher haben wir nun verschiedene Möglichkeiten:<\/p>\n Da wir die Steuerelemente nun bereits angelegt haben, wählen wir Option Nummer 2.<\/p>\n Daher fügen wir Code zum Formularmodul hinzu, der beim Laden des Formulars ausgeführt wird und die Daten für diese Optionen in die Steuerelemente schreibt. Beim Ändern der Option wird diese in die Tabelle zurückgeschrieben.<\/p>\n Wir starten mit der Prozedur, die beim Auswählen eines Eintrags im Kombinationsfeld cboStandardkategorie <\/b>ausgelöst wird. Diese finden wir in Listing 2. Die Prozedur führt eine UPDATE<\/b>-Abfrage aus, die das Feld StandardkategorieID <\/b>in der Tabelle tblOptionen <\/b>auf den aktuellen Wert des Steuerelements cboStandardkategorie <\/b>einstellt.<\/p>\n Listing 2: Aktualisieren des Standards für die Ausstattungskategorie<\/span><\/b><\/p>\n Danach prüft die Prozedur, wie viele Datensätze von dieser Änderungsabfrage betroffen waren. Wenn nicht kein Datensatz betroffen ist, hat die Prozedur ihre Aufgabe bereits erledigt.<\/p>\n Sollte jedoch kein Datensatz von der Änderung betroffen sein, ist vermutlich noch kein Datensatz in der Tabelle tblOptionen <\/b>enthalten und die folgende INSERT INTO<\/b>-Anweisung fügt einen neuen Datensatz hinzu, wobei das Feld StandardkategorieID <\/b>automatisch auf den aktuellen Wert des Kombinationsfeldes eingestellt wird.<\/p>\n Die Prozedur, die durch das Ändern des Wertes im Kontrollkästchen chkAufPreisschild <\/b>ausgelöst wird, funktioniert auf die gleiche Weise (siehe Listing 3). Auch sie versucht zunächst, einen vorhandenen Datensatz zu bearbeiten. Ist das nicht erfolgreich, wird auch hier ein neuer Datensatz angelegt, der direkt mit dem Wert des Kontrollkästchens im Feld AufPreisschild <\/b>ausgestattet wird.<\/p>\n Listing 3: Aktualisieren des Standards für die Ausgabe auf dem Preisschild<\/span><\/b><\/p>\n Wenn wir auf diese Weise eine Standardkategorie ausgewählt haben und festgelegt haben, dass die neu hinzugefügten Ausstattungen standardmäßig auf dem Preisschild landen sollen, sieht die Tabelle wie in Bild 18 aus.<\/p>\n Bild 18: Die Tabelle tblOptionen mit frisch geänderten Werten<\/span><\/b><\/p>\n Damit kommen wir zum Anzeigen dieser Werte, wenn der Benutzer das Formular neu öffnet.<\/p>\n Dazu fügen wir eine Ereignisprozedur für das Ereignis Beim Laden <\/b>hinzu.<\/p>\n Diese füllen wir mit den Anweisungen aus Listing 4. Wir stellen sowohl das Kombinationsfeld cboStandardkategorie <\/b>als auch das Kontrollkästchen chkAufPreisschild <\/b>mit dem Werten aus der Tabelle tblOptionen<\/b>, die wir mit entsprechenden DLookup<\/b>-Funktionen auslesen.<\/p>\n Listing 4: Einlesen der Optionen in die Steuerelemente des Formulars<\/span><\/b><\/p>\n Damit diese Einstellungen sich beim Hinzufügen von Ausstattungen zu einem Fahrzeug bemerkbar machen, passen wir die Prozedur lstAusstattungen_DblClick <\/b>noch ein wenig an. Genauer gesagt fügen wir nur zwei Felder zu der INSERT INTO<\/b>-Anweisung hinzu, welche die Werte der beiden neuen Kontrollkästchen direkt in die neuen Zuweisungen von Ausstattungen zum Fahrzeug schreiben (siehe Listing 5).<\/p>\n Listing 5: Anpassungen der Prozedur zum Hinzufügen von Ausstattungen<\/span><\/b><\/p>\n Probieren wir dies nun aus, nachdem wir die Standardwerte festgelegt haben, erscheinen nun auch die gewünschten Eigenschaften im Unterformular sfmFahrzeugeAusstattungenPreisschild<\/b> (siehe Bild 19).<\/p>\n Bild 19: Die Ausstattungen werden nun mit den Standardwerten angelegt.<\/span><\/b><\/p>\n Wir können wir die Einstellungen nachträglich ändern. Außerdem können wir auch manuell Einträge zu den Ausstattungen hinzufügen, indem wir einen Wert in der Spalte Ausstattung <\/b>auswählen.<\/p>\n Allerdings können wir auf diese Weise aktuell auch noch eine Ausstattung ein zweites Mal zu einem Fahrzeug hinzufügen.<\/p>\n Das wollen wir noch ändern. Dazu stellen wir für die beiden Felder FahrzeugID <\/b>und AusstattungID <\/b>in der Tabelle tblFahrzeugeAusstattungen <\/b>einen eindeutigen, zusammengesetzten Primärschlüssel ein (siehe Bild 20).<\/p>\n Bild 20: Hinzufügen eines eindeutigen Indexes für die Felder FahrzeugID und AusstattungID<\/span><\/b><\/p>\n Diesen legen wir über den Dialog Indizes: tblFahrzeugeAusstattungen <\/b>fest, den wir mit einem Rechtsklick auf die Titelleiste der Tabelle und anschließender Auswahl des Eintrags Indizes <\/b>erhalten.<\/p>\n Hier geben wir den Namen UniqueKey <\/b>ein und wählen rechts daneben und in der Zeile darunter die Felder FahrzeugID <\/b>und AusstattungID <\/b>aus. Außerdem legen wir für den Index die Eigenschaft Eindeutig <\/b>auf Ja <\/b>fest.<\/p>\n Wenn wir nun beispielsweise nochmals die Ausstattung namens Ausstattung 4 <\/b>zu einem Fahrzeug hinzufügen, erhalten wir eine Meldung wie die aus Bild 21.<\/p>\n Bild 21: Fehler, der beim Hinzufügen einer bereits vorhandenen Ausstattung ausgelöst wird.<\/span><\/b><\/p>\n Damit diese für den Benutzer normalerweise recht unverständliche Meldung nicht erscheint, ersetzen wir diese durch eine eigene Meldung. Dazu fügen wir der Ereigniseigenschaft Bei Fehler <\/b>des Unterformulars die Ereignisprozedur aus Listing 6 hinzu. Diese erhält mit dem Parameter DataErr <\/b>die Fehlernummer.<\/p>\n Listing 6: Fehlerbehandlung für Formularfehler<\/span><\/b><\/p>\n Lautet dieser auf 3022<\/b>, haben wir es mit dem Fehler zu tun, den wir zuvor angezeigt bekommen haben. In diesem Fall geben wir mit einer MsgBox<\/b>-Funktion unsere eigene, verständlichere Fehlermeldung aus. Danach stellen wir Response auf acDataErrContinue <\/b>ein, damit die eigentliche Fehlermeldung unterbunden wird.<\/p>\n Diese erscheint schließlich wie in Bild 22.<\/p>\n Bild 22: Neue, benutzerdefinierte Fehlermeldung beim Auftreten eines Fehlers<\/span><\/b><\/p>\n Damit haben wir nun zwar eine komfortable Möglichkeit zum Hinzufügen von Ausstattungen zu einem Fahrzeug geschaffen. Was aber, wenn wir eine Ausstattung versehentlich zu einem Fahrzeug hinzufügt haben? Dann können wir diese natürlich auf herkömmlichem Wege wieder löschen. Dazu klicken wir den Datensatzmarkierer und betätigen die Löschen<\/b>-Schaltfläche.<\/p>\n Das funktioniert grundsätzlich, jedoch wird das entfernte Ausstattungsmerkmal nicht direkt wieder im Listenfeld angezeigt.<\/p>\n Wir müssen also dafür sorgen, dass das Listenfeld im Hauptformular aktualisiert wird, wenn der Benutzer einen Datensatz im Unterformular löscht.<\/p>\n Es wäre praktisch, wenn wir dazu die Prozedur AusstattungslisteFuellen<\/b> des Hauptformulars vom Unterformular aus aufrufen könnten. Dazu müssen wir diese öffentlich machen, was wir durch Ändern des Schlüsselworts Private <\/b>in Public <\/b>erreichen:<\/p>\n Dann fügen wir im Unterformular für das Ereignis Beim Löschen <\/b>die folgende Ereignisprozedur hinzu:<\/p>\n Das funktioniert allerdings nicht wie gewünscht. Die Ereignisprozedur wird zwar, wie wir durch Setzen eines Haltepunktes ermittelt haben, beim Löschen eines Datensatzes im Unterformular ausgelöst. Wenn wir diesen Schritt für Schritt durchlaufen, landen wir auch in der Prozedur AusstattungslisteFuellen<\/b>. Allerdings erhalten wir dort am Ende der Prozedur manchmal den Fehler aus Bild 23.<\/p>\n Bild 23: Fehler beim Versuch, beim Löschen direkt das Listenfeld zu aktualisieren<\/span><\/b><\/p>\n Wir haben dann als Erstes probiert, die Funktionalität vom Unterformular in das Hauptformular zu ziehen. Dies ist ohnehin eine praktische Vorgehensweise, bei der man alle Funktionen aus einem Klassenmodul heraus steuert. Dazu haben wir die folgenden Schritte durchgeführt.<\/p>\n Als Erstes haben wir im Klassenmodul des Hauptformulars eine Objektvariable angelegt, mit der wir das Unterformular referenzieren können. Dabei verwenden wir das Schlüsselwort WithEvents<\/b>, damit wir auch die Ereignisse dieses Objekts im aktuellen Klassenmodul implementieren können:<\/p>\n Dann haben wir im Ereignis Form_Load <\/b>des Hauptformulars zwei Zeilen hinzugefügt, von denen die erste der Variablen sfm <\/b>einen Verweis auf das Unterformular zuweist und die zweite die Eigenschaft OnDelete <\/b>des Unterformulars auf den Wert [Event Procudure] <\/b>einstellt.:<\/p>\n Dies ist gleichbedeutend damit, im Eigenschaftenblatt des Unterformulars für die Eigenschaft Beim Löschen <\/b>den Wert [Ereignisprozedur] <\/b>einzutragen. Nun müssen wir noch das Ereignis implementieren. Dazu wählen wir im linken Kombinationsfeld des Codefensters des Klassenmoduls des Hauptformulars den Eintrag sfm <\/b>aus. Im rechten Kombinationsfeld selektieren wir den Eintrag Delete<\/b>. In die so erzeugte Ereignisprozedur sfm_Delete <\/b>tragen wir nun die Zeile ein, mit der wir die Prozedur AusstattungslisteFuellen <\/b>aufrufen:<\/p>\n Nach dem erneuten Anzeigen des Formulars in der Formularansicht erhalten wir allerdings immer noch die Fehlermeldung von oben. <\/p>\n Die nächste Idee in solchen Fällen ist immer, dass es sich um ein Timing-Problem handeln könnte. Die Fehlermeldung besagte, dass die Operation in Transaktionen nicht unterstützt wird. Gegebenenfalls müssen wir also nur eine Zehntelsekunde warten. Dazu führen wir zwei Schritte aus. Der erste ist, dass wir in der Ereignisprozedur, die beim Löschen eines Eintrags im Unterformular ausgelöst wird, den Aufruf von AusstattungslisteFuellen <\/b>entfernen und stattdessen einen Timer starten. Das erledigen wir durch Einstellen der Eigenschaft TimerInterval <\/b>auf einen Wert wie 100 <\/b>(Millisekunden):<\/p>\n![\"Beispieldaten](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_002.png\")
<\/p>\nAnpassung des Datenmodells<\/h2>\n
\n
![\"Erster](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_003.png\")
<\/p>\n\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_004.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_006.png\")
<\/p>\n\n
![\"Das](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_005.png\")
<\/p>\nAusstattungen auswählbar machen<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_007.png\")
<\/p>\nIdeen für die Benutzeroberfläche<\/h2>\n
Fahrzeuge und Ausstattungen in Haupt- und Unterformular<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_008.png\")
<\/p>\n![\"Haupt-](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_009.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_010.png\")
<\/p>\nProblem: Menge der Ausstattungsmerkmale<\/h2>\n
Einfachere Auswahl per Listenfeld<\/h2>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_011.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_012.png\")
<\/p>\n![\"SQL-Ausdruck](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_013.png\")
<\/p>\nPrivate Sub <\/span>AusstattungslisteFuellen()\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngFahrzeugID As Long<\/span>\r\n lngFahrzeugID = Me!FahrzeugID\r\n strSQL = \"SELECT AusstattungID, Ausstattung \" _\r\n & \"FROM tblAusstattungen \" _\r\n & \"WHERE AusstattungID \" _\r\n & \"Not<\/span> In (\" _\r\n & \" SELECT AusstattungID \" _\r\n & \" FROM tblFahrzeugeAusstattungen \" _\r\n & \" WHERE FahrzeugID = \" & lngFahrzeugID _\r\n & \");\"\r\n Me!lstAusstattungen.RowSource = strSQL\r\nEnd Sub<\/span> <\/pre>\nPrivate Sub <\/span>Form_Current()\r\n Call<\/span> AusstattungslisteFuellen\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_014.png\")
<\/p>\nAusstattung per Doppelklick hinzufügen<\/h2>\n
Private Sub <\/span>lstAusstattungen_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngFahrzeugID As Long<\/span>\r\n Dim <\/span>lngAusstattungID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngFahrzeugID = Me!FahrzeugID\r\n lngAusstattungID = Me!lstAusstattungen\r\n strSQL = \"INSERT INTO tblFahrzeugeAusstattungen(FahrzeugID, AusstattungID) VALUES(\" & lngFahrzeugID & \", \" _\r\n & lngAusstattungID & \")\"\r\n db.Execute strSQL, dbFailOnError\r\n Me!sfmFahrzeugeAusstattungenPreisschild.Form.Requery\r\n Call<\/span> AusstattungslisteFuellen\r\nEnd Sub<\/span><\/pre>\nINSERT INTO tblFahrzeugeAusstattungen(FahrzeugID, AusstattungID) VALUES(1, 3)<\/pre>\n
![\"Eine](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_015.png\")
<\/p>\n\n
\n
![\"Steuerelemente](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_016.png\")
<\/p>\nTabelle zum Speichern von Optionen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_017.png\")
<\/p>\nSteuerelemente mit Optionen füllen und synchronisieren<\/h2>\n
\n
Private Sub <\/span>cboStandardkategorie_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"UPDATE tblOptionen SET StandardkategorieID = \" & Me!cboStandardkategorie, dbFailOnError\r\n If <\/span>db.RecordsAffected = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblOptionen(StandardkategorieID) VALUES(\" & Me!cboStandardkategorie _\r\n & \")\", dbFailOnError\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>chkAufPreisschild_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"UPDATE tblOptionen SET AufPreisschild = \" & Me!chkAufPreisschild, dbFailOnError\r\n If <\/span>db.RecordsAffected = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblOptionen(AufPreisschild) VALUES(\" & Me!chkAufPreisschild & \")\", dbFailOnError\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_018.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Me!cboStandardkategorie = Nz(DLookup(\"StandardkategorieID\", \"tblOptionen\"), 0)\r\n Me!chkAufPreisschild = Nz(DLookup(\"AufPreisschild\", \"tblOptionen\"), 0)\r\nEnd Sub<\/span><\/pre>\nStandardwerte beim Hinzufügen von Ausstattungsmerkmalen berücksichtigen<\/h2>\n
Private Sub <\/span>lstAusstattungen_DblClick(Cancel As Integer<\/span>)\r\n ...\r\n strSQL = \"INSERT INTO tblFahrzeugeAusstattungen(FahrzeugID, AusstattungID, PreisschildAusstattungskategorieID, \" _\r\n & \"AufPreisschild) VALUES(\" & lngFahrzeugID & \", \" & lngAusstattungID & \", \" & Me!cboStandardkategorie _\r\n & \", \" & Me!chkAufPreisschild & \")\"\r\n db.Execute strSQL, dbFailOnError\r\n ...\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_019.png\")
<\/p>\nJede Ausstattung nur einmal pro Fahrzeug<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_020.png\")
<\/p>\n![\"Fehler,](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_021.png\")
<\/p>\nPrivate Sub <\/span>Form_Error(DataErr As Integer<\/span>, Response As Integer<\/span>)\r\n Select Case DataErr\r\n Case <\/span>3022\r\n MsgBox<\/span> \"Sie dürfen jede Ausstattung nur einmal zu einem Fahrzeug hinzufügen.\", vbOKOnly + _\r\n vbExclamation, \"Doppelte Zuweisung\"\r\n Response = acDataErrContinue\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Neue,](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_022.png\")
<\/p>\nEntfernen von Ausstattungen aus dem Datenblatt<\/h2>\n
Public Sub <\/span>AusstattungslisteFuellen()\r\n ...\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Delete(Cancel As Integer<\/span>)\r\n Call<\/span> Me.Parent.AusstattungslisteFuellen\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2024_04\/pic_1510_023.png\")
<\/p>\nAlternative: Unterformularereignisse vom Hauptformular aus implementieren<\/h2>\n
Private <\/span>WithEvents sfm As <\/span>Form<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> sfm = Me.sfmFahrzeugeAusstattungenPreisschild.Form\r\n sfm.OnDelete = \"[Event Procedure]\"\r\n ...\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>sfm_Delete(Cancel As Integer<\/span>)\r\n Call<\/span> AusstattungslisteFuellen\r\nEnd Sub<\/span><\/pre>\nPer Timer auf Löschen reagieren<\/h2>\n
Private Sub <\/span>sfm_Delete(Cancel