Es gibt verschiedene Systeme, mit denen wir die Objekte aus Access extrahieren und unter eine Versionsverwaltung stellen können. In diesem Beitrag stellen wir eine Kombination aus dem kostenlosen Tool „Version Control Add-In“ und „GitHub Desktop“ vor. Dabei zeigen wir, wie die notwendige Komponente zu Access hinzugefügt wird, wie wir diese nutzen, um die Access-Elemente zu extrahieren und wie wir diese mit GitHub Desktop verwalten, um beispielsweise Unterschiede zwischen verschiedenen Versionen einer Datenbank ausfindig zu machen.<\/b><\/p>\n
Vorbereitungen<\/h2>\n
Als Erstes treffen wir einige Vorbereitungen:<\/p>\n
![\"Installieren](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_001.png\")
<\/p>\n
Bild 1: Installieren des Version Control Add-Ins<\/span><\/b><\/p>\n Bild 2: Die Benutzeroberfläche des Version Control Add-Ins<\/span><\/b><\/p>\n Damit können wir den ersten Export der Datenbankelemente einer kleinen Beispieldatenbank durchführen. Wir klicken dazu einfach auf die Schaltfläche Export Source Files <\/b>(siehe Bild 3).<\/p>\n Bild 3: Erster Export der Objekte<\/span><\/b><\/p>\n Dieser Vorgang verläuft sehr schnell. Das Ergebnis dokumentiert das Tool in dem Dialog aus Bild 4.<\/p>\n Bild 4: Dokumentation des Exports<\/span><\/b><\/p>\n Schauen wir uns nun an, was der Export für uns erledigt hat. Dazu schauen wir uns das Verzeichnis der Datenbank an, in dem wir einen neuen Ordner finden mit dem Namen der Datei und angehängtem .src<\/b> (siehe Bild 5).<\/p>\n Bild 5: Exportierte Access-Elemente und Informationen<\/span><\/b><\/p>\n In diesem Verzeichnis sehen wir Ordner für Tabellen (tbldefs<\/b>), Abfragen (queries<\/b>), Formulare (forms<\/b>) und Module (modules<\/b>) sowie einige weitere Dateien, die Daten wie beispielsweise die Datenbankoptionen, Einstellungen des Navigationsbereichs, Verweise und mehr enthalten.<\/p>\n Bevor wir uns anschauen, wie wir mit dem Export in GitHub Desktop <\/b>arbeiten können, werfen wir einen Blick auf weitere Funktionen von Version Control<\/b>. Da wäre zum Beispiel die Schaltfläche Build From Source<\/b>. Diese rufen wir von einer neuen, leeren Datenbank aus auf und erzeugen so die komplette Anwendung, die wir soeben exportiert haben, neu. Das heißt, dass alle Elemente importiert werden und dass alle weiteren Einstellungen wie Verweise und Access-Optionen wiederhergestellt werden.<\/p>\n Mit der Schaltfläche Export VBA Code <\/b>können wir ausschließlich die VBA-Module exportieren. Dies exportiert nicht nur die reinen Standard- und Klassenmodule, sondern auch noch die Klassenmodule von Formularen und Berichten.<\/p>\n Wir können auch ein oder mehrere Elemente im Navigationsbereich selektieren und diese exportieren. Dazu nutzen wir die Schaltfläche Export Selected<\/b>.<\/p>\n Wir können nun, und das ist eine Funktion für den Fall, dass mehrere Entwickler an einer Datenbank arbeiten, die Änderung eines anderen Entwicklers an einem Element in unsere Access-Datenbank integrieren.<\/p>\n Stellen wir uns den folgenden Ablauf vor: Wir exportieren die Elemente unserer Datenbank in das oben erwähnte Verzeichnis.<\/p>\n Ein anderer Entwickler liest diese Elemente in seine Version der Datenbank ein. Dann ändert er eine oder mehrere Dateien und schreibt diese in Form der geänderten Elemente in das Verzeichnis zurück. Wir können nun die geänderten Elemente wiederum in unsere Version der Datenbank einlesen. Dazu ist es nötig, dass wir einmal den Befehl Build From Source <\/b>aufgerufen haben.<\/p>\n Danach können wir jederzeit alle Änderungen durch einen Klick auf die Schaltfläche Merge Build <\/b>in unsere Version einlesen. Wir haben zu Beispielzwecken einfach eine Zeile in der Datei mdlBeispiel <\/b>geändert. Rufen wir dann den Befehl Merge Build <\/b>auf, erhalten wir den Dialog aus Bild 6.<\/p>\n Bild 6: Import geänderter Elemente<\/span><\/b><\/p>\n Dieser Dialog meldet uns, welche Objekte seit dem letzten Export von außen geändert wurden – in diesem Fall genau die Datei mdlBeispiel.bas<\/b>, die den Code des Moduls mdlBeispiel <\/b>enthält. Klicken wir auf Continue<\/b>, wird die neue Version des Moduls in unsere Version der Datenbank eingelesen.<\/p>\n Die nächste Schaltfläche mit dem Text Build As…<\/b> ermöglicht es uns, aus dem aktuellen Inhalt des exportierten Verzeichnisses eine neue Version der Datenbank zu erstellen. Dazu geben wir einfach den Dateinamen der zu erstellenden Datei ein.<\/p>\n Der nächste Befehl Load Selected <\/b>setzt voraus, dass wir mindestens ein Element im Navigationsbereich markiert haben. Dieses wird dann aus dem Verzeichnis neu eingelesen. Wenn sich die beiden Versionen unterscheiden, erscheint wieder der Dialog zum Lösen von Konflikten.<\/p>\n In der nächsten Gruppe des Ribbons finden wir weitere Befehle:<\/p>\n Bisher haben wir einfach nur Elemente exportiert und importiert und gezeigt, wie wir diese nach Änderungen an den exportierten Elementen wieder importieren können.<\/p>\n Jetzt gehen wir einen Schritt weiter und stellen den exportierten Ordner unter Versionsverwaltung. Dazu öffnen wir GitHub Desktop<\/b>.<\/p>\n Hier finden wir den Startbildschirm aus Bild 7 vor. Hier wählen wir den Befehl Add an Existing Repository from your hard drive… <\/b>aus – wir haben die Dateien ja bereits angelegt. Hier wählen wir das Verzeichnis mit der Endung .src <\/b>aus.<\/p>\n Bild 7: GitHub Desktop nach dem Start<\/span><\/b><\/p>\n Nach dem Bestätigen fragt GitHub Desktop <\/b>uns, ob wir ein Repository erstellen sollen, da das Verzeichnis kein Repository repräsentiert.<\/p>\n Dem stimmen wir zu, indem wir auf den Link create a repository <\/b>klicken (siehe Bild 8).<\/p>\n Bild 8: Frage, ob ein Repository erstellt werden soll<\/span><\/b><\/p>\n Danach erscheint der Dialog Create a new repository<\/b>, der bereits den Pfad enthält, den wir soeben ausgewählt haben. Die Einstellungen übernehmen wir und klicken auf Create repository<\/b> (siehe Bild 9).<\/p>\n Bild 9: Eingeben der Eigenschaften des Repositorys<\/span><\/b><\/p>\n GitHub Desktop <\/b>zeigt nun das neue Repository an, allerdings nur durch die Anzeige unter Current repository<\/b> (siehe Bild 10).<\/p>\n Bild 10: GitHub Desktop mit dem neuen Repository<\/span><\/b><\/p>\n Ansonsten sehen wir keine Änderungen in der Historie, was auch kein Wunder ist, weil wir das Repository neu erstellt haben.<\/p>\n Dadurch wurde der aktuelle Stand bereits als erstes Commit gespeichert. Dieser Commit heißt Initial Commit<\/b>.<\/p>\n Im Verzeichnis finden wir eine neue Datei namens .gitattributes<\/b>, welche Informationen über das Git-Repository enthält.<\/p>\n Jetzt ändern wir eine Zeile im Modul mdlBeispiel<\/b> und exportieren die Elemente erneut.<\/p>\n Schauen wir uns nun den aktuellen Zustand in GitHub Desktop <\/b>an, sehen wir vier Dateien unter Changes<\/b>. Interessant ist die Datei modules\/mdlBeispiel.bas<\/b>. Diese markiert die geänderte Zeile mit grüner Hintergrundfarbe und stellt dieser ein Plus-Zeichen voran (siehe Bild 11).<\/p>\n Bild 11: Anzeige der Änderungen des Moduls<\/span><\/b><\/p>\n Löschen wir hingegen eine Zeile, wird dieser rot markiert und mit einem Minus-Zeichen versehen.<\/p>\n Ersetzen wir eine Zeile, wird die alte Zeile rot markiert und die neue Zeile grün (siehe Bild 12).<\/p>\n Bild 12: Anzeige weiterer Änderungen des Moduls<\/span><\/b><\/p>\n Was passiert hier im Hintergrund? Da das Verzeichnis unter der Verwaltung von GitHub Desktop steht, werden geänderte Dateien direkt registriert und die Änderungen werden erfasst. Diese werden daraufhin direkt grafisch dargestellt.<\/p>\n Im Beispiel haben wir die Änderungen am Code eines VBA-Moduls gesehen. Nun schauen wir uns an, wie weitere Änderungen abgebildet werden.<\/p>\n Wir haben einer Tabelle ein Feld wie in Bild 13 hinzugefügt.<\/p>\n Bild 13: Hinzufügen eines neuen Feldes<\/span><\/b><\/p>\n Wenn wir danach entweder den Befehl Export Source Files <\/b>aufrufen und so dafür sorgen, dass alle geänderten Dateien exportiert werden oder die geänderte Tabelle markieren und dann auf Export Selected <\/b>klicken, können wir anschließend in GitHub Desktop <\/b>die Änderungen betrachten.<\/p>\n Die erste Version sehen wir, wenn wir links auf tbldefs\\tblBeispiel.sql <\/b>klicken. Damit erhalten wir die Änderungen, die in einem SQL-Skript zum Erstellen der Tabelle notwendig wären (siehe Bild 14).<\/p>\n Bild 14: Unterschiede am SQL-Code für ein neues Feld in einer Tabelle<\/span><\/b><\/p>\n Es gibt jedoch noch eine weitere Ansicht. Diese enthält die Beschreibung des neuen Feldes im XML-Format. Die Änderung hier ist etwas präziser beschrieben, da wir hier nicht die Änderung der vorherigen Zeile durch das angefügte Komma sehen, sondern direkt nur die Informationen für das neue Feld dargestellt werden (siehe Bild 15).<\/p>\n Bild 15: Unterschiede am XML-Code für ein neues Feld in einer Tabelle<\/span><\/b><\/p>\n Ändern wir die Abfrage qryBeispiel<\/b>, die zuvor die beiden Felder ID <\/b>und Beispielfeld <\/b>der Tabelle tblBeispiele<\/b> enthielt, indem wir dieser das neue Feld der Tabelle tblBeispiele <\/b>hinzufügen, für das wir außerdem noch ein Kriterium festlegen. Exportieren wir diese Änderung und schauen uns das Ergebnis in GitHub Desktop an, sehen wir die Änderungen im SQL-Format wie in Bild 16.<\/p>\n Bild 16: Unterschiede am XML-Code für ein neues Feld mit Bedingung in einer Abfrage<\/span><\/b><\/p>\n Anschließend haben wir das Formular frmBeispiele <\/b>angepasst, indem wir das neue Feld der Tabelle tblBeispiele <\/b>hinzugefügt haben. Dies sieht wie in Bild 17 aus.<\/p>\n Bild 17: Änderungen für ein neues Textfeld<\/span><\/b><\/p>\n Hier sehen wir wiederum ein anderes Format – kein VBA, kein SQL und kein XML, sondern dies ist das Format, in dem Access die Definition von Formularen und Berichten exportiert. Der komplette grüne Bereich zeigt die Definition des neuen Steuerelements mit seinen Eigenschaften.<\/p>\n Wenn wir ein neues Makro anlegen und dieses exportieren, erhalten wir ebenfalls eine Änderung in GitHub Desktop. In diesem Fall wird die komplette Definition ausgegeben – siehe Bild 18.<\/p>\n Bild 18: Anlegen eines neuen Makros<\/span><\/b><\/p>\n Eine Funktion, die sehr spannend ist, ist das Tracken von Änderungen an den Access-Optionen. Angenommen, wir ändern einmal die Optionen der aktuellen Datenbank wie in Bild 19.<\/p>\n Bild 19: Änderungen an den Access-Optionen<\/span><\/b><\/p>\n Wenn wir die Datenbank dann exportieren und die Änderungen in GitHub Desktop anzeigen lassen, erhalten wir die Ansicht aus Bild 20. In diesem Ausschnitt sehen wir den hinzugefügten Anwendungstitel sowie die geänderte Einstellung für das automatische Komprimieren der Datenbank beim Schließen.<\/p>\n Bild 20: Änderungen an den Access-Optionen in GitHub Desktop<\/span><\/b><\/p>\n Nun fügen wir dem VBA-Projekt einen neuen Verweis hinzu (siehe Bild 21).<\/p>\n Bild 21: Hinzufügen eines Verweises<\/span><\/b><\/p>\n Nach dem Exportieren des aktuellen Standes der Datenbank finden wir diese Änderung ebenfalls in GitHub Desktop vor. Dazu zeigen wir den Bereich vbe-references.json<\/b>, der seine Informationen im JSON-Format speichert. Hier sehen wir einen neuen Eintrag wie in Bild 22.<\/p>\n Bild 22: Dokumentation der Änderung eines Verweises in GitHub<\/span><\/b><\/p>\n Wir wollen in diesem Beitrag weniger auf die Quellcodeverwaltung an sich eingehen, sondern eher die Zusammenarbeit zwischen dem Version Control Add-In und GitHub Desktop beschreiben. Dennoch müssen wir kurz das Thema Commit <\/b>anschauen. In unserem Beispiel, bei dem wir ein bestehendes Verzeichnis zu GitHub hinzugefügt haben, wurde direkt zu Beginn ein initiales Commit durchgeführt. Das heißt, dass der aktuelle Stand gespeichert wird.<\/p>\n Wir hätten auch andersherum starten können, indem wir ein neues, leeres Repository anlegen. Dazu hinterlegen wir ein weiteres Verzeichnis im Verzeichnis der Datenbankdatei. Dann wählen wir in GitHub Desktop den Befehl File|New Repository… <\/b>aus.<\/p>\n Im Dialog Create a new repository <\/b>geben wir einen Namen für das Repository an und wählen das Verzeichnis unter Local path <\/b>aus.<\/p>\n Unter Name <\/b>geben wir das Repository-Verzeichnis an, unter Local path <\/b>das Verzeichnis, in dem dieses erstellt werden soll (siehe Bild 23).<\/p>\n Bild 23: Anlegen eines neuen Repositorys<\/span><\/b><\/p>\n Dadurch wird das Verzeichnis NeuesRepository <\/b>angelegt, das bereits eine Datei namens .gitattributes <\/b>enthält. Außerdem wird ein Initial Commit <\/b>ausgeführt, der den aktuellen Stand der Dateien sichert. Davon können wir uns in GitHub Desktop überzeugen, wenn wir zum Registerreiter History<\/b> im linken Bereich wechseln (siehe Bild 24).<\/p>\n Bild 24: Der initiale Commit<\/span><\/b><\/p>\n Nun können wir den ersten Export der Elemente der Datenbank mit Version Control <\/b>durchführen. Dies wird normalerweise ein eigenes Verzeichnis nach den Standardvorgaben von Version Control <\/b>erstellen. Damit das Verzeichnis verwendet wird, in dem wir gerade das Repository angelegt haben, rufen wir den Befehl View Options <\/b>auf und tragen dort unter Export für die Eigenschaft Export Folder <\/b>das Zielverzeichnis ein (siehe Bild 25).<\/p>\n Bild 25: Einstellen des Zielverzeichnisses<\/span><\/b><\/p>\n Nun klicken wir in Access auf Export Source Files<\/b>. Dadurch wird ein initialer Export aller Elemente der Datenbank in das Verzeichnis durchgeführt.<\/p>\n Wechseln wir nun zu GitHub Desktop, sehen wir nach dem Aktivieren des Bereichs Changes <\/b>die Liste aller hinzugefügten und somit geänderten Elemente.<\/p>\n Nun wird es Zeit für einen ersten selbst angestoßenen Commit. Damit wird der aktuelle Stand ins Repository geschrieben. Den Commit führen wir aus, indem wir einen aussagekräftigen Text in das Feld Summary <\/b>schreiben und gegebenenfalls noch das Feld Description <\/b>füllen.<\/p>\n Dann klicken wir auf die Schaltfläche Commit to main<\/b> (siehe Bild 26).<\/p>\n Bild 26: Erstes Commit<\/span><\/b><\/p>\n Danach zeigt GitHub Desktop unter Changes<\/b> wieder eine leere Liste an. Warum das? Weil es seit dem letzten Commit keine Änderungen gab. Erst wenn wir eine der im Verzeichnis enthaltenen Dateien ändern, wird diese hier vermerkt. Haben wir durch mehrere Änderungen einen relevanten Stand erreicht, können wir ein neues Commit durchführen. Wann man ein Commit durchführt, kann man selbst entscheiden.<\/p>\n Warum aber sollte man überhaupt Commits durchführen? Ein wichtiger Punkt ist, dass wir damit einen Zwischenstand speichern, den wir zu jeder Zeit wieder herstellen können. Damit ermöglichen wir uns auch, die Datenbank aus einem solchen Zwischenstand wiederherzustellen.<\/p>\n Der Vollständigkeit halber schauen wir uns noch die wichtigsten Optionen des Add-Ins an, die wir mit dem Ribbon-Befehl View Options <\/b>einblenden. Auf der ersten Seite General <\/b>zeigt das Tool folgende Optionen an (siehe Bild 27):<\/p>\n Bild 27: Allgemeine Optionen<\/span><\/b><\/p>\n Die zweite Seite zeigt die Export-Optionen des Tools an (siehe Bild 28). Hier finden wir die folgenden Einstellungen:<\/p>\n Bild 28: Export-Optionen<\/span><\/b><\/p>\n Üblicherweise verwenden wir die Versionsverwaltung während der Entwicklung der Datenbank. Das heißt, dass wir die Daten der Tabellen nicht unbedingt mit versionieren. Wenn wir jedoch sicherstellen wollen, dass wir nach dem Exportieren und dem Erstellen einer neuen Datenbank auf Basis des Exports eine funktionsfähige Anwendung erhalten, ist das Exportieren der Daten bestimmter Tabellen manchmal notwendig. In Fall aus Bild 29 wollen wir zum Beispiel die Daten der Tabelle MSysResources<\/b> mit exportieren. Diese Tabelle speichert neben dem Design-Theme der Datenbankanwendung gegebenenfalls auch Bilddateien, die in den Formularen und Berichten angezeigt werden sollen oder die für das Ribbon oder für Kontextmenüs verwendet werden.<\/p>\n Bild 29: Optionen für Tabellendaten<\/span><\/b><\/p>\n Also sollten wir diese Daten auf jeden Fall mit ins Repository exportieren.<\/p>\n Tabellen, die exportiert werden sollen, erkennen wir an dem Eintrag in der Spalte Export As<\/b>. Hier steht entweder XML Format <\/b>oder Tab Delimited<\/b>.<\/p>\n Die Seite aus Bild 30 enthält Einstellungen, die beim Wiederherstellen einer Anwendung aus den Quelldateien verwendet werden:<\/p>\n Bild 30: Optionen für das Wiederherstellen aus der Versionsverwaltung<\/span><\/b><\/p>\n Es gibt noch ein paar Einstellungen, welche die Optionen selbst betreffen. Auf der Seite Settings<\/b> aus Bild 31 können wir aktuellen Einstellungen als Standard für neue Projekte sichern und diese wiederherstellen. Außerdem können wir alle Einstellungen zurücksetzen. Schließlich können wir hier noch den Installationsordner des Access VCS Add-Ins öffnen und dieses deinstallieren.<\/p>\n Bild 31: Einstellungen für die Optionen und mehr<\/span><\/b><\/p>\n Was nützt das Sichern der Datenbankelemente in Textdateien, wenn wir diese nicht zum Wiederherstellen nutzen? Oder wenn wir vielleicht sogar im Team an einer Access-Anwendung programmieren, möchten wir die Änderungen der anderen Entwickler in unsere Datenbank übernehmen. Wie die anderen Entwickler auf ein gemeinsames Repository zugreifen können, wird gegebenenfalls Thema eines weiteren Beitrags.<\/p>\n Im beiden Fällen wollen wir den aktuell im Quellverzeichnis gespeicherten Stand wiederherstellen. Dazu öffnen wir die Anwendung und rufen den Ribbonbefehl Build From Source <\/b>auf (siehe Bild 32).<\/p>\n Bild 32: Wiederherstellen einer Datenbank aus der exportierten Version<\/span><\/b><\/p>\n Dies ruft eine Meldung hervor, die anzeigt, aus welchem Verzeichnis die Datenbank wiederhergestellt werden soll (siehe Bild 33). Mit einem Klick auf Nein <\/b>können wir einen Dateiauswahl-Dialog öffnen, um ein anderes Quellverzeichnis auszuwählen. Bestätigen wir hier mit Ja<\/b>, wird eine Sicherheitskopie der aktuellen Datenbank angefertigt und eine neue Datenbank erstellt, die mit den Elementen aus dem Export gefüllt wird.<\/p>\n Bild 33: Meldung vor dem Wiederherstellen aus dem Repository<\/span><\/b><\/p>\n Dieser Beitrag zeigt, wie man mit dem Version Control Add-In <\/b>die Elemente seiner Datenbankanwendung und auch Einstellungen die Access-Optionen der aktuellen Datenbank oder die Verweise des VBA-Projekts in Textdateien exportieren kann. Dies eröffnet verschiedene Möglichkeiten. Man kann diese einfach wiederherstellen. Oder man verwendet zusätzlich das Tool GitHub Desktop<\/b>, mit dem wir verschiedene Stände der exportierten Dateien verwalten, Unterschiede anzeigen und einen beliebigen zwischenzeitlich gespeicherten Zustand in einer Access-Datenbank wiederherstellen können.<\/p>\n In einem weiteren Beitrag namens Datenbanken vergleichen mit GitHub Desktop <\/b>(www.access-im-unternehmen.de\/1502<\/b>) zeigen wir, wie man die Kombination aus Version Control Add-In <\/b>und GitHup Desktop <\/b>nutzen kann, um verschiedene Versionen einer .accdb<\/b>-Datenbank miteinander zu vergleichen. Damit finden wir beispielsweise heraus, welche Unterschiede zwischen den beiden Datenbanken bestehen.<\/p>\n","protected":false},"excerpt":{"rendered":" Es gibt verschiedene Systeme, mit denen wir die Objekte aus Access extrahieren und unter eine Versionsverwaltung stellen können. In diesem Beitrag stellen wir eine Kombination aus dem kostenlosen Tool „Version Control Add-In“ und „GitHub Desktop“ vor. Dabei zeigen wir, wie die notwendige Komponente zu Access hinzugefügt wird, wie wir diese nutzen, um die Access-Elemente zu extrahieren und wie wir diese mit GitHub Desktop verwalten, um beispielsweise Unterschiede zwischen verschiedenen Versionen einer Datenbank ausfindig zu machen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662024,66032024,44000025],"tags":[],"class_list":["post-55001495","post","type-post","status-publish","format-standard","hentry","category-662024","category-66032024","category-VBA_und_Programmiertechniken"],"yoast_head":"\n![\"Die](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_002.png\")
<\/p>\nExport der Datenbankelemente<\/h2>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_003.png\")
<\/p>\n![\"Dokumentation](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_004.png\")
<\/p>\nErgebnis des Exports<\/h2>\n
![\"Exportierte](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_005.png\")
<\/p>\nDatenbank aus Export neu erstellen<\/h2>\n
Nur VBA-Code exportieren<\/h2>\n
Ausgewählte Elemente exportieren<\/h2>\n
Extern geänderte Elemente „mergen“<\/h2>\n
![\"Import](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_006.png\")
<\/p>\nDatenbank neu aus Quellen erstellen<\/h2>\n
Einzelne Elemente aus dem Verzeichnis laden<\/h2>\n
Weitere Befehle<\/h2>\n
\n
Nutzen der Quellcodeverwaltung<\/h2>\n
![\"GitHub](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_007.png\")
<\/p>\n![\"Frage,](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_008.png\")
<\/p>\n![\"Eingeben](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_009.png\")
<\/p>\n![\"GitHub](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_010.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_011.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_012.png\")
<\/p>\nVerschiedene Änderungen<\/h2>\n
\n
Änderungen an Tabellen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_013.png\")
<\/p>\n![\"Unterschiede](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_014.png\")
<\/p>\n![\"Unterschiede](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_015.png\")
<\/p>\nÄnderungen an Abfragen<\/h2>\n
![\"Unterschiede](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_016.png\")
<\/p>\nÄnderungen an Formularen und Berichten<\/h2>\n
![\"Änderungen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_017.png\")
<\/p>\nÄnderungen an Makros<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_023.png\")
<\/p>\nÄnderungen an Optionen<\/h2>\n
![\"Änderungen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_018.png\")
<\/p>\n![\"Änderungen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_019.png\")
<\/p>\nÄnderungen an Verweisen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_020.png\")
<\/p>\n![\"Dokumentation](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_021.png\")
<\/p>\nGrundlegende GitHub-Funktionen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_024.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_025.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_022.png\")
<\/p>\n![\"Erstes](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_026.png\")
<\/p>\nDie Optionen von Access VCS Add-In<\/h2>\n
![\"Allgemeine](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_027.png\")
<\/p>\n\n
Export-Optionen<\/h2>\n
![\"Export-Optionen\"](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_028.png\")
<\/p>\n\n
Optionen für den Export von Tabellendaten<\/h2>\n
![\"Optionen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_029.png\")
<\/p>\nOptionen zum Wiederherstellen einer Anwendung aus den Quelldateien<\/h2>\n
![\"Optionen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_030.png\")
<\/p>\n\n
Einstellungen für die Optionen<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_031.png\")
<\/p>\nDatenbank aus Repository wiederherstellen<\/h2>\n
![\"Wiederherstellen](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_036.png\")
<\/p>\n![\"Meldung](\"..\/fileadmin\/_temp_\/2024_03\/pic_1495_035.png\")
<\/p>\nZusammenfassung und Ausblick<\/h2>\n