<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Beim Thema Versionsverwaltung fällt dem Anwender von Microsoft-Entwicklerprodukten erstmal Visual Source Safe ein. Wenn man über den Tellerrand schaut, finden sich dort einige vor allem aus der Unix-Welt stammende Produkte, allen voran CVS (Concurrent Version System). Der vorliegende Beitrag stellt die Grundlagen zu diesem System vor und klopft ab, inwieweit es sich zur Kooperation mit Microsoft Access bewegen lässt.<\/b><\/p>\n
<\/b><\/p>\n
CVS ist eine Software zur Versionsverwaltung von Dateien. Es ist das Open Source-Pendant zu Microsoft Visual Source Safe (VSS), ist aber im Vergleich zu diesem Open Source-Software.<\/p>\n
Versionsverwaltungssoftware erfüllt mehrere Aufgaben gleichzeitig: Der wichtigste Punkt ist, dass der Quellcode an einer zentralen Stelle gespeichert und von allen beteiligten Entwicklern kopiert, bearbeitet und wieder zurückgespielt werden kann.<\/p>\n
Halten sich alle beteiligten Personen an die Regeln, hat jede eine weitgehend aktuelle Version des Projektes auf der Festplatte. änderungen lassen sich mit Versionsverwaltungen leicht ins System übernehmen und an die anderen Entwickler verteilen.<\/p>\n
Der zweite wichtige Punkt folgt aus der Bezeichnung dieser Software als Versionsverwaltungssystem:<\/p>\n
Jede neue Version einer Datei wird mit allen änderungen registriert; dementsprechend kann das Versionsverwaltungssystem jederzeit frühere Versionen einer Datei rekonstruieren und bereitstellen.<\/p>\n
Dieser zweite Punkt bildet den Grundstein für die in diesem Beitrag vorgestellten Vorgehensweisen und die daraus resultierende Lösung.<\/p>\n
üblicherweise geht man bei der Versionsverwaltung davon aus, dass ein Verzeichnis mit seinen Unterverzeichnissen und Dateien den Quellcode für ein Projekt oder einen Teil eines Projektes repräsentiert. Da der Quellcode während der Entwicklung änderungen unterworfen ist, müsste man ohne Versionsverwaltung regelmäßig Kopien des Verzeichnisses anlegen, um später bestimmte Versionsstände rekonstruieren zu können – etwa, wenn man in die falsche Richtung entwickelt hat und ein Stück zurückrudern möchte.<\/p>\n
Der Ablauf bei der Entwicklung von Software mit der Unterstützung durch eine Versionsverwaltung sieht folgendermaßen aus:<\/p>\n
Sobald man es für sinnvoll erachtet, fügt man der Versionsverwaltung den vorhandenen Quellcode hinzu. Unter CVS heißt dieser Vorgang „Import“.<\/p>\n
Sobald der Quellcode einmal in einem Modul des Repositorys gelandet ist, kann man die komplette Struktur in jedem beliebigen Verzeichnis wieder herstellen. Dieses Verzeichnis wird somit zum Arbeitsverzeichnis.<\/p>\n
Hat man dort änderungen an den Dateien vorgenommen, kann man die änderungen auf die im Repository gespeicherten Dateien übertragen. Arbeitet man allein (das ist bei Access-Entwicklern recht oft der Fall), ist man weitgehend flexibel, was den Zeitpunkt des „Eincheckens“ der änderungen betrifft: Alle zwei Stunden, einmal am Tag, oder einfach, wenn Sie den Eindruck haben, dass Sie den aktuellen Zwischenstand noch einmal reproduzieren möchten.<\/p>\n
Im Team sieht das natürlich anders aus: Hier sollte man regelmäßig die aktuelle Version seiner Arbeitsdateien wieder einchecken, gerade wenn mehrere Entwickler an zusammenhängenden Teilen des Projekts arbeiten und auf die jeweiligen Aktualisierungen des anderen angewiesen sind.<\/p>\n
Wer mit Access entwickelt, kennt das: Aufgrund der „monolithischen“ Struktur einer Access-Anwendung kann man gar nicht viel anders, als regelmäßig Sicherungskopien der kompletten Datenbank anzulegen.<\/p>\n
Das macht es natürlich sehr schwer, einen bestimmten Versionsstand zu finden – wenn man die vorgenommenen änderungen nicht umfassend dokumentiert hat.<\/p>\n
Dies kommt vor allem dann ungelegen, wenn man nur mal eben die letzten paar geänderten Zeilen wiederherstellen möchte, aber die Kapazität der Rückgängig-Funktion des Visual Basic-Editors wieder mal ein wenig zu klein ist.<\/p>\n
Der Schnelldurchlauf der Installation von CVS für Windows sieht folgendermaßen aus:<\/p>\n
CVS speichert die zu zu verwaltenden Dateien in einem so genannten „Repository“. Das erstellen Sie wie folgt:<\/p>\n
![](\"..\/fileadmin\/_temp_\/{C1209DCA-F519-4B22-8F5E-B62933D4C107}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 1: CVS in der Systemsteuerung<\/b><\/p>\nZugriffsart<\/h2>\n
CVS bietet verschiedene Arten des Zugriffs auf das Repository an, die an die einzelnen Anwendungsfälle angepasst sind. In unserem Falle soll sich das Repository auf dem lokalen Rechner befinden und ohne Benutzername und Kennwort erfolgen. Je nachdem, ob man sich in einem als solches gekennzeichneten Arbeitsverzeichnis befindet, muss man CVS die Art der Verbindung und die damit zusammenhängenden Parameter mitteilen, bevor man auf das Repository zugreifen kann. Ruft man eine CVS-Anweisung vom Arbeitsverzeichnis selbst auf, bezieht CVS die benötigten Informationen aus Dateien, die extra für diesen Zweck zusätzlich zu den Arbeitsdateien im Verzeichnis vorliegen.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{C1209DCA-F519-4B22-8F5E-B62933D4C107}\/pic002.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 2: Festlegen des Verzeichnisses und Bestätigen des Einrichtungsvorgangs<\/b><\/p>\n
Nachfolgend lernen Sie die grundlegende Funktion der Anweisungen von CVS kennen. Der Schwerpunkt liegt dabei auf den Anweisungen, die von accessCVS, einem Plugin für Access-Datenbanken zur Integration von CVS, verwendet werden.<\/p>\n
Weitere Informationen sowie eine Referenz zu CVSNT finden Sie im Internet unter der Adresse http:\/\/www.cvsnt.org. <\/p>\n
Damit CVS überhaupt Wind von den zu verwaltenden Daten bekommt, „importieren“ Sie diese und speichern sie damit erstmalig im Repository.<\/p>\n
Das ist die Grundlage für alle weiteren Operationen, mit denen Sie eine Datei bearbeiten und als neue Version ablegen, alte Versionen wieder hervorholen, Dateien hinzufügen oder entfernen können. Das Einchecken erfolgt allgemein mit folgender Anweisung:<\/p>\n
cvs import -m \"<Bemerkung>\" CVSBeispiel avendor arelease<\/pre>\nDamit kopiert man das komplette Verzeichnis inklusive aller Unterverzeichnisse und Dateien in das Repository. Der Platzhalter <Bemerkung> enthält eine Logmessage, mit der Sie Informationen über den aktuellen Stand speichern können. Diese Informationen können Sie mit jeder Aktualisierung des Inhalts des Repository übergeben. Damit erhalten Sie ein sehr wichtiges Mittel zur späteren Identifizierung des Inhalts des jeweiligen Revisionsstandes.<\/p>\n
Legen Sie zu Beispielzwecken ein Verzeichnis mit einer kurzen Textdatei an. Das Ganze erledigen Sie vom DOS-Prompt aus. Erstellen Sie zunächst das Testverzeichnis:<\/p>\n
mkdir c:\\\\cvsTest<\/pre>\nWechseln Sie in das Verzeichnis:<\/p>\n
cd c:\\\\cvsTest<\/pre>\nöffnen Sie anschließend den Texteditor, geben Sie einen kurzen Text (etwa „Beispieltext“) ein und speichern Sie die Textdatei mit den entsprechenden Menübefehlen:<\/p>\n
edit Beispiel.txt<\/pre>\nNun können Sie den Inhalt des Verzeichnisses in ein neues Modul im CVS-Repository importieren:<\/p>\n
cvs -d :local:<Repositorypfad> import -m \"Neues Modul\" Beispiel avendor arelease<\/pre>\nDabei geben Sie für <Repositorypfad> den Pfad an, unter dem Sie das Repository angelegt haben. Achten Sie darauf, dass Sie statt des Backslash (\\\\) das Slash-Zeichen (\/) verwenden.<\/p>\n
Die Zeichenfolge :local: gibt an, dass es sich um ein Repository auf dem lokalen Rechner handelt. Der Parameter -m und der folgende String dienen zum Anlegen einer Logmessage. Diese sollte in der Regel Informationen zu der eingecheckten Version enthalten. „Beispiel“ ist der Name des neuen Repository. Diesen sollten Sie sinnvoll auswählen, da Sie ihn für alle weiteren Zugriffe benötigen. Die beiden letzten Elemente, avendor und arelease, sind zwar erforderlich, haben aber in diesem Zusammenhang keine wichtige Bedeutung und werden daher nicht weiter erläutert. CVS antwortet wie folgt (eingerückte Zeilen sind Fortsetzungen der vorherigen Zeile):<\/p>\n
cvs import: cwd=C:\\\\cvstest, \n current=C:\\\\cvstest\nN Beispiel\/Beispiel.txt\nNo conflicts created by this import<\/pre>\nDas N vor der Angabe der Beispieldatei signalisiert, dass es sich um eine neue Datei handelt.<\/p>\n
Dateien auschecken<\/h2>\n
Zum Auschecken von Dateien, also zum Anlegen einer Kopie der aktuellsten Version der kompletten Struktur, dient folgende Anweisung:<\/p>\n
csv checkout CVSBeispiel<\/pre>\nDie Anweisung legt – soweit nicht vorhanden – ein Arbeitsverzeichnis mit dem Namen des Moduls im aktuellen Verzeichnis an und kopiert dort die komplette Struktur des aktuellen Standes hinein.<\/p>\n
Mit dem folgenden Schalter können Sie alle Dateien eines bestimmten Versionsstandes in das Arbeitsverzeichnis auschecken:<\/p>\n
cvs checkout -r <Version> CVSBeispiel<\/pre>\nPraxis-Tipp<\/h3>\n
CVS legt beim Checkout standardmäßig ein neues Verzeichnis in dem aktuellen Verzeichnis mit dem Namen des Moduls an. Um die Arbeitskopie in einem individuellen Verzeichnis anzulegen, verwenden Sie einfach den Schalter -d <Verzeichnis>. <\/p>\n
Ganz besonders wichtig für das Auschecken von Dateien ist die Möglichkeit, die Version der ausgecheckten Dateien per Parameter anzugeben. So kann man beispielsweise alle Dateien aus dem Repository in das Arbeitsverzeichnis kopieren lassen, die zu einem bestimmten Datum Gültigkeit hatten. Außerdem kann man auch zu einem beliebigen Zeitpunkt einen Release-Stand festlegen, der jederzeit wieder abgerufen werden kann.<\/p>\n
Beispiel<\/h3>\n
Um bei unserem Beispiel zu bleiben, checken wir die ins Repository importierte Datei direkt einmal aus. Ohne diesen Schritt können Sie die Datei zwar bearbeiten, aber die Datei nicht mit dem Repository abgleichen (in einer Zeile):<\/p>\n
C:\\\\cvstest>cvs -d :local:h:\/cvsrepository checkout -d c:\\\\cvstest Beispiel<\/pre>\nCVS gibt folgende Meldung zurück und bestätigt damit, dass ein Update auf dem Verzeichnis erfolgt ist (erkennbar an dem Buchstaben U vor dem Dateinamen):<\/p>\n
cvs checkout: cwd=C:\\\\cvstest, current=C:\\\\cvstest\ncvs checkout: Updating c:\\\\cvstest\nU c:\\\\cvstest\/Beispiel.txt<\/pre>\nDateien updaten<\/h2>\n
Wenn mehrere Entwickler an einem Projekt arbeiten, kann es sein, dass Entwickler A eine Datei des Projekts ändert und seine Version in das Repository überführt hat.<\/p>\n
Damit nun nicht Entwickler B zufällig änderungen an der gleichen Datei durchführt, diese zum Repository überträgt und damit eventuell die änderungen von Entwickler A verwirft, gibt es die Update-Anweisung.<\/p>\n
Damit gleicht Entwickler B seine Version mit der aktuellen Version im Repository ab, wobei die änderungen aus der Version des Repositorys auf die Version von Entwickler B im Arbeitsverzeichnis übertragen werden – aber auch nur die änderungen.<\/p>\n
Entwickler B kann dann die neue Version mit den eigenen änderungen und denen von Entwickler A ins Repository einchecken. Und wenn zufällig mal beide an der gleichen Stelle im Code gearbeitet haben (was im übrigen von einer schlechten Absprache zeugt) muss Entwickler B den Konflikt manuell beheben und die richtige Version ins Repository übertragen.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 3: Geänderte Textdatei<\/b><\/p>\n
Dem Access-Entwickler, der in der Regel als Einzelkämpfer auftritt, wird dies aber vermutlich eher selten passieren.<\/p>\n
Beispiel<\/h3>\n
Für ein Update-Beispiel ändern Sie den Inhalt der Datei Beispiel.txt im Verzeichnis c:\\\\cvstest, indem Sie einfach eine Zeile hinzufügen (s. Abb. 3).<\/p>\n
Anschließend setzen Sie vom Arbeitsverzeichnis aus folgende Anweisung ab:<\/p>\n
C:\\\\cvstest>cvs update<\/pre>\nCVS zeigt den Update-Vorgang an und kennzeichnet die Beispieldatei mit dem Buchstaben M als „modified“.<\/p>\n
cvs update: Updating .\nM Beispiel.txt<\/pre>\nDamit ist die änderung aber noch nicht ins Repository übertragen. Dazu benötigen Sie noch eine weitere Anweisung, die Sie im nächsten Abschnitt kennen lernen.<\/p>\n
Hinweis<\/h3>\n
Möglicherweise wundern Sie sich, dass die Angabe der Verbindungseigenschaften und des Repository fehlen. Der Grund ist, dass Sie sich gerade in einem Arbeitsverzeichnis befinden, und dort hat CVS ein zusätzliches Verzeichnis namens CVS angelegt. Es enthält alle notwendigen Informationen, sodass Sie von hier aus alle Anweisungen ohne den Parameter d und die entsprechenden Zugangsanweisungen angeben können. <\/p>\n
änderungenübertragen<\/h2>\n
Um änderungen an einer Datei im Arbeitsverzeichnis in das Repository zu bringen, verwenden Sie den Commit-Befehl. Dieser erfolgt am besten im Anschluss an den Aufruf der Update-Anweisung. Mit der übertragung der änderungen legt CVS im Repository einen neuen Versionsstand der geänderten Dateien an.<\/p>\n
Beispiel<\/h3>\n
Die soeben vorgenommene änderung haben Sie per „Update“-Anweisung bereits markiert, nun soll diese noch ins Repository übernommen werden. Dazu verwenden Sie folgende Anweisung:<\/p>\n
C:\\\\cvstest>cvs commit -m \"Zweizeiler\"<\/pre>\nDiese Anweisung überträgt alle änderungen ins Repository. Wenn Sie also mehrere Dateien geändert haben, aber nur die änderungen an einem Teil der Dateien in das Repository übertragen möchten, geben Sie alle Dateinamen an. Der Parameter m leitet die Angabe der Logmessage für diese Version ein. CVS gibt als Antwort Folgendes aus:<\/p>\n
cvs commit: Examining .\nChecking in Beispiel.txt;\nh:\/cvsrepository\/Beispiel\/Beispiel.txt,v <-- Beispiel.txt\nnew revision: 1.2; previous revision: 1.1\ndone<\/pre>\nHistorie einer Datei<\/h2>\n
CVS speichert Dateien nur beim Import beziehungsweise beim ersten Hinzufügen komplett.<\/p>\n
Anschließend notiert es lediglich die Unterschiede zwischen der Originaldatei und der geänderten Datei mit; daraus resultiert unter Umständen eine enorme Speicherplatzersparnis.<\/p>\n
RCS file: h:\/cvsrepository\/Beispiel\/Beispiel.txt,v\nWorking file: Beispiel.txt\nhead: 1.2\nbranch:\nlocks: strict\naccess list:\nsymbolic names:\n arelease: 1.1.1.1\n avendot: 1.1.1\nkeyword substitution: kv\ntotal revisions: 3; selected revisions: 3\ndescription:\n----------------------------\nrevision 1.2\ndate: 2004\/09\/20 14:31:02; author: Administrator; state: Exp; lines: +1 -0;\nkopt: kv; commitid: 670414ee9a66f3b; filename: Beispiel.txt;\nZweizeiler\n----------------------------\nrevision 1.1\ndate: 2004\/09\/20 13:58:54; author: Administrator; state: Exp;\nbranches: 1.1.1;\nInitial revision\n----------------------------\nrevision 1.1.1.1\ndate: 2004\/09\/20 13:58:54; author: Administrator; state: Exp; lines: +0 -0;\nNeues Modul\n=============================================================================<\/pre>\nQuellcode 1<\/b><\/p>\n
Die Historie einer oder mehrerer Dateien lässt sich leicht mit der Anweisung „log“ anzeigen.<\/p>\n
Beispiel<\/h3>\n
Nach nur einem Import- und einem Commit-Vorgang ist noch keine besonders umfangreiche Historie vorhanden.<\/p>\n
Daher können wir diese leicht an dieser Stelle abdrucken. Mit dem folgenden Aufruf zeigen Sie die Historie für alle Dateien des angegebenen Repository an:<\/p>\n
C:\\\\cvstest>cvs log \ncvs log: Logging .<\/pre>\nCVS antwortet mit den Zeilen aus Quellcode 1. Dabei ist die mit revision 1.2 gekennzeichnete Version diejenige, die wir soeben ins Repository überführt haben. Die Angabe lines +1 -0 gibt an, dass eine Zeile hinzugekommen ist und keine gelöscht wurde.<\/p>\n
Unterschiede zwischenVersionsständen<\/h2>\n
Oft muss man gar nicht zu einem älteren Versionsstand zurückkehren, um in der Entwicklung voranzuschreiten: In vielen Fällen reicht es, die änderungen an einer Datei einzusehen. Für diesen Fall bietet CVS die Anweisung diff.<\/p>\n
Mit dieser Anweisung kann man die aktuell im Arbeitsverzeichnis befindliche Version einer Datei mit jeder gespeicherten Version vergleichen.<\/p>\n
Es ist sogar möglich, die änderungen zwischen zwei im Repository gespeicherten Dateien anzuzeigen.<\/p>\n
Beispiel<\/h3>\n
Um die Unterschiede zwischen der im Arbeitsverzeichnis befindlichen Version der Textdatei und beispielsweise der Version 1.1 anzuzeigen, geben Sie im Arbeitsverzeichnis die folgende Anweisung ein:<\/p>\n
C:\\\\cvstest>cvs diff -r1.1 Beispiel.txt<\/pre>\nDie Ausgabe der Unterschiede sieht etwa folgendermaßen aus. Dabei findet CVS automatisch heraus, dass die Version im Arbeitsverzeichnis mit der Version 1.2 übereinstimmt und zeigt die Unterschiede zwischen Version 1.1 und 1.2 an:<\/p>\n
Index: Beispiel.txt\n========================================\nRCS file: h:\/cvsrepository\/Beispiel\/Beispiel.txt,v\nretrieving revision 1.1\nretrieving revision 1.2\ndiff -r1.1 -r1.2\n1a2\n> Mehr Beispieltext<\/pre>\naccessCVS ist eine Schnittstelle für die Verwendung von CVS mit Access. Es verwendet die in den vorhergehenden Abschnitten vorgestellten Techniken zur Verwaltung der Versionsstände für folgende Objekttypen:<\/p>\n
Da accessCVS ständig weiterentwickelt wird und Sie hier keine Dokumentation vorfinden sollen, die beim Erscheinen des Beitrags schon nicht mehr aktuell ist, drucken wir an dieser Stelle keine Beschreibung der Anwendung ab. Damit Sie ständig mit der aktuellen Version des Tools und einer entsprechenden Dokumentation arbeiten können, bieten wir beides unter http:\/\/www.accesscvs.de zum Download an. <\/p>\n
In der oben aufgeführten Liste der Objekte, die man mit CVS verwalten kann, fehlen die Tabellen. Der Grund ist, dass Access Tabellen nicht in einer Art und Weise exportieren kann, die eine Verwaltung in CVS sinnvoll macht. Alternativ sollte man die Tabellen in ein Backend ausgliedern und dieses Backend separat mit CVS verwalten. So kann man zu jedem Release die derzeit gültige Fassung des Datenmodells per Backend versionieren.<\/p>\n
Wenn Sie auch an dieser Stelle keine Beschreibung der kompletten Lösung finden, möchten wir auf einige technische Besonderheiten hinweisen.<\/p>\n
CVS arbeitet normalerweise so, dass nach dem erstmaligen Speichern der Dateien eines Projekts zunächst ein „Checkout“ in ein Arbeitsverzeichnis erfolgen muss. Der Entwickler arbeitet im Folgenden mit der in diesem Arbeitsverzeichnis abgelegten Version des Projekts.<\/p>\n
Wenn er die vorgenommenen änderungen an das Repository übermitteln möchte, überprüft er zunächst per „Update“-Anweisung, ob nicht zufällig ein anderer Entwickler an den gleichen Dateien gearbeitet hat und eventuell Konflikte zu lösen sind. Erst dann kann er mit der „Commit“-Anweisung die vorgenommenen änderungen ins Repository überführen.<\/p>\n
Will man CVS mit Access anwenden, kommt noch ein Schritt hinzu, denn prinzipiell ist ja Access auch eine Art „Repository“. Dort gilt es zunächst, die mit CVS zu verwaltenden Daten zu exportieren.<\/p>\n
Zum Glück gibt es dort zwei undokumentierte Funktionen, mit denen Abfragen, Formulare, Berichte, Makros und Module im Textformat exportiert und wieder importiert werden können. Die beiden nützlichen Helfer heißen SaveAsText und LoadFromText und ihr Aufruf sieht beispielsweise folgendermaßen aus:<\/p>\n
Application.SaveAsText acModule, \"mdlTest\", \"c:\\\\mdlText.txt\"<\/pre>\nDiese Anweisung speichert den Inhalt des Moduls mdlText in eine Datei namens mdlText.txt im Verzeichnis c:\\\\. Genau andersherum arbeitet die Methode LoadFromText.<\/p>\n
Mit diesen beiden Methoden bewaffnet kann man die gewünschten Datenbankobjekte im Textformat im Arbeitsverzeichnis speichern und sie von dort aus mit den entsprechenden CVS-Anweisungen mit dem Inhalt des Repository abgleichen.<\/p>\n
Wenn man einen früheren Versionsstand als den aktuellen wiederherstellen möchte, macht man die entsprechenden Dateien per „Checkout“-Anweisung im Arbeitsverzeichnis verfügbar; von dort greift sich die Access-Anwendung diese per „LoadFromText“-Befehl.<\/p>\n
Automatisierung ist Trumpf<\/h2>\n
Sie können die Versionsverwaltung von Access-Objekten natürlich von Hand erledigen, aber dann werden Sie wahrscheinlich mehr Zeit mit dem Dos-Prompt als mit dem VBA-Editor verbringen.<\/p>\n
Deshalb versucht accessCVS, Ihnen einen Großteil der Arbeit abzunehmen und die Versionsverwaltung weitgehend automatisiert zu erledigen.<\/p>\n
Sprich: Sie können beispielsweise mit wenigen Mausklicks einen neuen Versionsstand der aktuellen Fassung der Datenbankobjekte im Repository unterbringen oder einen bestimmten dort gespeicherten Stand in der Datenbank wiederherstellen.<\/p>\n
Die Realisierung enthält einige Stolpersteine. Damit aus der Kommunikation der Anwendung mit CVS keine Einbahnstraße wird, ist es nötig, die Antworten von CVS auf die abgesetzten Anweisungen auszuwerten. Da CVS ein Kommandozeilentool ist, sendet es alle Ausgaben an den DOS-Prompt.<\/p>\n
Von dort wollen diese Informationen erst mal nach Access gelangen. Mit Hilfe einiger API-Funktionen (unter anderem CreateProcess) kann man die Ausgabe direkt in eine Variable umleiten.<\/p>\n
Anschließend müssen die Antworten von CVS so ausgewertet werden, dass sich ein Erfolg oder Misserfolg der abgesetzten Anweisungen ablesen lässt.<\/p>\n
Weitere Informationen zu der Vorgehensweise finden Sie in der Dokumentation zum Download unter http:\/\/www.accesscvs.de. <\/p>\n
Wer sich auch außerhalb von Access mit CVS beschäftigen möchte und kein Kommandozeilen-Freund ist, kann sich im Internet unter http:\/\/www.wincvs.org das Tool WinCVS herunterladen. Es ist Explorer-ähnlich aufgebaut und ermöglicht die menügesteuerte Bedienung von CVS.<\/p>\n
Und lernen können Sie durch die Benutzung dieses Tools auch noch: WinCVS zeigt alle per Menübefehl oder Schaltfläche aufgerufenen CVS-Anweisungen mit allen Parametern an und präsentiert zusätzlich auch die jeweiligen Antworten von CVS. <\/p>\n
Der Beitrag liefert einen überblick über die Möglichkeiten von CVS und zeigt auf, wie sich diese in Kooperation mit Microsoft Access einsetzen lassen.<\/p>\n
Unter http:\/\/www.accesscvs.de finden Sie alles, was unter den Bereich Ausblick fällt: nämlich die Umsetzung der hier vorgestellten Möglichkeiten in Form einer Erweiterung von Access, mit der Sie Access-Datenbankobjekte mit wenigen Mausklicks einer Versionsverwaltung zuführen können.<\/p>\n","protected":false},"excerpt":{"rendered":"
Beim Thema Versionsverwaltung fällt dem Anwender von Microsoft-Entwicklerprodukten erstmal Visual Source Safe ein. Wenn man über den Tellerrand schaut, finden sich dort einige vor allem aus der Unix-Welt stammende Produkte, allen voran CVS (Concurrent Version System). Der vorliegende Beitrag stellt die Grundlagen zu diesem System vor und klopft ab, inwieweit es sich zur Kooperation mit Microsoft Access bewegen lässt.<\/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":[662004,66052004,44000027],"tags":[],"class_list":["post-55000236","post","type-post","status-publish","format-standard","hentry","category-662004","category-66052004","category-Loesungen"],"yoast_head":"\n
Versionsverwaltung mit Access und CVS - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Versionsverwaltung mit Access und CVS\" \/>\n<meta property=\"og:description\" content=\"Beim Thema Versionsverwaltung fällt dem Anwender von Microsoft-Entwicklerprodukten erstmal Visual Source Safe ein. Wenn man über den Tellerrand schaut, finden sich dort einige vor allem aus der Unix-Welt stammende Produkte, allen voran CVS (Concurrent Version System). Der vorliegende Beitrag stellt die Grundlagen zu diesem System vor und klopft ab, inwieweit es sich zur Kooperation mit Microsoft Access bewegen lässt.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2023-02-10T14:47:37+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-19T08:18:26+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"17\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Versionsverwaltung mit Access und CVS\",\"datePublished\":\"2023-02-10T14:47:37+00:00\",\"dateModified\":\"2024-02-19T08:18:26+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/\"},\"wordCount\":3159,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/bf571190d1124ee8b74163ae69a64450\",\"articleSection\":[\"2004\",\"5\\\/2004\",\"L\u00f6sungen\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/\",\"name\":\"Versionsverwaltung mit Access und CVS - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/bf571190d1124ee8b74163ae69a64450\",\"datePublished\":\"2023-02-10T14:47:37+00:00\",\"dateModified\":\"2024-02-19T08:18:26+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/bf571190d1124ee8b74163ae69a64450\",\"contentUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/bf571190d1124ee8b74163ae69a64450\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/versionsverwaltung_mit_access_und_cvs\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Versionsverwaltung mit Access und CVS\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Versionsverwaltung mit Access und CVS - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/","og_locale":"de_DE","og_type":"article","og_title":"Versionsverwaltung mit Access und CVS","og_description":"Beim Thema Versionsverwaltung fällt dem Anwender von Microsoft-Entwicklerprodukten erstmal Visual Source Safe ein. Wenn man über den Tellerrand schaut, finden sich dort einige vor allem aus der Unix-Welt stammende Produkte, allen voran CVS (Concurrent Version System). Der vorliegende Beitrag stellt die Grundlagen zu diesem System vor und klopft ab, inwieweit es sich zur Kooperation mit Microsoft Access bewegen lässt.","og_url":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/","og_site_name":"Access im Unternehmen","article_published_time":"2023-02-10T14:47:37+00:00","article_modified_time":"2024-02-19T08:18:26+00:00","og_image":[{"url":"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"17\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Versionsverwaltung mit Access und CVS","datePublished":"2023-02-10T14:47:37+00:00","dateModified":"2024-02-19T08:18:26+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/"},"wordCount":3159,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#primaryimage"},"thumbnailUrl":"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450","articleSection":["2004","5\/2004","L\u00f6sungen"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/","url":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/","name":"Versionsverwaltung mit Access und CVS - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#primaryimage"},"thumbnailUrl":"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450","datePublished":"2023-02-10T14:47:37+00:00","dateModified":"2024-02-19T08:18:26+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#primaryimage","url":"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450","contentUrl":"http:\/\/vg01.met.vgwort.de\/na\/bf571190d1124ee8b74163ae69a64450"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/versionsverwaltung_mit_access_und_cvs\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Versionsverwaltung mit Access und CVS"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000236","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000236"}],"version-history":[{"count":1,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000236\/revisions"}],"predecessor-version":[{"id":88075294,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000236\/revisions\/88075294"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000236"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000236"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000236"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}