{"id":55001112,"date":"2017-12-01T00:00:00","date_gmt":"2022-03-30T19:04:49","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1112"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Daten_anonymisieren","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Daten_anonymisieren\/","title":{"rendered":"Daten anonymisieren"},"content":{"rendered":"

\"\"<\/p>\n

Wenn ein potenzieller Kunde Sie um Unterstützung beim Programmieren oder Anpassen einer bestehenden Datenbank bittet, ist es am einfachsten, wenn diese Ihnen die Datenbank zum Analysieren zur Verfügung stellt. Das scheitert aber oft daran, dass der Kunde die Datenbank nicht herausgeben darf, weil die enthaltenen Daten nicht weitergegeben werden dürfen. Oft handelt es sich dabei um Adressdaten. Dieser Beitrag zeigt, wie Sie dem Kunden das Werkzeug bereitstellen, die enthaltenen Daten zu anonymisieren.<\/b><\/p>\n

Warum anonymisieren<\/h2>\n

Aber warum sollte man sich überhaupt die Mühe machen, die Daten zu anonymisieren Es wäre doch viel einfacher, einfach die Datenbank zu kopieren und die enthaltenen Daten vor der Weitergabe zu löschen. Klar, das geht viel schneller: Allerdings enthält die Datenbank dann auch keine Daten und der Entwickler – in diesem Fall Sie – oder der Kunde müssen manuell einige Testdatensätze eingeben. Und manchmal sollen ja gerade Performance-Probleme behoben werden. In diesem Fall ist es natürlich komplett abwegig, eine leere Datenbank an den Entwickler zu übergeben.<\/p>\n

Beides sind gute Anlässe, ein Tool zu programmieren, das den Kunden dabei unterstützt, die Datenbank in eine Form zu bringen, die keine nachvollziehbaren personenbezogenen Daten mehr enthält.<\/p>\n

Konkreter Anlass<\/h2>\n

Im konkreten Fall geht es viel weniger um die oben beschriebene Konstellation, als um die änderung der Personendaten zwecks Veröffentlichung der programmierten Lösung samt Beispieldaten zum Ausprobieren der Anwendung.<\/p>\n

Der erste Vorsitzende eines befreundeten Sportvereins ist nämlich mit einer Excel-Datei mit Mitgliedsdaten an mich herangetreten und hat mich gebeten, einmal eine vernünftige Mitgliederverwaltung zu programmieren, mit der die Daten nicht mehr in einer einzigen Excel-Tabelle verwaltet werden müssen, sondern die es auch noch ermöglicht, zusätzliche Auswertungen zu produzieren.<\/p>\n

Wenn ich Ihnen als Leser von Access im Unternehmen meine Umsetzung dieser Lösung darlegen möchte, muss ich also die Personendaten in dieser Excel-Tabelle vorher anonymisieren. Die Lösung mit der Umwandlung der Mitgliedsdatei in eine richtige Anwendung finden Sie übrigens unter dem Titel Vereinsverwaltung: Von Excel zum Datenmodell <\/b>(www.access-im-unternehmen.de\/1106<\/b>) in diesem Heft.<\/p>\n

Konzept für das Tool<\/h2>\n

Wie aber gestalten wir nun das Tool, mit dem wir die Personendaten anonymisieren wollen Normalerweise würde ich es als Add-In programmieren. Allerdings müsste der Kunde dann erst das Add-In installieren, was diesen möglicherweise überfordern könnte. Also gehen wir diesmal einen anderen Weg und programmieren eine eigene Access-Lösung, mit welcher der Kunde dann die betroffene Access-Anwendung auswählen soll. Im Formular dieser Lösung sollen dann die Tabellen der Ausgangsanwendung zur Auswahl angeboten werden. Für die Felder der gewählten Tabelle soll der Benutzer dann angeben, mit welchen Daten diese gefüllt werden sollen – also mit Vornamen, Nachnamen, Straßen, PLZ und Ort, Land und so weiter. Dann soll er per Mausklick den Anonymisierungsvorgang starten können, welcher dann eine Kopie der Datenbank erstellt und die enthaltenen Daten ändert.<\/p>\n

Das Tool erstellen<\/h2>\n

Als Tool legen wir also eine ganz normale Access-Datenbank an. Diese sollte beim öffnen möglichst gleich die enthaltene Funktion offenbaren, damit der Benutzer sich gleich zurechtfindet. In diesem Fall wäre dies das öffnen des Formulars, welches die Funktionen zum Auswählen der zu kopierenden und zu manipulierenden Datenbank enthält.<\/p>\n

Das Formular soll keine Datensätze anzeigen, also stellen wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>ein.<\/p>\n

Fügen Sie im oberen Bereich zwei Textfelder namens txtQuelldatei <\/b>und txtZieldatei <\/b>ein sowie zwei Schaltflächen namens cmdDateiauswahl <\/b>und cmdZieldateiFestlegen<\/b>. Diese ordnen Sie wie in Bild 1 an.<\/p>\n

\"Steuer-elemente<\/p>\n

Bild 1: Steuer-elemente zum Auswählen von Quell- und Zieldatei<\/span><\/b><\/p>\n

Für die Beim Klicken<\/b>-Ereigniseigenschaft hinterlegen wir jeweils eine entsprechende Ereignisprozedur. Ein Klick auf die Schaltfläche cmdDateiauswahl <\/b>löst die Prozedur cmdDateiauswahl_Click <\/b>aus Listing 1 aus. Diese verwendet die Funktion Openfilename<\/b>, die Sie im Modul mdlDateidialoge <\/b>finden. Sie übergibt der Funktion den aktuellen Datenbankpfad als Parameter und stellt die Access-Dateiendungen .mdb <\/b>und .accdb <\/b>als Filter ein.<\/p>\n

Private Sub <\/span>cmdDateiauswahl_Click()\r\n     Dim <\/span>strQuelldatei As String<\/span>\r\n     strQuelldatei = Openfilename(CurrentProject.Path, \"Quelldatei auswählen\", \"Access-DB (*.mdb;*.accdb)|Alle Dateien (*.*)\")\r\n     Me!txtQuelldatei = strQuelldatei\r\n     Me!txtZieldatei = VerzeichnisAusPfad(strQuelldatei) & \"\\\" & ZieldateiAusPfad(strQuelldatei)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdZieldateiFestlegen_Click()\r\n     Dim <\/span>strZieldatei As String<\/span>\r\n     Dim <\/span>strQuelldatei As String<\/span>\r\n     Dim <\/span>strZielverzeichnis As String<\/span>\r\n     strQuelldatei = Me!txtQuelldatei\r\n     If <\/span>Len<\/span>(Dir(strQuelldatei, vbDirectory)) > 0 Then<\/span>\r\n         strZieldatei = ZieldateiAusPfad(strQuelldatei)\r\n         strZielverzeichnis = VerzeichnisAusPfad(strQuelldatei)\r\n     End If<\/span>\r\n     strZieldatei = GetSaveFile(strZielverzeichnis, strZieldatei, \"Access-DB (*.mdb;*.accdb)|Alle Dateien (*.*)\", _\r\n         \"Zieldatei auswählen\")\r\n     Me!txtZieldatei = strZieldatei\r\nEnd Sub<\/span>\r\nPrivate Function <\/span>VerzeichnisAusPfad(strPfad As String<\/span>) As String<\/span>\r\n     Dim <\/span>strVerzeichnis As String<\/span>\r\n     strVerzeichnis = Left<\/span>(strPfad, InStrRev<\/span>(strPfad, \"\\\") - 1)\r\n     VerzeichnisAusPfad = strVerzeichnis\r\nEnd Function<\/span>\r\nPrivate Function <\/span>ZieldateiAusPfad(strPfad As String<\/span>) As String<\/span>\r\n     Dim <\/span>strZieldatei As String<\/span>\r\n     Dim <\/span>intPunkt As String<\/span>\r\n     strZieldatei = Mid<\/span>(strPfad, InStrRev<\/span>(strPfad, \"\\\") + 1)\r\n     intPunkt = InStrRev<\/span>(strZieldatei, \".\")\r\n     strZieldatei = Left<\/span>(strZieldatei, intPunkt - 1) & \"_Anonymisiert\" & Mid<\/span>(strZieldatei, intPunkt)\r\n     ZieldateiAusPfad = strZieldatei\r\nEnd Function<\/span><\/pre>\n
Listing 1: Prozeduren zum Auswählen von Quell- und Zieldatei<\/span><\/b><\/p>\n
Das Ergebnis dieses Dialogs speichert sie in der Variablen, deren Inhalt direkt an das Textfeld txtQuelldatei <\/b>weitergegeben wird. Außerdem ruft die Prozedur zwei weitere Hilfsfunktionen namens VerzeichnisAusPfad <\/b>und ZieldateiAusPfad <\/b>auf, welche sich ebenfalls im Klassenmodul des Formulars befinden und im Listing abgebildet sind.<\/p>\n
VerzeichnisAusPfad <\/b>erwartet einen kompletten Pfad, also beispielsweise die Angabe aus Bild 2 im oberen Textfeld. Es ermittelt die Position des hintersten Backslash und liefert die Zeichenkette bis zu dieser Position minus eins, damit der Backslash wegfällt.<\/p>\n
\"Auswählen<\/p>\n
Bild 2: Auswählen von Quell- und Zieldatei<\/span><\/b><\/p>\n
Die Funktion ZieldateiAusPfad <\/b>arbeitet etwas spezifischer und liefert nicht nur einfach den Dateinamen des hineingegebenen Pfades, sondern ergänzt diesen so, dass der Dateiname gut als die anonymisierte Version zu erkennen ist. Die Funktion ermittelt ebenfalls zunächst in einer Anweisung den Teil des mit strPfad <\/b>übergebenen Pfades, der sich hinter dem letzten Backslash in strPfad <\/b>befindet. Das Verzeichnis wird also vorn abgeschnitten. Dann ermittelt sie die Position des Punktes, also des Zeichens, das sich zwischen dem eigentlichen Dateinamen und der Dateiendung befindet. Der in der Variablen strZieldatei <\/b>zwischengespeicherte Ausdruck besteht dann aus dem Teil vor dem Punkt, dem Ausdruck _anonymisiert. <\/b>und der Dateiendung. Dieses automatische Füllen des Feldes txtZieldatei <\/b>ist eine Möglichkeit, dem Benutzer weitere Schritte abzunehmen, denn er braucht in den meisten Fällen nicht noch die Zieldatei auszuwählen.<\/p>\n
Möchte er dies dennoch tun, hat er natürlich die Möglichkeit dazu. Er braucht dann nur auf die Schaltfläche cmdZieldateiFestlegen <\/b>zu klicken, welche die Prozedur cmdZieldateiFestlegen_Click <\/b>auslöst. Diese liest den Wert des Feldes txtQuelldatei <\/b>in die Variable strQuelldatei <\/b>ein und prüft, ob dieser Ausdruck ein gültiges Verzeichnis enthält.<\/p>\n
In diesem Fall ermittelt die Prozedur über die Funktion ZieldateiAusPfad <\/b>einen Vorschlag für den Namen der Zieldatei und speichert diesen in der Variablen strZieldatei<\/b>. Das Zielverzeichnis wird über die Funktion VerzeichnisAusPfad <\/b>ermittelt und landet in der Variablen strZielverzeichnis<\/b>.<\/p>\n
Danach ruft die Prozedur über die Funktion GetSaveFile <\/b>einen Dialog auf, über den der Benutzer die Zieldatei festlegen soll. Hier wird auch klar, warum wir zuvor Zielverzeichnis und Zieldatei in zwei verschiedene Variablen geschrieben haben: Beim Aufruf dieser Funktion wird das Zielverzeichnis als beim öffnen anzuzeigendes Verzeichnis gewählt und der Name der Zieldatei wird unten im Dialog voreingestellt (s. Bild 3). Schließlich landet die hier ausgewählte Datei im Textfeld txtZieldatei<\/b>.<\/p>\n
\"Auswählen<\/p>\n
Bild 3: Auswählen der Zieldatei<\/span><\/b><\/p>\n
Datei kopieren<\/h2>\n
Wir haben ja avisiert, dass wir nicht in der vom Benutzer ausgewählten Datei herumspielen – es kann immerhin sein, dass der Benutzer zuvor keine Kopie anlegt und direkt eine Originaldatei zum anonymisieren auswählt. Also legen wir auf jeden Fall zuvor eine Kopie der Datenbank an, wozu wir die zuvor ermittelten Daten zur Quell- und Zieldatei nutzen. <\/p>\n
Wir legen direkt einmal eine Schaltfläche namens cmdAnonymisieren <\/b>im Formular an, auch wenn wir noch keine Steuer-elemente zum Einstellen der Anonymisierungsdetails hinzugefügt habe und diese Funktionalität noch fehlt. Allerdings ist das Kopieren der Datei der Grundstein, daher beginnen wir damit (s. Bild 4). Diese Schaltfläche löst nun die folgende Prozedur aus, welche wiederum eine Funktion zum Kopieren der Quelldatenbank in die Zieldatenbank aufruft. Sollte diese Funktion namens DateiKopieren <\/b>den Wert True <\/b>zurückliefern, soll der Inhalt der If…Then<\/b>-Bedingung ausgeführt werden:<\/p>\n
\"Schaltfläche<\/p>\n
Bild 4: Schaltfläche zum Start des Vorgangs<\/span><\/b><\/p>\n
Private Sub <\/span>cmdAnonymisieren_Click()\r\n     If <\/span>DateiKopieren(Me!txtQuelldatei, Me!txtZieldatei) Then<\/span>\r\n         ''''...anonymisieren\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Funktion zum Kopieren der Datenbank<\/h2>\n
Die dadurch aufgerufene Funktion DateiKopieren <\/b>finden sie in Listing 2. Die Funktion erwartet den Pfad der Quell- und der Zieldatenbank als Parameter. Das Kopieren gelingt nicht, wenn die Quelldatei geöffnet ist. Ob dies der Fall ist, ermitteln wir, indem wir nach einer Datei suchen, deren Dateiname auf .ldb <\/b>oder .laccdb <\/b>endet. Dies ist die Dateiendung der Datei, die beim öffnen einer Access-Datei angelegt wird. Ist eine solche Datei vorhanden, dann ist die Quelldatei offensichtlich geöffnet und kann nicht kopiert werden. Der Versuch, dies mit der FileCopy<\/b>-Funktion zu erledigen, würde sonst zum Auslösen des Fehlers mit der Nummer 70 <\/b>führen (Zugriff verweigert<\/b>). In diesem Fall gibt die Funktion eine entsprechende Meldung aus. Auch für die Zieldatei erfolgt eine entsprechende überprüfung. Ist die Quelldatenbank hingegen nicht geöffnet und die Zieldatenbank entweder nicht geöffnet oder nicht vorhanden, kopiert die Prozedur diese mit der FileCopy<\/b>-Methode, der Sie den Pfad zur Quell- und zur Zieldatei übergibt.<\/p>\n
Public Function <\/span>DateiKopieren(strQuelle As String<\/span>, strZiel As String<\/span>)\r\n     Dim <\/span>strQuelleTemp As String<\/span>\r\n     Dim <\/span>strZielTemp As String<\/span>\r\n     strQuelleTemp = Replace<\/span>(strQuelle, \".mdb\", \".ldb\")\r\n     strQuelleTemp = Replace<\/span>(strQuelleTemp, \".accdb\", \".laccdb\")\r\n     If <\/span>Len<\/span>(Dir(strQuelleTemp)) > 0 Then<\/span>\r\n         MsgBox<\/span> \"Die Quelldatei muss geschlossen sein.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     strZielTemp = Replace<\/span>(strZiel, \".mdb\", \".ldb\")\r\n     strZielTemp = Replace<\/span>(strZielTemp, \".accdb\", \".laccdb\")\r\n     If <\/span>Len<\/span>(Dir(strZielTemp)) > 0 Then<\/span>\r\n         MsgBox<\/span> \"Die Zieldatei muss geschlossen sein.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     FileCopy strQuelle, strZiel\r\n     If <\/span>Len<\/span>(Dir(strZiel)) > 0 Then<\/span>\r\n         DateiKopieren = True<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 2: Die Funktion zum Kopieren der Zieldatei in die Quelldatei<\/span><\/b><\/p>\n
Ist die Zieldatei anschließend im Dateisystem vorhanden, stellt die Funktion den Rückgabewert auf True <\/b>ein.<\/p>\n
Tabellen und Felder speichern<\/h2>\n
Wir wollen es dem Benutzer ermöglichen, alle zu ändernden Tabellen und Felder auf einen Streich zu definieren. Dazu muss er diese zunächst einlesen und wir müssen mit einem geeigneten Formular dafür sorgen, dass diese auch vom Benutzer bearbeitet werden können.<\/p>\n
Wir wollen also Informationen über die Tabellen und die darin enthaltenen Felder speichern. Dazu benötigen wir zwei Tabellen namens tblTabellen<\/b> und tblFelder<\/b>. Die erste sieht im Entwurf wie in Bild 5 aus.<\/p>\n
\"Entwurf<\/p>\n
Bild 5: Entwurf der Tabelle tblTabellen<\/span><\/b><\/p>\n
Sie enthält ein Primärschlüsselfeld, ein Feld mit dem Namen der Tabelle sowie ein Ja\/Nein<\/b>-Feld namens Anonymisieren<\/b>, mit der Benutzer festlegen kann, ob diese Tabelle komplett anonymisiert werden soll. Die zweite Tabelle namens tblFelder <\/b>enthält einige Felder mehr. Das liegt daran, dass hier die Details zum Anonymisieren der Inhalte gespeichert werden. Den Entwurf der Tabelle können Sie Bild 6 entnehmen. Neben den bereits aus der Tabelle tblTabellen <\/b>bekannten Feldern nutzen wir hier die folgenden Felder:<\/p>\n
\"Entwurf<\/p>\n
Bild 6: Entwurf der Tabelle tblFelder<\/span><\/b><\/p>\n