Dies bedeutet, dass Sie eine Kopie der Anwendung anlegen müssen, deren Daten Sie dann anonymisieren und beispielsweise für die Weitergabe an einen externen Entwickler nutzen können.<\/p>\n
Achtung: SQL-Server-Datenbank<\/h2>\n
Besondere Vorsicht ist bei Verwendung des SQL Servers geboten. Hier reicht es nicht aus, einfach eine Kopie des Frontends zu machen, von dem aus wir das Access-Add-In zum Anonymisieren öffnen. Eine Kopie des Frontends verweist nämlich ohne weitere Änderungen auf die gleiche SQL Server-Datenbank wie das Original – zumindest, wenn wir keine weiteren Änderungen vornehmen. In diesem Fall muss also eine Kopie der SQL Server-Datenbank erstellt werden und das Frontend, von dem aus die Daten anonymisiert werden sollen, muss die Tabellen der Kopie einbinden.<\/p>\n
Neue Anonymisierungsarten<\/h2>\n
Wir haben drei neue Anonymisierungsarten hinzugefügt:<\/p>\n
- \n
- Die erste kann wie die bereits vorhandenen Methoden auf Textfelder angewendet werden. Sie trägt einfach einen immer gleichen Ausdruck ein und kombiniert diesen mit dem Primärschlüsselwert. Daraus entstehen Werte wie Artikel1<\/b>, Artikel2<\/b>, Artikel3 <\/b>und so weiter, die gegebenenfalls eine bessere Grundlage zum Nachvollziehen von Zusammenhängen liefern.<\/li>\n
- Die zweite neue Möglichkeit ist das Anonymisieren von Zahlenwerten. Hier bieten wir die Möglichkeit, für die neuen Werte eines Zahlenfeldes einen kleinsten und einen größten Wert sowie die Anzahl der Dezimalstellen festzulegen.<\/li>\n
- Die dritte Variante ist für Datumsfelder gedacht. Auch hier können wir einen Bereich für die einzufügenden Datumsangaben festlegen.<\/li>\n<\/ul>\n
amvDatenAnonymisieren installieren<\/h2>\n
Die Lösung finden Sie im Download unter dem Namen amvDatenAnonymisieren.accda<\/b>. Die Dateiendung deutet bereits darauf hin, dass es sich um ein Access-Add-In handelt.<\/p>\n
Dieses installieren wir, indem wir eine beliebige Access-Datenbank öffnen und den Ribbonbefehl Datenbanktools|Add-Ins|Add-Ins|Add-In-Manager<\/b> aufrufen.<\/p>\n
Hier klicken wir auf Neues hinzufügen… <\/b>und wählen im folgenden Dateidialog die .accda<\/b>-Datei aus. Danach schließen wir den Add-In-Manager. Beim erneuten Aufklappen des Add-In-Menüs sehen wir den neuen Eintrag amvDatenAnonymisieren <\/b>und können das Add-In durch Anklicken öffnen.<\/p>\n
Daten anonymisieren in der Praxis<\/h2>\n
Danach erscheint die Benutzeroberfläche des Add-Ins (siehe Bild 1). Hier sehen wir zunächst das Auswahlfeld Konfiguration<\/b>.<\/p>\n
![\"Der](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_001.png\")
<\/p>\nBild 1: Der Daten-Anonymisierer nach dem ersten Start<\/span><\/b><\/p>\n
Klicken wir es an, sehen wir einen weiteren Eintrag namens Neue Konfiguration<\/b> (siehe Bild 2). Wählen wir diesen aus, erscheint eine Inputbox, der wir den Namen der zu erstellenden Konfiguration übergeben können.<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_002.png\")
<\/p>\nBild 2: Anlegen einer neuen Konfiguration<\/span><\/b><\/p>\n
Für unsere Beispieldatenbank Südsturm.accda <\/b>geben wir hier beispielsweise den Namen Südsturm <\/b>ein. So können wir später leicht erkennen, welche Konfiguration wir für welche Datenbank angelegt haben.<\/p>\n
Nach dem Anlegen wird die neue Konfiguration automatisch selektiert und auch die Schaltfläche Tabellen und Felder einlesen <\/b>ist nun aktiviert (siehe Bild 3).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_016.png\")
<\/p>\nBild 3: Die neue Konfiguration wird nun aktiviert.<\/span><\/b><\/p>\n
Wenn wir diese betätigen, liest das Add-In alle Tabellen der aktuellen Datenbank mit Ausnahme derer, die mit MSys… <\/b>beginnen ein. Zuvor erscheint der Hinweis, dass alle bestehenden Daten für diese Konfiguration gelöscht und überschrieben werden.<\/p>\n
Wir sehen nun alle Tabellen der aktuellen Datenbank. Klappen wir einen der Einträge auf, sehen wir die enthaltenen Felder (siehe Bild 4).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_004.png\")
<\/p>\nBild 4: Die Tabellen und Felder der aktuellen Anwendung<\/span><\/b><\/p>\n
Hier können wir nun festlegen, welche Feldinhalte auf welche Art anonymisiert werden sollen.<\/p>\n
Wenn wir das Feld Artikelname <\/b>anonymisieren wollen, wählen wir beispielsweise den Eintrag Ausdruck plus PK-ID <\/b>aus (siehe Bild 5).<\/p>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_018.png\")
<\/p>\nBild 5: Auswahl einer der Anonymisierungsarten<\/span><\/b><\/p>\n
Danach wird für diesen Eintrag das Feld Wert1 <\/b>mit dem Namen des Feldes vorbelegt. Außerdem sehen wir im Infobereich unten im Formular Hinweise zu den Bedeutungen der Felder Wert1<\/b>, Wert2 <\/b>und Wert3 <\/b>(siehe Bild 6).<\/p>\n
![\"Informationen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_006.png\")
<\/p>\nBild 6: Informationen zur Anonymisierung<\/span><\/b><\/p>\n
Außerdem ändert sich auf der Ebene der Tabelle die Zahl in Klammern in der ersten Spalte. Diese gibt an, wie viele Felder mit Anonymisierungen versehen wurden. Auf diese Weise können wir auch bei zugeklappten Tabellen-Einträgen schnell erkennen, hinter welchem Eintrag sich Anonymisierungen befinden.<\/p>\n
Anonymisierung durchführen<\/h2>\n
Nun wird auch die Schaltfläche Anonymisieren <\/b>aktiviert. Wenn wir diese betätigen, erscheint eine Rückfrage, ob die Anonymisierung durchgeführt werden soll. Bestätigen wir dies, führt das Add-In den Auftrag aus und trägt für alle Datensätze der Tabelle tblArtikel <\/b>im Feld Artikel <\/b>die entsprechenden Werte ein.<\/p>\n
Anschließend können wir die Tabelle mit den anonymisierten Daten öffnen und sehen das Ergebnis aus Bild 7. Das Feld wurde mit den Werten Artikelname1<\/b>, Artikelname2 <\/b>und so weiter gefüllt.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_007.png\")
<\/p>\nBild 7: Tabelle mit anonymisierten Daten im Feld Artikel<\/span><\/b><\/p>\n
Anonymisieren von Zahlenfeldern<\/h2>\n
Als Nächstes wollen wir die Werte eines Zahlenfeldes anonymisieren. Hier bietet sich das Feld Einzelpreis <\/b>der Tabelle tblArtikel <\/b>an (siehe Bild 8).<\/p>\n
![\"Anonymisieren](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_008.png\")
<\/p>\nBild 8: Anonymisieren eines Zahlenfeldes<\/span><\/b><\/p>\n
Dazu wählen wir für dieses Feld den Eintrag Zufallszahl <\/b>aus. Die Werte sind wie folgt zu füllen:<\/p>\n
Wert1<\/b>: Kleinster Wert<\/p>\n
Wert2<\/b>: Größter Wert<\/p>\n
Wert3<\/b>: Nachkommastellen<\/p>\n
Die entsprechenden Hinweise werden wieder im unteren Bereich des Formulars eingeblendet.<\/p>\n
Hier legen wir fest, dass wir Preise im Bereich von 5 bis 20 EUR mit einer Nachkommastelle eintragen wollen.<\/p>\n
Wenn wir nun auf die Schaltfläche Anonymisieren <\/b>klicken, wird das Feld Artikelname <\/b>nochmals anonymisiert, allerdings mit den gleichen Werten wie zuvor. Wenn wir das nicht wollen, weil die Tabelle beispielsweise sehr viele Datensätze enthält und der Vorgang lange dauert, können wir den Haken vorn für die Zeile mit dem Feld Artikelname <\/b>entfernen.<\/p>\n
Anschließend starten wir die Anonymisierung und finden das Ergebnis aus Bild 9 vor.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_009.png\")
<\/p>\nBild 9: Tabelle mit anonymisierten Preisen<\/span><\/b><\/p>\n
Datum anonymisieren<\/h2>\n
Schließlich wollen wir noch ein Datumsfeld anonymisieren. Dazu bietet sich die Tabelle tblBestellungen <\/b>an.<\/p>\n
Hier wählen wir für das Feld Bestelldatum den Eintrag Zufallsdatum<\/b> aus und legen für die beiden Felder Wert1 <\/b>und Wert2 <\/b>das kleinste und das größte Datum fest (siehe Bild 10).<\/p>\n
![\"Anonymisieren](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_010.png\")
<\/p>\nBild 10: Anonymisieren von Datumsangaben<\/span><\/b><\/p>\n
Klicken wir nun auf Anonymisieren<\/b>, wird das Feld Bestelldatum <\/b>mit zufälligen Datumsangaben gefüllt.<\/p>\n
Beenden des Add-Ins<\/h2>\n
Wenn wir das Add-In nun schließen, bleibt die Konfiguration im Add-In gespeichert. Wir können es also später wieder aufrufen und die gespeicherte Konfiguration im Auswahlfeld oben selektieren.<\/p>\n
Dies lädt die bereits angelegte Konfiguration mit allen Tabellen, Feldern und Anonymisierungsparametern wieder in die Liste (siehe Bild 11).<\/p>\n
![\"Wiederherstellen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_011.png\")
<\/p>\nBild 11: Wiederherstellen eines Konfiguration<\/span><\/b><\/p>\n
Erweitern des Add-Ins um eigene Anonymisierungsfunktionen<\/h2>\n
Wir haben nur fünf Basisfunktionen für die Anonymisierung hinterlegt. Es gibt sicher Anwendungsfälle, in denen andere Funktionen erforderlich sind. Wie die Regeln definiert sind und wie Sie neue Funktionen anlegen können, schauen wir uns in den folgenden Abschnitten an. Dabei fügen wir auch gleich noch weitere Funktionen hinzu.<\/p>\n
Zum Hinzufügen einer Anonymisierungsfunktion sind folgende Schritte erforderlich:<\/p>\n
- \n
- Der erste ist das Anlegen eines neuen Eintrags in der Tabelle tblErsetzenMit<\/b>.<\/li>\n
- Der zweite ist das Hinzufügen der Anonymisierungsfunktion im Modul mdlAnonymisieren<\/b>.<\/li>\n
- Der dritte ist das Hinzufügen des Aufrufs der Anonymisierungsfunktion in der Prozedur cmdAnonymisieren_Click<\/b> im Modul Form_frmDatenAnonymisieren<\/b>.<\/li>\n<\/ul>\n
Wichtig: Immer direkt im Add-In programmieren<\/h2>\n
Wenn wir Änderungen an einem Add-In vornehmen wollen, müssen wir dazu immer direkt die .accda<\/b>-Datenbank öffnen. Was oft geschieht und verführerisch ist, sind VBA-Fehler beim produktiven Einsatz des Add-Ins, die man direkt an Ort und Stelle repariert. Bei der nächsten Nutzung wundert man sich dann, dass der Fehler wieder auftaucht und die Änderungen zur Behebung des Fehlers nicht gespeichert wurden.<\/p>\n
Das Problem ist, dass wir zwar VBA-Fehler im Code des Add-Ins bei der Verwendung von einer anderen Datenbankanwendung aus feststellen können, aber der Code des VBA-Projekts des Add-Ins ist zu diesem Zeitpunkt nicht speicherbar.<\/p>\n
Ein Workaround ist, die Fehlerbehebung gleich an Ort und Stelle durchzuführen, da man dies so gleich testen kann, und dann das Modul mit dem geänderten Code in die Zwischenablage zu kopieren, um es später im eigentlichen Add-In wieder einzufügen.<\/p>\n
Beispiel für eine neue Anonymisierungsfunktion<\/h2>\n
Wir wollen dem Add-In eine Funktion zum Anonymisieren von Ja\/Nein<\/b>-Feldern hinzufügen. Hier stehen nur zwei Werte zur Verfügung. Gibt es hier überhaupt Spielraum für den Einsatz der Parameter für die Anonymisierungen? Ja, denn wir können festlegen, mit welcher Wahrscheinlichkeit die Werte True <\/b>oder False <\/b>eingetragen werden sollen.<\/p>\n
Wir legen zunächst einen neuen Datensatz mit den Einstellungen für die Anonymisierung für Ja\/Nein<\/b>-Felder in der Tabelle tblErsetzenMit <\/b>an (siehe Bild 12).<\/p>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_012.png\")
<\/p>\nBild 12: Einstellungen für den Anonymisierungstyp Ja\/Nein<\/span><\/b><\/p>\n
Im Feld ErsetzenMit <\/b>tragen wir die Bezeichnung ein, die später im Auswahlfeld im Formular des Add-Ins erscheinen soll. Wir wollen zwei Parameter hinterlegen. Der erste gibt die Wahrscheinlichkeit für den Wert True <\/b>an, der zweite die Wahrscheinlichkeit für den Wert False<\/b>. Wir tragen auch gleich zwei Beispielwerte dafür ein, nämlich 50 <\/b>für das Feld Wert1 <\/b>und ebenfalls 50 <\/b>für das Feld Wert2<\/b>.<\/p>\n
Die Werte sollen immer ins Verhältnis gesetzt werden – wir können also auch 1 und 1 eintragen, wenn wir eine gleichmäßige Verteilung wünschen. Oder wir tragen 2 <\/b>und 1 <\/b>ein, wenn in zwei von drei Fällen True <\/b>gesetzt werden soll.<\/p>\n
Anonymisierungsfunktion programmieren<\/h2>\n
Im Modul mdlAnonymisierung <\/b>finden wir bereits die fünf Funktionen vor, mit denen die anderen Anonymisierungen durchgeführt werden. Hier legen wir eine neue Funktion namens JaNein <\/b>an.<\/p>\n
Diese nimmt per Parameter die beiden Werte lngJa <\/b>und lngNein <\/b>entgegen. In der Funktion ermitteln wir mit Rnd() <\/b>einen Zufallswert zwischen 0 <\/b>und 1<\/b>. Für diesen prüfen wir, ob er kleiner als der Wert von lngJa <\/b>durch die Summe der Werte lngJa <\/b>und lngNein <\/b>ist. <\/p>\n
Im Falle der Werte 1 <\/b>für lngJa <\/b>und 1 <\/b>für lngNein <\/b>prüfen wir also, ob Rnd() <\/b>kleiner als 0,5 <\/b>ist:<\/p>\n
Public Function <\/span>JaNein(lngJa As Long<\/span>, lngNein As Long<\/span>)\r\n Dim <\/span>bol As Boolean<\/span>\r\n bol = Rnd() < lngJa \/ (lngJa + lngNein)\r\n JaNein = bol\r\nEnd Function<\/span><\/pre>\nMit der folgenden Prozedur können wir diese Funktion testen:<\/p>\n
Public Function <\/span>Test_JaNein()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngAnzahlJa As Long<\/span>\r\n Dim <\/span>lngAnzahlNein As Long<\/span>\r\n For i = 1 To 10000\r\n If <\/span>JaNein(3, 1) = True<\/span> Then<\/span>\r\n lngAnzahlJa = lngAnzahlJa + 1\r\n Else<\/span>\r\n lngAnzahlNein = lngAnzahlNein + 1\r\n End If<\/span>\r\n Next<\/span> i\r\n Debug.Print<\/span> lngAnzahlJa, lngAnzahlNein\r\nEnd Function<\/span><\/pre>\nDabei rufen wir die Funktion 10.000 Mal auf und übergeben zum Beispiel die Werte 3 <\/b>und 1 <\/b>für die Parameter lngJa <\/b>und lngNein<\/b>.<\/p>\n
Jedes Mal, wenn die Funktion JaNein <\/b>den Wert True<\/b> zurückliefert, erhöhen wir den Wert der Variablen lngAnzahlJa <\/b>um eins, anderenfalls den Wert der Variablen lngAnzahlNein<\/b>. Anschließend geben wir die beiden Werte aus. Dabei erhalten wir beispielsweise ein Ergebnis wie dieses hier:<\/p>\n
7518 2482<\/pre>\n
Einbau des Aufrufs in die Prozedur cmdAnonymisieren_Click<\/h2>\n
Damit kommen wir zur Erläuterung der Prozedur, die den Anonymisierungsvorgang steuert und in die wir auch die Aufrufe weiterer Anonymisierungsfunktionen einfügen können (siehe Listing 1 ).<\/p>\n
Private Sub <\/span>cmdAnonymisieren_Click()\r\n Dim <\/span>dbc As <\/span>DAO.Database, dbAnonymisieren As <\/span>DAO.Database\r\n Dim <\/span>rstAnonymisieren As <\/span>DAO.Recordset, rstTabellen As <\/span>DAO.Recordset, rstFelder As <\/span>DAO.Recordset\r\n Dim <\/span>strPK As String<\/span>, strTabelle As String<\/span> \r\n If MsgBox<\/span>(\"Sicher, dass die Daten in dieser Datenbank anonymisiert werden sollen?\", vbYesNo + vbCr<\/span>itical, _\r\n \"Daten anomysieren\") = vbYes Then\r\n DoCmd.Hourglass True<\/span>\r\n Set<\/span> dbAnonymisieren = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> rstTabellen = dbc.OpenRecordset(\"SELECT DISTINCT tblTabellen.TabelleID, tblTabellen.Tabellenname \" _\r\n & \"FROM tblTabellen INNER JOIN tblFelder ON tblTabellen.TabelleID = tblFelder.TabelleID \" _\r\n & \"WHERE tblFelder.Anonymisieren = True\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstTabellen.EOF\r\n Set<\/span> rstFelder = dbc.OpenRecordset(\"SELECT * FROM tblFelder WHERE Anonymisieren = TRUE AND TabelleID = \" _\r\n & rstTabellen!TabelleID, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstFelder.EOF\r\n Set<\/span> rstAnonymisieren = dbAnonymisieren.OpenRecordset(\"SELECT * FROM \" & rstTabellen!Tabellenname, _\r\n dbOpenDynaset, dbSeeChanges)\r\n If <\/span>rstFelder!ErsetzenMitID = 3 Then<\/span>\r\n strTabelle = rstTabellen!Tabellenname\r\n strPK = PKErmitteln(dbAnonymisieren, strTabelle)\r\n End If<\/span>\r\n Do While<\/span> Not<\/span> rstAnonymisieren.EOF\r\n rstAnonymisieren.Edit\r\n Select Case rstFelder!ErsetzenMitID\r\n Case <\/span>1\r\n rstAnonymisieren(rstFelder!Feldname) = Zufallszeichenkette(rstFelder!Wert1, _\r\n rstFelder!Wert2, rstFelder!Wert3)\r\n Case <\/span>2\r\n rstAnonymisieren(rstFelder!Feldname) = BuchstabenVerfremden(Nz(rstAnonymisieren( _\r\n rstFelder!Feldname), \"\"))\r\n Case <\/span>3\r\n rstAnonymisieren(rstFelder!Feldname) = AusdruckPlusID(rstAnonymisieren.Fields(strPK), _\r\n rstFelder!Wert1)\r\n Case <\/span>4\r\n rstAnonymisieren(rstFelder!Feldname) = Zufallszahl(rstFelder!Wert1, rstFelder!Wert2, _\r\n rstFelder!Wert3)\r\n Case <\/span>5\r\n rstAnonymisieren(rstFelder!Feldname) = Zufallsdatum(rstFelder!Wert1, rstFelder!Wert2)\r\n Case <\/span>6\r\n rstAnonymisieren(rstFelder!Feldname) = JaNein(rstFelder!Wert1, rstFelder!Wert2)\r\n Case Else<\/span>\r\n Debug.Print<\/span> rstFelder!ErsetzenMitID\r\n End Select<\/span>\r\n rstAnonymisieren.Update\r\n rstAnonymisieren.MoveNext<\/span>\r\n Loop<\/span>\r\n rstFelder.MoveNext<\/span>\r\n Loop<\/span>\r\n rstTabellen.MoveNext<\/span>\r\n Loop<\/span>\r\n DoCmd.Hourglass False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 1: Prozedur zum Steuern der Anonymisierung<\/span><\/b><\/p>\n
Die Prozedur deklariert gleich zwei Variablen des Typs Database. Die erste namens dbc <\/b>benötigen wir für den Zugriff auf die Elemente der Add-In-Datenbank. Wir füllen sie mit der Funktion CodeDb<\/b>. Die zweite heißt dbAnonymisieren <\/b>und wird mit CurrentDb <\/b>gefüllt, damit sie die aktuell geöffneten Datenbank referenziert.<\/p>\n
Außerdem benötigen wir verschiedene Recordset<\/b>-Variablen. Die erste namens rstAnonymisieren <\/b>soll die Datensätze der Tabelle mit den zu anonymisierenden Daten aufnehmen. Das Recordset rstTabellen <\/b>nimmt die Datensätze der Tabelle tblTabellen <\/b>für die aktuelle Konfiguration auf, das Recordset rstFelder <\/b>füllen wir jeweils mit den Feldern der aktuell verarbeiteten Tabelle.<\/p>\n
Nach dem Bestätigen der Meldungsbox mit dem Hinweis, dass nun Daten in der Datenbank geändert werden, geht es mit dem Aktivieren der Sanduhr los. Dann weisen wir den beiden Database<\/b>-Variablen die Verweise auf die jeweilige Datenbank zu.<\/p>\n
Anschließend füllen wir das Recordset rstTabellen <\/b>mit allen Datensätzen der Tabelle tblTabellen<\/b>, die mindestens mit einem Datensatz der Tabelle tblFelder <\/b>verknüpft sind, dessen Feld Anonymisieren <\/b>auf True <\/b>eingestellt ist.<\/p>\n
Dieses Recordset durchlaufen wir in einer Do While<\/b>-Schleife. Innerhalb der Schleife füllen wir das Recordset rstFelder <\/b>mit allen Einträgen der Tabelle tblFelder<\/b>, die zur aktuellen Tabelle gehören.<\/p>\n
Auch diese durchlaufen wir in einer Do While<\/b>-Schleife.<\/p>\n
Nun holen wir uns ein Recordset auf Basis der zu anonymisierenden Tabelle, die wir aus rstTabellen <\/b>ermitteln.<\/p>\n
Sollte die Ersetzungsmethode mit dem Wert 3 <\/b>im Feld ErsetzenMitID <\/b>gewählt worden sein, schreiben wir den Namen der Tabelle in die Variable strTabelle <\/b>und ermitteln außerdem mit der Funktion PKErmitteln <\/b>den Namen des Primärschlüsselfeldes der Tabelle, den wir in die Variable strPK <\/b>eintragen.<\/p>\n
Danach durchlaufen wir alle Datensätze des Recordsets mit den zu anonymisierenden Daten und aktivieren mit der Edit-Methode den Bearbeitungsmodus.<\/p>\n
Nun ermitteln wir in einer Select Case<\/b>-Bedingung die zu verwendende Anonymisierungsmethode und weisen dem betroffenen Feld den Wert der Funktion zu, welcher der gewählten Methode entspricht – also beispielsweise Zufallszeichenkette <\/b>oder BuchstabenVerfremden<\/b>.<\/p>\n
An dieser Stelle fügen wir auch den sechsten Fall mit der Funktion JaNein <\/b>und den Parametern, die wir aus den Feldern Wert1 <\/b>und Wert2 <\/b>ermitteln.<\/p>\n
Danach aktualisieren wir den aktuellen Datensatz des Recordsets rstAnonymisieren <\/b>und fahren mit dem folgenden Datensatz vor.<\/p>\n
Sind alle Datensätze für dieses Feld in dieser Tabelle angepasst, gehen wir die übrigen Felder dieser Tabelle durch, für die Anonymisierungen geplant sind, und bearbeiten schließlich die übrigen Tabellen.<\/p>\n
Weitere Funktion zum Ermitteln zufälliger abhängiger Datumsangaben<\/h2>\n
Wenn wir beispielsweise Datumsangaben anonymisieren wollen und es sich dabei um mehrere Felder handelt, die voneinander abhängig sind, kommen wir allein mit der Funktion Zufallsdatum <\/b>nicht aus.<\/p>\n
Wenn wir beispielsweise Bestelldatum und Lieferdatum mit Werten füllen wollen, sollte das Lieferdatum immer nach dem Bestelldatum liegen.<\/p>\n
Wir könnten nun zwar für das Bestelldatum als Unter- und Obergrenze beispielsweise 1.1.2025 <\/b>und 30.6.2025 <\/b>sowie 1.7.2025 <\/b>und 31.12.2025 <\/b>eintragen. Aber wenn die Lieferdaten beispielsweise immer zwischen zwei und fünf Tagen hinter dem Bestelldatum liegen, schränkt uns diese Funktion allen zu sehr ein.<\/p>\n
Also entwickeln wir eine neue Funktion namens Abhängiges Zufallsdatum<\/b>. Dieses soll den Wert eines anderen Datumsfeldes als Referenz nutzen und dann Tage hinzuaddieren, die sich in einem bestimmten Bereich befinden, der mit dem zweiten und dritten Parameter angegeben wird.<\/p>\n
Zunächst bauen wir wieder den Eintrag in die Tabelle tblErsetzenMit <\/b>ein, der diesmal wie in Bild 13 aussieht.<\/p>\n
![\"Konfiguration](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_013.png\")
<\/p>\nBild 13: Konfiguration für abhängige Datumsangaben<\/span><\/b><\/p>\n
Danach fügen wir die Funktion aus Listing 2 zum Modul mdlAnonymisieren <\/b>hinzu. Die Funktion nimmt das Referenzdatum sowie den minimalen und den maximalen Abstand von diesem Datum entgegen.<\/p>\n
Public Function <\/span>AbhaengigesZufallsdatum(datReferenz As Date<\/span>, lngMindestabstand As Long<\/span>, lngMaximalabstand As Long<\/span>)\r\n Dim <\/span>lngAbstand As Long<\/span>\r\n Dim <\/span>dat As Date<\/span>\r\n lngAbstand = Fix(Rnd(Now) * (lngMaximalabstand + 1 - lngMindestabstand) + lngMindestabstand)\r\n dat = datReferenz + lngAbstand\r\n AbhaengigesZufallsdatum = dat\r\nEnd Function<\/span><\/pre>\nListing 2: Funktion von Ermitteln von Datumswerten abhängig von einem Referenzdatum<\/span><\/b><\/p>\n
Dann ermittelt sie einen zufälligen Abstand. Dieser wird zum Referenzdatum addiert und das Ergebnis zurückgegeben.<\/p>\n
Schließlich fügen wir der Select Case<\/b>-Bedingung der Prozedur cmdAnonymisieren_Click <\/b>noch einen Case<\/b>-Zweig hinzu, der diese Funktion aufruft (siehe Listing 3).<\/p>\n
Private Sub <\/span>cmdAnonymisieren_Click()\r\n ...\r\n Select Case rstFelder!ErsetzenMitID\r\n ... \r\n Case <\/span>7\r\n rstAnonymisieren(rstFelder!Feldname) = AbhaengigesZufallsdatum(rstAnonymisieren.Fields(rstFelder!Wert1), _\r\n rstFelder!Wert2, rstFelder!Wert3)\r\n End Select<\/span>\r\n ...\r\nEnd Sub<\/span><\/pre>\nListing 3: Anpassung der Prozedur cmdAnonymisieren_Click<\/span><\/b><\/p>\n
Abhängige Datumsangaben anonymisieren<\/h2>\n
Wenn wir nun in der Beispieldatenbank das Add-In öffnen, können wir die Untereinträge der Tabelle tblBestellungen <\/b>erweitern. Hier sehen wir das Feld Bestelldatum<\/b>, das wir bereits anonymisiert haben (siehe Bild 14).<\/p>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_019.png\")
<\/p>\nBild 14: Einstellungen zum Anonymisieren von Datumsfeldern<\/span><\/b><\/p>\n
Darunter sehen wir die beiden Felder Lieferdatum <\/b>und Versanddatum<\/b>. Das Lieferdatum soll ein oder zwei Tage nach dem Bestelldatum liegen, das Versanddatum weitere ein oder zwei Tage dahinter.<\/p>\n
Also wählen wir erst für das Feld Lieferdatum <\/b>den Eintrag Abhängiges Zufallsdatum <\/b>aus und geben als ersten Wert den Namen des Datumsfeldes an, das als Referenz verwendet werden soll. Für den zweiten und dritten Wert geben wir die minimale und die maximale Anzahl von Tagen nach diesem Datum an.<\/p>\n
Für das Feld Versanddatum <\/b>gehen wir genauso vor, nur dass wir nun das Feld Lieferdatum <\/b>als Referenzdatum verwenden.<\/p>\n
Wenn im Beispiel das Versanddatum mit dem Lieferdatum übereinstimmen soll, können wir auch einfach die Werte 0 <\/b>für Wert1 <\/b>und Wert2 <\/b>angeben.<\/p>\n
Wir können theoretisch auch festlegen, dass das Lieferdatum vor dem Versanddatum liegen soll. Dazu geben wir einfach negative Werte an, zum Beispiel -2 <\/b>und -1<\/b>. Wichtig ist nur, dass der zweite Wert größer als der erste ist, was hier der Fall ist.<\/p>\n
Eine Einschränkung an dieser Stelle ist, dass wir die Abhängigkeit nur in der Reihenfolge der Felder im Tabellenentwurf gestalten können. Wenn das Bestelldatum im Tabellenentwurf beispielsweise unter Lieferdatum und Versanddatum angelegt ist, könnten wir in einem ersten Schritt das Bestelldatum anonymisieren und in einem zweiten Schritt die beiden Felder Lieferdatum <\/b>und Versanddatum <\/b>bearbeiten.<\/p>\n
Dazu müssen wir lediglich sicherstellen, dass im zweiten Schritt der Haken vor dem Feld Bestelldatum <\/b>entfernt wird.<\/p>\n
Das Ergebnis sieht beispielsweise wie in Bild 15 aus.<\/p>\n
![\"Anonymisierte](\"..\/fileadmin\/_temp_\/2025_06\/pic_1579_015.png\")
<\/p>\n - Der zweite ist das Hinzufügen der Anonymisierungsfunktion im Modul mdlAnonymisieren<\/b>.<\/li>\n