<\/p>\n
Es gibt verschiedene Gründe, um Kopien einer Datenbank anzulegen. Das Herstellen einer Sicherungskopie ist wohl der am meisten verbreitete Grund. Das ist sinnvoll, aber es kann dabei zu Problemen kommen, wenn man nicht achtsam ist: Dann arbeitet man auf einmal in der Sicherheitskopie weiter und wundert sich, wenn man anschließend die Originaldatenbank öffnet und die Funktionen, die man neu hinzuprogrammiert, nicht mehr findet. Oder man testet mit einer Datenbankdatei auf einer virtuellen Maschine und fügt dort Anpassungen hinzu. Auch hier kann es zu einem ähnlichen Durcheinander kommen. Um in einem solchen Fall die aktuelle Version zu finden, reicht es nicht, sich das Änderungsdatum der Datei anzusehen. Warum das nicht reicht und wie wir die aktuellere Datenbank zuverlässig finden, zeigen wir in diesem Beitrag.<\/b><\/p>\n
Die Ausgangssituation lässt sich auch wie folgt zusammenfassen: Uns liegen zwei Datenbankdateien gleichen Namens vor, von denen wir nicht mehr wissen, welche den aktuellsten Bearbeitungsstand aufweist. Und leider haben wir auch noch soeben beide Versionen geöffnet, um zu schauen, ob wir so herausfinden können, welche die aktuelle Version ist. Damit haben wir einen wichtigen Marker zerstört – nämlich das Änderungsdatum der Datei.<\/p>\n
Daran hätten wir zumindest erkennen können, welche Version wir zuletzt geöffnet haben. Allerdings wird bereits beim Öffnen einer Access-Anwendung das Änderungsdatum auf das aktuelle Datum eingestellt – wir brauchen dazu gar keine Änderungen am Entwurf oder an den Daten vorzunehmen.<\/p>\n
Nun haben wir also zwei verschiedene Versionen einer Datenbank vorliegen und benötigen Kriterien, um herauszufinden, an welcher wir zuletzt gearbeitet haben.<\/p>\n
Diese lauten beispielsweise wie folgt:<\/p>\n
Wenn wir diese Kriterien untersuchen, sollten wir annähernd herausfinden können, welche der beiden Datenbankdateien den aktuelleren Stand aufweist. Das ist zumindest dann der Fall, wenn wir nur an einer der beiden Änderungen seit einem bestimmten Zeitpunkt vorgenommen haben.<\/p>\n
Wenn wir die Datenbanken abwechselnd geöffnet und Änderungen an verschiedenen (oder sogar den gleichen) Stellen vorgenommen haben, ist das zwar unangenehm, weil wir die Änderungen dann zusammenführen müssen. Wir wissen dann aber zumindest, warum bestimmte Änderungen, von denen wir sicher waren, dass wir sie durchgeführt haben, nicht mehr vorhanden sind.<\/p>\n
Den Änderungszeitpunkt eines Objekts können wir neben dem Erstellungszeitpunkt über die Benutzeroberfläche von Access ermitteln. Dazu klicken wir mit der rechten Maustaste in die Titelleiste des Navigationsbereichs von Access und wählen dort den Eintrag Anzeigen nach|Details <\/b>aus. Danach sehen wir die gewünschten Informationen zu jedem Eintrag (siehe Bild 1).<\/p>\n
![\"Änderungszeitpunkt](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_001.png\")
<\/p>\n
Bild 1: Änderungszeitpunkt von Objekten ermitteln<\/span><\/b><\/p>\n Wenn wir Datenbanken mit so wenigen Objekten wie die aus dem Screenshot vergleichen wollen, brauchen wir dafür keine eigene Anwendung zu entwickeln. Aber in der Regel ist die Anzahl der enthaltenen Objekte größer und ein manueller Abgleich macht schnell keinen Spaß mehr.<\/p>\n Also machen wir uns auf die Suche nach dem Speicherort dieser Informationen und stoßen dabei schnell auf die Systemtabelle MSysObjects<\/b>. Systemtabellen wie diese sind standardmäßig ausgeblendet. Wir holen diese hervor, indem wir wieder mit der rechten Maustaste auf die Titelleiste des Navigationsbereichs klicken und nun den Eintrag Navigationsoptionen… <\/b>auswählen. Es erscheint der Dialog Navigationsoptionen<\/b>, wo wir im Bereich Anzeigeoptionen <\/b>die Optionen Ausgeblendete Objekte anzeigen <\/b>und Systemobjekte anzeigen <\/b>aktivieren.<\/p>\n Diese Tabelle liefert für alle Datenbankobjekte wie Tabellen, Abfragen, Formulare, Berichte, Makros und VBA-Module jeweils einen Eintrag (und für einige weitere Objekttypen, die hier nicht von Interesse sind). Dieser enthält neben dem Objekttyp und dem Namen auch zwei Felder namens DateCreated <\/b>und DateUpdated<\/b>. Damit haben wir bereits alle Informationen, die wir benötigen. Wir müssen sie nur noch zusammenführen und abgleichen.<\/p>\n Dazu erstellen wir eine neue Datenbank namens AktuellereDatenbankFinden.accdb<\/b>. In diese wollen wir zuerst die Tabelle MSysObjects <\/b>der beiden Versionen der Datenbank importieren. Dazu benötigen wir bereits ein Formular, denn wir wollen die Auswahl der Datenbankdateien so komfortabel wie möglich gestalten – in diesem Fall mit entsprechenden Dateiauswahl-Dialogen.<\/p>\n Nach der Auswahl der abzugleichenden Datenbanken wollen wir mit einer Schaltfläche einen Vorgang starten, bei dem die relevanten Daten für alle in den beiden Datenbanken enthaltenen Objekte in eine zusammenfassende Tabelle geschrieben werden.<\/p>\n Diese heißt tblObjekte <\/b>und ihr Entwurf sieht wie in Bild 2 aus. Neben dem Objektnamen speichern wir darin den Objekttyp sowie das Änderungsdatum für das Objekt in der ersten und in der zweiten Datenbank. Wenn das Objekt nur in einer der beiden Datenbanken vorhanden ist, schreiben wir das Datum nur in das entsprechende Feld.<\/p>\n Bild 2: Entwurf der Tabelle zum Speichern der Änderungsdaten der Objekte<\/span><\/b><\/p>\n Das Formular zur Auswahl der zu untersuchenden Dateien und zum Anzeigen der relevanten Daten legen wir unter dem Namen frmVergleichen <\/b>an. Diesem fügen wir zunächst zwei Textfelder namens txtVersion1 <\/b>und txtVersion2<\/b> hinzu. Daneben platzieren wir zwei Schaltflächen.<\/p>\n Diese statten wir jeweils mit einem Ordner-Icon aus und stellen die Eigenschaften Hintergrundart <\/b>und Rahmenart <\/b>auf Transparent<\/b> ein. Das Formular sieht anschließend wie in Bild 3 aus.<\/p>\n Bild 3: Felder zum Auswählen der zu vergleichenden Dateien<\/span><\/b><\/p>\n Für die Ereignisprozeduren der beiden Schaltflächen, die durch das Ereignis Beim Klicken <\/b>ausgelöst werden, hinterlegen wir die folgenden Prozeduren:<\/p>\n Beide nutzen die gleiche Funktion, um den Pfad zu der zu untersuchenden Datei zu ermitteln:<\/p>\n Um das FileDialog<\/b>-Objekt zu nutzen, benötigen wir einen Verweis auf die Bibliothek Microsoft Office 16.0 Object Library<\/b>, den wir mit dem Verweise<\/b>-Dialog aus Bild 4 hinzufügen (VBA-Editor, Menüeintrag Extras|Verweise<\/b>). Für die beiden Textfelder stellen wir die Eigenschaft Horizontaler Anker <\/b>auf Beide <\/b>ein, damit sich diese an die Formularbreite anpassen.<\/p>\n Bild 4: Hinzufügen eines Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n Bevor wir die Funktion zum Abgleichen der Unterschiede anlegen, fügen wir dem Formular ein Unterformular zum Anzeigen der Ergebnisse hinzu. Das Unterformular heißt sfmVergleichen <\/b>und verwendet die Tabelle tblObjekte <\/b>als Datensatzquelle. Wir fügen alle Felder dieser Tabelle zum Formular hinzu und stellen seine Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein (siehe Bild 5).<\/p>\n Bild 5: Unterformular der Anwendung<\/span><\/b><\/p>\n Danach fügen wir das Formular samt einer weiteren Schaltfläche namens cmdVergleichen <\/b>zum Hauptformular hinzu (siehe Bild 6). Für das hinzugefügte Unterformular stellen wir die beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf Beide <\/b>ein.<\/p>\n Bild 6: Das Hauptformular der Anwendung in der Entwurfsansicht<\/span><\/b><\/p>\n Im nächsten Schritt fügen wir der Schaltfläche cmdVergleichen<\/b> eine Prozedur für das Ereignis Beim Klicken <\/b>hinzu (siehe Listing 1).<\/p>\n Listing 1: Prozedur zum Abgleichen der Änderungsdaten der Objekt der zu untersuchenden Datenbanken<\/span><\/b><\/p>\n Hier führen wir zuerst einige Aufräumarbeiten durch. Wir leeren die Tabelle tblObjekte<\/b>, damit keine Daten aus vorherigen Untersuchungen mehr in der Tabelle sind. Außerdem löscht die Prozedur zwei Tabellen namens tblObjects1 <\/b>und tblObjects2<\/b>, die wir bisher noch gar nicht angelegt haben.<\/p>\n Genau aus diesem Grund erledigen wir diese Aufgabe auch bei deaktivierter eingebauter Fehlerbehandlung – der Versuch, eine nicht vorhandene Tabelle zu löschen, würde sonst einen Fehler auslösen.<\/p>\n Was aber sind das überhaupt für Tabellen? In diese kopieren wir die Daten der Systemtabellen namens MSysObjects <\/b>der zu untersuchenden Datenbanken. Das erledigen wir mit der Methode TransferDatabase <\/b>der DoCmd<\/b>-Klasse. Damit diese einen Import durchführt, übergeben wir als ersten Parameter den Wert acImport<\/b>. Der zweite Parameter gibt die Herkunftsanwendung der Daten an, der dritte den Typ des einzulesenden Objekts. Die letzten beiden Parameter legen fest, dass die Daten der Tabelle MSysObjects <\/b>in die Tabelle tblObjects1 <\/b>beziehungsweise tblObjects2 <\/b>eingelesen werden sollen. Dieser Befehl erstellt die Tabellen auf Basis der Quelltabelle neu.<\/p>\n Die folgenden Anweisungen legen die für den Abgleich der Änderungsdaten notwendigen Daten in der Tabelle tblObjekte <\/b>an. Dabei wollen wir nur die Datensätze der Tabelle MSysObjects <\/b>berücksichtigen, die eines der zu untersuchenden Objekte betreffen. Außerdem wollen wir Systemtabellen und temporäre Objekte oder im Hintergrund verwendete Objekte nicht berücksichtigen.<\/p>\n Dazu stellen wir ein Where<\/b>-Kriterium zusammen, das nur die Objekttypen 1<\/b>, 4<\/b>, 5<\/b>, 6<\/b>, -32761<\/b>, -32764<\/b>, -32766 <\/b>und -32768 <\/b>berücksichtigt (mehr dazu weiter unten) und einige Objekte aufgrund ihres Objektnamens ausschließt (f_*<\/b>, MSys*<\/b> oder ~*<\/b>).<\/p>\n Nun beginnen wir mit dem Einlesen der Daten aus der ersten zu untersuchenden Datenbank. Dazu erstellen wir ein Recordset auf Basis der Tabelle tblObjects1<\/b>, welches das Kriterium aus strWhere <\/b>berücksichtigt. Das Recordset enthält also nur die Objekte der Datenbank, die wir untersuchen wollen. Anschließend durchlaufen wir die Elemente des Recordsets in einer Do While<\/b>-Schleife. Dabei rufen wir als Erstes eine Funktion namens ObjekttypErmitteln <\/b>auf, der wir den Wert des Feldes Type <\/b>übergeben. Die Funktion untersucht diesen Wert in einer Select Case<\/b>-Bedingung und liefert einen Text zurück, welcher dem angegebenen Zahlenwert entspricht – bei dem Wert 1 <\/b>beispielsweise den Text Tabelle<\/b>:<\/p>\n Damit ausgestattet rufen wir die Execute<\/b>-Methode des Database<\/b>-Objekts der aktuellen Datenbank auf und übergeben dieser eine INSERT INTO<\/b>-Anweisung, mit der wir einen neuen Datensatz zur Tabelle tblObjekte <\/b>hinzufügen.<\/p>\n Dieser trägt die Werte für die Felder Objektname<\/b>, Objekttyp <\/b>und Geaendert1 <\/b>ein, also das Änderungsdatum für das Objekt aus der ersten zu untersuchenden Datenbank.<\/p>\n Nach dem Durchlaufen der ersten Schleife sieht die Tabelle wie in Bild 7 aus. Für jedes relevante Objekt wurde ein Eintrag angelegt. Lediglich das Änderungsdatum für das gleichnamige Objekt in der zweiten zu untersuchenden Datenbank ist noch nicht vorhanden.<\/p>\n Bild 7: Die Tabelle tblObjekte nach dem Untersuchen der ersten Datenbank<\/span><\/b><\/p>\n Dieses fügen wir nun hinzu. Dazu erstellen wir ein weiteres Recordset, das nun die Datensätze der Tabelle tblObjects2 <\/b>mit den Daten aus der zweiten zu untersuchenden Datenbank enthält.<\/p>\n Während wir die Datensätze dieses Recordsets durchlaufen, ermitteln wir per DLookup <\/b>den Primärschlüsselwert eines eventuell bereits vorhandenen Datensatzes für das aktuelle Objekt in der Tabelle tblObjekte<\/b>. Hat lngObjektID <\/b>anschließend den Wert 0<\/b>, handelt es sich hierbei um ein Objekt, das nur in der zweiten, nicht aber in der ersten zu untersuchenden Datenbank vorhanden ist.<\/p>\n In diesem Fall legen wir einen neuen Datensatz in der Tabelle tblObjekte <\/b>an, für den wir lediglich das Datum im Feld Geaendert2 <\/b>eintragen – das Feld Geaendert1 <\/b>bleibt leer. Ist lngObjektID <\/b>nicht 0<\/b>, ist das Objekt bereits in der Tabelle tblObjekte <\/b>vorhanden und wir brauchen nur per UPDATE<\/b>-Abfrage das Datum im Feld Geaendert2 <\/b>zu ergänzen.<\/p>\n Nachdem wir so alle Objekte der beiden zu untersuchenden Datenbanken und ihre Änderungsdaten eingetragen haben, brauchen wir nur noch das Unterformular mit dem Inhalt der Tabelle tblObjekte <\/b>zu aktualisieren.<\/p>\n Schauen wir uns nun das Ergebnis an, sehen wir, dass alle Daten wie gewünschte eingetragen wurden (siehe Bild 8). Allerdings können wir nicht besonders gut erkennen, ob irgendein Objekt in der einen oder anderen Datenbank ein aktuelleres Änderungsdatum aufweist. Das wird bei einer größeren Anzahl von Objekten nur noch schwieriger. Also passen wir das Unterformular noch so an, dass wir die Unterschiede besser erkennen können.<\/p>\n Bild 8: Anzeige der Änderungsdaten im Formular<\/span><\/b><\/p>\n Dazu bietet sich der Einsatz der bedingten Formatierung an. Dazu zeigen wir das Formular in der Formularansicht an und klicken in die Datenblattansicht des Unterformulars. Im Ribbon finden wir nun unter Formulardatenblatt <\/b>den Eintrag Formatierung|Bedingte Formatierung<\/b>.<\/p>\n Klicken wir diesen Befehl an, nachdem wir das Feld Geaendert1 <\/b>markiert haben, erscheint der Dialog Manager für Regeln zur bedingten Formatierung<\/b> und zeigt unter Formatierungsregeln anzeigen für:<\/b> direkt das gewünschte Feld an (siehe Bild 9).<\/p>\n Bild 9: Der Manager für die bedingte Formatierung<\/span><\/b><\/p>\n Hier klicken wir auf Neue Regel <\/b>und führen im Dialog Neue Formatierungsregel <\/b>die folgenden Schritte durch:<\/p>\n Bild 10: Einfügen der ersten Regel<\/span><\/b><\/p>\n<\/ul>\n Danach können wir den Dialog wieder schließen und legen dann eine zweite Regel an, diesmal für das Feld Geaendert2<\/b>. Dazu wählen wir dieses Feld im Manager für Regeln zur bedingten Formatierung <\/b>aus. Die Formatierungsregel ist fast genauso aufgebaut – nur dass wir hier mit dem Feld [Geaendert1] <\/b>vergleichen.<\/p>\n Mit ein paar unterschiedlichen Änderungsdaten sieht das Unterformular nun wie in Bild 11 aus.<\/p>\n Bild 11: Farbige Markierung aktuellerer Elemente<\/span><\/b><\/p>\n Es fehlt noch eine Markierung für Elemente, die nur in einer der beiden Datenbanken vorhanden sind. Diese wollen wir zur besseren Unterscheidbarkeit mit einem blauen Hintergrund versehen. Die Formatierungsregel bauen wir anders auf als die vorherigen. Wir stellen im ersten Auswahlfeld den Wert Ausdruck ist <\/b>ein. Für das zweite Feld daneben geben wir folgenden Ausdruck an:<\/p>\n Dadurch wird Geaendert1 <\/b>blau markiert, wenn es nicht leer ist, aber Geaendert2 <\/b>keinen Inhalt hat. Die vollständige Regel sehen Sie in Bild 12.<\/p>\n Bild 12: Regel für Elemente, die nur in einer Anwendung vorkommen<\/span><\/b><\/p>\n Für das Feld Geaendert2 <\/b>formulieren wir die Regel genau andersherum. Das Ergebnis sieht, wenn jede Version der Datenbank ein Objekt aufweist, dass die andere Version nicht enthält, wie in Bild 13 aus.<\/p>\n Bild 13: Unterformular mit verschiedenen Unterschieden<\/span><\/b><\/p>\n Was noch auffällt, sind die überflüssigen Elemente im Hauptformular – diese entfernen wir durch Einstellen der Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf den Wert Nein<\/b>. Außerdem soll das Formular zentriert erscheinen. Dazu stellen wir die Eigenschaft Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n Der nächste Schritt ist die Umwandlung dieser Anwendung in ein Add-In, das wir über die Liste der Add-Ins im Ribbon starten können. Warum sollen wir diesen Aufwand betreiben? <\/p>\n Weil es nicht so häufig vorkommt, dass wir es einsetzen – und wenn wir es dann brauchen, wissen wir sicher, dass es über die Liste der Add-Ins in Access aufrufbar ist. Außerdem haben wir im Beitrag Access-Add-In per Knopfdruck erstellen <\/b>(www.access-im-unternehmen.de\/1427<\/b>) ein Add-In programmiert, mit dem wir Datenbankanwendungen wie die vorliegende schnell in ein Add-In umwandeln können. Zeit, dieses Add-In einmal einzusetzen!<\/p>\n Dazu rufen wir das Add-In, das Sie im Download zu dem oben genannten Beitrag finden und installieren können, über das Add-In-Menü auf. Es erscheint ein Dialog, den wir wie in Bild 14 füllen.<\/p>\n Bild 14: Erstellen eines Add-Ins aus einer Datenbank<\/span><\/b><\/p>\n Danach sind noch folgende Schritte nötig:<\/p>\nObjektedaten in neue Datenbank importieren<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_002.png\")
<\/p>\nFormular zum Anzeigen der Änderungsdaten<\/h2>\n
![\"Felder](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_003.png\")
<\/p>\nPrivate Sub <\/span>cmdDateiOeffnen1_Click()\r\n Me!txtVersion1 = DateiOeffnen\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdDateiOeffnen2_Click()\r\n Me!txtVersion2 = DateiOeffnen\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>DateiOeffnen() As String<\/span>\r\n Dim <\/span>objFiledialog As <\/span>Office.FileDialog\r\n Dim <\/span>varFilename As Variant<\/span>\r\n Set<\/span> objFiledialog = _\r\n Application.FileDialog(msoFileDialogFilePicker)\r\n objFiledialog.InitialFileName = CurrentProject.Path\r\n If <\/span>objFiledialog.Show = True<\/span> Then<\/span>\r\n DateiOeffnen = objFiledialog.SelectedItems(1)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_004.png\")
<\/p>\nUnterformular zum Anpassen der Ergebnisse<\/h2>\n
![\"Unterformular](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_005.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_006.png\")
<\/p>\nEinlesen der Objektdaten der Datenbanken<\/h2>\n
Private Sub <\/span>cmdVergleichen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngObjektID As Long<\/span>\r\n Dim <\/span>strObjekttyp As String<\/span>\r\n Dim <\/span>strWhere As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.Execute \"DELETE FROM tblObjekte\", dbFailOnError\r\n db.Execute \"DROP TABLE tblObjects1\", dbFailOnError\r\n db.Execute \"DROP TABLE tblObjects2\", dbFailOnError\r\n On Error GoTo<\/span> 0\r\n DoCmd.TransferDatabase acImport, \"Microsoft Access\", Me.txtVersion1, acTable, \"MSysObjects\", \"tblObjects1\"\r\n DoCmd.TransferDatabase acImport, \"Microsoft Access\", Me.txtVersion2, acTable, \"MSysObjects\", \"tblObjects2\"\r\n strWhere = \" WHERE Type IN (1, 4, 5, 6, -32761, -32764, -32766, -32768) AND NOT Name LIKE ''~*'' \" _\r\n & \"AND NOT Name LIKE ''MSys*'' AND NOT Name LIKE ''f_*''\"\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblObjects1\" & strWhere, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strObjekttyp = ObjekttypErmitteln(rst!Type)\r\n db.Execute \"INSERT INTO tblObjekte(Objektname, Objekttyp, Geaendert1) VALUES(''\" & rst!Name & \"'', ''\" _\r\n & strObjekttyp & \"'', \" & ISODatum(rst!DateUpdate) & \")\", dbFailOnError\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblObjects2\" & strWhere, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n lngObjektID = Nz(DLookup(\"ObjektID\", \"tblObjekte\", \"Objektname = ''\" & rst!Name & \"''\"), 0)\r\n If <\/span>lngObjektID = 0 Then<\/span>\r\n strObjekttyp = ObjekttypErmitteln(rst!Type)\r\n db.Execute \"INSERT INTO tblObjekte(Objektname, Objekttyp, Geaendert2) VALUES(''\" & rst!Name & \"'', ''\" _\r\n & strObjekttyp & \"'', \" & ISODatum(rst!DateUpdate) & \")\", dbFailOnError\r\n Else<\/span>\r\n db.Execute \"UPDATE tblObjekte SET Geaendert2 = \" & ISODatum(rst!DateUpdate) & \" WHERE ObjektID = \" _\r\n & lngObjektID, dbFailOnError\r\n End If \r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Me!sfmVergleichen.Form.Requery\r\nEnd Sub<\/span><\/pre>\nAbgleich der Änderungsdaten<\/h2>\n
Private Function <\/span>ObjekttypErmitteln(lngObjekttyp As <\/span>_\r\n Long) As String<\/span>\r\n Select Case lngObjekttyp\r\n Case <\/span>1\r\n ObjekttypErmitteln = \"Lokale Tabelle\"\r\n Case <\/span>4\r\n ObjekttypErmitteln = \"ODBC-Tabelle\"\r\n Case <\/span>5\r\n ObjekttypErmitteln = \"Abfrage\"\r\n Case <\/span>6\r\n ObjekttypErmitteln = \"Verknüpfte Tabelle\"\r\n Case <\/span>-32761\r\n ObjekttypErmitteln = \"VBA-Modul\"\r\n Case <\/span>-32764\r\n ObjekttypErmitteln = \"Bericht\"\r\n Case <\/span>-32766\r\n ObjekttypErmitteln = \"Makro\"\r\n Case <\/span>-32768\r\n ObjekttypErmitteln = \"Formular\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_007.png\")
<\/p>\nFormular anpassen<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_008.png\")
<\/p>\nUnterschiede mit bedingter Formatierung<\/h2>\n
![\"Der](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_009.png\")
<\/p>\n\n
![\"Einfügen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_010.png\")
<\/p>\n![\"Farbige](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_011.png\")
<\/p>\n[Geaendert2] Ist Null Und [Geaendert1] Ist Nicht Null<\/pre>\n
![\"Regel](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_012.png\")
<\/p>\n![\"Unterformular](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_013.png\")
<\/p>\nOptimierungen der Benutzeroberfläche<\/h2>\n
Umwandlung in ein Add-In<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1448_014.png\")
<\/p>\n