<\/p>\n
Bauen Sie sich ein Tool zum Vergleichen des Datenmodells verschiedener Versionen einer Datenbank.<\/p>\n
Tabellen, VBA<\/p>\n
Access 2000 und höher<\/p>\n
MDBComparer.mdb<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
„Mmmh… irgendwas stimmt nicht. Die Anwendung, die mir der Kunde gerade zurückgeschickt hat, lief doch eben noch Und jetzt – fehlende Parameter, nicht vorhandene Tabellen“ – Nun, so oder ähnlich sieht das aus, wenn der Anwender im Datenmodell wirkt und dann der Code nicht mehr passt. „Nicht, dass das Debugging allein schon nervend wäre – dann muss ich auch noch die kompletten Tabellen nach änderungen durchsuchen!“ Aber nicht mehr lange – ab jetzt vergleichen Sie die Tabellen und Felder zweier Datenbankversionen vollautomatisch!<\/b><\/p>\n
Im vorliegenden Beitrag lernen Sie ein Tool kennen, mit dem Sie die Unterschiede der Tabellen und Felder zweier Versionen einer Datenbank ermitteln können.<\/p>\n
Der MDB-Comparer soll helfen, die Datenstruktur zweier Access-Datenbanken zu vergleichen. Dazu gehören in dieser ersten Version die Tabellen und die enthaltenen Felder samt wichtigen Eigenschaften wie Datentypen und Feldgrößen. Um weitere wichtige Informationen wie Verknüpfungen zwischen den einzelnen Tabellen oder Indizes soll sich eine erweiterte Fassung der hier vorgestellten Lösung in einer der folgenden Ausgaben von Access im Unternehmen kümmern.<\/p>\n
Gerade noch liegt dem Autor eine Datenbank auf dem Tisch, deren Funktionen nicht mehr wie gewünscht arbeiten, weil der Besitzer die zugrunde liegenden Tabellen geändert hat. Was nun Am einfachsten wäre es wohl, einfach den durch die änderungen nicht mehr funktionierenden VBA-Code einfach einmal laufen zu lassen und diesen zu überarbeiten. Mit ein wenig Glück hängt es nur an einer Stelle; anderenfalls kann dies aber auch zu einem lang andauernden Hinterherfixen führen.<\/p>\n
Die Analyse der änderungen am Datenmodell macht auf jeden Fall Sinn: Vielleicht muss man ja gar nicht an den VBA-Code heran, sondern kann das Problem auf andere Weise umgehen Wenn die Daten wie im vorliegenden Fall aus verknüpften Tabellen stammen, kann man das Problem viel eleganter lösen: Man benennt einfach die Verknüpfungen um – etwa durch Anhängen eines Zeichens wie dem Unterstrich (_) – und erstellt eine Abfrage, die auf der geänderten Tabelle beruht und genauso heißt. Formulare, Berichte und VBA-Code merken es in den meisten Fällen nicht, wenn man diesen statt einer Tabelle eine Abfrage mit dem Namen der eigentlich verwendeten Tabelle präsentiert. Man muss nur den Aufbau der verwendeten Abfragen auf das der ursprünglich verwendeten Tabelle anpassen – im einfachsten Fall durch das Umbenennen von Tabellen- und\/oder Feldnamen.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Die komplette Benutzeroberfläche des MDB-Comparers<\/span><\/b><\/p>\n Und um zu erkennen, ob dies Sinn macht, muss man zuvor die änderungen an der Datenstruktur identifizieren.<\/p>\n Die Benutzeroberfläche der Anwendung besteht aus einem einzigen Formular. Dort gibt der Benutzer die Namen der beiden zu untersuchenden Datenbanken ein und klickt auf die Schaltfläche Vergleichen – fertig! Das Tool schreibt nun eine Textdatei auf die Festplatte und öffnet diese direkt im Anschluss mit Notepad.<\/p>\n Die Optionen des Formulars sind schnell erklärt: Das Kontrollkästchen „gleiches Verzeichnis wie oben“ sorgt dafür, dass beim öffnen des Datei öffnen-Dialogs direkt das Verzeichnis angezeigt wird, aus dem auch die erste Version der Datenbank stammt, und mit der Option Systemtabellen einbeziehen entscheidet man, ob man selbige ebenfalls vergleichen möchte.<\/p>\n Auch für den Bau einer scheinbar einfachen Anwendung wie dem MDB-Comparer sind einige sorgfältige Planungen notwendig. Sonst programmiert man einfach los und stellt irgendwann fest, dass man etwa eine Menge VBA-Code geschrieben hat, aber dieser so aussieht, dass man ihn nicht sinnvoll von einem Formular aus steuern und dessen Ergebnisse nicht in diesem darstellen kann.<\/p>\n Daher stellt man sich zunächst einen Plan zusammen, welche Aufgaben die Anwendung erledigen soll, welche Eingangswerte dafür erforderlich und welches Ergebnis die Anwendung liefern soll. Die Eingangswerte stehen schon fest: Dabei handelt es sich um die beiden zu vergleichenden Datenbanken. Zur Eingabe eigenen sich zwei Textfelder, gegebenenfalls um zwei Schaltflächen zum Aufrufen eines Datei öffnen-Dialogs ergänzt.<\/p>\n Bei den Ergebnissen sieht das schon anders aus: Wie sollen denn die Unterschiede in den Datenmodellen der beiden Datenbanken ausgegeben werden Sollen alle enthaltenen Informationen gegenübergestellt und die Unterschiede markiert werden, oder soll das Ergebnis nur die Unterschiede liefern Welche Unterschiede sind denn eigentlich zu erwarten Und wo soll das Ergebnis ausgegeben werden In einem Textfeld im gleichen Formular, das die Eingabe der zu vergleichenden Datenbanken ermöglicht Nun, wenn viele Unterschiede vorhanden sind, ist das in Abhängigkeit von der geplanten Größe des Formulars gegebenenfalls etwas unkomfortabel. Vielleicht kann man die Ergebnisse einfach in eine Textdatei schreiben, wie es auch Versionierungstools beim Vergleichen verschiedener Dateien tun Die Textdateien kann sich der Benutzer dann im Texteditor seiner Wahl ansehen und dessen Möglichkeiten wie etwa zum Durchsuchen der Datei voll ausschöpfen.<\/p>\n Wo Sie die Unterschiede ausgeben, spielt letzten Endes keine Rolle – die unterschiedlichen Techniken unterscheiden sich nur durch wenige Handgriffe voneinander.<\/p>\n Aber welche Unterschiede soll die Anwendung nun ausgeben und wie ermittelt man diese<\/p>\n Beginnen wir mit einer Liste der möglichen Unterschiede. Die Anwendung soll<\/p>\n ausgeben.<\/p>\n Dabei sollte man noch klären, inwieweit man versucht, Tabellen mit geänderten Tabellennamen oder Felder mit geänderten Feldnamen zu identifizieren oder ob man die jeweiligen Elemente als gelöscht und wieder hinzugefügt deklariert.<\/p>\n Hier spielen dann auch die zur Verfügung stehenden Techniken eine Rolle: Sicher sollte man für ein Tool wie dieses darauf verzichten, einen Algorithmus zu entwickeln, der prüft, ob eine Tabelle mit geändertem Namen neu ist oder nur eine neue Fassung einer bestehenden Tabelle – wer viel Zeit hat, kann sich sicher einmal mit diesem Thema befassen, aber an dieser Stelle soll mit wenig Aufwand ein brauchbares Tool zum Erkennen der Unterschiede zweier Versionen einer Datenbank her.<\/p>\n Unvermeidlich scheint, dass man zunächst die Elemente der einen Version der Datenbank durchläuft und schaut, ob die passenden Elemente in der zweiten Version der Datenbank ebenfalls enthalten sind und dies anschließend für die Elemente der zweiten Version wiederholt. Und wie das genau passiert, zeigt das folgende Kapitel.<\/p>\n Als Beispiel kommt wieder mal die Nordwind-Datenbank zum Zuge – wenn auch diesmal in zweifacher und vor allem unterschiedlicher Ausführung.<\/p>\n Die beiden Beispieldatenbanken heißen Nordwind_Alt.mdb und Nordwind_Neu.mdb, wobei die erstgenannte die Tabellen im Originalzustand enthält.<\/p>\n Die neuere Version enthält folgende änderungen, die der MDB-Comparer erkennen soll:<\/p>\n <\/b><\/p>\n Bild 2: Das Datenmodell der Beispieldatenbank<\/span><\/b><\/p>\n Das Datenmodell besteht aus zwei Tabellen, die die einzelnen Tabellen sowie die Felder und deren Eigenschaften speichern (siehe Bild 2). Zusätzlich dazu bekommt jede Tabelle zwei Felder, die angeben, in welcher der beiden Datenbankversionen die Tabelle beziehungsweise das Feld enthalten ist.<\/p>\n Die Tabellen speichern nicht das endgültige Ergebnis der Untersuchung, sondern lediglich die beim Untersuchen vorgefundenen Tabellen, Felder und deren Eigenschaften. Die Auswertung übernehmen die im nächsten Kapitel beschriebenen VBA-Prozeduren.<\/p>\n Die beiden Tabellen sind über das Fremdschlüsselfeld TabelleID miteinander verknüpft; für die Verknüpfung ist referentielle Integrität festgelegt. Außerdem stellt die Aktivierung der Löschweitergabe sicher, dass beim Löschen der Einträge der Tabelle tblTabellen auch die passenden Einträge der Tabelle tblFelder gelöscht werden.<\/p>\n <\/b><\/p>\n Bild 3: Ein aus mehreren Feldern zusammengesetzter eindeutiger Schlüssel<\/span><\/b><\/p>\n Damit die nachfolgend beschriebenen Routinen bereits vorhandene Elemente beim Einfügen identifizieren können, stellen Sie die Eigenschaft Indiziert des Feldes Tabellenname der Tabelle tblTabellen auf Ja (Ohne Duplikate) ein.<\/p>\n <\/p>\n Für die Tabelle tblFelder erzeugen Sie einen zusammengesetzten eindeutigen Schlüssel wie in Bild 3. Auf diese Weise markiert das Tool nur solche Felder als in beiden Versionen vorhanden, die wirklich exakt gleich sind. Wie dies genau ermittelt wird, erfahren Sie weiter unten.<\/p>\n Das Formular frmVergleichen dient als Benutzerschnittstelle zu den im Modul mdlCompare enthaltenen Funktionen. Hier gibt man die zu vergleichenden Datenbanken sowie zwei weitere Optionen ein und startet den Vorgang mit der passenden Schaltfläche.<\/p>\n Da der Schwerpunkt dieses Tools auf dem Vorgang zum Vergleichen der Tabellen und Felder zweier Datenbanken liegt, sollen die wenigen Funktionen des Formulars nicht in aller Länge beschrieben werden.<\/p>\n Wichtig ist allein, dass die Prozedur, die durch einen Klick auf die Schaltfläche cmdVergleichen ausgelöst wird, erst die in den Tabellen des MDB-Comparers enthaltenen Daten löscht, diese dann über die Routine Einlesen mit den aus den angegebenen Datenbanken gewonnen Informationen füllt und den Inhalt der Tabellen dann mit der Prozedur Auswertung analysiert und die Ergebnis in einer Textdatei speichert.<\/p>\n Die Untersuchung erfolgt in zwei Schritten: Im ersten Schritt liest der MDB-Comparer die benötigten Informationen über Tabellen und Felder der beiden Datenbanken ein und schreibt diese in die Datenbank, im zweiten Schritt analysiert das Tool die gewonnen Daten und gibt ein Ergebnis aus.<\/p>\n Quellcode 1: Modulkopf und die Steuerroutine für das Einlesen der Tabellen- und Feldinformationen der zu vergleichenden Datenbanken<\/b><\/p>\n Einlesen der Tabellen und Felder<\/b><\/p>\n Das Speichern der Tabellen und Felder samt Informationen in den zwei beschriebenen Tabellen erleichtert die anschließende Auswertung – erstens kostet das Einlesen von Informationen aus externen Datenbanken Zeit, die man möglichst nur einmal aufwenden sollte, und zweitens bereiten die nachfolgenden Routinen gleichzeitig die Daten für eine einfachere Untersuchung vor.<\/p>\n Quellcode 1 enthält den Kopf des Standardmoduls mdlCompare, das alle für das Vergleichen benötigten Routinen enthält, sowie die erste Routine namens Einlesen.<\/p>\n Diese Routine erzeugt Objektverweise des Typs Database auf die beiden zu vergleichenden Datenbanken und ruft die Routine TabellenAuflisten einmal für die alte und einmal für die neue Version der zu vergleichenden Datenbank auf.<\/p>\n Die Routine TabellenErfassen durchläuft alle Tabellen der per Parameter übergebenen Datenbank und schreibt diese in die Tabelle tblTabellen. Dazu durchläuft sie in einer For Each-Schleife alle TableDef-Objekte der zu erfassenden Datenbank und prüft dort zunächst, welchen Wert der Parameter bolSystemtabellen hat – ist dieser gleich False, dann soll die Routine die Systemtabellen nicht erfassen.<\/p>\n Innerhalb der Schleife versucht die Routine zunächst, einfach den Tabellennamen in die Tabelle tblTabellen zu schreiben und je nach der aktuell untersuchten Version das Feld Version_1 oder Version_2 auf den Wert True zu setzen. Damit markiert das Tool jeden Tabelleneintrag so, dass man bereits aus der Tabelle tblTabellen erkennen kann, ob eine Tabelle in der ersten, der zweiten oder gar beiden Versionen enthalten ist (siehe Bild 4).<\/p>\n Wenn eine Tabelle in der ersten und in der zweiten Version der Datenbank enthalten ist, wird die Routine TabellenErfassen für diese Tabelle zweimal durchlaufen: Beim ersten Mal legt die Routine einen Datensatz für diese Tabelle an, beim zweiten Durchlauf verursacht der Versuch, den Datensatz anzulegen, einen Fehler, weil schon ein Datensatz mit dem gleichen Tabellennamen vorhanden ist und das Feld mit den Tabellennamen keine Duplikate enthalten darf. Diesen Fehler fangen die folgenden Zeilen ab, die einfach eine UPDATE-Anweisung verwenden, um in dem bereits vorhandenen Datensatz den Wert des Feldes Version_2 auf True zu setzen.<\/p>\n Jeweils im Anschluss an das Anlegen oder Anpassen eines Datensatzes ruft die Routine die Prozedur auf, die alle Felder dieser Tabelle erfassen soll – dazu weiter unten mehr. Für die übrigen Zeilen der Routine TabellenErfassen ist nun nur wichtig, dass die Tabelle tblFelder die Felder der soeben untersuchten Tabelle enthält. Aus den Felddatensätzen einer Tabelle erzeugt die Routine nämlich nun eine Art Schlüssel: Sie durchläuft die Felder in alphabetischer Reihenfolge und hängt alle Informationen wie Name, Datentyp, Feldgröße und Standardwert hintereinander an eine Zeichenkette an, die dann als zusätzlicher Wert zu jeder Tabelle gespeichert wird.<\/p>\n <\/b><\/p>\n Bild 4: Die Tabelle tblTabellen speichert Informationen über die in den zu vergleichenden Datenbanken enthaltenen Tabellen.<\/span><\/b><\/p>\n Quellcode 2: Erfassen der Tabellen der zu vergleichenden Datenbanken<\/b><\/p>\n Wozu dies dient Nun, es kann ja sein, dass ein Benutzer eine Tabelle einfach nur umbenannt hat. In erster Instanz erkennt das Tool dann die alte Tabelle und die neue, umbenannte Version als zwei verschiedene Tabellen an, geht also davon aus, dass die alte Tabelle gelöscht und eine neue erzeugt wurde. Wenn aber alle Felder und sonstigen Informationen gleich sind, soll das Tool die änderung einfach als Umbenennung der Tabelle erkennen, was hiermit möglich ist.<\/p>\n Prinzipiell genauso wie die vorherige Routine funktioniert die Prozedur FelderErfassen (s. Quellcode 3). Sie schreibt zwar einige Infomationen mehr in die hier verwendete Tabelle tblFelder, aber auch hier sorgt eine Fehlerbehandlung dafür, dass beim Anfügen bereits vorhandener Felder kein neuer Datensatz, sondern nur ein passender Eintrag im Feld Version_2 vorgenommen wird. Verantwortlich ist dafür der oben erwähnte zusammengesetzte eindeutige Schlüssel. Das Ergebnis sieht etwa wie in Bild 5 aus.<\/p>\n <\/b><\/p>\n Bild 5: Erfassung der Felder einer Tabelle – hier mit je zwei entfernten und zwei neuen Feldern<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 6: Das Ergebnis eines Datenbankvergleichs<\/span><\/b><\/p>\n Quellcode 3: Erfassen der Felder der alten und der neuen Datenbankversion<\/b><\/p>\n Ermitteln der Unterschiede<\/b><\/p>\n Trotz guter Vorbereitung erfordert das Ermitteln und Ausgeben der Unterschiede immer noch eine Menge VBA-Code. Damit Sie selbst änderungen daran vornehmen können, drucken wie diesen dennoch komplett ab und beschreiben die Funktionsweise. Die Routine schreibt alle Ergebnisse in eine Textdatei namens Unterschiede.txt. Den Kopf bilden die Dateinamen der untersuchten Versionen inklusive Pfad.<\/p>\n Die vorangestellten Größer(>)- und Kleiner(<)-Zeichen dienen der Zuordnung der nachfolgenden Ergebnisse zu den beiden Datenbankversionen.<\/p>\n Quellcode 4: Die Routine „Auswertung“ ermittelt die Unterschiede zwischen den Tabellen zweier Datenbanken auf Basis der zuvor erzeugten Tabellen (erster Teil).<\/b><\/p>\n Damit Sie eine Vorstellung davon bekommen, was die Routine überhaupt tut, betrachten Sie einfach Abb. 6. Nach der Ausgabe der beteiligten Datenbanken folgen die Unterschiede zwischen den beteiligten Tabellen:<\/p>\n Zunächst diejenigen, bei denen sich nur einzelne Felder innerhalb einer Tabelle geändert haben, dann Tabellen, deren Namen sich geändert hat und schließlich komplett entfernte und hinzugefügte Tabellen.<\/p>\n An der mit [1] markierten Stelle beginnt im Quellcode 4 die Untersuchung der Tabellen, die in beiden Versionen enthalten sind. Die folgende Do While-Schleife durchläuft alle Tabellen, für die dies der Fall ist. In [2] öffnet die Routine eine Datensatzgruppe, die alle Felder dieser Tabelle enthält, die entweder in der einen oder der anderen Tabelle fehlen. Ist die Datensatzgruppe nicht leer, ist klar: Hier gibt es änderungen, also kann man den Tabellennamen in die Textdatei mit den Ergebnissen drucken. Fehlen also nur noch die eigentlichen Unterschiede. <\/p>\n Quellcode 5: Fortsetzung der Prozedur „Auswertung“<\/b><\/p>\n Um die kümmern sich dann die in der unter [3] zu findenden Do While-Schleife. Die Variable intCount wird mit der Anzahl der Datensätze der Tabelle tblFelder gefüllt, die das Feld mit dem aktuellen Namen enthalten – ist dieser Wert 2, dann gibt es für jede Version der Datenbank einen Eintrag und damit einen Unterschied bezüglich der Eigenschaften dieses Feldes [4].<\/p>\n Also gibt die Routine das Feld und dessen Eigenschaften aus der ersten Version und dann die passenden Informationen für die zweite Version aus. Dazu springt sie mit .MoveNext einfach einen Datensatz weiter.<\/p>\n Die Sortierung nach dem Feldnamen und der Version in [2] sorgt dafür, dass dabei auch der passende, zweite Datensatz angesprungen wird.<\/p>\n Gibt es keine zwei Versionen des gleichen Feldnamens in der Tabelle, ist das Feld entweder gelöscht oder hinzugefügt worden: Dies ermittelt man über den Wert des Feldes Version_1 der Datensatzgruppe. Ist dieser True, stammt das Feld aus der ersten Version und ist in der zweiten Version nicht mehr enthalten, ansonsten andersherum [5].<\/p>\n Auf diese Weise durchläuft die Routine alle Felddatensätze aller Tabellen und schreibt Ungereimtheiten in den Bericht.<\/p>\n Quellcode 5 zeigt den zweiten Teil dieser Prozedur. Der hier enthaltene Code untersucht noch die Tabellen, die nur in der ersten Version der Datenbank enthalten sind.<\/p>\n Ziel dieser Untersuchung ist es, herauszufinden, ob es möglicherweise zwei Tabellen unterschiedlichen Namens in den beiden Versionen der Datenbank gibt, die aber genau die gleichen Felder enthalten und damit gegebenenfalls nur umbenannt wurden.<\/p>\n Die Routine öffnet zunächst zwei Datensatzgruppen, von denen die erste alle Tabellen-Datensätze enthält, die nur in der ersten Version vorkommen, und die zweite nur diejenigen, die nur in der zweiten Version enthalten sind.<\/p>\n Dann vergleicht Sie jeden Datensatz der ersten mit jedem Datensatz der zweiten Tabelle und prüft, ob der Inhalt des Feldes Identifier gleich ist. Ist das der Fall, sind die Felder der Tabelle identisch und die Tabelle somit nur umbenannt worden. Anderenfalls scheint die Tabelle in der zweiten Version nicht mehr vorhanden zu sein. Beide Fälle ziehen einen entsprechenden Eintrag in der Ausgabedatei nach sich.<\/p>\n Zuletzt untersucht die Routine alle Tabellen, die nur in der zweiten, aber nicht in der ersten Version enthalten sind.<\/p>\n Damit die Tabellen, die bereits vorher als „umbenannt“ erkannt wurden, nicht erneut untersucht werden müssen, erhalten diese in der Tabelle tblTabellen den Wert True für das Feld Umbenannt.<\/p>\n Wenn die Ausführung des Codes einer neuen Version einer Datenbank einmal hakt, nachdem jemand änderungen an den zugrunde liegenden Tabellen vorgenommen hat, kann man die erfolgten änderungen mit dem hier vorgestellten Tool leicht entdecken.<\/p>\n Erweiterungspotential gibt es genug: Beim Vergleich der Felder betrachtet das Tool derzeit nur, ob ein Feld gleichen Namens sowohl in der ersten als auch in der zweiten Version der Datenbank enthalten ist, und schließt gegebenenfalls auf ein Entfernen oder Hinzufügen dieses Feldes.<\/p>\n Man könnte zusätzlich noch prüfen, ob Felder, die nur in einer Version vorkommen, zumindest gleiche Eigenschaften haben und dementsprechend einfach nur umbenannt worden sein können.<\/p>\n Schließlich könnte man den Vergleich auf die Verknüpfungen und Indizes ausdehnen, und auch die übrigen Datenbankobjekte könnte man dabei direkt mit untersuchen.<\/p>\n Für viele Anwendungen ist auch das Einbeziehen der MDW-Dateien wichtig – anderenfalls hätte das Tool keinen Zugriff auf geschützte Dateien. Sie sehen schon – die Geschichte ist noch nicht ausgestanden: Fortsetzung folgt!<\/p>\n Enthaltene Beispieldateien:<\/p>\n MDBComparer.mdb<\/p>\n Nordwind_Alt.mdb<\/p>\n Nordwind_Neu.mdb<\/p>\nDas Hauptformular der Anwendung<\/h3>\n
Ausgabe der Unterschiede<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic002.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic003.png\")
<\/p>\nOption Compare Database\r\nOption Explicit\r\nDim db As DAO.Database\r\nDim rstFelder As DAO.Recordset\r\nConst cstrLine = \"------------------------------------------\"\r\nPublic Function Einlesen(strDatenbankAlt As String, _ strDatenbankNeu As String, bolSystemtabellen As Boolean) _ As String\r\n Dim dbAlt As DAO.Database\r\n Dim dbNeu As DAO.Database\r\n Set db = CurrentDb\r\n Set dbAlt = DBEngine.OpenDatabase(strDatenbankAlt)\r\n Set dbNeu = DBEngine.OpenDatabase(strDatenbankNeu)\r\n TabellenErfassen dbAlt, bolSystemtabellen, 1\r\n TabellenErfassen dbNeu, bolSystemtabellen, 2\r\n Set db = Nothing\r\n Set dbAlt = Nothing\r\n Set dbNeu = Nothing\r\nEnd Function<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic004.png\")
<\/p>\nPrivate Sub TabellenErfassen(dbExtern As DAO.Database, bolSystemtabellen As Boolean, _ intVersion As Integer)\r\n Dim tdf As DAO.TableDef\r\n Dim lngTabelleID As Long\r\n Dim strIdentifier As String\r\n For Each tdf In dbExtern.TableDefs\r\n If Not (bolSystemtabellen = False And (tdf.Attributes And dbSystemObject) <> 0) Then\r\n On Error Resume Next\r\n db.Execute \"INSERT INTO tblTabellen(Tabellenname, Version_\" & intVersion _ & \") VALUES (''\" & tdf.Name & \"'', True)\", dbFailOnError\r\n If Err.Number = 3022 Then\r\n db.Execute \"UPDATE tblTabellen SET Version_\" & intVersion _ & \" = True WHERE Tabellenname = ''\" & tdf.Name & \"''\", dbFailOnError\r\n End If\r\n On Error GoTo 0\r\n lngTabelleID = DLookup(\"TabelleID\", \"tblTabellen\", \"Tabellenname = ''\" _ & tdf.Name & \"''\")\r\n FelderErfassen tdf, intVersion, lngTabelleID\r\n Set rstFelder = db.OpenRecordset(\"SELECT * FROM tblFelder WHERE TabelleID = \" _ & lngTabelleID & \" ORDER BY Feld\", dbOpenDynaset)\r\n strIdentifier = \"\"\r\n Do While Not rstFelder.EOF\r\n strIdentifier = strIdentifier & rstFelder!Feld & \"|\" & rstFelder!Datentyp _ & \"|\" & rstFelder!Feldgroesse & \"|\" & rstFelder!Standardwert & \"|\"\r\n rstFelder.MoveNext\r\n Loop\r\n db.Execute \"UPDATE tblTabellen SET Identifier = ''\" & strIdentifier _ & \"'' WHERE Tabellenname = ''\" & tdf.Name & \"''\", dbFailOnError\r\n End If\r\n Next tdf\r\nEnd Sub<\/pre>\n![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic005.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{1E265FCC-EA90-4466-A3C7-8596E9D018DF}\/pic006.png\")
<\/p>\nPrivate Sub FelderErfassen(tdf As DAO.TableDef, intVersion As Integer, lngTabelleID As Long)\r\n Dim fld As DAO.Field\r\n For Each fld In tdf.Fields\r\n On Error Resume Next\r\n db.Execute \"INSERT INTO tblFelder(TabelleID, Feld, Datentyp, Feldgroesse, \" _ & \"Standardwert, Version_\" & intVersion & \") VALUES(\" & lngTabelleID & \", ''\" _ & fld.Name & \"'', \" & fld.Type & \", \" & fld.Size & \", ''\" & fld.DefaultValue _ & \"'', True)\", dbFailOnError\r\n If Err.Number = 3022 Then\r\n db.Execute \"UPDATE tblFelder SET Version_\" & intVersion _ & \" = True WHERE TabelleID = \" & lngTabelleID & \" AND Feld = ''\" & fld.Name _ & \"''\", dbFailOnError\r\n End If\r\n On Error GoTo 0\r\n Next fld\r\nEnd Sub<\/pre>\n
Public Sub Auswertung(strDateiAlt As String, strDateiNeu As String)\r\n Dim intCount As Integer\r\n Dim rstT As DAO.Recordset\r\n Dim rstT1 As DAO.Recordset\r\n Dim rstT2 As DAO.Recordset\r\n Dim rstF As DAO.Recordset\r\n Dim rstF1 As DAO.Recordset\r\n Dim rstF2 As DAO.Recordset\r\n Dim bolLine As Boolean\r\n Dim i As Integer\r\n Dim bolUmbenannt As Boolean\r\n Open CurrentProject.Path & \"\\Unterschiede.txt\" For Output As #1\r\n Print #1, \"> Alte Datenbank: \" & strDateiAlt\r\n Print #1, \"< Neue Datenbank: \" & strDateiNeu\r\n Print #1, cstrLine\r\n Set db = CurrentDb\r\n[1] Set rstT = db.OpenRecordset(\"SELECT * FROM tblTabellen WHERE Version_1 = True \" _ & \"AND Version_2 = True\", dbOpenDynaset)\r\n Do While Not rstT.EOF\r\n ''Felder durchsuchen, die nicht in beiden Versionen enthalten sind\r\n[2] Set rstF = db.OpenRecordset(\"SELECT * FROM tblFelder WHERE TabelleID = \" _ & rstT!TabelleID & \" AND (Version_1 = False OR Version_2 = False) \" _ & \"ORDER BY Feld, Version_1\", dbOpenDynaset)\r\n If Not rstF.EOF Then\r\n Print #1, \"Tabelle: \" & rstT!Tabellenname\r\n Print #1, cstrLine\r\n End If\r\n[3] Do While Not rstF.EOF\r\n intCount = DCount(\"Feld\", \"tblFelder\", \"TabelleID = \" & rstT!TabelleID _ & \" AND Feld = ''\" & rstF!Feld & \"''\")\r\n[4] If intCount = 2 Then\r\n Print #1, \"> Feld: \" & rstF!Feld, GetDatentyp(rstF!Datentyp), _ rstF!Feldgroesse, rstF!Standardwert\r\n rstF.MoveNext\r\n Print #1, \"< Feld: \" & rstF!Feld, GetDatentyp(rstF!Datentyp), _ rstF!Feldgroesse, rstF!Standardwert\r\n Else\r\n[5] If rstF!Version_1 = True Then\r\n Print #1, \"> Feld: \" & rstF!Feld, GetDatentyp(rstF!Datentyp), _ rstF!Feldgroesse, rstF!Standardwert\r\n Print #1, \"< Feld: .\/.\"\r\n Else\r\n Print #1, \"> Feld: .\/.\"\r\n Print #1, \"< Feld: \" & rstF!Feld, GetDatentyp(rstF!Datentyp), _ rstF!Feldgroesse, rstF!Standardwert\r\n End If\r\n End If\r\n Print #1, cstrLine\r\n rstF.MoveNext\r\n Loop\r\n rstT.MoveNext\r\n Loop<\/pre>\n
''Tabellen durchsuchen, die nur in der ersten Version enthalten sind\r\n Set rstT1 = db.OpenRecordset(\"SELECT * FROM tblTabellen WHERE Version_1 = True \" _ & \"AND Version_2 = False\", dbOpenDynaset)\r\n Set rstT2 = db.OpenRecordset(\"SELECT * FROM tblTabellen WHERE Version_1 = False \" _ & \"AND Version_2 = True\", dbOpenDynaset)\r\n Do While Not rstT1.EOF\r\n bolUmbenannt = False\r\n If rstT2.EOF Then\r\n Print #1, \"Tabelle: \" & rstT1!Tabellenname & \" entfernt\"\r\n Print #1, cstrLine\r\n Else\r\n Do While Not rstT2.EOF\r\n If rstT1!Identifier = rstT2!Identifier Then\r\n Print #1, \"Tabelle: \" & rstT1!Tabellenname & \" umbenannt in \" _ & rstT2!Tabellenname\r\n db.Execute \"UPDATE tblTabellen SET Umbenannt = True WHERE TabelleID = \" _ & rstT2!TabelleID, dbFailOnError\r\n Print #1, cstrLine\r\n bolUmbenannt = True\r\n End If\r\n rstT2.MoveNext\r\n Loop\r\n If bolUmbenannt = False Then\r\n Print #1, \"Tabelle: \" & rstT1!Tabellenname & \" entfernt\"\r\n Print #1, cstrLine\r\n End If\r\n rstT2.MoveFirst\r\n End If\r\n rstT1.MoveNext\r\n Loop\r\n ''Tabellen durchsuchen, die nur in der zweiten Version enthalten sind\r\n rstT2.MoveFirst\r\n Do While Not rstT2.EOF\r\n rstT1.MoveFirst\r\n If rstT1.EOF Or (Not rstT1.EOF And rstT2!Umbenannt = False) Then\r\n Print #1, \"Tabelle: \" & rstT2!Tabellenname & \" hinzugefügt\"\r\n Print #1, cstrLine\r\n End If\r\n rstT2.MoveNext\r\n Loop\r\n Close #1\r\nEnd Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n