<\/p>\n
Das ändern von Daten ist in manchen Fällen an der Tagesordnung – zum Beispiel bei Kundendaten. Wenn Sie in einer Datenbank Kunden verwalten, die nicht nur für einen einzigen Auftrag oder eine einzige Bestellung angelegt werden, sondern mit denen Sie wiederkehrend geschäftlichen Kontakt haben, müssen Sie die Adressdaten auf dem aktuellen Stand halten. Kein Problem: Die entsprechenden Felder lassen sich ja schnell mal überschreiben. Das Problem ist nur, dass hier auch Fehler geschehen. Wenn Sie beispielsweise beim falschen Michael Müller die Lieferadresse ändern, freut sich ein Michael Müller über eine Lieferung, aber der andere, der nichts bestellt hat, wird die Rechnung wohl nicht bezahlen. Und wenn sich solche Fehler nur schwer verhindern lassen, so sollen Sie zumindest die Adressdaten schnell wiederherstellen können …<\/b><\/p>\n
Und genau darum kümmert sich der vorliegende Beitrag: Wir entwickeln hier eine automatische Lösung zum Archivieren von geänderten oder gelöschten Datensätzen einer Kundendatenbank. Außerdem wollen wir ein Formular bereitstellen, mit dem Sie den aktuellen und die bereits archivierten Datensätze zu einem Kunden einsehen, vergleichen und beliebige Versionsstände wiederherstellen können.<\/p>\n
Voraussetzung<\/b><\/p>\n
Die Sache hat einen kleinen Haken: Die Lösung basiert auf der Verwendung von Access 2010 oder höher. Der Grund ist, dass wir hier mit den Tabellenereignissen arbeiten, die erst mit Access 2010 eingeführt wurden. Tabellenereignisse sind das Access-Pendant etwa zu den Triggern beim SQL Server. Dabei handelt es sich um ereignisgesteuerte, benutzerdefinierte Aktionen, die durch das Anlegen, Bearbeiten oder Löschen von Daten ausgelöst werden.<\/p>\n
In unserem Fall spielt das Anlegen keine Rolle: Wir wollen nur die Möglichkeit liefern, geänderte oder gelöschte Daten wiederherzustellen. Dazu benötigen wir kein Anlegedatum oder ähnliche Informationen. Also werden wir später nur ein Ereignis definieren, das beim ändern eines Datensatzes der betroffenen Tabelle ausgelöst wird sowie eines für das Löschen eines Datensatzes der Tabelle.<\/p>\n
Beispieltabelle<\/b><\/p>\n
Als Beispieltabelle verwenden wir eine einfache Kundentabelle. Diese sieht im Entwurf wie in Bild 1 aus und enthält nur die notwendigsten Felder.<\/p>\n
![\"Tabelle,](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_001.png\")
<\/p>\n
Bild 1: Tabelle, deren Daten beim ändern archiviert werden sollen<\/span><\/b><\/p>\n Zieltabelle der Archivierung<\/b><\/p>\n Das Ziel der Archivierung ist eine Tabelle, die fast genauso wie die Originaltabelle aufgebaut ist. Es gibt allerdings einige kleine Unterschiede: Die Zieltabelle verwendet das Feld KundeID <\/b>nämlich nicht als Primärschlüsselfeld mit dem Felddatentyp Autowert<\/b>, sondern als einfaches Feld mit dem Typ Zahl<\/b>. Als Primärschlüsselfeld definieren wir ein weiteres Feld namens ArchivKundeID<\/b>. Dies legen wir wiederum als Autowertfeld aus (s. Bild 2).<\/p>\n Bild 2: Tabelle zum Archivieren von Daten vor dem ändern oder Löschen<\/span><\/b><\/p>\n Außerdem finden Sie am Ende des Entwurfs der Tabelle zwei weitere Felder namens GeaendertAm <\/b>und Geloescht-Am <\/b>mit dem Datentyp Datum\/Uhrzeit<\/b>. Wenn der Benutzer einen Datensatz der Tabelle tblKunden <\/b>ändert, soll die Version des Datensatzes vor der änderung in die Tabelle tblKundenArchiv <\/b>kopiert werden und das aktuelle Datum im Feld GeaendertAm <\/b>erhalten. Wenn der Benutzer hingegen einen Datensatz löscht, landet dieser zwar auch komplett in der Tabelle tblKundenArchiv <\/b>– diesmal allerdings mit dem aktuellen Datum im Feld GeloeschtAm<\/b>.<\/p>\n Makro zum Archivieren eines geänderten Datensatzes<\/b><\/p>\n Damit ein geänderter Datensatz vor der änderung in der Archivtabelle landet, legen Sie ein Makro für das Ereignis Nach Aktualisierung <\/b>der Tabelle an. Dies erledigen Sie durch einen Mausklick auf den Ribbon-Eintrag Tabelle|Nachfol-ge-er-eignisse|Nach Aktualisierung<\/b> (s. Bild 3), während die Tabelle in der Datenblattansicht geöffnet ist.<\/p>\n Bild 3: Anlegen des Makros für das Ereignis Nach Aktualisierung der Tabelle ausgelöst<\/span><\/b><\/p>\n In der Entwurfsansicht legen Sie das entsprechende Makro über den Ribbon-Eintrag Entwurf|Feld-, Datensatz- und Ta-bel-len-er-eig-nis-se|Da-ten-mak-ros erstellen|Nach Ak-tu-alisierung<\/b> an.<\/p>\n Daraufhin erscheint ein leeres Makro, das Sie nun mit Leben füllen müssen. Das gelingt relativ schnell: Als Erstes wählen Sie mit dem Kombinationsfeld Neue Aktion hinzufügen <\/b>den Eintrag Datensatz erstellen in <\/b>aus und tragen als ersten Parameter den Namen der Zieltabelle ein, also tblKundenArchiv<\/b>. Nun müssen Sie festlegen, wie die einzelnen Felder dieser Tabelle gefüllt werden – und womit. Die benötigte Makroaktion ist schnell gefunden: Sie heißt FestlegenFeld <\/b>und kann nur angelegt werden, wenn Sie die Makroaktion Datensatz erstellen in <\/b>markieren und dann das zu dieser Makroaktion gehörende Kombinationsfeld Neue Aktion hinzufügen <\/b>aufklappen.<\/p>\n Haben Sie diese Aktion hinzugefügt, geben Sie die beiden Parameter ein. Wir beginnen mit dem Feld KundeID<\/b>, welches in das gleichnamige Feld der Tabelle tblKundenArchiv <\/b>eingefügt werden soll. Dazu tragen Sie für den Parameter Name <\/b>einfach den Feldnamen KundeID <\/b>ein. Das Makro weiß nun automatisch, dass das Feld KundeID <\/b>der Tabelle tblKundenArchiv <\/b>gefüllt werden soll. Aber woher beziehen wir den Inhalt für das Feld KundeID<\/b> Wenn Sie dort ebenfalls den Eintrag KundeID <\/b>hinzufügen, greift Access auf den Inhalt des Feldes des geänderten Datensatzes zu. Wenn Sie auf den Feldinhalt des Datensatzes vor der änderung zugreifen möchten, müssen Sie auf die generische Tabelle namens Alt <\/b>zugreifen. Für den vorherigen Wert des Feldes KundeID <\/b>verwenden Sie also etwa den Ausdruck [Alt].[KundeID]<\/b>. Gut: Beim Feld Kunde-ID <\/b>hätten Sie auch auf den Wert des geänderten Datensatzes zugreifen können, denn das Primärschlüsselfeld wird ja in der Regel nicht geändert – schon gar nicht, wenn es als Autowert definiert ist. Aber bei den anderen, tendenziell änderbaren Feldern, macht der Zugriff auf die mit Alt <\/b>referenzierten vorherigen Werte durchaus Sinn. Dementsprechend fügen Sie dem Makro weitere FestlegenFeld<\/b>-Aktionen hinzu, welche Feld für Feld die Inhalte der Tabelle Alt <\/b>in die Tabelle tblKundenArchiv <\/b>überträgt.<\/p>\n Schließlich fehlt noch die Füllung für das Feld GeaendertAm<\/b>. Hier tragen Sie einfach die Funktion Jetzt() <\/b>ein. Das komplette Makro finden Sie in Bild 4.<\/p>\n Bild 4: Makro, das durch das Ereignis Nach Aktualisierung ausgelöst wird<\/span><\/b><\/p>\n Makro beim Löschen<\/b><\/p>\n Das Makro, das beim Löschen eines Datensatzes der Tabelle tblKunden <\/b>ausgelöst werden soll, sieht ähnlich aus. Der einzige Unterschied ist, dass es nicht das Feld GeaendertAm<\/b>, sondern GeloeschtAm<\/b> mit dem aktuellen Datum füllt (s. Bild 5). Und natürlich legen Sie es über einen anderen Ribbon-Eintrag an, nämlich Tabelle|Nachfolgeereignis-se|-Nach Löschen<\/b>. Den Zugriff auf die Feldinhalte des gelöschten Datensatzes liefert wiederum die Tabelle Alt<\/b>.<\/p>\n Bild 5: Makro, das durch das Ereignis Nach Löschung ausgelöst wird<\/span><\/b><\/p>\n Probieren geht über studieren<\/b><\/p>\n Nun müssen wir die beiden Makros noch ausprobieren. Legen Sie also einen neuen Datensatz in der Tabelle an. Nach dem ändern des Feldes Vorname <\/b>und dem Speichern des Datensatzes in der Tabelle tblKunden <\/b>finden Sie in der Tabelle tblKundenArchiv <\/b>einen neuen Datensatz vor, der den Datensatz in der Form vor der änderung enthält – samt änderungsdatum.<\/p>\n Wenn Sie den Datensatz auch noch aus der Tabelle tblKunden <\/b>löschen, verschwindet dieser zwar aus dieser Tabelle, aber eine Kopie dieses Datensatzes landet in der Tabelle tblKundenArchiv <\/b>– samt aktuellem Datum im Feld GeloeschtAm<\/b>.<\/p>\n Die Tabelle tblKundenArchiv <\/b>sieht danach beispielsweise wie in Bild 6 aus.<\/p>\n Bild 6: Die Tabelle tblKundenArchiv mit einem geänderten und einem gelöschten Datensatz<\/span><\/b><\/p>\n Datenarchiv im Formular<\/b><\/p>\n Nun hilft diese Archivierung nicht viel, wenn man es nicht entsprechend einsehen und nutzen kann – zum Beispiel, um einen bestimmten Stand wiederherzustellen. Dazu benötigen wir ein Formular, das sowohl den aktuellen Stand des Datensatzes liefert als auch die archivierten Versionen des Datensatzes. <\/p>\n Am übersichtlichsten ist vermutlich eine Darstellung der Datensätze in der Datenblattansicht. Bevor wir uns an die Umsetzung begeben, wollen wir uns noch überlegen, welche Möglichkeiten uns diese liefern soll.<\/p>\n Sollen Datensätze direkt in der Datenblattansicht geändert werden können Nein. Es soll nur möglich sein, eine beliebige archivierte Version eines Datensatzes wiederherzustellen – egal, ob der Datensatz wegen einer änderung oder wegen einer Löschung in der Tabelle tblKundenArchiv <\/b>gespeichert wurde.<\/p>\n Wir könnten nun zwei Datenblätter übereinander darstellen, indem wir diese in zwei Unterformularen unterbringen. Das Problem dabei ist wie immer, dass die Datenblätter in den beiden Unterformularen möglichst synchron gehandhabt werden sollten – wenn der Benutzer das obere Datenblatt scrollt, sollte dies auch mit dem unteren geschehen, und wenn die Spaltenbreiten in einer von beiden Ansichten geändert werden, sollte dies auch für das jeweils andere Datenblatt durchgeführt werden.<\/p>\n Datenherkunft des Unterformulars<\/b><\/p>\n Da wir aber soeben festgelegt haben, dass wir ohnehin nicht direkt änderungen am aktuellen Datensatz vornehmen wollen und auch nicht an den archivierten Datensätzen, können wir auch den aktuellen Datensatz und die archivierten Datensätze gemeinsam in einem Unterformular in der Datenblattansicht unterbringen.<\/p>\n Dies gelingt ganz einfach durch Zusammenführen des aktuellen Datensatzes aus der Tabelle tblKunden <\/b>und der archivierten Datensätze aus der Tabelle tblKundenArchiv <\/b>per UNION<\/b>-Abfrage.<\/p>\n Dies ist auch dann möglich, wenn der Datensatz gar nicht mehr in der Tabelle tblKunden <\/b>enthalten ist – der erste Teil der UNION<\/b>-Abfrage liefert dann halt keine Daten.<\/p>\n Schauen wir uns zunächst den Teil der UNION<\/b>-Abfrage an, der den Teil der Datensätze beisteuert, die aus der Tabelle tblKundenArchiv <\/b>stammen.<\/p>\n Diese sollen wie in Bild 7 daherkommen, wo eine Abfrage namens qryKundenArchiv<\/b> neben den eigentlichen Feldern der Tabelle tblKundenArchiv <\/b>noch zwei berechnete Felder liefert.<\/p>\n Bild 7: Die Abfrage qryKundenArchiv liefert die Daten der Tabelle tblKundenArchiv und bereitet diese auf.<\/span><\/b><\/p>\n Das erste heißt Aktion und soll den Wert Gelöscht am: <\/b>enthalten, wenn das Feld GeloeschtAm <\/b>des Datensatzes der Tabelle tblKundenArchiv <\/b>einen Wert enthält (s. Bild 8). Wenn hingegen das Feld GeaendertAm <\/b>gefüllt ist, soll das Feld Aktion <\/b>den Wert Geändert am: <\/b>anzeigen. Der Ausdruck für dieses Feld sieht so aus:<\/p>\n Bild 8: Die Abfrage qryKundenArchiv in der Entwurfsansicht<\/span><\/b><\/p>\n Das zweite berechnete Feld heißt Archivdatum <\/b>und soll entweder den Inhalt des Feldes GeaendertAm <\/b>oder GeloeschtAm <\/b>aufnehmen – je nachdem, welches der beiden einen Wert enthält. Dieses Feld enthält den folgenden Ausdruck:<\/p>\n Außerdem soll die Abfrage absteigend nach dem Wert dieses Feldes sortieren. Nun wollen wir diese Abfrage mit dem betroffenen Datensatz der Tabelle tblKunden <\/b>zusammenführen. Dazu legen Sie eine UNION<\/b>-Abfrage wie die aus Bild 9 an.<\/p>\n Bild 9: UNION-Abfrage<\/span><\/b><\/p>\n Damit die Spalte Aktion <\/b>wie in Bild 10 den Wert Aktuelle Version <\/b>für den aktuellen Datensatz anzeigt, definieren wir das zweite Feld der UNION<\/b>-Abfrage mit “Aktuelle Version“ AS Aktion<\/b>.<\/p>\n Bild 10: Die Abfrage führt den aktuellen Datensatz und seine archivierten Versionen zusammen.<\/span><\/b><\/p>\n Das Feld Archivdatum <\/b>des aktuellen Datensatzes soll, damit dieser immer ganz oben angezeigt wird, mit dem aktuellen Datum und der aktuellen Uhrzeit gefüllt werden. Dies erreichen wir mit dem Ausdruck Now AS Archivdatum<\/b>.<\/p>\n Bevor wir diese Abfrage nun als Datenherkunft des Unterformulars verwenden, müssen wir diesem noch einen Parameter hinzufügen, der als Vergleichswert eines WHERE<\/b>-Kriteriums dient und nur diejenigen Datensätze zurückliefert, die dem zu untersuchenden Datensatz entsprechen.<\/p>\n Der Parameter soll prmKundeID <\/b>heißen und wird in jede SELECT<\/b>-Anweisung der Abfrage je einmal eingefügt:<\/p>\n Unterformular zur Anzeige der Datensätze<\/b><\/p>\n Nun erstellen wir zunächst das Unterformular sfmArchivierteDatensaetze<\/b>. Diesem weisen wir zunächst die Abfrage qryKundenArchiv <\/b>als Datenherkunft zu, da dieses alle Felder enthält, die später im Unterformular angezeigt werden sollen. Später, wenn der Benutzer das Formular öffnet, soll dieses mit dem Wert des Feldes KundeID <\/b>des zu untersuchenden Datensatzes der Tabelle tblKunden <\/b>als Parameter geöffnet werden, woraufhin das Unterformular mit einem Recordset auf Basis der Abfrage qryKundenArchivUnion <\/b>gefüllt wird, das zuvor bereits mit dem entsprechenden Parameter versehen wurde. Das Unterformular sieht nach dem Hinzufügen der entsprechenden Felder wie in Bild 11 aus.<\/p>\n Bild 11: Das Unterformular sfmArchivierteDatensaetze, hier zunächst mit der Abfrage qryKundenArchiv als Datenherkunft<\/span><\/b><\/p>\n Damit können wir uns nun gleich an die Erstellung des Hauptformulars begeben, das – mit integriertem Unterformular – im Entwurf wie in Bild 12 aussehen soll. Das Unterformular fügen Sie dem Hauptformular hinzu, indem Sie es einfach aus dem Navigationsbereich in den Detailbereich des Hauptformulars ziehen. Anschließend stellen Sie die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf Beide <\/b>ein, damit sich das Unterformular beim Vergrößern des Hauptformulars anpasst.<\/p>\n Bild 12: Haupt- und Unterformular in der Entwurfsansicht<\/span><\/b><\/p>\n Außerdem fügen Sie im Hauptformular eine Schaltfläche namens cmdWiederherstellen <\/b>ein, mit welcher der Benutzer den aktuell markierten Datensatz wiederherstellt und somit den bestehenden Datensatz überschreibt beziehungsweise einen gelöschten Datensatz wiederherstellt.<\/p>\n Unterformular filtern<\/b><\/p>\n <\/p>\n Zuvor müssen wir allerdings noch sicherstellen, dass das Unterformular auch nur die betroffenen Datensätze anzeigt. Deshalb erstellen wir noch eine ähnliche Kombination aus Haupt- und Unterformular, die im Unterformular alle Kunden aus der Tabelle tblKunden <\/b>anzeigt und mit cmdHistorie <\/b>eine Schaltfläche enthält, mit der Sie die Historie für den aktuell im Unterformular ausgewählten Kunden im Formular frmArchivierteDatensaetze <\/b>anzeigen können (s. Bild 13).<\/p>\n Bild 13: Anzeige aller Kunden und Aufrufen der Historie eines Kunden<\/span><\/b><\/p>\n Die Schaltfläche cmdHistorie <\/b>löst die Prozedur aus Listing 1 aus, die das Formular frmArchivierteDatensaetze <\/b>öffnet und mit dem öffnungsargument den Wert des Feldes KundeID <\/b>des aktuell ausgewählten Datensatzes übergibt. Diese ist dann im Klassenmodul des Formulars frmArchivierteDatensaetze <\/b>über die Eigenschaft Me.OpenArgs <\/b>verfügbar und kann als Parameter der dem Unterformulars dieses Formulars zugrunde liegenden Abfrage verwendet werden.<\/p>\n Listing 1: Diese Prozedur öffnet das Formular sfmArchivierteDatensaetze<\/span><\/b><\/p>\n Kunde mit Archiv anzeigen<\/b><\/p>\n Nun müssen wir das Hauptformular frmArchivierteDatensaetze <\/b>noch mit einer Ereignisprozedur ausstatten, die beim Laden das öffnungsargument auswertet und die Datensätze zum richtigen Kunden im Unterformular anzeigt.<\/p>\n Diese sieht wie in Listing 2 aus. Die Prozedur prüft, ob Me.OpenArgs <\/b>überhaupt einen Wert enthält. Falls ja, füllt die Prozedur die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Die Variable qdf <\/b>referenziert dann die Abfrage qryKundenArchivUNION<\/b>, der mit der folgenden Anweisung der Parameter prmKundeID <\/b>zugewiesen wird.<\/p>\n Listing 2: Ermitteln und Zuweisen der Datenherkunft des Unterformulars beim Laden<\/span><\/b><\/p>\n Nachdem dieser den Wert erhalten hat, den Me.OpenArgs <\/b>liefert, kann die Prozedur ein Recordset<\/b>-Objekt auf Basis dieser Abfrage mit dem gegebenen Parameter erstellen und dieses dem Unterformular als Datenherkunft zuweisen.<\/p>\n Die festgelegte Sortierung sorgt dafür, dass der aktuelle Datensatz ganz oben angezeigt wird, die übrigen folgen dann in der Reihenfolge der änderung weiter unten.<\/p>\n Unterschiede anzeigen<\/b><\/p>\n Nun wäre es hilfreich, die Unterschiede zwischen den Datensätzen anzuzeigen. Wie aber sollen wir hier vorgehen Man könnte alle Unterschiede der archivierten Datensätze zum aktuellen Datensatz anzeigen. Alternativ zeigt man alle Unterschiede an, die sich von Version zu Version ergeben haben. Da dies ein schönes Beispiel für den Einsatz der bedingten Formatierung ist, wenden wir einfach beide Versionen an – der Benutzer kann dann zwischen den Versionen umschalten.<\/p>\n Die erste Variante erhalten Sie, wenn Sie für die Felder des Datenblatts im Unterformular jeweils eine bedingte Formatierung festlegen, wie sie in Bild 14 dargestellt ist.<\/p>\n Bild 14: Einstellen der bedingten Formatierung zur Anzeige der Unterschiede zur aktuellen Version<\/span><\/b><\/p>\n Dazu klicken Sie erst auf das Feld, für das Sie die bedingte Formatierung festlegen wollen, und wählen dann aus dem Ribbon den Eintrag Daten-blatt|For-matierung|Bedingte For-matierung <\/b>aus. Klicken Sie im nun erscheinenden Dialog Manager für Regeln zur bedingten Formatierung <\/b>auf die Schaltfläche Neue Regel<\/b>. Im nächsten Dialog wählen Sie im linken Kombinationsfeld Feldwert <\/b>und im rechten Kombinationsfeld Ungleich <\/b>aus. Geben Sie dann als Vergleichswert den folgenden Ausdruck ein:<\/p>\n Dies vergleicht den Wert des Feldes Vorname <\/b>für den aktuellen Datensatz mit dem Wert des Feldes der Tabelle tblKunden<\/b> mit dem gleichen Wert im Feld KundeID<\/b>. Dadurch, dass der oberste Datensatz der aktuelle Datensatz ist, stimmt dessen Vorname <\/b>natürlich mit dem Vornamen des gleichen Datensatzes, diesmal mit der DomWert<\/b>-Funktion referenziert, überein – dadurch werden für diesen Datensatz niemals Unterschiede angezeigt.<\/p>\n Was aber tun wir, wenn das Formular gerade die archivierten Datensätze für einen bereits gelöschten Datensatz anzeigt – wenn also kein Originaldatensatz mehr verfügbar ist In diesem Fall sollten wir einfach die Unterschiede zwischen den einzelnen Versionen aufzeigen.<\/p>\n Unterschiede von Version zu Version<\/b><\/p>\n Dies wird etwas aufwendiger. Zunächst einmal wollen wir der Abfrage qryKundenArchivUnion <\/b>ein Feld hinzufügen, dass den Wert des Feldes ArchivKun-deID <\/b>der vorherigen Version des Datensatzes enthält. Dies soll dann beispielsweise wie in Bild 15 aussehen.<\/p>\n Bild 15: Erweiterung der Abfrage qryKundenArchivUNION um ein Feld, das die ArchivKundeID der vorherigen Version enthält<\/span><\/b><\/p>\n Den Code der SQL-Abfrage ändern wir dazu wie folgt (neue Felder fett gedruckt):<\/p>\n Im ersten Teil der UNION<\/b>-Abfrage fügen wir einfach nur das Feld VorherigeVersionID <\/b>hinzu, das jedoch leer bleiben soll. Im zweiten Teil kommt ebenfalls das Feld VorherigeVersionID <\/b>hinzu, diesmal allerdings mit einer Domänenfunktion als Inhalt.<\/p>\n Diese liefert den kleinsten Wert des Feldes ArchivKundeID <\/b>der Abfrage qryKundenArchiv<\/b>, wobei nur die Datensätze berücksichtigt werden, die als Versionen des mit dem Feld KundeID <\/b>festgelegten Originaldatensatzes der Tabelle tblKunden <\/b>angelegt wurden.<\/p>\n Außerdem soll das Feld ArchivKundeID <\/b>des gesuchten Datensatzes größer sein als der Wert des entsprechenden Feldes des aktuellen Datensatzes.<\/p>\n Damit hätten wir also festgelegt, welcher Datensatz die Vorgängerversion des aktuellen Datensatzes repräsentiert.<\/p>\n Damit können wir nun zum Datenblatt des Unterformulars sfmArchivierteDatensaetze <\/b>zurückkehren. Dort fügen wir nun für alle Inhaltsfelder, also solche Felder, die aus der Originaltabelle tblKunden <\/b>stammen, eine entsprechende bedingte Formatierung hinzu. Das Ergebnis soll wie in Bild 16 aussehen. Dort ist immer das Feld, das sich vom Feld der nachfolgenden Version unterscheidet, farblich hinterlegt.<\/p>\n Bild 16: Markierung der Felder der Datensätze, die sich von den Feldern der vorherigen Version unterscheiden<\/span><\/b><\/p>\n Wenn also der Vorname von Version 8 auf Version 9 von André <\/b>in Andreas <\/b>geändert wurde, dann ist der Wert André <\/b>in Version 8 farbig markiert. Wenn sich der Nachname von Version 9 zu Version 10 von Minhorst <\/b>auf Müller <\/b>ändert, dann soll der Eintrag Minhorst <\/b>in Version 9 farbig hinterlegt werden.<\/p>\n Nun benötigen wir nur noch die entsprechende Bedingung für die bedingte Formatierung der betroffenen Felder beziehungsweise Steuerelemente. Diese legen Sie etwa für das Feld Vorname <\/b>wie in Bild 17 an.<\/p>\n Bild 17: Hinzufügen einer bedingten Formatierung zum Vergleich der einzelnen Versionen<\/span><\/b><\/p>\n Der Feldwert des Feldes mit der bedingten Formatierung soll ungleich dem folgenden Ausdruck sein:<\/p>\n Nur in diesem Fall soll die Formatierung angewendet werden, hier ein farbiger Hintergrund.<\/p>\n Der Ausdruck fragt den Wert des Feldes Vorname <\/b>für den Datensatz ab, dessen Feld ArchivKundeID <\/b>den Wert enthält, den das Feld VorherigeVersionID <\/b>des zu formatierenden Datensatzes enthält.<\/p>\n Im Beispiel des Datensatzes mit dem Wert 8 <\/b>im Feld ArchivKundeID <\/b>aus der Abbildung also etwa den Datensatz, dessen Feld ArchivKundeID <\/b>den Wert 9 <\/b>enthält. Dieses Feld enthält im Feld Vorname <\/b>den Wert Andreas<\/b>, während das zu formatierende Feld den Wert André <\/b>enthält. Die Werte sind ungleich, also wendet Access die vorgegebene bedingte Formatierung an.<\/p>\n Beim Feld Firma <\/b>sieht die Formel für den Vergleichswert in der bedingten Formatierung für dieses Feld so aus:<\/p>\n Hier soll im Beispiel aus Bild 18 der Wert des ersten archivierten Datensatzes, also André Minhorst Verlag<\/b>, mit dem Wert des aktuellen Datensatzes verglichen werden, also mit Andreas Müller Verlag<\/b>. Die innerhalb des obigen Ausdrucks verwendete DomWert<\/b>-Funktion liefert keinen passenden Datensatz, wodurch der zweite Teil der umschließenden Nz<\/b>-Funktion ausgewertet wird. Dieser ermittelt den Wert des beobachteten Feldes für den aktuellen Datensatz aus der Tabelle tblKunden<\/b>. Die beiden Versionen sind verschieden, daher wird das in der Abbildung markierte Feld entsprechend formatiert.<\/p>\n Bild 18: Markierung der Felder der Datensätze, die sich von den Feldern der vorherigen Version unterscheiden – andere Version<\/span><\/b><\/p>\n Fleißarbeit<\/b><\/p>\n Nachdem wir die passende Bedingung für die bedingte Formatierung entwickelt haben, müssen wir diese für alle betroffenen Felder einstellen. Das ist dummerweise reine Fleißarbeit, die überdies noch fehleranfällig ist. Zum Glück kann man die bedingte Formatierung auch per VBA zuweisen, was wir im Folgenden so erledigen. Dazu rufen wir in der Ereignisprozedur Form_Load<\/b> eine weitere Prozedur namens BedingteFormatierung <\/b>auf:<\/p>\n Diese Prozedur sieht wie in Listing 3 aus und speichert zunächst einen Verweis auf die aktuelle Datenbank in der Variablen db<\/b>. Dann referenziert sie die Tabellendefinition der Tabelle tblKunden <\/b>mit der TableDef<\/b>-Variablen tdf<\/b>.<\/p>\n Listing 3: Definieren der bedingten Formatierung für die Steuerelemente im Unterformular<\/span><\/b><\/p>\n Dann durchläuft die Prozedur alle Steuerelemente des Unterformulars sfmArchivierteDatensaetze<\/b> in einer For Each<\/b>-Schleife über die Elemente der Controls<\/b>-Auflistung. Das aktuelle Steuerelement referenziert die Prozedur dabei mit der Variablen ctl<\/b>. Während die Prozedur die Fehlerbehandlung deaktiviert, leert sie eine Variable namens fld <\/b>und versucht diese gleich danach wieder zu füllen – und zwar mit einem Verweis auf ein Feld der Tabelle tblKunden<\/b>, dessen Feldname mit dem Feld übereinstimmt, an welches das aktuelle mit ctl <\/b>referenzierte Steuerelement gebunden ist – dies allerdings nur, wenn das Steuerelement überhaupt an ein Feld gebunden ist. Dies wiederum prüft die Prozedur über den Ausdruck Len(ctl.ControlSource) > 0<\/b> – sprich: Enthält die Eigenschaft Controls <\/b>des Steuerelements ctl <\/b>überhaupt einen Wert, dessen Länge größer als 0 <\/b>ist<\/p>\n Falls ja, kann es sich ja auch um ein Feld handeln, das nicht aus der Tabelle tblKunden <\/b>stammt, sondern um ein anderes Feld der Datenherkunft qryKundenArchivUNION<\/b>.<\/p>\n Sowohl das Prüfen der Länge der Eigenschaft ControlSource <\/b>für ein Steuerelement, das diese Eigenschaft gar nicht aufweist, als auch das Referenzieren eines Feldes einer Tabellendefinition, das nicht vorhanden ist, kann einen Fehler auslösen – deshalb haben wir die Fehlerbehanldung mit On Error Resume Next <\/b>temporär ausgeschaltet und stellen diese nach dem Versuch, fld <\/b>mit dem Verweis auf das Feld zu füllen, an welches das aktuelle Steuerelement gebunden ist, mit On Error Goto 0 <\/b>wieder ein.<\/p>\n Sollte fld <\/b>hiernach nicht Nothing <\/b>sein, referenziert ctl <\/b>ein Steuerelement, das an ein Feld der Tabelle tblKunden <\/b>gebunden ist. In diesem Fall (Not fld Is Nothing<\/b>) durchläuft die Prozedur so lange eine Do While<\/b>-Schleife, bis die Anzahl der bedingten Formatierungen für dieses Steuerelement gleich 0 <\/b>ist. Damit dies irgendwann geschieht, löscht die einzige Anweisung innerhalb der Do While<\/b>-Schleife das jeweils erste Element der Auflistung mit der Delete<\/b>-Methode dieses Elements.<\/p>\n Dann stellt sie ein Kriterium zusammen, das dem oben beschriebenen Vergleichsausdruck für das jeweilige Feld entspricht. Damit wir dieses für jedes einzelne Feld dynamisch generieren können, enthält der Ausdruck mit ctl.ControlSource <\/b>den Namen des Feldes, an welches das Steuerelement gebunden ist.<\/p>\n Die folgende Anweisung definiert die bedingte Formatierung und referenziert diese mit der Variablen objFormatCondition<\/b>. Beim Anlegen verwendet diese Anweisung als ersten Parameter den Wert acFieldValue<\/b>, was der Einstellung Feldwert ist <\/b>im Dialog Formatierungsregel bearbeiten <\/b>entspricht. Den zweiten Parameter stellt die Prozedur auf acNotEqual <\/b>ein (entspricht Ungleich<\/b>). Schließlich folgt als dritter Parameter der zuvor zusammengestellte und in der Variablen strKriterium <\/b>gespeicherte Vergleichsausdruck. Die Referenzierung der bedingten Formatierung war nötig, weil wir die Formatierung nicht direkt beim Anlegen übergeben können, sondern dies mit einer Eigenschaft des Objekts objFormatCondition <\/b>erledigen müssen. Diese Eigenschaft für die Einstellung der Hintergrundfarbe lautet BackColor und erhält den gewünschten Farbwert beispielsweise als Hexadezimalzahl.<\/p>\n Auf diese Weise durchläuft die Prozedur alle Steuerelemente und legt für all jene, die an ein Feld der Tabelle tblKunden <\/b>gebunden sind, die entsprechende bedingte Formatierung fest.<\/p>\n Vorherige Version wiederherstellen<\/b><\/p>\n Da wir nun die optische Seite des Formulars frmArchivierteDatensaetze<\/b> und seines Unterformulars hergestellt haben, kümmern wir uns um die eigentlich interessante Funktion: das Wiederherstellen vorheriger Versionen eines Datensatzes.<\/p>\n An dieser Stelle müssen wir uns einig werden, was geschehen soll, wenn der Benutzer eine ältere Version eines Datensatzes der Tabelle tblKunden <\/b>anklickt und dann die Schaltfläche cmdWiederherstellen <\/b>betätigt. Eins ist klar: Der zu diesem Zeitpunkt aktivierte Datensatz im Unterformular sfmArchivierteDatensaetze <\/b>soll als aktueller Datensatz mit dem aktuellen Wert des Feldes KundeID <\/b>in die Tabelle tblKunden <\/b>übernommen werden.<\/p>\n Die erste Frage, die sich hier stellt, ist: Wie geschieht dies Soll der aktuelle Datensatz zunächst gelöscht und dann der wiederherzustellende Datensatz als neuer Datensatz in der Tabelle tblKunden <\/b>angelegt werden<\/p>\n Oder überschreiben wir den aktuellen Datensatz mit dem entsprechenden Wert im Feld KundeID <\/b>mit dem wiederherzustellenden Datensatz Die zweite Frage ist: Was geschieht mit den Daten in der Tabelle tblKundenArchiv<\/b> Werden alle Versionen, die sich zwischen der aktuellen Version und der wiederherzustellenden Version befinden, gelöscht Oder wollen wir die Historie komplett beibehalten und fügen der Tabelle tblKundenArchiv <\/b>den aktuellen Datensatz der Tabelle tblKunden <\/b>vor dem Wiederherstellen des entsprechenden Datensatzes wie gewohnt als neue frühere Version hinzu<\/p>\n Wir wählen in beiden Fällen die zuletzt vorgestellte Variante, was auch prima zusammenpasst. Wenn wir in einer SQL-UPDATE-Anweisung die Werte des wiederherzustellenden Datensatzes in die Felder des aktuellen Datensatzes mit dem gleichen Wert im Feld KundeID <\/b>eintragen, löst dies ja wieder automatisch das Tabellenereignis Nach Aktualisierung <\/b>aus, wodurch die aktuelle Version des Datensatzes vor dem überschreiben mit dem wiederherzustellenden Datensatz als neuer Datensatz in die Tabelle tblKundenArchiv <\/b>geschrieben wird.<\/p>\n Die notwendige Prozedur sieht wie in Listing 4 aus. Sie ruft mit der Execute<\/b>-Methode des aktuellen Database<\/b>-Objekts eine UPDATE<\/b>-Anweisung auf, die den Datensatz in der Tabelle tblKunden<\/b>, dessen Feld KundeID <\/b>den Wert des gleichen Feldes im aktuell markierten Datensatz des Unterformulars sfmArchivierteDatensaetze <\/b>enthält, mit den Feldinhalten des wiederherzustellenden Datensatzes füllt.<\/p>\n Listing 4: Wiederherstellen einer älteren Version eines Datensatzes<\/span><\/b><\/p>\n Das Ergebnis zeigt Bild 19. Hier wurde der unterste Datensatz wiederhergestellt, der nun wieder als erster Datensatz im Unterformular sfmArchivierteDatensaetze <\/b>auftaucht.<\/p>\n Bild 19: Archivierte Datensätze mit einem wiederhergestellten Datensatz<\/span><\/b><\/p>\n Gelöschte Datensätze wiederherstellen<\/b><\/p>\n Beim Wiederherstellen gelöschter Datensätze gibt es zunächst ein ganz anderes Problem: Wir benötigen erst einmal eine übersicht aller bereits gelöschten Datensätze. Legen wir also zunächst ein oder zwei neue Datensätze in der Tabelle tblKunden <\/b>an, die wir direkt wieder löschen oder erst nach dem Ausführen einiger änderungen. Die gelöschten Datensätze werden dann wie in Bild 20 in der Archivtabelle angezeigt.<\/p>\n Bild 20: Archivtabelle mit zwei gelöschten Datensätzen<\/span><\/b><\/p>\n Passend dazu kopieren wir nun das Formular frmArchivierteDatensaetze<\/b> in das Formular frmGeloeschteDatensaetze <\/b>(s. Bild 21). Die Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird, können Sie löschen. Das Unterformular sfmArchivierteDatensaetze <\/b>kopieren wir in das Unterformular sfmGeloeschteDatensaetze<\/b>.<\/p>\n Bild 21: Formular zur Anzeige der gelöschten Datensätze<\/span><\/b><\/p>\n Das Unterformular-Steuerelement sfmArchivierteDatensaetze <\/b>statten wir dementsprechend mit dem Namen sfmGeloeschteDatensaetze <\/b>aus und weisen diesem das entsprechende Unterformular als Herkunftsobjekt <\/b>zu. Die Datenherkunft passen wir wie in Bild 22 an, indem wir die Abfrage qryKundenArchiv<\/b> in die neue Abfrage qryKundenGeloescht <\/b>kopieren und dieser ein Kriterium für das Feld Aktion <\/b>zuweisen. Der Vergleichswert lautet „Geloescht“<\/b>, wodurch die Abfrage nur noch als gelöscht markierte Datensätze liefert.<\/p>\n Bild 22: Datenherkunft des Unterformulars sfmDatensaetzeGeloescht<\/span><\/b><\/p>\n Schließlich weist das Formular frmGeloeschteDatensaetze <\/b>zwei Schaltflächen auf. Die erste heißt cmdHistorieAnzeigen <\/b>und löst eine ähnliche Prozedur aus wie die gleichnamige Schaltfläche des Formulars frmKunden <\/b>(s. Listing 5). Diese öffnet das Formular frmArchivierteDatensaetze <\/b>und filtert es nach dem Wert des Feldes KundeID <\/b>für den betroffenen Datensatz.<\/p>\n Listing 5: Anzeigen eines gelöschten Datensatzes in der Archivansicht<\/span><\/b><\/p>\n Die zweite heißt cmdWiederherstellen<\/b> und löst die Prozedur aus Listing 6 aus. Die Prozedur führt eine INSERT INTO<\/b>-Anweisung aus, die alle Feldinhalte aus dem aktuell markierten Datensatz des Unterformulars sfmGeloeschteDatensaetze <\/b>in die Tabelle tblKunden <\/b>schreibt. Sie prüft, ob der Datensatz erfolgreich in die Ursprungstabelle eingetragen wurde und löscht in diesem Fall den entsprechenden Datensatz aus der Tabelle tblKundenArchiv<\/b>. Dies kann beispielsweise in dem Fall zu Problemen führen, wenn der Benutzer etwa den Datensatz mit dem Wert 7 <\/b>im Feld KundeID <\/b>löscht (wodurch dieser unter diesem Primärschlüsselwert in der Tabelle tblKundenArchiv <\/b>gespeichert wird), dann die Datenbank komprimiert und der Datensatz mit der Nummer 7 <\/b>zufällig der neueste Datensatz der Tabelle war. In diesem Fall wird ein neuer Datensatz in der Tabelle tblKunden <\/b>wiederum mit dem Wert 7 <\/b>im Feld KundeID <\/b>angelegt. Für diesen Fall müssten Sie der Prozedur noch eine entsprechende Variante hinzufügen, welche den wiederherzustellenden Datensatz unter einem anderen Primärschlüsselwert wiederherstellt.<\/p>\n Listing 6: Direktes Wiederherstellen eines gelöschten Datensatzes<\/span><\/b><\/p>\n Archivierung deaktivieren<\/b><\/p>\n Für verschiedene Zwecke kann es sinnvoll sein, die Archivierung zu deaktivieren. Dazu müssen Sie in allen beteiligten Makros eine entsprechende Abfrage eines Wertes etwa aus einer Optionentabelle integrieren, die beispielsweise tblOptionen <\/b>heißt und im Entwurf wie in Bild 23 aussieht. Wenn diese den Wert -1<\/b> enthält, soll keine Archivierung stattfinden. Damit der Wert des Feldes ArchivierungDeaktiviert <\/b>dieser Tabelle beim ändern oder Löschen eines Datensatzes der Tabelle tblKunden <\/b>abgefragt wird, müssen Sie den beiden Tabellenereignismakros, die durch die Ereignisse ![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_002.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_003.png\")
<\/p>\n![\"Makro,](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_004.png\")
<\/p>\n![\"Makro,](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_005.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_006.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_007.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_008.png\")
<\/p>\nAktion: Wenn(IstNull([GeaendertAm]);\"Gelöscht\";\"Geändert\")<\/pre>\n
Archivdatum: Wenn(IstNull([GeaendertAm]);[GeloeschtAm];[GeaendertAm])<\/pre>\n
![\"UNION-Abfrage\"](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_009.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_010.png\")
<\/p>\nSELECT 0 AS ArchivKundeID, \r\n''Aktuelle Version'' AS Aktion, \r\nNow AS Archivdatum, KundeID, \r\nAnredeID, Vorname, Nachname, Firma, Strasse, PLZ, Ort, Land\r\nFROM tblKunden \r\nWHERE KundeID = [prmKundeID];\r\nUNION SELECT ArchivKundeID, Aktion, \r\nArchivdatum, KundeID, AnredeID, \r\nVorname, Nachname, Firma, Strasse, \r\nPLZ, Ort, Land \r\nFROM qryKundenArchiv \r\nWHERE KundeID = [prmKundeID]\r\nORDER BY Archivdatum;<\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_011.png\")
<\/p>\n![\"Haupt-](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_012.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_013.png\")
<\/p>\nPrivate Sub <\/span>cmdHistorie_Click()\r\n DoCmd.OpenForm \"frmArchivierteDatensaetze\", OpenArgs:=Me!sfmArchivierteDatensaetze.Form!kundeID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>prm As <\/span>DAO.Parameter\r\n If <\/span>Not<\/span> IsNull(Me.OpenArgs) Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryKundenArchivUNION\")\r\n Set<\/span> prm = qdf.Parameters(\"prmKundeID\")\r\n prm.Value = Me.OpenArgs\r\n Set<\/span> rst = qdf.OpenRecordset\r\n Set<\/span> Me!sfmArchivierteDatensaetze.Form.Recordset = rst\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_014.png\")
<\/p>\nDomWert(\"Vorname\";\"tblKunden\";\"KundeID = \" & [KundeID])<\/pre>\n
![\"Erweiterung](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_015.png\")
<\/p>\nSELECT 0 AS ArchivKundeID, \r\n''Aktuelle Version'' AS Aktion, \r\n... , \r\n\"\" AS VorherigeVersionID \r\nFROM tblKunden \r\nWHERE KundeID = [prmKundeID]\r\nUNION \r\nSELECT ArchivKundeID, Aktion, ... , \r\nNz(DMin(\"ArchivKundeID\",\r\n\"tblKundenArchiv\",\r\n\"KundeID= \" & KundeID \r\n& \" AND ArchivKundeID > \" \r\n& ArchivKundeID),0) \r\nAS VorherigeVersionID\r\nFROM qryKundenArchiv \r\nWHERE KundeID = [prmKundeID]\r\nORDER BY Archivdatum DESC;<\/pre>\n
![\"Markierung](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_016.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_017.png\")
<\/p>\nNz(DomWert(\"Vorname\";\"qryKundenArchiv\";\r\n\"KundeID = \" & [KundeID] \r\n& \" AND ArchivKundeID = \" \r\n& [VorherigeVersionID]);\r\nDomWert(\"Vorname\";\"tblKunden\";\r\n\"KundeID = \" & [KundeID]))<\/pre>\n
Nz(DomWert(\"Firma\";\"qryKundenArchiv\";\r\n\"KundeID = \" & [KundeID] \r\n& \" AND ArchivKundeID = \" \r\n& [VorherigeVersionID]);\r\nDomWert(\"Firma\";\r\n\"tblKunden\";\r\n\"KundeID = \" & [KundeID]))<\/pre>\n
![\"Markierung](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_018.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n If <\/span>Not<\/span> IsNull(Me.OpenArgs) Then<\/span>\r\n ...\r\n BedingteFormatierung\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BedingteFormatierung()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strKriterium As String<\/span>\r\n Dim <\/span>objFormatCondition As <\/span>FormatCondition\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(\"tblKunden\")\r\n For Each ctl In Me!sfmArchivierteDatensaetze.Form.Controls\r\n On Error Resume Next<\/span>\r\n Set<\/span> fld = Nothing\r\n If <\/span>Len<\/span>(ctl.ControlSource) > 0 Then<\/span>\r\n Set<\/span> fld = tdf.Fields(ctl.ControlSource)\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> fld Is Nothing Then<\/span>\r\n Do While<\/span> ctl.FormatConditions.Count > 0\r\n ctl.FormatConditions(0).Delete\r\n Loop<\/span>\r\n strKriterium = \"Nz(DLookUp(\"\"\" & ctl.ControlSource & \"\"\",\"\"qryKundenArchiv\"\",\"\"KundeID = \"\" & [KundeID] _\r\n & \"\" AND ArchivKundeID = \"\" & [VorherigeVersionID]),DLookUp(\"\"\" & ctl.ControlSource _\r\n & \"\"\",\"\"tblKunden\"\",\"\"KundeID = \"\" & [KundeID]))\"\r\n Set<\/span> objFormatCondition = ctl.FormatConditions.Add(acFieldValue, acNotEqual, strKriterium)\r\n objFormatCondition.BackColor = &HFF\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdWiederherstellen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n With<\/span> Me!sfmArchivierteDatensaetze.Form\r\n db.Execute \"UPDATE tblKunden SET AnredeID = \" & !AnredeID & \", Vorname = ''\" _\r\n & !Vorname & \"'', Nachname = ''\" _\r\n & !Nachname & \"'', Firma = ''\" & !Firma & \"'', Strasse = ''\" & !Strasse & \"'', PLZ = ''\" _\r\n & !PLZ & \"'', Ort = ''\" & !Ort _\r\n & \"'', Land = ''\" & !Land & \"'' WHERE KundeID = \" & !KundeID, dbFailOnError\r\n Me!sfmArchivierteDatensaetze.Form.Requery\r\n End With<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Archivierte](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_019.png\")
<\/p>\n![\"Archivtabelle](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_020.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_021.png\")
<\/p>\n![\"Datenherkunft](\"..\/fileadmin\/_temp_\/2014_02\/pic_925_022.png\")
<\/p>\nPrivate Sub <\/span>cmdHistorieAnzeigen_Click()\r\n DoCmd.OpenForm \"frmArchivierteDatensaetze\", OpenArgs:=Me!sfmGeloeschteDatensaetze.Form!KundeID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdWiederherstellen_Click()\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>lngIDNeu As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n With<\/span> Me!sfmGeloeschteDatensaetze.Form\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblKunden SELECT KundeID, AnredeID, Vorname, " _\r\n "Nachname, Firma, Strasse, PLZ, Ort, Land \" _\r\n & \"FROM tblKundenArchiv WHERE KundeID = \" & !KundeID _\r\n & \" AND NOT GeloeschtAm IS NULL\", dbFailOnError\r\n On Error GoTo<\/span> 0\r\n If <\/span>db.RecordsAffected = 1 Then<\/span>\r\n lngIDNeu = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n If <\/span>lngIDNeu = !KundeID Then<\/span>\r\n db.Execute \"DELETE FROM tblKundenArchiv WHERE KundeID = \" & lngIDNeu, dbFailOnError\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Der Datensatz konnte nicht wiederherstellt werden.\"\r\n End If<\/span>\r\n Me!sfmGeloeschteDatensaetze.Form.Requery\r\n End With<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n