<\/p>\n
Im Laufe der Zeit können sich einen Menge Daten ansammeln, die Sie in Zusammenhang mit Kunden, Produkten oder ähnlichen Entitäten speichern wollen. Dabei möchten Sie vielleicht nicht für jede neue Eigenschaft ein neues Feld anlegen und damit den Tabellenentwurf ändern. Das gilt umso mehr, wenn eine Anwendung bereits von vielen Kunden genutzt wird. Es gibt jedoch eine Alternative: Sie können eine zusätzliche Tabelle hinzufügen, die in jedem Datensatz eine Eigenschaft mit dem jeweiligen Wert für die Entität speichert. Die Frage ist nur: Wie können wir diese Daten genauso nutzen, als wenn diese wie üblich in der gleichen Tabelle wie der Kunde oder das Produkt gespeichert werden<\/b><\/p>\n
Nehmen wir an, Sie möchten einer Kundentabelle zwei neue Felder hinzufügen, mit denen Sie festlegen, wann der Kunde sich für den Newsletter angemeldet hat und wann er sich wieder abgemeldet hat. Sie wollen aber nicht die Kundentabelle anpassen, weil Sie das in der Vergangenheit schon öfter gemacht haben und dies immer mit viel Aufwand verbunden ist.<\/p>\n
Stattdessen wollen Sie eine Lösung schaffen, mit der Sie langfristig zwar nach Bedarf neue Felder hinzufügen können, aber nicht jedesmal den Entwurf der Kundentabelle ändern müssen.<\/p>\n
Die Lösung ist eine zusätzliche Tabelle, welche ausschließlich Metadaten zu den Elementen der Haupttabelle speichert. Wie muss eine solche Tabelle aussehen, wenn wir dort nach Wunsch verschiedene Attribute mit ihren Werten hinzufügen wollen <\/p>\n
Die erste Anforderung ist, dass die Daten der Metadaten-Tabelle den Einträgen der Haupttabelle zugeordnet werden können müssen. Die Metadaten-Tabelle, nennen wir Sie hier tblKundenMeta<\/b>, erhält also neben dem Primärschlüsselfeld KundeMetaID <\/b>ein Fremdschlüsselfeld namens KundeID<\/b>. Außerdem wollen wir den Namen des Attributs und den Wert des Attributs in der Tabelle speichern. Dazu legen wir zwei weitere Felder namens Attributname <\/b>und Attributwert <\/b>an. Dem Feld Attributname <\/b>weisen wir logischerweise den Felddatentyp Kurzer Text <\/b>zu.<\/p>\n
Aber welchen Datentyp soll das Feld Attributwert<\/b> erhalten – immerhin sollen dort gegebenenfalls Daten mit verschiedenen Datentypen gespeichert werden In diesem Fall können wir nur den Datentyp Kurzer Text <\/b>wählen, da alle anderen Datentypen Einschränkungen haben – zum Beispiel können Sie Zahlenfelder nicht mit Texten füllen, aber umgekehrt schon.<\/p>\nJedes Attribut nur einmal pro Datensatz<\/h2>\n
Grundsätzlich sollten wir für die Kombination des Fremdschlüsselfeldes (hier KundeID<\/b>) und Attributname <\/b>einen eindeutigen Index festlegen, damit jedes Attribut für jeden Kunden nur einmal angelegt werden kann – so, wie es auch in einem einfachen Feld direkt in der Kundentabelle der Fall ist.<\/p>\n
Andererseits stellt sich die Frage, ob es nicht auch Anwendungsfälle gibt, in denen mehrere Werte für ein Attribut benötigt werden, die unter dem gleichen Attributnamen abrufbar sein sollen. Dann wäre ein zusammengesetzter, eindeutiger Index nicht sinnvoll. Und was, wenn es zwar Felder gibt, die nur einmal vorkommen dürfen, andere aber mehrmals Dies müssten wir in der Prozedur prüfen und behandeln, mit der wir Daten zu der Meta-Tabelle hinzufügen.<\/p>\n
Für unser Beispiel sieht das Datenmodell wie in Bild 1 aus. Die Beziehung zwischen den Tabellen wird über das Fremdschlüsselfeld KundeID <\/b>der Tabelle tblKundenMeta <\/b>hergestellt. Für diese Beziehung legen wir referentielle Integrität mit Löschweitergabe fest.<\/p>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_001.png\")
<\/p>\n
Bild 1: Datenmodell mit Metatabelle<\/span><\/b><\/p>\n Wenn der Benutzer dann einen Datensatz der Tabelle tblKunden <\/b>löscht, werden die damit verknüpften Datensätze der Tabelle tblKundenMeta <\/b>automatisch mitgelöscht.<\/p>\n Die flexibelste Art, die Metadaten in einem Formular anzuzeigen, ist ein Unterformular, dass alle Datensätze der Tabelle tblKundenMeta <\/b>anzeigt, die zu dem im Hauptformular gehörenden Datensatz der Tabelle tblKunden <\/b>gehören. Zum Erstellen des Unterformulars gehen Sie wie folgt vor:<\/p>\n Den Entwurf des Unterformulars mit den Eigenschaften finden Sie in Bild 2.<\/p>\n Bild 2: Entwurf des Unterformulars sfmKundenMitMetadaten<\/span><\/b><\/p>\n Das Hauptformular legen Sie wie folgt an:<\/p>\n Wenn die Tabellen korrekt verknüpft sind und Sie nun das Unterformular-Steuerelement markieren, zeigen die Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>beide den Wert KundeID <\/b>an (siehe Bild 3).<\/p>\n Bild 3: Entwurf des Hauptformulars frmKundenMitMetadaten<\/span><\/b><\/p>\n Wechseln Sie in die Formularansicht des Hauptformulars, können Sie erste Daten eintragen. Beginnen Sie mit denen auf der linken Seite. Danach fügen wir rechts zuerst einen Attributnamen und dann den Wert ein. Auf diese Weise legen wir die Eigenschaften E-Mail <\/b>und Newsletteranmeldung <\/b>mit den gewünschten Weren (siehe Bild 4).<\/p>\n Bild 4: Eingabe von Attributen und Attributwerten<\/span><\/b><\/p>\n Wenn Sie nun entscheiden, dass Sie für neue Metadaten zwar keine Änderungen am Datenmodell vornehmen möchten, aber sehr wohl an der Benutzeroberfläche, wird es viel aufwendiger.<\/p>\n Aber warum sollte man Änderungen an der Benutzeroberfläche tolerieren, wenn man das Datenmodell nicht antasten möchte Es kann beispielsweise sein, dass das Backend nicht so einfach angepasst werden kann, weil es beispielsweise ein SQL Server-Backend ist. Beim Frontend hingegen ist das kein Problem – wenn es vernünftig programmiert ist, können Sie dieses einfach ersetzen, ohne dass der Betrieb eingeschränkt wird.<\/p>\n Daher wollen wir nun die beiden neuen Attribute E-Mail und Newsletteranmeldung wie die Felder der Tabelle tblKunden <\/b>im Formular anzeigen. Dazu legen wir ein neues Formular namens tblKundenMitMetafeldern <\/b>an.<\/p>\n Wenn wir eine Datensatzquelle für alle Felder erhalten wollen, benötigen wir eine entsprechend formulierte Abfrage. Diese sollte also nicht nur die Felder der Tabelle tblKunden <\/b>enthalten, sondern auch noch zwei Felder namens EMail <\/b>und Newsletteranmeldung<\/b>.<\/p>\n Um es kurz zu machen: Eine solche Abfrage, die gleichzeitig auch noch aktualisierbar ist, lässt sich nicht erstellen. Aktualisierbar muss diese aber sein, weil wir auch Daten in das Formular eingeben wollen.<\/p>\n Also legen wir für die beiden Attribute E-Mail <\/b>und Newsletteranmeldung <\/b>ungebundene Textfelder an, die wir beim Anzeigen des Datensatzes mit den Werten der Tabelle tblKundenMitMetadaten <\/b>füllen.<\/p>\n Wenn der Benutzer die Inhalte ändert, tragen wir die Änderungen per Code in diese Tabelle ein.<\/p>\n Die beiden Textfelder nennen wir txtEMail<\/b> und txtNewsletteranmeldung<\/b>. Wir fügen diese wie in Bild 5 in das Formular ein.<\/p>\n Bild 5: Ungebundene Felder für die Metadaten<\/span><\/b><\/p>\n Für später tragen wir für die beiden Textfelder txtEMail <\/b>und txtNewsletteranmeldung <\/b>die jeweiligen Attributnamen in die Eigenschaft Marke <\/b>ein, die Sie auf der Registerseite Andere <\/b>des Eigenschaftenblatts finden.<\/p>\n Diese benötigen wir später für die VBA-Programmierung.<\/p>\n Damit die Felder beim Anzeigen eines neuen Datensatzes gefüllt werden, hinterlegen wir eine Ereignisprozedur für das Ereignis Beim Anzeigen<\/b>. Diese enthält zwei Anweisungen. Die erste verwendet die DLookup<\/b>-Funktion, um den Wert des Feldes Attributwert <\/b>des Datensatzes der Tabelle tblKundenMeta <\/b>zu ermitteln, für den das Feld KundeID <\/b>dem aktuellen Kunden und das Feld Attributname <\/b>dem gesuchten Attribut entspricht (siehe Listing 1).<\/p>\n Listing 1: Einlesen der Metadaten und Schreiben in die Textfelder<\/span><\/b><\/p>\n Es kann vorkommen, dass gar nicht alle gesuchten Attribute in der Tabelle tblKundenMeta <\/b>vorhanden sind. Daher fassen wir das Ergebnis der DLookup<\/b>-Funktion noch in die Nz<\/b>-Funktion ein, die eine leere Zeichenkette zurückliefert, wenn kein passender Datensatz gefunden werden konnte.<\/p>\n Schließlich wird dieser Prozedur auch aufgerufen, wenn das Formular einen neuen, leeren Datensatz anzeigt. In diesem Fall ist das Feld KundeID <\/b>noch leer. Also fassen wir auch dieses mit der Nz<\/b>-Funktion ein und liefern den Wert 0 <\/b>zurück, wenn KundeID <\/b>den Wert Null <\/b>hat. Die zurückgelieferten Zeichenketten landen in jedem Fall in den beiden Feldern txtEMail <\/b>und txtNewsletterAngemeldet<\/b> (siehe Bild 6).<\/p>\n Bild 6: Die unteren beiden Textfelder enthalten Metadaten aus der verknüpften Tabelle tblKundenMeta.<\/span><\/b><\/p>\n Nun wollen wir sicherstellen, dass Änderungen an den Daten der beiden Textfelder txtEMail <\/b>und txtNewsletteranmeldung <\/b>auch in der Tabelle tblKundenMeta <\/b>landen.<\/p>\n Das soll erst dann geschehen, wenn auch die Daten aus den übrigen Textfeldern gespeichert werden, also beim Speichern des Datensatzes. Dazu eignen sich die beiden Ereignisse Vor Aktualisierung <\/b>und Nach Aktualisierung <\/b>des Formulars.<\/p>\n Wir verwenden Nach Aktualisierung<\/b>, weil der Datensatz der Tabelle tblKunden <\/b>zum Zeitpunkt des Auslösens des Ereignisses Vor Aktualisierung <\/b>noch nicht gespeichert ist (siehe Listing 2). Dann haben wir auch noch keinen Primärschlüsselwert eines neuen Datensatzes der Tabelle tblKunden <\/b>und können folglich auch keine damit verknüpften Datensätze in der Tabelle tblKundenMeta <\/b>anlegen.<\/p>\n Listing 2: Schreiben der Metadaten<\/span><\/b><\/p>\n In der Prozedur prüfen wir zunächst, ob es bereits einen Datensatz in der Tabelle tblKundenMeta <\/b>gibt, der zum aktuellen Kunden gehört und das betroffene Attribut enthält.<\/p>\n Falls ja, landet der Primärschlüsselwert dieses Datensatzes der Tabelle tblKundenMeta <\/b>in der Variablen lngKundeMetaID<\/b>, anderenfalls der Wert 0<\/b>.<\/p>\n Hat lngKundeMetaID <\/b>danach den Wert 0<\/b>, legen wir mit einer INSERT INTO<\/b>-Abfrage einen neuen Datensatz in der Tabelle tblKundenMeta <\/b>an, der das Attribut mit dem Wert aus dem Textfeld enthält. Falls nicht, aktualisieren wir den vorhandenen Datensatz für den Kunden und das Attribut mit einer UPDATE<\/b>-Abfrage.<\/p>\n Das erledigen wir zuerst für das Feld txtEMail <\/b>und dann für das Feld Newsletteranmeldung<\/b>. Der Code ist recht redundant und kann ausgelagert und parametrisiert werden – dazu später mehr.<\/p>\n <\/p>\n Zunächst prüfen wir, ob die Prozedur wie gewünscht funktioniert. Dazu legen wir einen neuen Datensatz an und speichern diesen dann beispielsweise durch den Wechseln zum nächsten neuen Datensatz, zum vorherigen Datensatz oder einfach durch Betätigen der Tastenkombination Strg + S<\/b>.<\/p>\n Das funktioniert wie gewünscht – die Daten aus den beiden Textfeldern txtEMail <\/b>und txtNewsletteranmeldung <\/b>landen in zwei neuen Datensätzen der Tabelle tblKundenMeta<\/b>.<\/p>\n Nun probierern wir uns an einem vorhandenen Datensatz und ändern ein oder mehrere der gebundenen Felder sowie die beiden Textfelder txtEMail <\/b>und txtNewsletteranmeldung<\/b>. Auch das gelingt: Die geänderten Daten der beiden ungebundenen Textfelder landen in den entsprechenden Datensätzen der Tabelle tblKundenMeta<\/b>.<\/p>\n Wenn wir allerdings nur die Daten von txtEMail <\/b>und\/oder txtNewsletteranmeldung <\/b>ändern, werden die Änderungen nicht übernommen. Der Grund ist, dass wir den Datensatz nur durch das Ändern der ungebundenen Textfelder nicht in den bearbeiteten Zustand versetzen und somit auch das Ereignis Nach Aktualisierung <\/b>beim Verlassen des Datensatzes nicht ausgelöst wird.<\/p>\n Wir müssen also irgendwie dafür sorgen, dass die Eigenschaft Dirty <\/b>des Formulars den Wert True <\/b>erhält, dass der Datensatz also als „dreckig“ markiert wird. Das wollen wir erledigen, sobald der Benutzer eine Änderung in einem der beiden Textfelder txtEMail <\/b>oder txtNewsletteranmeldung <\/b>vorgenommen hat. Wir dachten, das wäre mit den folgenden beiden Prozedur schnell erledigt:<\/p>\n Allerdings lösen wir damit nur den Fehler aus Bild 7 aus. Wir müssen also den Fokus auf eines der gebundenen Steuerelemente setzen, um den Datensatz als bearbeitet zu markieren. Wie erledigen wir das, ohne das der Benutzer es mitbekommt<\/p>\n Bild 7: Die Dirty-Eigenschaft lässt sich nur setzen, wenn ein gebundenes Feld den Fokus hat.<\/span><\/b><\/p>\n Dazu erweitern wir die durch das Ereignis Bei Änderung <\/b>ausgelösten Ereignisprozeduren wie folgt:<\/p>\n Wir speichern also die aktuelle Position der Einfügemarke und die Größe der Markierung in den beiden Variablen intSelStart <\/b>und intSelLength<\/b>. Dann verschieben wir den Fokus auf das gebundene Feld Firma<\/b>, markieren den Datensatz mit Me.Dirty = True <\/b>als bearbeitet und verschieben den Fokus wieder zurück auf das ungebundene Textfeld txtEMail<\/b>.<\/p>\n Außerdem stellen wir die Markierung wieder her, indem wir die Eigenschaften SelStart <\/b>und SelLength <\/b>auf die in den Variablen intSelStart <\/b>und intSelLength <\/b>gespeicherten Werte zurücksetzen.<\/p>\n Damit gelingt nun auch das Speichern der neuen Werte in den beiden Textfeldern txtEMail <\/b>und txtNewsletteranmeldung<\/b>, ohne dass wir gebundene Felder des Datensatzes bearbeiten müssen – vorausgesetzt, Sie haben auch für das Ereignis Bei Änderung <\/b>des Textfeldes txtNewsletteranmeldung <\/b>eine entsprechende Prozedur hinterlegt (siehe Listing 3).<\/p>\n Listing 3: Rückgängigmachen von Änderungen<\/span><\/b><\/p>\n Um das Verhalten gebundener Textfelder noch genauer abzubilden, fehlt noch die Möglichkeit, die noch nicht gespeicherten Änderungen in den Textfeldern durch Betätigen der Esc<\/b>-Taste rückgängig zu machen.<\/p>\n Dazu fangen wir das Betätigen der Esc<\/b>-Taste ab, wenn eines der ungebundenen Textfelder den Fokus hat. Das erledigen wir mit einer Prozedur, die durch das Ereignis Bei Taste ab <\/b>ausgelöst wird.<\/p>\n Den Parameter KeyCode<\/b>, der einen Zahlenwert für die gedrückte Taste liefert, prüfen wir dabei in einer Select Case<\/b>-Bedingung. Hat KeyCode <\/b>den Wert vbKeyEscape<\/b>, lesen wir den zuletzt gespeicherten Wert für dieses Attribut in die Variable strAlt <\/b>ein. Dann vergleichen wir diesen mit dem aktuellen Wert des jeweiligen Textfeldes. Sind die Werte nicht gleich, fügen wir den alten Wert wieder in das Textfeld ein.<\/p>\n Nun müssen wir noch entscheiden, ob wir die ursprünglich gedrückte Taste, nämlich die Esc<\/b>-Taste, an das System weiterleiten, damit seine eigentliche Funktion ausgeführt werden kann. Dieses lautet eben, Änderungen noch nicht gespeicherter Felder oder Datensätze zu verwerfen, und zwar in zwei Stufen – zunächst für das aktuelle Feld und dann, falls noch nicht gespeicherte Änderungen in anderen gebundenen Feldern vorliegen, auch für den kompletten Datensatz. Bei uns gibt es nun zwei Fälle:<\/p>\n Also fügen wir noch eine Bedingung hinzu, die prüft, ob gebundene Felder bearbeitet wurden. Die Prüfung erledigen wir mit zwei Funktion namens GebundeneFelderBearbeitet<\/b> und MetaFelderBearbeitet<\/b>.<\/p>\n Die erste namens GebundeneFelderBearbeitet <\/b>prüft, ob eines der gebundenen Felder nicht den Wert enthält, den es beim Öffnen des Datensatzes hatte:<\/p>\n Die Prozedur durchläuft alle Steuerelemente des Formulars und liest den Wert ihrer Eigenschaft ControlSource <\/b>in die Variable strControlSource <\/b>ein. Das geschieht bei deaktivierter Fehlerbehandlung, weil nicht alle Steuerelemente diese Eigenschaft aufweisen. Die Variable strControlSource <\/b>ist also anschließend nur gefüllt, wenn die Eigenschaft auch vorhanden ist. Und ob ein Steuerelement eines der zu untersuchenden Steuerelemente ist, erkennen wir dann daran, ob strControlSource <\/b>leer ist oder nicht.<\/p>\n Falls nicht, prüfen wir innerhalb der folgenden If…Then<\/b>-Bedingung, ob der aktuelle Wert (Value<\/b>) des Steuerelements mit dem gespeicherten Wert (OldValue<\/b>) übereinstimmt. Falls ja, stellt die Funktion ihren Rückgabewert auf True <\/b>ein und die Funktion wird verlassen.<\/p>\n In diesem Fall, also wenn mindestens eines der übrigen gebundenen Steuerelemente bearbeitet wurde, soll KeyCode <\/b>den Wert 0 <\/b>erhalten. Wir setzen also nur den Wert dieses Feldes zurück, leiten aber nicht die Betätigung der Esc<\/b>-Taste weiter – dadurch werden nicht die Änderungen des vollständigen Datensatzes rückgängig gemacht.<\/p>\n Die zweite Funktion MetaFelderBearbeitet <\/b>prüft, ob noch ein anderes als das aktuelle ungebundene Feld bereits bearbeitet wurde (siehe Listing 4).<\/p>\n Listing 4: Prüfen, ob noch andere Metafelder bearbeitet wurden<\/span><\/b><\/p>\n Damit das ungebundene Feld, welches die Prozedur txtNewsletteranmeldung_KeyDown <\/b>auslöst, nicht auch kontrolliert wird, übergeben wir einen Verweis darauf mit dem Parameter ctlAktiv<\/b>. Auch hier durchlaufen wir alle Steuerelemente des Formulars in einer For Each<\/b>-Schleife über die Controls<\/b>-Auflistung. Diesmal schließen wir mit der ersten If…Then<\/b>-Bedingung aus, dass wir das mit ctlAktiv <\/b>gelieferte Steuerelement untersuchen.<\/p>\n Danach prüfen wir, ob es sich bei dem Steuerelement aus ctl <\/b>um eines der Textfelder zum Anzeigen der Metadaten handelt. Das ist der Fall, wenn die VBA-Eigenschaft Tag<\/b>, die wir weiter oben über die Marke<\/b>-Eigenschaft der Steuerelemente mit den Attributnamen gefüllt haben, nicht leer sind. Finden wir so ein ungebundenes Textfeld, prüfen wir, ob sein Wert seit dem letzten Speichern geändert wurde.<\/p>\n Dazu vergleichen wir den aktuellen Wert (aus ctl.Value<\/b>) mit dem zuvor gespeicherten Wert, den wir per DLookup ermitteln. In der DLookup<\/b>-Funktion verwenden wir als Parameter den Wert des Primärschlüsselfeldes KundeID <\/b>sowie den Namen des Attributs aus der Tag<\/b>-Eigenschaft.<\/p>\n Entspricht der aktuelle Wert nicht dem gespeicherten Wert, liefert die Funktion MetafelderBearbeitet <\/b>den Wert True <\/b>zurück und die Funktion wird verlassen.<\/p>\n Nur wenn kein Element mit geändertem Inhalt gefunden wird, liefert die Funktion den Standardwert False <\/b>zurück.<\/p>\n Wenn der Wert des beim Betätigen der Esc<\/b>-Taste aktiven Steuerelements mit dem zuletzt gespeicherten Wert übereinstimmt, ruft die Prozedur txtNewsletteranmeldung_KeyDown <\/b>die Routine MetafelderZuruecksetzen <\/b>auf (siehe Listing 5).<\/p>\n Listing 5: Inhalte der Metafelder zurücksetzen<\/span><\/b><\/p>\n Diese durchläuft wiederum alle Steuerelemente zur Anzeige von Metafeldern in einer For Each<\/b>-Schleife. Um ein Steuerelement als eines mit Metafeld zu identifizieren, prüft sie, ob dieses einen Wert in der Eigenschaft Tag <\/b>enthält. Falls ja, ermittelt sie per DLookup<\/b>-Funktion den zuletzt gespeicherten Wert des Eintrags der Tabelle tblKundenMeta <\/b>für das in der Tag<\/b>-Eigenschaft angegebene Feld und den Kunden mit dem Primärschlüsselwert aus KundeID<\/b>.<\/p>\n Ist der Wert aus ctl.Value <\/b>ungleich dem aus strAlt<\/b>, wird der Wert auf den Inhalt aus strAlt <\/b>eingestellt.<\/p>\n Leider haben wir damit noch nicht alle Fälle abgedeckt, denn auch beim Verwerfen von Änderungen in den gebundenen Feldern wollen wir noch berücksichtigen, ob der Benutzer seit dem letzten Speichern des Datensatzes bereits Änderungen an den ungebundenen Feldern durchgeführt hat.<\/p>\n Wenn der Benutzer also beispielsweise erst ein ungebundenes Steuerelement mit dem Inhalt eines der Metafelder geändert hat und danach ein gebundenes Textfelder ändert, soll die Escape<\/b>-Taste wie gewohnt funktionieren.<\/p>\n Das heißt, dass dann zuerst das ungebundene Textfeld zurückgesetzt werden soll und beim zweiten Betätigen von Escape auch alle anderen Steuerelemente – gebundene wie ungebundene. Dazu hinterlegen wir für die gebundenen Steuerelemente ebenfalls Prozeduren für das Ereignis Bei Taste ab<\/b>. Für das Textfeld Firma<\/b> sieht diese wie in Listing 6 aus.<\/p>\n Listing 6: Aktion beim Betätigen der Esc-Taste für eines der gebundenen Steuerelemente<\/span><\/b><\/p>\n Die Prozedur prüft zunächst, ob es sich bei der gedrückten Taste um die Esc<\/b>-Taste handelt. In diesem Fall prüft sie zuerst, ob der aktuelle Inhalt des Textfeldes aus der Eigenschaft Text <\/b>mit dem Wert vor dem Speichern übereinstimmt. Diesen ermitteln wir für gebundene Textfelder mit der Eigenschaft OldValue<\/b>.<\/p>\n Danach vergleichen wir den Wert der Eigenschaft Value <\/b>mit OldValue<\/b>. Warum vergleichen wir erst Text <\/b>mit OldValue <\/b>und dann noch Value <\/b>mit OldValue<\/b> Weil es sein kann, dass der Benutzer von diesem Steuerelement aus die Esc<\/b>-Taste betätigt, direkt nachdem er den Inhalt geändert hat (Vergleich mit Text<\/b>) oder erst nachdem er zwischenzeitlich den Fokus auf ein anderes Steuerelement verschoben hat (Vergleich mit Value<\/b>).<\/p>\n Sind sowohl Text <\/b>als auch Value <\/b>nicht mit OldValue <\/b>identisch, macht die Prozedur zunächst die Änderung am Textfeld mit der Undo<\/b>-Methode rückgängig. Dann prüft sie, ob noch andere Felder bearbeitet wurden. In diesem Fall wird die Eigenschaft Dirty <\/b>auf den Wert True <\/b>eingestellt, damit der Datensatz im bearbeiteten Zustand bleibt. Außerdem erhält KeyCode <\/b>den Wert 0<\/b>, damit die eigentliche Funktion der Esc<\/b>-Taste nicht ausgeführt wird.<\/p>\n Wenn nur die erste If…Then<\/b>-Bedingung den Wert True <\/b>liefert, also wenn das beim Betätigen der Esc<\/b>-Schaltfläche aktive Steuerelement zwar geändert ist, aber nicht als letztes Steuerelement den Fokus hatte, wird KeyCode <\/b>nicht auf 0<\/b> eingestellt, damit die Werte alle gebundenen Steuerelemente einfach zurückgesetzt werden.<\/p>\n Außerdem setzen wir auch die geänderten Metafelder mit der Routine MetafelderZuruecksetzen <\/b>zurück, die wir bereits weiter oben beschrieben haben.<\/p>\n Zusammengefasst verarbeiten wir beim Betätigen der Esc<\/b>-Taste die folgenden Konstellationen:<\/p>\n Die hier vorgestellte Vorgehensweise ist eher eine Studie als ein praxiserprobtes Vorgehen. Wenn Sie diesen Ansatz in der Praxis einsetzen wollen, würden Sie zum Beispiel die Ereignisprozeduren nicht für jedes Steuerelement einzeln anlegen, sondern diese in eine Klasse auslagern, die dann für jedes Steuerelement erstellt wird.<\/p>\n Eine weitere Aufgabe ist: Wie können wir die Daten aus der zusätzlichen Tabelle mit dem Metadaten gemeinsam mit den Daten aus der Haupttabelle abfragen und so darstellen, als ob sie aus einer einzigen Tabelle stammen<\/p>\n Zur Veranschaulichung finden Sie in Bild 8 die beiden Tabellen mit einige Beispieldaten. Wie können wir die beiden Tabellen in einer Abfrage verknüpfen, sodass die Werte des Feldes Bearbeiten der Metadaten über die Benutzeroberfläche<\/h2>\n
\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_002.png\")
<\/p>\n\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_003.png\")
<\/p>\nAttribute eingeben<\/h2>\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_004.png\")
<\/p>\nAlternative Eingabemöglichkeit<\/h2>\n
![\"Ungebundene](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_005.png\")
<\/p>\nMeta-Attributnamen in die Marke-Eigenschaft schreiben<\/h2>\n
Anzeigen der Daten aus der Metadaten-Tabelle<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Me!txtEMail = Nz(DLookup(\"Attributwert\", \"tblKundenMeta\", \"KundeID = \" & Nz(Me!KundeID, 0) _\r\n & \" AND Attributname = 'E-Mail'\"), \"\")\r\n Me!txtNewsletteranmeldung = Nz(DLookup(\"Attributwert\", \"tblKundenMeta\", \"KundeID = \" & Nz(Me!KundeID, 0) _\r\n & \" AND Attributname = 'Newsletteranmeldung'\"), \"\")\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_006.png\")
<\/p>\nÄndern der Metadaten<\/h2>\n
Private Sub <\/span>Form_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngKundeMetaID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngKundeMetaID = Nz(DLookup(\"KundeMetaID\", \"tblKundenMeta\", \"KundeID = \" & Me!KundeID _\r\n & \" AND Attributname = 'E-Mail'\"), 0)\r\n If <\/span>lngKundeMetaID = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblKundenMeta(KundeID, Attributname, Attributwert) VALUES(\" & Me!KundeID _\r\n & \", 'E-Mail', '\" & Me!txtEMail & \"')\", dbFailOnError\r\n Else<\/span>\r\n db.Execute \"UPDATE tblKundenMeta SET Attributwert = '\" & Me!txtEMail & \"' WHERE KundeID = \" & Me!KundeID _\r\n & \" AND Attributname = 'E-Mail'\", dbFailOnError\r\n End If<\/span>\r\n lngKundeMetaID = Nz(DLookup(\"KundeMetaID\", \"tblKundenMeta\", \"KundeID = \" & Me!KundeID _\r\n & \" AND Attributname = 'Newsletteranmeldung'\"), 0)\r\n If <\/span>lngKundeMetaID = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblKundenMeta(KundeID, Attributname, Attributwert) VALUES(\" & Me!KundeID _\r\n & \", 'Newsletteranmeldung', '\" & Me!txtNewsletteranmeldung & \"')\", dbFailOnError\r\n Else<\/span>\r\n db.Execute \"UPDATE tblKundenMeta SET Attributwert = '\" & Me!txtNewsletteranmeldung & \"' WHERE KundeID = \" _\r\n & Me!KundeID & \" AND Attributname = 'Newsletteranmeldung'\", dbFailOnError\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKein Speichern ohne „dreckigen“ Datensatz<\/h2>\n
Private Sub <\/span>txtEMail_Change()\r\n Me.Dirty = True<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtNewsletteranmeldung_Change()\r\n Me.Dirty = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2021_01\/pic_1280_007.png\")
<\/p>\nPrivate Sub <\/span>txtEMail_Change()\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n intSelStart = Me!txtEMail.SelStart\r\n intSelLength = Me!txtEMail.SelLength\r\n Me!Firma.SetFocus\r\n Me.Dirty = True<\/span>\r\n Me!txtEMail.SetFocus\r\n Me!txtEMail.SelStart = intSelStart\r\n Me!txtEMail.SelLength = intSelLength\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtNewsletteranmeldung_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strAlt As String<\/span>\r\n Select Case KeyCode\r\n Case <\/span>vbKeyEscape\r\n strAlt = Nz(DLookup(\"Attributwert\", \"tblKundenmeta\", \"KundeID = \" & Nz(Me!KundeID, 0) _\r\n & \" AND Attributname = 'Newsletteranmeldung'\"), \"\")\r\n If <\/span>Not<\/span> Me!txtNewsletteranmeldung.Value = strAlt Then<\/span>\r\n Me!txtNewsletteranmeldung = strAlt\r\n If <\/span>GebundeneFelderBearbeitet Or MetaFelderBearbeitet(Me.txtNewsletteranmeldung) Then<\/span>\r\n KeyCode = 0\r\n End If<\/span>\r\n Else<\/span>\r\n MetafelderZuruecksetzen\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nUndo für ungebundene Textfelder<\/h2>\n
\n
Public Function <\/span>GebundeneFelderBearbeitet() As Boolean<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strControlSource As String<\/span>\r\n For Each ctl In Me.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strControlSource) = 0 Then<\/span>\r\n If <\/span>Not<\/span> ctl.Value = ctl.OldValue Then<\/span>\r\n GebundeneFelderBearbeitet = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>MetaFelderBearbeitet(ctlAktiv As <\/span>Control)\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>txt As <\/span>TextBox\r\n For Each ctl In Me.Controls\r\n If <\/span>Not<\/span> ctl Is ctlAktiv Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(ctl.Tag) = 0 Then<\/span>\r\n If Not<\/span> ctl.Value = Nz(DLookup(\"Attributwert\", \"tblKundenMeta\", \"KundeID = \" & Me!KundeID _\r\n & \" AND Attributname = '\" & ctl.Tag & \"'\"), \"\") Then\r\n MetaFelderBearbeitet = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>MetafelderZuruecksetzen()\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strAlt As String<\/span>\r\n For Each ctl In Me.Controls\r\n If <\/span>Not<\/span> Len<\/span>(ctl.Tag) = 0 Then<\/span>\r\n strAlt = Nz(DLookup(\"Attributwert\", \"tblKundenMeta\", \"KundeID = \" & Me.KundeID & \" AND Attributname = '\" _\r\n & ctl.Tag & \"'\"), \"\")\r\n If <\/span>Not<\/span> ctl.Value = strAlt Then<\/span>\r\n ctl.Value = strAlt\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nPrüfen der Metafelder bei Undo von gebundenen Textfeldern<\/h2>\n
Private Sub <\/span>Firma_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strAlt As String<\/span>\r\n Select Case KeyCode\r\n Case <\/span>vbKeyEscape\r\n If <\/span>Not<\/span> (Me!Firma.Text = Me!Firma.OldValue) Then<\/span>\r\n If <\/span>Not<\/span> (Me!Firma.Value = Me!Firma.OldValue) Then<\/span>\r\n Me!Firma.Undo\r\n If <\/span>MetaFelderBearbeitet(Me!Firma) Or GebundeneFelderBearbeitet Then<\/span>\r\n Me.Dirty = True<\/span>\r\n KeyCode = 0\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n MetafelderZuruecksetzen\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Abfragen von Metadaten <\/h2>\n