<\/p>\n
So, jetzt habe ich endgültig die Nase voll. Schon wieder ist es passiert: Mit letzter Kraft eine wichtige Routine zu Ende programmiert und jetzt nur noch Access schließen, den Rechner runterfahren und ab ins Bett. Und am nächsten Morgen die Ernüchterung: Die änderungen sind nicht mehr da! Da habe ich wohl mal wieder mit „Nein“ auf die Frage geantwortet, ob ich die geänderten Objekte speichern möchte … Aber damit ist jetzt Schluss: Ich baue mir ein Tool, das regelmäßig meine Formulare, Berichte und Module speichert – und dabei auch noch alte Versionen aufbewahrt.<\/b><\/p>\n
Es ist ein Kreuz: Es braucht unter Access nur ein wenig Ungeschicklichkeit, um eine Menge Arbeit zu vernichten. Wenn Sie mal ein umfangreiches Modul programmiert und dann die Datenbank oder das Modul geschlossen haben, ohne den neuen Stand zu speichern, wissen Sie, wovon ich spreche. Zwischenspeichern <\/p>\n
Wenn man gerade im Programmierrausch ist und eine Zeile nach der anderen schreibt, denkt man nicht unbedingt an das Zwischenspeichern, auch wenn es doch so einfach wäre, zwischendurch einfach mal Strg + S <\/b>zu drücken.<\/p>\n
Wie kommt man dem bei Termine in Outlook setzen, die einen alle 15 Minuten daran erinnern, mal durchzupusten und den aktuellen Stand zu speichern<\/p>\n
So weit kommt es noch – wir sind schließlich Programmierer und die helfen sich selbst.<\/p>\n
Wenn man sich aber schon an die Programmierung eines Tools macht, das regelmäßig für das Speichern geänderter Objekte sorgt, was sollte dieses Tool praktischerweise noch erledigen<\/p>\n
Das automatische Speichern ist nicht unbedingt immer eine perfekte Lösung: Immerhin zerstört man damit ja auch die Möglichkeit, zum Stand der letzten Speicherung zurückzukehren – und damit zur möglicherweise letzten funktionstüchtigen Version.<\/p>\n
Unter Access und speziell im VBA-Editor ist das praktisch eine Lebensversicherung, wenn man mal größere änderungen durchführt und diese dann doch nicht übernehmen möchte – man speichert sie dann einfach nicht.<\/p>\n
Der VBA-Editor bietet nämlich auch in der aktuellen Version nur die Möglichkeit, 20 Schritte rückgängig zu machen – insgesamt, nicht pro Modul!<\/p>\n
Es scheint also eine gute Idee, die gespeicherten Zwischenstände zu sichern. Aber wohin damit – und wie<\/p>\n
Bevor wir uns diesen technischen Feinheiten zuwenden, halten wir fest: Access soll den Stand der Entwicklung in regelmäßigen Abständen, zumindest aber beim Schließen der Anwendung, sichern.<\/p>\n
Auf diese Weise sorgen Sie nicht nur dafür, dass änderungen nicht verloren gehen, sondern können auch noch auf frühere Stände zurückgreifen.<\/p>\n
Schauen wir uns an, wie das Ganze funktioniert: Nachdem Sie die Elemente der Anwendung wie im Kasten „Im Soforteinsatz“ zu einer Datenbank hinzugefügt und dafür gesorgt haben, dass das Formular frmAccVersion <\/b>angezeigt wird, können Sie schon loslegen.<\/p>\n
Das Formular sehen Sie in Bild 1. Es enthält ein Listenfeld zur Anzeige der Module und ein weiteres zur Auflistung der Versionen zum aktuell im ersten Listenfeld markierten Modul. Zu den Modulen gehören in dem Fall Formulare, Berichte, Standardmodule und Klassenmodule, aber auch Abfragen.<\/p>\n
![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Das Formular zur Verwaltung der Versionen<\/span><\/b><\/p>\n Beim ersten Öffnen des Formulars sind diese Listenfelder natürlich noch leer, was sich aber nach einem Klick auf die Schaltfläche Neue Version aller geänderten Objekte speichern <\/b>ändert. Die Versionsverwaltung durchläuft dann alle Objekte der genannten Typen und legt zunächst das Modul im ersten Listenfeld und dann die Version im zweiten Listenfeld an.<\/p>\n Damit hat man schon einmal einen Zwischenstand, mit dem man sich ganz unbeschwert an den Code heranwagen kann, denn mit der Schaltfläche Bestehendes Objekt mit dieser Version überschreiben <\/b>können Sie sich ganz leicht eine ältere Version zurückholen.<\/p>\n Falls Sie sich nicht sicher sind, welche Version die richtige ist, stellen Sie einfach die Version wieder her, hinter der Sie die richtige vermuten – und zwar mit der Schaltfläche Objekt wiederherstellen als <Name>_yyyymmdd_hhnnss<\/b>, die bestehende Objekte nicht überschreibt, sondern unter einem Namen anlegt, der den Zeitpunkt der Speicherung enthält.<\/p>\n Die Schaltfläche Version löschen <\/b>dient schließlich dazu, eine oder mehrere Versionen zu entsorgen – wenn man einen Versionsstand erreicht hat, bei dem alles funktioniert, braucht man selbstverständlich keine Altlasten mehr mit sich herumzutragen.<\/p>\n Schließlich gibt es im unteren Bereich noch die Steuerelemente zum Festlegen der regelmäßigen Sicherung von Versionsständen. Mit dem Kontrollkästchen Geänderte Objekte alle x Minuten als neue Version sichern <\/b>aktivieren Sie diese Funktion, in das Textfeld Intervall [min] <\/b>tragen Sie ein, in welchem Abstand die Sicherung erfolgen soll.<\/p>\n Wenn der Benutzer die Datenbankanwendung beendet, schließt er auch das Formular frmAccVersion<\/b>. Dieses sorgt dann mit seiner letzten Aktion noch einmal dafür, dass nicht gespeicherte Module in den Versionierungstabellen gespeichert werden.<\/p>\n Wenn Sie also ein Modul namens mdlTest <\/b>bearbeiten, die änderungen nicht speichern und dann die Anwendung schließen, speichert frmAccVersion <\/b>trotzdem die aktuelle Version des Moduls.<\/p>\n Beim nächsten Öffnen der Datenbank erscheint eine Meldung, die den Benutzer darauf hinweist, dass es Module oder Objekte gibt, die vor dem letzten Schließen geändert, aber nicht gespeichert wurden (siehe Bild 2).<\/p>\n Bild 2: Diese Meldung macht den Benutzer auf ungespeicherte Elemente aufmerksam.<\/span><\/b><\/p>\n Im Anschluss erscheint das Formular frmAccVersion<\/b> und zeigt das nicht gespeicherte Objekt unter dem Originalobjekt an – versehen mit einer GUID. Mit einem Klick auf die Schaltfläche Objekte wiederherstellen als <Name>_yyyymmdd_hhnnss <\/b>erzeugen Sie dann eine Kopie des Objekts mit dem ungespeicherten Stand beim letzten Schließen der Anwendung (siehe Bild 3).<\/p>\n Bild 3: Nicht gespeicherte änderungen lassen sich mit AccVersion zurückholen.<\/span><\/b><\/p>\n Für manche Objekte ist es wichtig, diese vor dem Versionieren zu speichern. Dies gilt für Abfragen, Berichte und Formulare. Standard- und Klassenmodule stehen ohne weitere Schritte zum Versionieren bereit.<\/p>\n Das ist allerdings ein Problem, denn dieses Tool soll ja gerade auch dann, wenn der Benutzer es versäumt, ein Objekt vor dem Beenden der Datenbank zu speichern, geradestehen und die seit dem letzten Speichern getätigten änderungen sichern.<\/p>\n Ganz einfach ist das allerdings nicht, ohne den Benutzer nicht doch noch zu einem Klick auf die Ja<\/b>-Schaltfläche der Speichern<\/b>-Frage zu nötigen – warum, erfahren Sie weiter unten.<\/p>\n Die Anwendung braucht genau zwei Tabellen: Eine zum Speichern der Informationen zu den Modulen selbst und eine für die einzelnen Versionen der Module. Bild 4 zeigt die Tabellen und ihre Beziehung.<\/p>\n Bild 4: Datenmodell für die Verwaltung von Modulen und deren Versionen<\/span><\/b><\/p>\n Die Tabelle tblModule <\/b>enthält neben dem Feld Modulname <\/b>mit der Bezeichnung des Moduls nur noch ein Feld namens Modultyp<\/b>. Dieses enthält einen Zahlenwert, der einer der Konstanten der VBA-Enumeration acObjectType <\/b>entspricht. In diesem Zusammenhang kommen die folgenden Typen vor (Zahlenwert in Klammern):<\/p>\n Unter acModule <\/b>fallen dabei sowohl Klassen- als auch Standardmodule.<\/p>\n Die zweite Tabelle heißt tblVersionen <\/b>und ist über ein Fremdschlüsselfeld namens ModulID <\/b>mit der Tabelle tblModule <\/b>verknüpft. Auf diese Weise können die Datensätze dieser Tabelle den Modulen aus der Tabelle tblModule <\/b>zugeordnet werden.<\/p>\n Die Tabelle enthält weitere Felder zum Speichern des eigentlichen Inhalts des Moduls (Modulinhalt<\/b>) und des Speicherdatums (Speicherdatum<\/b>).<\/p>\n Das Feld Modulinhalt <\/b>ist dabei als Memofeld ausgelegt, weil es sehr lange Texte erfassen können muss.<\/p>\n Der Benutzer soll so wenige Objekte wie möglich in seine Anwendung importieren müssen, um mit der Versionsverwaltung arbeiten zu können. Daher soll das Hauptformular von AccVersion <\/b>– so soll das Tool heißen – beim Laden prüfen, ob die benötigten Tabellen schon vorhanden sind und diese anderenfalls anlegen. Ist das der Fall, kommt die Prozedur aus Listing 1 zum Einsatz.<\/p>\n Listing 1: Anlegen der für die Versionsverwaltung benötigten Tabellen per SQL<\/p>\n Diese Routine erzeugt zunächst die Tabelle tblModule<\/b>, dann tblVersionen <\/b>und schließlich das Fremdschlüsselfeld mit referentieller Integrität sowie Lösch- und Aktualisierungsweitergabe.<\/p>\n Der Inhalt der meisten Felder der Tabellen des Datenmodells bedarf keiner Erklärung, das Feld Modulinhalt<\/b> aber sehr wohl. Wer sich ein Modul (sei es ein einfaches Klassenmodul, ein Standardmodul oder auch das Klassenmodul eines Formulars oder Berichts) einmal angesehen hat, sieht zunächst nur den darin enthaltenen Code.<\/p>\n Nur diesen zu speichern, würde zwar schon weiterhelfen, denn somit könnten Sie zumindest den Verlust umfangreicher Codeänderungen verhindern.<\/p>\n Wer aber einmal ein Formular oder einen Bericht mit einer Menge Steuerelemente und entsprechenden Anpassungen der Eigenschaften gebaut hat und später alles noch einmal neu bauen musste, weil er im falschen Moment die falsche Schaltfläche angeklickt hat, wird sich über Folgendes freuen: Auch die Definition sämtlicher Eigenschaften von Formularen und Berichten und den darin enthaltenen Steuerelementen liegt in Textform vor und Sie können sogar darauf zugreifen!<\/p>\n Nun ist es nicht so, als ob diese Informationen offen herumliegen, aber über einen Zwischenschritt können Sie die komplette Definition von Objekten wie Formularen oder Berichten im Feld Modulinhalt <\/b>der Tabelle tblVersionen <\/b>speichern.<\/p>\n Dies macht die verborgene Methode SaveAsText <\/b>von Access.Application<\/b> möglich, die drei Parameter erwartet:<\/p>\n Wenn Sie mit dieser Methode ein noch leeres Formular als Textdatei speichern und es anschließend in einem Texteditor ansehen, sieht das beispielsweise wie in Bild 5 aus.<\/p>\n Bild 5: Die Definition eines leeren Formulars als Textdatei<\/span><\/b><\/p>\n Der schwierigste Teil von AccVersion <\/b>ist das eigentliche Versionieren der Module.<\/p>\n Dabei durchläuft eine Routine alle Elemente der Anwendung, die einem der möglichen Typen entsprechen und unterzieht diese einer ganzen Reihe von Methoden.<\/p>\n Wie aufwendig das ist, verdeutlicht ein Blick auf das Flussdiagramm aus Bild 6, dessen einzelne Schritte wir in den nächsten Abschnitten genau beleuchten werden.<\/p>\n Bild 6: Ablauf beim Versionieren der Objekte einer Access-Anwendung<\/span><\/b><\/p>\n Der Hauptteil dieses Flussdiagramms läuft in der Routine ModuleSpeichern <\/b>ab (s. Listing 2). Von dort aus werden noch eine Reihe weiterer Routinen aufgerufen. Den Rahmen bildet eine Do While<\/b>-Schleife, die alle Datensätze der Tabelle MSysObjects <\/b>durchläuft, die speziellen Anforderungen genügen.<\/p>\n Listing 2: Diese Routine steuert das Versionieren der Module.<\/p>\n <\/p>\n Diese Tabelle enthält Informationen über alle Objekte der Datenbank – Tabellen, Abfragen, Formulare, Berichte, Module, Indizes, in Formulare, Berichte und Steuerelemente eingebettete Abfragen und mehr. Diese Tabelle interessiert uns, weil sie zuverlässig den Namen und den Typ der gewünschten Access-Objekte liefert. Die für strSQL <\/b>angegebenen Kriterien entsprechen je einer Objektart, allerdings sind die Zahlenwerte nicht mit denen der VBA-Enumeration acObjectType <\/b>identisch.<\/p>\n Nachfolgend wird durch Zahlen in Klammern auf die einzelnen Stationen des Flussdiagramms verwiesen.<\/p>\n Der obere Teil der Routine aus Listing 2 beschäftigt sich mit dem Ermitteln der betroffenen Objekte und enthält außerdem den Start der Do While<\/b>-Schleife, die alle Datensätze der oben erwähnten Abfrage durchläuft (1). Direkt im Anschluss prüft eine If…Then<\/b>-Bedingung einige weitere Eigenschaften, so etwa, ob der Objektname mit zwei Unterstrichen (__) oder mit der Tilde (~) beginnt.<\/p>\n Ersteres ist eine Kennzeichnung für temporäre und zum Betrachten gedachte Objekte (mehr dazu weiter unten), Letzteres das erste Zeichen spezieller und hier nicht berücksichtigter Access-Objekte wie etwa die in Daten- und Datensatzherkünften gespeicherten Abfragen (2).<\/p>\n Der Objektname wird dann in der Variablen strModulname <\/b>und der Objekttyp in lngObjectType <\/b>gespeichert, wobei Letzteres in einer Select Case<\/b>-Anweisung geschieht, welche die Objekt-IDs aus der Tabelle MSysObjects <\/b>in die der Enumeration acObjectType <\/b>übersetzt.<\/p>\n Den Modulnamen speichert die Routine dann sicherheitshalber in einer weiteren Variablen namens strModulname_Original <\/b>zwischen, dieser Wert wird weiter unten noch benötigt. <\/p>\n Dann folgt die erste externe Funktion, nämlich SaveModule<\/b> (s. Listing 3). Im ersten Schritt (3) versucht diese Routine, den Inhalt des aktuellen Objekts als Textdatei zu speichern. Dies gelingt gerade bei Formularen und Berichten nicht unbedingt: Wenn diese sich in einem ungespeicherten Zustand befinden, kann man sie nicht so einfach mit SaveAsText<\/b> auf die Festplatte bannen. Im schlechtesten Fall löst dies einen Fehler aus, der aber in der folgenden Select Case<\/b>-Anweisung behandelt wird.<\/p>\n Listing 3: Diese Routine prüft, ob ein Modul aktuell gespeichert ist.<\/p>\n Ungespeicherter Zustand bedeutet, dass ein Objekt zwar geändert (egal, ob diese änderung sich auf den Code oder auch auf Steuerelemente et cetera bezieht), aber seit dieser änderung noch nicht gespeichert wurde.<\/p>\n Die Verhaltensweise ist bei Abfragen, Formularen und Berichten gegenüber Standard- und einfachen Klassenmodulen unterschiedlich: Bei Ersteren lässt sich ohne Speicherung gar kein Speichern in eine Textdatei per SaveAsText <\/b>bewerkstelligen, bei Letzteren hingegen schon: Dort speichert SaveAsText <\/b>ohne Probleme den aktuellen Stand in eine Textdatei, ohne dass man zuvor auf den Speichern-Knopf der VBA-Entwicklungsumgebung klicken müsste.<\/p>\n Dementsprechend treten die in der Select Case<\/b>-Anweisung (4) behandelten Fehler 32584 <\/b>und 2001 <\/b>auch nur in Zusammenhang mit Abfragen, Formularen und Berichten auf.<\/p>\n Ist dies der Fall, geschieht Folgendes (5): Wenn das Objekt sich nicht ungespeichert per SaveAsText <\/b>auf die Festplatte bannen lässt, kopieren wir das Objekt einfach in ein temporäres Objekt, speichern dieses und schreiben es dann ganz einfach in eine Textdatei.<\/p>\n Einziges Problem: Wir haben jetzt eine Dublette des eigentlichen Objekts und müssen mit dieser weiterarbeiten. Daher weist die Routine dem Übergabeparameter strModulname <\/b>den neuen Modulnamen zu, der aus dem alten Modulnamen plus einer GUID besteht – eine GUID ist eine mit hoher Wahrscheinlichkeit eindeutige Zeichenfolge.<\/p>\n Auch bei Standard- oder Klassenmodulen kann es vorkommen, dass diese zwar geändert, aber nicht gespeichert sind. Dies wirkt sich nicht auf SaveAsText <\/b>aus: Es speichert immer den aktuellen Stand, der damit nicht unbedingt dem in der Datenbank gespeicherten Zustand entsprechen muss.<\/p>\n Daher prüft die Routine SaveModule <\/b>auch bei solchen Objekten den Gespeichert-Zustand, was hier allerdings viel einfacher über eine Eigenschaft namens Saved <\/b>geschieht. Ist die Routine noch nicht gespeichert, wird auch hier der Modulname mit anhängender GUID statt des einfachen Modulnamens zurückgegeben.<\/p>\n Warum das ganze Theater mit den veränderten Modulnamen für nicht gespeicherte Objekte <\/p>\n Ganz einfach: Eines der Ziele von AccVersion <\/b>ist es ja gerade, auch nicht gespeicherte änderungen zu versionieren, also in einem eigenen Datensatz der Tabelle tblVersionen <\/b>zu speichern. Wenn so etwas geschieht – also der Anwender änderungen an einem Modul vornimmt, ohne diese beim Schließen der Anwendung zu speichern – soll er, ähnlich wie bei Word, darauf aufmerksam gemacht werden.<\/p>\n Und damit die aufrufende Routine ModulSpeichern <\/b>erkennt, dass es sich um einen solchen Fall handelt, ändern wir den als Parameter übergebenen Modulnamen, um einen weiteren Parameter zu sparen, der diesen Zustand an die aufrufende Routine weitergibt.<\/p>\n Nun liegt also eine Kopie des Moduls im Textformat vor – und das, obwohl eigentlich noch gar nicht feststeht, ob das Modul überhaupt in einer neuen Version gespeichert werden soll.<\/p>\n Warum schon vorher so viel Arbeit investieren Ganz einfach: Es gibt keine andere Möglichkeit, den Inhalt eines Moduls mit dem in der Tabelle tblVersionen <\/b>gespeicherten Inhalt zu vergleichen, als über den per SaveAsText <\/b>gespeicherten Inhalt.<\/p>\n Die Vorbereitung für diesen Vergleich geschieht wieder in der Routine ModuleSpeichern<\/b>.<\/p>\n Sie ruft die Funktion LoadModule <\/b>auf, die auf die soeben gespeicherte Datei zugreift und den Inhalt in einer Textvariablen speichert (6).<\/p>\n Die Routine sieht wie folgt aus und liefert den Inhalt der Textdatei als String zurück:<\/p>\n Dabei ist zu berücksichtigen, dass sämtliche temporär auf der Festplatte gespeicherten Module dort unter dem Namen temp.txt <\/b>im Verzeichnis der aktuellen Datenbank liegen. Wurde dieses Modul überhaupt schon einmal gespeichert<\/p>\n Diese Frage beantwortet die Funktion MustSaveObject<\/b>, die in der Tabelle tblModule <\/b>nach einem Modul mit dem Namen des aktuell bearbeiteten Objekts sucht (7):<\/p>\n Ist das nicht der Fall, legt die Routine SaveObject <\/b>mit einer INSERT INTO<\/b>-SQL-Abfrage einen entsprechenden Datensatz in der Tabelle tblModule <\/b>an (9):<\/p>\n Und dann kommt endlich die in der Variablen strModulinhalt <\/b>gespeicherte Kopie des aktuellen Inhalts des Objekts zum Tragen:<\/p>\n Die Prozedur MustSaveVersion <\/b>(s. Listing 4) vergleicht den Inhalt der Variablen, also den aktuellen Zustand, mit dem zuletzt in der Tabelle tblVersionen <\/b>gespeicherten (8). <\/p>\n Listing 4: Vergleichen der aktuellen Version mit der zuletzt gespeicherten Fassung<\/p>\n Unterscheiden sich die beiden Versionen, schreibt die Prozedur MakeNewVersion <\/b>(s. Listing 5) einen neuen Datensatz mit dem aktuellen Inhalt des Moduls in die Tabelle tblVersionen <\/b>(10).<\/p>\n Listing 5: Erstellen einer neuen Version in der Tabelle tblVersionen<\/p>\n Schließlich werden noch die temporären Objekte gelöscht, was die Routine TemporaereObjekteLoeschen <\/b>aus Listing 6 erledigt (11).<\/p>\n Listing 6: Temporäre Objekte und Dateien löschen<\/p>\n Diese kümmert sich zunächst um die in (5) angelegten temporären Objekte in der Datenbank, deren Objektname ja aus dem Originalnamen plus einer angehängten GUID besteht.<\/p>\n Auch diese Objekte sind in der Tabelle MSysObjects <\/b>aufgeführt. Dementsprechend ermittelt die Routine zunächst alle Objekte, deren Name mit einer GUID endet.<\/p>\n Dies lässt sich relativ einfach durch den Vergleichsausdruck Name LIKE '*_—-'<\/b> erledigen. Das Sternchen entspricht dabei dem ursprünglichen Objektnamen und der Rest ist ein Platzhalter für eine beliebige, aber immer gleich aufgebaute GUID.<\/p>\n Die Hauptfunktion ModuleSpeichern<\/b>, die Sie soeben kennen gelernt haben, wird von verschiedenen Stellen des Formulars frmAccVersion <\/b>aus mit verschiedenen Parametern aufgerufen.<\/p>\n Beim Schließen des Formulars erfolgt der Aufruf mit dem Wert True <\/b>für den Parameter bolZwischenspeichern<\/b>. Dieser legt fest, ob auch der aktuelle Stand nicht gespeicherter Abfragen, Formulare und Berichte gesichert werden soll. Da dies einige Rechenzeit für das Kopieren, Speichern, Vergleichen und Versionieren erfordert, soll dies nur beim Schließen der Anwendung geschehen.<\/p>\n Das Listenfeld lstModule <\/b>zeigt alle in der Tabelle tblModule<\/b> gespeicherten Module an. Die Datensatzherkunft wird im Ereignis Beim Anzeigen <\/b>des Formulars gefüllt:<\/p>\n Diese Routine ruft gleichzeitig die Prozedur VersionenAktualisieren <\/b>auf. Diese füllt das Listenfeld lstVersionen <\/b>mit den Datensätzen der Tabelle tblVersionen<\/b>, die zu dem Modul gehören, das im Listenfeld lstModule <\/b>angezeigt wird:<\/p>\n Die folgende Ereignisprozedur sorgt dafür, dass dies auch beim Aktualisieren des Listenfelds lstModule <\/b>geschieht:<\/p>\n Wann speichern<\/p>\n Es gibt drei Möglichkeiten für den Aufruf der oben beschriebenen Routine ModuleSpeichern<\/b>. Der erste erfolgt ganz einfach über einen Mausklick auf die Schaltfläche cmdStandSpeichern<\/b>:<\/p>\n Nach dem Speichern sorgt die Routine für das Aktualisieren der Listenfelder. Die zweite Möglichkeit ist zeitgesteuert. Mit den Steuerelementen im unteren Bereich können Sie festlegen, ob dies überhaupt geschehen soll und in welchem Intervall. Ein Klick auf das Kontrollkästchen ctlZwischenspeichern <\/b>löst die folgende Routine aus, die zunächst diese Einstellung in der Registry speichert, damit diese beim nächsten Aufruf automatisch gelesen werden kann.<\/p>\n Außerdem aktiviert oder deaktiviert sie das Textfeld zur Angabe des Speicherintervalls.<\/p>\n Eine änderung des Intervalls ist nur bei aktiviertem Textfeld txtSpeicherintervall <\/b>möglich und löst die folgende Prozedur aus. Der eingegebene Wert wird zunächst ebenfalls in die Registry geschrieben.<\/p>\n Falls das Zwischenspeichern aktiviert ist, stellt die Routine die Eigenschaft TimerIntervall <\/b>des Formulars frmAccVersion<\/b> auf den entsprechenden Wert ein.<\/p>\n Dies sorgt dafür, dass die für das Ereignis Bei Zeitgeber <\/b>festgelegte Prozedur in entsprechenden Abständen aufgerufen wird.<\/p>\n Die durch den Zeitgeber ausgelöste Prozedur enthält lediglich eine Anweisung:<\/p>\n Die dritte Möglichkeit zum Aufrufen von ModuleSpeichern <\/b>befindet sich im Ereignis Beim Entladen <\/b>des Formulars. Es wird automatisch beim Schließen des Formulars ausgelöst. Damit der Benutzer das Formular nicht willkürlich schließen kann, wurden die Schließen-Schaltfläche und andere Elemente der Titelleiste entfernt. Es gibt nur noch eine Schaltfläche im Formular zum Unsichtbarmachen.<\/p>\n Tritt in ModuleSpeichern<\/b> ein Fehler auf, liefert dieses den Wert False <\/b>zurück. Die Anwendung wird dann aus Sicherheitsgründen nicht geschlossen.<\/p>\n Mit der Schaltfläche cmdUeberschreiben<\/b> kann man eine Version wiederherstellen, indem man sie über die bestehende Fassung des Objekts schreibt.<\/p>\n Die dadurch ausgelöste Routine sieht wie in Listing 7 aus. Sie fragt zunächst nach, ob man die bestehende Fassung wirklich überschreiben möchte, und bricht bei negativer Antwort ab.<\/p>\n Listing 7: Ein Objekt durch Überschreiben eines bestehenden Objekts wiederherstellen<\/p>\n Anderenfalls öffnet sie eine Datensatzgruppe auf Basis der Abfrage qryModuleVersionen<\/b>, die alle Felder der beiden Tabellen tblModule <\/b>und tblVersionen <\/b>enthält und nach der ID des im Listenfeld lstVersion <\/b>ausgewählten Eintrags gefiltert ist.<\/p>\n Dann öffnet die Routine eine Textdatei und schreibt den Modultext hinein.<\/p>\n Sie benennt das bestehende Objekt um und legt dann mit der Methode LoadFromText <\/b>ein neues, auf der Textdatei bestehendes Objekt an. Anschließend löscht sie das temporär erstelle Objekt und aktualisiert das Datenbankfenster.<\/p>\n Wenn ein Objekt beispielsweise versioniert, aber nicht gespeichert wurde, kann der Benutzer dieses Objekt auch wiederherstellen, ohne das bestehende Objekt zu überschreiben, und es zunächst prüfen. Dies erledigt die Prozedur aus Listing 8.<\/p>\n Listing 8: Ein Objekt unter einem anderen Namen wiederherstellen<\/p>\n Der Einfachheit halber soll dies auch für mehrere Versionen gleichzeitig möglich sein. Deshalb gibt es eine Schleife, die alle markierten Einträge des Listenfeldes durchläuft. Damit der Benutzer im Listenfeld mehrere Einträge gleichzeitig markieren kann, stellen Sie die Eigenschaft Mehrfachauswahl <\/b>auf einen anderen Wert als Keine <\/b>ein, in diesem Fall auf Erweitert<\/b>.<\/p>\n Innerhalb der Schleife öffnet die Routine jeweils ein Recordset mit einem Datensatz der Abfrage qryModuleVersionen<\/b>. Der Modultext wird auch hier in einer Textdatei gespeichert, damit er anschließend mit der Methode LoadFromText <\/b>als Objekt angelegt werden kann.<\/p>\n Der Objektname besteht diesmal aus dem ursprünglichen Objektnamen und einer aus einem Unterstrich und dem Datum und der Uhrzeit der Speicherung bestehenden Erweiterung.<\/p>\n Möglicherweise ist schon ein Objekt gleichen Namens vorhanden; in diesem Fall wird der Vorgang mit einem entsprechenden Hinweis abgebrochen.<\/p>\n Die hier vorgestellte Lösung bietet eine Möglichkeit, den Fortschritt beim Entwickeln der Objekte und Module einer Datenbank in passenden Intervallen zu sichern. Zusätzlich bietet sie eine gewissen Sicherheit und das auf zweierlei Weise:<\/p>\n Es gibt allerdings noch eine Menge Erweiterungsmöglichkeiten für dieses Tool.<\/p>\n So muss man derzeit noch die fünf benötigten Elemente in die Datenbank importieren, in der man die Versionierung einsetzen möchte.<\/p>\n Praktischer wäre es sicherlich, wenn AccVersion <\/b>als COM-Add-In daherkäme und man dort festlegen könnte, in welchen Datenbanken das Tool tätig werden soll.<\/p>\n Die bisher in den beiden Tabellen tblModule <\/b>und tblVersionen <\/b>gespeicherten Daten könnte man auch extern speichern. Fürs Erste scheint das Sichern der Versionen in Tabellen, die sich in der selben Datenbank wie die zu sichernden Daten befinden, ausreichend – zumindest solange man diese Datenbank hin und wieder sichert.<\/p>\n Aber das sollten Sie ohnehin tun, denn der Stand des Datenmodells wird von AccVersion <\/b>nicht berücksichtigt.<\/p>\n Und das ist auch ein Punkt: Es wäre doch toll, wenn man verschiedene Stände der Entwicklung des Datenmodells ebenfalls sichern könnte.<\/p>\n Hier ist allerdings noch eine Menge mehr Arbeit erforderlich, denn Tabellen lassen sich nicht so einfach per SaveAsText <\/b>auf der Festplatte speichern – auch wenn der Befehl eine passende Konstante hergibt, die sich aber als nicht funktionell erweist.<\/p>\n Schließlich fehlt dem Tool noch jegliche Fehlerbehandlung – für den Produktiveinsatz sollten Sie es deshalb nur mit Bedacht einsetzen.<\/p>\n Sollte Ihnen die grundsätzliche Idee dieser Access-internen Versionierung gefallen, schreiben Sie es uns – am besten per E-Mail an info@access-im-unternehmen.de<\/b>.<\/p>\n Bei entsprechendem Interesse verfolgen wir dieses Thema weiter und liefern in den nächsten Monaten zusätzliche Features nach. Dazu können Sie uns natürlich auch gern eigene Ideen liefern – wir sind schon gespannt auf Ihr Feedback!<\/p>\n Im Soforteinsatz<\/p>\n<\/td>\n<\/tr>\n Wenn Sie die Versionierung in der aktuellen Fassung in einer eigenen Anwendung einsetzen möchten, importieren Sie dort die Objekte frmAccVersion<\/b>, frmProgress<\/b>, qryModuleVersionen<\/b>, mdlAccVersion <\/b>und mdlFortschrittsanzeige <\/b>in die Zieldatenbank. Sorgen Sie dafür, dass das Formular frmAccVersion <\/b>beim Start der Datenbank geöffnet wird – beispielsweise, indem Sie es als Startformular der Anwendung eintragen.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Enthaltene Beispieldateien:<\/p>\n accVersion.mdb<\/p>\nSchließen ohne zu speichern<\/h2>\n
![\"pic004.tif\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/pic004_opt.jpeg\")
<\/p>\n![\"pic005.tif\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/pic005_opt.jpeg\")
<\/p>\nNebenwirkungen<\/h2>\n
Datenmodell<\/h2>\n
![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/pic002_opt.jpeg\")
<\/p>\n\n
Datenmodell automatisch erstellen<\/h2>\n
Public Sub TabellenAnlegen()\r\nDim cnn As Object\r\nSet cnn = CurrentProject.Connection\r\ncnn.Execute "CREATE TABLE tblModule(ModulID COUNTER CONSTRAINT PK PRIMARY KEY, " _\r\n& "Modulname VARCHAR(255), Modultyp INT)", dbFailOnError\r\ncnn.Execute "CREATE TABLE tblVersionen(VersionID COUNTER CONSTRAINT PK PRIMARY KEY, " _\r\n& "Modulinhalt LONGTEXT, Speicherdatum DATETIME, ModulID INT)", dbFailOnError\r\ncnn.Execute "ALTER TABLE tblVersionen ADD CONSTRAINT FKModulID FOREIGN KEY (ModulID) " _\r\n& "REFERENCES tblModule ON DELETE CASCADE ON UPDATE CASCADE", dbFailOnError\r\nApplication.RefreshDatabaseWindow\r\nEnd Sub<\/pre>\n
Tabelleninhalt<\/h2>\n
\n
![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/pic003_opt.jpeg\")
<\/p>\nVersionieren von Access-Objekten<\/h2>\n
![\"Flussdiagramm.emf\"](\"..\/fileadmin\/_temp_\/2008_02\/Versionsverwaltung-web-images\/Flussdiagramm_opt.jpeg\")
<\/p>\nPublic Function ModuleSpeichern(bolZwischenspeichern As Boolean) As Boolean\r\n ...\r\n Set db = CurrentDb\r\n strSQL = "SELECT Name, Type FROM MSysObjects WHERE Type=1 Or Type=5 Or Type=8 Or Type=-32761 " _\r\n & "Or Type=-32764 Or Type=-32768;"\r\n Set rst = db.OpenRecordset(strSQL, dbOpenDynaset)\r\n FortschrittAnzeigen\r\n Do While Not rst.EOF\r\n If Not (Left(rst!Name, 2) = "__" Or Left(rst!Name, 1) = "~") Then\r\n strModulname = rst!Name\r\n Select Case rst!Type\r\n Case -32761 'Modul\r\n lngObjecttype = acModule\r\n Case -32764 'Report\r\n lngObjecttype = acReport\r\n Case -32768 'Form\r\n lngObjecttype = acForm\r\n Case 5\r\n lngObjecttype = acQuery\r\n Case Else 'andere Objekte\r\n strModulname = ""\r\n End Select\r\n If Not Len(strModulname) = 0 Then\r\n FortschrittAktualisieren "Versioniere " & rst!Name, _\r\n 100 * rst.AbsolutePosition \/ rst.RecordCount\r\n strModulname_Original = strModulname\r\n If SaveModule(strModulname, lngObjecttype, bolZwischenspeichern) = True Then\r\n strModulinhalt = LoadModule\r\n If MustSaveObject(strModulname) Then\r\n SaveObject strModulname, lngObjecttype\r\n End If\r\n lngModulID = DLookup("ModulID", "tblModule", "Modulname='" & strModulname & "'")\r\n If MustSaveVersion(lngModulID, strModulinhalt) Then\r\n MakeNewVersion lngModulID, strModulinhalt\r\n End If\r\n TemporaereObjekteLoeschen\r\n End If\r\n End If\r\n End If\r\n rst.MoveNext\r\n Loop\r\n FortschrittBeenden\r\nEnd Function<\/pre>\nPublic Function SaveModule(strModulname As String, lngObjecttype As AcObjectType, _\r\n bolZwischenspeichern As Boolean) As Boolean\r\n On Error Resume Next\r\n Dim strGuid As String\r\n strGuid = CreateGUID\r\n SaveAsText lngObjecttype, strModulname, CurrentProject.Path & "\\temp.txt"\r\n Select Case Err.Number\r\n Case 32584, 2001\r\n If Not bolZwischenspeichern Then\r\n On Error GoTo 0\r\n DoCmd.SelectObject lngObjecttype, strModulname, True\r\n On Error Resume Next\r\n DoCmd.CopyObject , strModulname & "_" & strGuid, lngObjecttype, strModulname\r\n On Error GoTo 0\r\n SaveAsText lngObjecttype, strModulname & "_" & strGuid, _\r\n CurrentProject.Path & "\\temp.txt"\r\n strModulname = strModulname & "_" & strGuid\r\n SaveModule = True\r\n Else\r\n SaveModule = False\r\n End If\r\n Case 0\r\n SaveModule = True\r\n Case Else\r\n SaveModule = False\r\n MsgBox "Fehler " & Err.Number & " " & Err.Description\r\n End Select\r\n If lngObjecttype = acModule Then\r\n If VBE.ActiveVBProject.VBComponents.Item(strModulname).Saved = False Then\r\n strModulname = strModulname & "_" & strGuid\r\n End If\r\n End If\r\nEnd Function<\/pre>\n
Public Function LoadModule() As String\r\n Dim strFilename As String\r\n strFilename = _\r\n CurrentProject.Path & "\\temp.txt"\r\n Open strFilename For Input As #1\r\n LoadModule = Input$(LOF(1), #1)\r\n Close #1\r\nEnd Function<\/pre>\n
Public Function MustSaveObject(strObjectname _\r\n As String) As Boolean\r\n MustSaveObject = Nz(DLookup("ModulID", _\r\n "tblModule", "Modulname LIKE '" _\r\n & strObjectname & "'"), 0) = 0\r\nEnd Function<\/pre>\nPublic Sub SaveObject(strModulname As String, _\r\nlngModultyp As AcModuleType)\r\nDim db As DAO.Database\r\nSet db = CurrentDb\r\ndb.Execute "INSERT INTO tblModule SELECT '" _\r\n& strModulname & "' AS Modulname, " _\r\n& lngModultyp & " AS Modultyp", _\r\ndbFailOnError\r\nEnd Sub<\/pre>\n
Public Function MustSaveVersion(lngModulID As Long, strModulinhalt As String) As Boolean\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT TOP 1 Modulinhalt FROM tblVersionen WHERE ModulID =" _\r\n & lngModulID & " ORDER BY Speicherdatum DESC", dbOpenDynaset)\r\n If Not rst.EOF Then\r\n If Not StrComp(strModulinhalt, rst!Modulinhalt, vbTextCompare) = 0 Then\r\n MustSaveVersion = True\r\n End If\r\n Else\r\n MustSaveVersion = True\r\n End If\r\nEnd Function<\/pre>\nPublic Sub MakeNewVersion(lngModulID As Long, strModulinhalt As String)\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT * FROM tblVersionen WHERE 1 = 2", dbOpenDynaset)\r\nrst.AddNew\r\nrst!ModulID = lngModulID\r\nrst!Modulinhalt.AppendChunk strModulinhalt\r\nrst!Speicherdatum = Now\r\nrst.Update\r\nrst.Close\r\nSet rst = Nothing\r\nSet db = Nothing\r\nEnd Sub<\/pre>\nPublic Sub TemporaereObjekteLoeschen()\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nDim lngObjecttype As AcModuleType\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT * FROM MSysObjects " _\r\n& "WHERE Name LIKE '*_----'", dbOpenDynaset)\r\nDo While Not rst.EOF\r\n Select Case rst!Type\r\n Case -32761 'Modul\r\n lngObjecttype = acModule\r\n Case -32764 'Report\r\n lngObjecttype = acReport\r\n Case -32768 'Form\r\n lngObjecttype = acForm\r\n Case 5\r\n lngObjecttype = acQuery\r\n End Select\r\n DoCmd.DeleteObject lngObjecttype, rst!Name\r\n rst.MoveNext\r\nLoop\r\nKill CurrentProject.Path & "\\temp.txt"\r\nEnd Sub<\/pre>\nBenutzeroberfläche<\/h2>\n
Steuerelemente<\/h2>\n
Private Sub Form_Current()\r\nMe!lstModule.RowSource = _\r\n"SELECT tblModule.ModulID, tblModule." _\r\n& "Modulname FROM tblModule " _\r\n& "ORDER BY tblModule.Modulname;"\r\nMe!lstModule = Me!lstModule.ItemData(0)\r\nVersionenAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub VersionenAktualisieren()\r\nMe!lstVersionen.RowSource = _\r\n"SELECT VersionID, Speicherdatum " _\r\n& "FROM tblVersionen WHERE ModulID = " _\r\n& Me.lstModule _\r\n& " ORDER BY Speicherdatum DESC"\r\nMe!lstVersionen = Me!lstVersionen.ItemData(0)\r\nEnd Sub<\/pre>\n
Private Sub lstModule_AfterUpdate()\r\nVersionenAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub cmdStandSpeichern_Click()\r\nModuleSpeichern True\r\nMe!lstModule.Requery\r\nVersionenAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub ctlZwischenspeichern_AfterUpdate()\r\nSaveSetting "AccVersion", "Konfiguration", _\r\n"Zwischenspeichern", _\r\nMe!ctlZwischenspeichern\r\nIf Me!ctlZwischenspeichern = True Then\r\n Me!txtSpeicherintervall.Enabled = True\r\nElse\r\n Me!txtSpeicherintervall.Enabled = False\r\nEnd If\r\nEnd Sub<\/pre>\n
Private Sub txtSpeicherintervall_AfterUpdate()\r\nSaveSetting "AccVersion", "Konfiguration", _\r\n"Speicherintervall", _\r\nMe!txtSpeicherintervall\r\nIf Me!ctlZwischenspeichern = True Then\r\n Me.TimerInterval = _\r\n Me!txtSpeicherintervall * 60 * 1000\r\n Me!txtSpeicherintervall.Enabled = True\r\nElse\r\n Me.TimerInterval = 0\r\n Me!txtSpeicherintervall.Enabled = False\r\nEnd If\r\nEnd Sub<\/pre>\n
Private Sub Form_Timer()\r\nModuleSpeichern True\r\nEnd Sub<\/pre>\n
Private Sub Form_Unload(Cancel As Integer)\r\nCancel = Not ModuleSpeichern(False)\r\nEnd Sub<\/pre>\n
Version wiederherstellen<\/h2>\n
Private Sub cmdUeberschreiben_Click()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n If MsgBox("Möchten Sie die bestehende Fassung wirklich überschreiben", vbYesNo, _\r\n "Überschreiben") = vbYes Then\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT * FROM qryModuleVersionen WHERE VersionID = " _\r\n & Me!lstVersionen.ItemData(Me!lstVersionen.ItemsSelected(0)), dbOpenDynaset)\r\n Open CurrentProject.Path & "\\temp.txt" For Output As #1\r\n Print #1, rst!Modulinhalt\r\n Close #1\r\n DoCmd.Rename rst!Modulname & "_tmp", rst!Modultyp, rst!Modulname\r\n LoadFromText rst!Modultyp, rst!Modulname, CurrentProject.Path & "\\temp.txt"\r\n DoCmd.DeleteObject rst!Modultyp, rst!Modulname & "_tmp"\r\n Application.RefreshDatabaseWindow\r\nEnd If\r\nEnd Sub<\/pre>\nObjekte testweise wiederherstellen<\/h2>\n
Private Sub cmdWiederherstellenAls_Click()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim var As Variant\r\n Set db = CurrentDb\r\n For Each var In Me.lstVersionen.ItemsSelected\r\n Set rst = db.OpenRecordset("SELECT * FROM qryModuleVersionen WHERE VersionID = " _\r\n & Me!lstVersionen.ItemData(var), dbOpenDynaset)\r\n Open CurrentProject.Path & "\\temp.txt" For Output As #1\r\n Print #1, rst!Modulinhalt\r\n Close #1\r\n On Error Resume Next\r\n LoadFromText rst!Modultyp, "__" & rst!Modulname _\r\n & Format(rst!Speicherdatum, "_yyyymmdd_hhnnss"), CurrentProject.Path & "\\temp.txt"\r\n If Err.Number = 2950 Then\r\n MsgBox "Dieses Objekt ist bereits vorhanden. " _\r\n & "Löschen Sie es zunächst oder benennen Sie es um."\r\n End If\r\n On Error GoTo 0\r\n Next var\r\n Application.RefreshDatabaseWindow\r\n End Sub<\/pre>\nZusammenfassung und Ausblick<\/h2>\n
\n
\n\n
\n \n \n \n Downloads zu diesem Beitrag<\/h3>\n