<\/p>\n
Die neuen Tabellenereignisse, die mit Access 2010 eingeführt wurden, erlauben die automatische Sicherung von Tabellendaten vor der Durchführung von änderungen an den Datensätzen. Dazu legen Sie entsprechende Datenmakros an, die durch die Tabellenereignisse ausgelöst werden. Außerdem benötigen Sie eine Tabelle, welche die geänderten Datensätze speichert. Wenn Sie beides für mehrere Tabellen durchführen wollen, ist dies eine Menge Handarbeit. Grund genug, diesen Vorgang zu automatisieren.<\/b><\/p>\n
Dazu eignet sich natürlich ein Access-Add-In am besten: Dieses können Sie in allen betroffenen Datenbanken starten und die Tabellen mit den zu sichernden Daten präparieren. Dazu soll die Tabelle zunächst kopiert und unter einem passenden Namen gespeichert werden – bei der Tabelle tblArtikel <\/b>beispielsweise unter dem Namen _tblArtikel_Backup<\/b>. Diese Tabelle soll zusätzlich noch zwei Felder enthalten, die das änderungsdatum oder das Löschdatum aufnehmen.<\/p>\n
Die Lösung setzt auf dem Beitrag Geänderte Daten archivieren <\/b>auf (www.access-im-unternehmen.de\/925<\/b>).<\/p>\nAussehen der Makros zum Erstellen des Backups<\/h2>\n
Das Makro für das Speichern der Daten der Tabelle etwa nach der Aktualisierung eines Datensatzes sieht wie in Bild 1 aus.<\/p>\n
![\"Aufbau](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_001.png\")
<\/p>\n
Bild 1: Aufbau des Makros zum Sichern der Daten vor dem Aktualisieren<\/span><\/b><\/p>\n Der erste Teil prüft, ob die Option zum Deaktivieren der Sicherung gegebenenfalls deaktiviert ist. Dazu muss eine Tabelle namens tblOptionen <\/b>vorhanden sein. Diese können Sie gegebenenfalls auch unter einem anderen Namen anlegen, da viele Anwendungen bereits über eine solche Tabelle verfügen.<\/p>\n Die folgenden Befehle erstellen einen neuen Datensatz in der jeweiligen Zieltabelle und stellen die Werte der Felder auf die Werte vor der änderung ein. Diese Werte liefert jeweils die Tabelle Alt<\/b>.<\/p>\n Schließlich weist das Makro dem Feld GeaendertAm <\/b>noch den änderungszeitpunkt zu.<\/p>\n Beim Löschen eines Datensatzes sieht es ähnlich aus – der einzige Unterschied besteht darin, dass der Löschzeitpunkt im Feld GeloeschtAm <\/b>gesichert wird.<\/p>\n Für das Sichern von Daten per Tabellenereignis gibt es eine Einschränkung bezüglich der Felddatentypen: Von der Sicherung sind nämlich sowohl Memofelder als auch Anlagefelder und mehrwertige Felder ausgeschlossen. Die Backup-Tabellen müssen diese Felder also gar nicht erst aufnehmen und auch das Tabellenereignis berücksichtigt diese nicht.<\/p>\n Ein weiteres Problem ist die automatische übersetzung des Makro-Codes. Wenn Access nämlich ein deutsches Literal erkennt, das in der englischen Version irgendeinem Access-Schlüsselwort entspricht, dann übersetzt Access dieses automatisch.<\/p>\n Sollten Sie also in einem Datenmakro den Feldnamen [Old].[Beschreibung] <\/b>verwenden, wird dieser in [Old].[Description] <\/b>geändert. Das ist unbefriedigend, aber außer durch Umgehung der entsprechenden Feldnamen wohl kaum zu lösen.<\/p>\n Das zu erstellende Add-In soll also folgende Aufgaben erledigen:<\/p>\n Das einzige Formular des Add-Ins dazu sieht wie in Bild 2 aus. Es bietet die folgenden Steuerelemente:<\/p>\n Bild 2: Add-In-Formular zum Anlegen von Sicherungstabellen und zum Generieren der benötigten Makros<\/span><\/b><\/p>\n Wenn Sie die Tabelle ausgewählt und die Schaltfläche Protokollierung einrichten <\/b>angeklickt haben, erhalten Sie die beiden benötigten Datenmakros mit den XML-Dokumenten aus den beiden unteren Textfeldern.<\/p>\n Diese können Sie zur Ansicht oder für Notfälle nutzen, falls das automatische Hinzufügen der Datenmakros zu den Tabellen nicht gelingt.<\/p>\n Und hier ist der Notfallplan: Wenn Sie beispielsweise die Datensätze der Tabelle tblAnreden <\/b>archivieren möchten, erhalten Sie mit der Konfiguration aus dem Screenshot eine neue Tabelle namens tblAnreden_Archiv<\/b>.<\/p>\n Kopieren Sie dann den Inhalt des Textfeldes mit dem Makro für den Fall der Aktualisierung in die Zwischenablage. öffnen Sie dann die Tabelle, hier tblAnreden<\/b>, beispielsweise in der Datenblattansicht.<\/p>\n Nun wählen Sie im Ribbon den Eintrag Tabelle|Nach-folge-er-eignisse|Nach Aktualisierung <\/b>aus (s. Bild 3). Es erscheint ein leeres Makro, das Sie nun einfach markieren und dann per Strg + C <\/b>den Inhalt der Zwischenablage einfügen.<\/p>\n Bild 3: Ribbon-Befehl zum Anzeigen des Datenmakros, das durch das Tabellenereignis Nach Aktualisierung ausgelöst wird<\/span><\/b><\/p>\n Und siehe da: Der Generator hat tatsächlich einen XML-Code zusammengestellt, der die benötigten Makrobefehle liefert (s. Bild 4).<\/p>\n Bild 4: Frisch eingefügtes Datenmakro<\/span><\/b><\/p>\n Auf die gleiche Weise gehen Sie nun noch für das Datenmakro Nach Löschung <\/b>vor. Damit haben Sie der Tabelle zwei Makros hinzugefügt, die dafür sorgen, dass die letzte Version eines Datensatzes vor einer änderung oder Löschung in der jeweiligen Archivtabelle, hier tblAnreden_Archiv<\/b>, gespeichert wird.<\/p>\n Aber, wie eingangs erwähnt: Normalerweise sollte das Add-In die Datenmakros automatisch hinzufügen.<\/p>\n Beim Testen des Add-Ins ist aufgefallen, dass es beim überschreiben vorhandener Datenmakros zu Problemen kommen kann. Wir sind so vorgegangen, dass wir den kompletten vorhandenen Inhalt des Datenmakros mit Strg + A <\/b>markiert und diesen dann durch Betätigen der Tastenkombination Strg + C <\/b>durch den Inhalt der Zwischenablage ersetzt haben. Zumindest haben wir das gedacht! Der Inhalt wurde nämlich mitnichten ersetzt, sondern blieb einfach an Ort und Stelle. Also gehen Sie beim Ersetzen des Inhalts eines Datenmakros einfach wie folgt vor: Markieren Sie den kompletten Inhalt mit Strg + A<\/b>, löschen Sie diesen und fügen dann den neuen Inhalt mit Strg + C <\/b>aus der Zwischenablage ein.<\/p>\n In den folgenden Abschnitten schauen wir uns die technischen Hintergründe des Add-Ins an. Dabei arbeiten wir uns anhand des Formulars und des oben beschriebenen Ablaufs vor.<\/p>\n Den Start macht dabei das Ereignis Beim Laden<\/b>, das die Ereignisprozedur aus Listing 1 auslöst. Sie ruft zunächst eine Funktion namens OptionentabelleFinden <\/b>auf und übergibt dieser einen Rückgabeparameter namens strOptionentabelle<\/b>, der modulweit wie folgt deklariert wird:<\/p>\n Listing 1: Diese Prozedur wird beim Laden des Formulars ausgelöst.<\/span><\/b><\/p>\n Die Funktion hat die Aufgabe, aus den Tabellen der Anwendung diejenige zu identifizieren, die vom Add-In als Optionentabelle definiert wurde. Diese wird nicht am Namen erkannt, sondern anhand einer speziell zu diesem Zweck zu der Tabelle hinzugefügten Eigenschaft namens Optionentabelle<\/b>. Die Funktion OptionentabelleFinden <\/b>schauen wir uns weiter unten an, zunächst reicht es uns zu wissen, dass diese Funktion die Variable strOptionentabelle <\/b>mit dem Namen der Tabelle füllt – oder aber den Wert False <\/b>als Funktionswert zurückliefert, wenn keine passende Tabelle vorhanden ist.<\/p>\n Liegt eine Optionentabelle vor, trägt die Prozedur ihren Namen in das Textfeld txtOptionentabelle <\/b>ein, anderenfalls fragt sie vom Benutzer per InputBox <\/b>den gewünschten Namen für die Optionentabelle ab. Damit ruft die Prozedur eine weitere Funktion namens OptionentabelleAnlegen <\/b>auf und übergibt dieser den Namen der anzulegenden Tabelle. Diese Funktion (siehe weiter unten) legt die Tabelle an und liefert im Erfolgsfall den Wert True <\/b>zurück.<\/p>\n Schließlich stellt die Prozedur die Eigenschaft Datensatzherkunft <\/b>für das Listenfeld lstTabellen <\/b>auf einen Wert ein, den die Funktion TabellenEinlesen <\/b>liefert. Das Ergebnis dieser Funktion ist eine kommaseparierte Liste der Tabellennamen der aktuellen Anwendung. Schließlich liest die Prozedur noch den aktuellen Ausdruck für die Erstellung der Archivtabellen aus dem Feld NameDerArchivtabelle <\/b>aus der Optionentabelle aus und trägt diesen in das Textfeld txtSicherungstabelle <\/b>ein.<\/p>\n In der Regel müssen Sie einer Anwendung immer erst eine Optionentabelle hinzufügen, sofern diese noch nicht vorhanden ist. Dies erledigt die Funktion OptionentabelleAnlegen<\/b> aus Listing 2. Diese erwartet den Namen der zu erstellenden Tabelle als Parameter. Die Funktion erstellt zunächst die Tabelle mit dem angegebenen Namen als neues TableDef<\/b>-Objekt und fügt dieser dann das Feld ArchivierungDeaktiviert <\/b>sowie das Feld NameDerArchivtabelle <\/b>hinzu. Dies geschieht in zwei Schritten – dem eigentlichen Erstellen mit der Methode CreateField <\/b>des TableDef<\/b>-Objekts und dem Anhängen an die Fields<\/b>-Auflistung der Tabelle. Danach hängt die Funktion die Tabelle selbst an die TableDefs<\/b>-Auflistung an.<\/p>\n <\/p>\n Listing 2: Anlegen der Optionentabelle<\/span><\/b><\/p>\n Damit das Add-In später auf irgendeine Weise die neu erstellte Optionentabelle identifizieren kann, fügen wir dieser noch eine benutzerdefinierte Eigenschaft hinzu. Dazu erstellt die Funktion mit der CreateProperty<\/b>-Funktion eine neue Property namens Optionentabelle <\/b>und stellt den Datentyp auf Boolean <\/b>ein. Danach hängt sie die Property <\/b>an die Properties<\/b>-Auflistung an. Die Refresh<\/b>-Methode aktualisiert die TableDefs<\/b>-Auflistung und die Methode RefreshDatabaseWindow <\/b>sorgt dafür, dass die neue Tabelle gleich im Navigationsbereich erscheint.<\/p>\n Schließlich fügt die Funktion direkt noch einen einzigen Datensatz zur Tabelle hinzu und stellt diesen auf den Wert False <\/b>ein. Die Tabelle sieht nun wie in Bild 5 aus.<\/p>\n Bild 5: Tabelle zum Speichern einer Option<\/span><\/b><\/p>\n Natürlich müssen wir dem Add-In auch eine Funktion hinzufügen, mit der dieses beim Starten prüfen kann, ob die benötigte Optionentabelle bereits vorhanden ist. Dies erledigt die Funktion OptionentabelleFinden<\/b> aus Listing 3. Diese erwartet ebenfalls einen Parameter namens strOptionentabelle<\/b>, dieser soll jedoch mit dem Namen der gefundenen Tabelle als Rückgabewert gefüllt werden. Außerdem gibt der Funktionswert selbst einen Boolean<\/b>-Wert zurück, der aussagt, ob eine Optionentabelle gefunden wurde.<\/p>\n Listing 3: Auffinden einer bereits vorhandenen Optionentabelle<\/span><\/b><\/p>\n Die Funktion OptionenTabelleFinden <\/b>durchläuft alle Tabellen der Datenbank und trägt bei deaktivierter Fehlerbehandlung den Wert der Property Optionentabelle <\/b>der aktuellen Tabelle in die Variable strTemp <\/b>ein. Löst dies einen Fehler aus, hat Err.Number <\/b>danach nicht mehr den Wert 0 <\/b>und es handelt sich nicht um die passende Tabelle. Erst wenn diese Eigenschaft für eine Tabelle gefunden werden konnte und somit Err.Number <\/b>den Wert 0 <\/b>aufweist, durchläuft die Funktion den Teil innerhalb der If…Then<\/b>-Bedingung. In diesem Fall stellt die Prozedur den Wert des Rückgabeparameters strOptionentabelle <\/b>auf den Namen der aktuell untersuchten Tabelle ein und legt als Rückgabewert der Funktion den Wert True <\/b>fest.<\/p>\n Außerdem wird die Funktion an dieser Stelle beendet, da die Optionentabelle ja hier gefunden wurde.<\/p>\n Zur Vervollständigung des Starts des Formulars fehlt noch die Funktion TabellenEinlesen<\/b>, die eine Liste der Tabellen der Host-Datenbank, von der aus Sie das Add-In starten, enthält. Diese Liste wird dann der Datensatzherkunft des Listenfeldes des Formulars zugewiesen.<\/p>\n Sie werden nun sicher fragen, warum man nicht einfach eine Abfrage auf Basis der Tabelle MSysObjects <\/b>erstellt. Die Frage ist leicht zu beantworten: Das Formular befindet sich ja in der Add-In-Datenbank und kann somit nur an Tabellen oder Abfragen dieser Datenbank gebunden werden – das Gleiche gilt natürlich auch für das Listenfeld. Daher müssen wir uns manuell an diese Aufgabe begeben.<\/p>\n Die Funktion aus Listing 4 füllt ein Database<\/b>-Objekt mit einem Verweis auf die Add-In-Datenbank, den wir mit der Funktion CodeDb <\/b>einlesen. Dann erstellt sie ein Recordset auf Basis der Tabelle MSysObjects<\/b>, das die Namen aller Tabellen liefert, die lokal vorliegen (das Feld Connect <\/b>hat den Wert Null<\/b>), die keine Systemtabelle sind (Name beginnt nicht mit MSys<\/b>) und die nicht als Hintergrundtabelle für Anlage- oder mehrwertige Felder dienen (Name beginnt nicht mit ~<\/b>) – all dies noch nach dem Feld Name <\/b>sortiert.<\/p>\n Listing 4: Einlesen der Tabellen der Host-Anwendung<\/span><\/b><\/p>\n Die folgende Do While<\/b>-Schleife durchläuft das Recordset und schreibt alle Tabellennamen durch Semikola getrennt in die Variable strTabellen<\/b>, die schließlich als Funktionswert zurückgegeben wird.<\/p>\n Damit können wir uns der Schaltfläche cmdProtokollierungEinrichten<\/b> zuwenden. Diese löst die Ereignisprozedur aus Listing 5 aus. Die Prozedur prüft zunächst, ob der Benutzer im Listenfeld lstTabellen <\/b>die zu behandelnde Tabelle ausgewählt hat und bricht die Prozedur im Zweifelsfall ab.<\/p>\n Listing 5: Einrichten der Archivtabelle<\/span><\/b><\/p>\n Anderenfalls liest sie den Namen der gewählten Tabelle in die Variable strTabelle <\/b>ein. Eine weitere Variable namens strTabelleNeu <\/b>füllt die Prozedur mit dem Namen der zu erstellenden Tabelle.<\/p>\n Dazu verwendet sie die Vorgabe aus der Optionentabelle, zum Beispiel [Tabelle]_Archiv<\/b>, und ersetzt hier [Tabelle]<\/b> durch den tatsächlichen Namen der zu archivierenden Tabelle. Im Falle der Tabelle tblAnreden <\/b>würde hier etwa tblAnreden_Archiv <\/b>herauskommen.<\/p>\n Danach versucht die Tabelle, ein TableDef<\/b>-Objekt auf Basis der zu erstellenden Tabelle zu referenzieren. Würde dies keinen Fehler auslösen, hieße das, dass die Tabelle bereits vorhanden ist. In diesem Fall gibt die Prozedur eine entsprechende Meldung aus.<\/p>\n Anderenfalls erstellt die Prozedur die Archivtabelle neu, indem sie die vorhandene Tabelle mit einer SELECT INTO<\/b>-Anweisung in eine neue Tabelle kopiert. Durch das Kriterium 1=2 <\/b>werden dabei keine Datensätze kopiert, sondern es wird nur die Tabellenstruktur angelegt. Die folgenden beiden Anweisungen aktualisieren die TableDefs<\/b>-Auflistung und den Navigationsbereich. Nun wird die TableDef<\/b>-Variable tdf <\/b>mit einem Verweis auf die neu erstellte Tabelle gefüllt, damit die Prozedur zwei weitere notwendige Felder hinzufügen kann, nämlich Geaendert-Am <\/b>und GeloeschtAm<\/b>.<\/p>\n Dazu verwendet sie jeweils zunächst die CreateField<\/b>-Methode des TableDef<\/b>-Objekts, um das so erstellte und mit fld <\/b>referenzierte Feld dann mit der Append<\/b>-Methode an die Fields<\/b>-Auflistung der Tabelle anzuhängen. Dies geschieht für beide Felder analog.<\/p>\n Nun folgt der interessante Teil: Die Funktion MakrosErstellen <\/b>erhält den Namen der alten und der neuen Tabelle sowie zwei weitere Parameter, die angeben, welche Makros erstellt werden sollen. Wenn das Nach Aktualisierung<\/b>-Makro erstellt werden soll, erhalten int1 <\/b>und int2 <\/b>jeweils den Wert 1<\/b>, für das Nach Löschung<\/b>-Makro erhalten beide Parameter den Wert 2<\/b>. Das Ergebnis des ersten Aufrufs mit dem Wert 1 <\/b>für int1 <\/b>und int2 <\/b>landet im Textfeld txtMakroAktualisierung<\/b>, das Ergebnis für den Wert 2 <\/b>für die beiden Parameter int1 <\/b>und int2 <\/b>im Textfeld txtMakroLoeschung<\/b>.<\/p>\n Das folgende Meldungsfenster fragt den Benutzer, ob die Datenmakros direkt in die Originaltabelle eingefügt werden sollen. Dies ist wichtig, weil die Tabellen ja immerhin auch bereits Datenmakros enthalten können. In diesem Fall könnten Sie das Datenmakro aus dem Textfeld kopieren, das Datenmakro der Tabelle öffnen und den Inhalt der Zwischenablage hinter dem vorhandenen Makro einfügen.<\/p>\n Wenn die Datenmakros direkt in die Tabelle eingefügt werden sollen, ruft die Prozedur wiederum die Prozedur MakrosErstellen <\/b>auf, diesmal aber mit dem Wert 1 <\/b>für den Parameter int1 <\/b>und den Wert 2 <\/b>für den Parameter int2<\/b>. Warum dies so ist, wird gleich bei der Beschreibung der Funktion MakrosErstellen <\/b>deutlich. Dann ruft die Prozedur die Routine MakroInZieldatenbank <\/b>auf und übergibt den Makro-Text sowie den Namen der Zieltabelle als Parameter. Diese Prozedur erläutern wir weiter unten.<\/p>\n Damit ist die Tabelle bereits mit den Makros ausgestattet und die Archivtabelle erstellt. Bei änderungen oder Löschungen in der Originaltabelle wird der ursprüngliche Datensatz nun direkt in die Archivtabelle geschrieben. Wichtig ist an dieser Stelle, das Verhalten einmal zu testen. Sollten die Datensätze nicht in der Zieltabelle erscheinen, klicken Sie im Ribbon auf Datei und dann auf Informationen. Dort sollte nun eine Schaltfläche namens Anwendungsprotokolltabelle anzeigen <\/b>erscheinen (s. Bild 6).<\/p>\n Bild 6: Schaltfläche zum öffnen der Anwendungsprotokolltabelle<\/span><\/b><\/p>\n Damit öffnen Sie die Tabelle aus Bild 7. Hier finden Sie eine Liste aller bisher aufgetretenen Fehler beim Ausführen von Datenmakros. Hier suchen Sie zunächst nach Einträgen, deren Feld SourceObjekt <\/b>den Namen der Tabelle plus dem Zusatz AfterUpdate <\/b>oder AfterDelete <\/b>enthält.<\/p>\n Bild 7: Protokollierung von Fehlern bei der Ausführung von Datenmakros<\/span><\/b><\/p>\n Hier erhalten Sie dann im Feld Description <\/b>Informationen über die aufgetretenen Fehler und können diese analysieren. Meist treten solche Fehler in Zusammenhang mit der Verwendung von Memo-, Anlage- oder mehrwertigen Feldern auf oder wenn Access die Feldnamen beim Interpretieren des Makros als übersetzung englischer Schlüsselwörter erkennt.<\/p>\n Die Funktion MakrosErstellen <\/b>stellt den XML-Code für die Datenmakros zusammen (s. Listing 6). Dabei gibt es verschiedene Varianten.<\/p>\n Listing 6: Zusammenstellen der Makros (Teil 1)<\/span><\/b><\/p>\n Im einfachsten Fall erstellt man ein XML-Dokument, das gleich beide Datenmakros für die Aktionen Nach Aktualisierung <\/b>und Nach Löschung <\/b>enthält. Es kann aber auch sein, dass die Tabelle bereits Datenmakros für die Tabellenereignisse enthält.<\/p>\n In diesem Fall sollen die Tabellenmakros nicht direkt in die Tabelle geschrieben werden, dass diese sonst die vorhandenen Makros überschreiben würden. Stattdessen sollen die Datenmakros für die Aktionen Nach Aktualisierung <\/b>und Nach Löschung <\/b>einzeln zusammengestellt und als XML-Dokumente in den beiden unteren Textfeldern des Formulars bereitgestellt werden, damit der Benutzer diese über die Zwischenablage zu den bestehenden Makros hinzufügen kann.<\/p>\n Nun hat die Funktion MakrosErstellen <\/b>ja diese ominösen beiden Parameter int1 <\/b>und int2<\/b>. Der Hintergrund ist einfach: Die XML-Dokumente bestehen jeweils aus einem Kopf, der wie folgt aussieht:<\/p>\n Danach folgen die Datenmakros: also entweder nur das Makro Nach Aktualisierung<\/b>, nur Nach Löschung <\/b>oder Nach Aktualisierung <\/b>und Nach Löschung<\/b>.<\/p>\n Der Teil für Nach Aktualisierung <\/b>sieht verkürzt so aus:<\/p>\n Und dies ist der Teil für Nach Löschung<\/b>:<\/p>\n Schließlich folgt der Fußteil des XML-Dokuments:<\/p>\n Sie sehen: die beiden Hauptelemente des XML-Dokuments sehen fast genau gleich aus. Daher wollen wir einige Zeilen Code sparen und haben um das Hinzufügen dieser Codezeilen eine For…Next<\/b>-Schleife aufgebaut. Diese läuft entweder von 1 <\/b>bis 1<\/b>, von 2 <\/b>bis 2 <\/b>oder von Einschränkungen<\/h2>\n
Deutsch-Englisch<\/h2>\n
Aufgaben des geplanten Add-Ins<\/h2>\n
\n
![\"Add-In-Formular](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_003.png\")
<\/p>\n\n
Datenmakros kopieren<\/h2>\n
![\"Ribbon-Befehl](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_004.png\")
<\/p>\n![\"Frisch](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_005.png\")
<\/p>\nAchtung: Ersetzen vorhandener Datenmakros<\/h2>\n
Technischer Hintergrund des Add-Ins<\/h2>\n
Private Sub <\/span>Form_Load()\r\n If <\/span>OptionentabelleFinden(strOptionentabelle) = True<\/span> Then<\/span>\r\n Me!txtOptionentabelle = strOptionentabelle\r\n Else<\/span>\r\n strOptionentabelle = \"tblOptionenArchiv\"\r\n strOptionentabelle = InputBox(\"Keine Optionentabelle gefunden. " _\r\n & "Geben Sie den Namen der zu erstellenden Tabelle ein.\", _\r\n \"Optionentabelle fehlt\", strOptionentabelle)\r\n If <\/span>Not<\/span> Len<\/span>(strOptionentabelle) = 0 Then<\/span>\r\n If <\/span>OptionentabelleAnlegen(strOptionentabelle) = True<\/span> Then<\/span>\r\n Me!txtOptionentabelle = strOptionentabelle\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Me!lstTabellen.RowSourceType = \"Value List\"\r\n Me!lstTabellen.RowSource = TabellenEinlesen\r\n Me!txtSicherungstabelle = DLookup(\"NameDerArchivtabelle\", strOptionentabelle)\r\nEnd Sub<\/span><\/pre>\nDim <\/span>strOptionentabelle As String<\/span><\/pre>\nOptionstabelle erstellen<\/h2>\n
Private Function <\/span>OptionentabelleAnlegen(strOptionentabelle As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.CreateTableDef(strOptionentabelle)\r\n Set<\/span> fld = tdf.CreateField(\"ArchivierungDeaktiviert\", dbBoolean)\r\n tdf.Fields.Append fld\r\n Set<\/span> fld = tdf.CreateField(\"NamederArchivtabelle\", dbText, 255)\r\n tdf.Fields.Append fld\r\n db.TableDefs.Append tdf\r\n Set<\/span> prp = tdf.CreateProperty(\"Optionentabelle\", dbBoolean, True<\/span>)\r\n tdf.Properties.Append prp\r\n db.TableDefs.Refresh\r\n Application.RefreshDatabaseWindow\r\n db.Execute \"INSERT INTO \" & strOptionentabelle _\r\n & \"(ArchivierungDeaktiviert, NameDerArchivTabelle) " _\r\n & "VALUES(0, ''[Tabelle]_Archiv'')\", dbFailOnError\r\n OptionentabelleAnlegen = True<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_002.png\")
<\/p>\nOptionentabelle auffinden<\/h2>\n
Private Function <\/span>OptionentabelleFinden(strOptionentabelle As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>bolOptionentabelle As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n On Error Resume Next<\/span>\r\n strTemp = tdf.Properties(\"Optionentabelle\").Name\r\n bolOptionentabelle = Err.Number = 0 And Not<\/span> (Left<\/span>(tdf.Name, 1) = \"~\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>bolOptionentabelle = True<\/span> Then<\/span>\r\n strOptionentabelle = tdf.Name\r\n OptionentabelleFinden = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Function<\/span><\/pre>\nTabellen der Host-Datenbank einlesen<\/h2>\n
Private Function <\/span>TabellenEinlesen() As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strTabellen As String<\/span>\r\n Set<\/span> db = CodeDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Name FROM MSysObjects WHERE Connect IS NULL " _\r\n & "And Not<\/span> Name LIKE ''~*'' And Not<\/span> Name LIKE ''MSys*'' ORDER BY Name\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strTabellen = strTabellen & rst!Name & \";\"\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n TabellenEinlesen = strTabellen\r\nEnd Function<\/span><\/pre>\nSicherungstabelle erstellen<\/h2>\n
Private Sub <\/span>cmdProtokollierungEinrichten_Click()\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>strTabelle As String<\/span>\r\n Dim <\/span>strTabelleNeu As String<\/span>\r\n Dim <\/span>strMakros As String<\/span>\r\n If <\/span>IsNull(Me!lstTabellen) Then<\/span>\r\n MsgBox<\/span> \"Wählen Sie eine Tabelle aus.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n strTabelle = Me!lstTabellen\r\n strTabelleNeu = Replace<\/span>(Me!txtSicherungstabelle, \"[Tabelle]\", strTabelle)\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n Set<\/span> tdf = db.TableDefs(strTabelleNeu)\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n MsgBox<\/span> \"Die Tabelle ''\" & strTabelleNeu & \"'' ist bereits vorhanden.\"\r\n Else<\/span>\r\n On Error GoTo<\/span> 0\r\n db.Execute \"SELECT * INTO \" & strTabelleNeu & \" FROM \" & strTabelle _\r\n & \" WHERE 1 = 2\", dbFailOnError\r\n db.TableDefs.Refresh\r\n Application.RefreshDatabaseWindow\r\n Set<\/span> tdf = db.TableDefs(strTabelleNeu)\r\n Set<\/span> fld = tdf.CreateField(\"GeaendertAm\", dbDate)\r\n tdf.Fields.Append fld\r\n Set<\/span> fld = tdf.CreateField(\"GeloeschtAm\", dbDate)\r\n tdf.Fields.Append fld\r\n End If<\/span>\r\n Me!txtMakroAktualisierung = MakrosErstellen(strTabelle, strTabelleNeu, 1, 1)\r\n Me!txtMakroLoeschung = MakrosErstellen(strTabelle, strTabelleNeu, 2, 2)\r\n If MsgBox<\/span>(\"Datenmakros in die Tabelle einfügen " _\r\n "Dies überschreibt bereits vorhandene Datenmakros.\", vbYesNo) = vbYes Then\r\n strMakros = MakrosErstellen(strTabelle, strTabelleNeu, 1, 2)\r\n MakrosInZieldatenbank strMakros, strTabelle\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Datenmakros können nun kopiert und zur Tabelle ''\" & strTabelle _\r\n & \"'' hinzugefügt werden.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_006.png\")
<\/p>\n![\"Protokollierung](\"..\/fileadmin\/_temp_\/2015_05\/pic_995_007.png\")
<\/p>\nMakro per VBA erstellen<\/h2>\n
Private Function <\/span>MakrosErstellen(strTabelle As String<\/span>, strTabelleNeu As String<\/span>, _\r\n int1 As Integer<\/span>, int2 As Integer<\/span>) As String<\/span>\r\n Dim <\/span>strMakro As String<\/span>\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>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(strTabelle)\r\n If <\/span>Len<\/span>(strOptionentabelle) = 0 Then<\/span>\r\n OptionentabelleFinden strOptionentabelle\r\n End If<\/span>\r\n strMakro = \"<xml version=\"\"1.0\"\" encoding=\"\"UTF-16\"\" standalone=\"\"no\"\">\"\r\n strMakro = strMakro & \"<DataMacros " _\r\n "xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/accessservices\/2009\/11\/application\"\">\"\r\n For i = int1 To int2\r\n If <\/span>i = 1 Then<\/span>\r\n strMakro = strMakro & \"<DataMacro Event=\"\"AfterUpdate\"\">\"\r\n Else<\/span>\r\n strMakro = strMakro & \"<DataMacro Event=\"\"AfterDelete\"\">\"\r\n End If<\/span>\r\n strMakro = strMakro & \"<Statements>\"\r\n strMakro = strMakro & \"<LookUpRecord>\"\r\n strMakro = strMakro & \"<Data>\"\r\n strMakro = strMakro & \"<Reference>\" & strOptionentabelle & \"<\/Reference>\"\r\n strMakro = strMakro & \"<\/Data>\"\r\n strMakro = strMakro & \"<Statements>\"\r\n strMakro = strMakro & \"<ConditionalBlock>\"\r\n strMakro = strMakro & \"<If>\"\r\n strMakro = strMakro & \"<Condition>[\" & strOptionentabelle _\r\n & \"].[ArchivierungDeaktiviert]=-1<\/Condition>\"\r\n strMakro = strMakro & \"<Statements>\"\r\n strMakro = strMakro & \"<Action Name=\"\"LogEvent\"\">\"\r\n strMakro = strMakro & \"<Argument Name=\"\"Description\"\">" _\r\n & "Archivierung deaktiviert<\/Argument>\"\r\n strMakro = strMakro & \"<\/Action>\"\r\n strMakro = strMakro & \"<Action Name=\"\"StopMacro\"\"\/>\"\r\n strMakro = strMakro & \"<\/Statements>\"\r\n strMakro = strMakro & \"<\/If>\"\r\n strMakro = strMakro & \"<\/ConditionalBlock>\"\r\n strMakro = strMakro & \"<\/Statements>\"\r\n strMakro = strMakro & \"<\/LookUpRecord>\"\r\n strMakro = strMakro & \"<CreateRecord>\"\r\n strMakro = strMakro & \"<Data>\"\r\n strMakro = strMakro & \"<Reference>\" & strTabelleNeu & \"<\/Reference>\"\r\n strMakro = strMakro & \"<\/Data>\"\r\n strMakro = strMakro & \"<Statements>\"<\/pre>\n<xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\">\r\n<DataMacros xmlns=\"http:\/\/schemas.microsoft.com\/office\/accessservices\/2009\/11\/application\"><\/pre>\n
<DataMacro Event=\"AfterUpdate\">\r\n <Statements>\r\n <LookUpRecord>\r\n ...\r\n <\/LookUpRecord>\r\n <CreateRecord>\r\n ...\r\n <\/CreateRecord>\r\n <\/Statements>\r\n<\/DataMacro><\/pre>\n
<DataMacro Event=\"AfterDelete\">\r\n <Statements>\r\n <LookUpRecord>\r\n ...\r\n <\/LookUpRecord>\r\n <CreateRecord>\r\n ...\r\n <\/CreateRecord>\r\n <\/Statements>\r\n<\/DataMacro><\/pre>\n
<\/DataMacros><\/pre>\n