{"id":55000491,"date":"2025-12-01T00:00:00","date_gmt":"2026-02-05T15:59:10","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=491"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SQL_ServerDatenbank_von_Access_aus_updaten","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/SQL_ServerDatenbank_von_Access_aus_updaten\/","title":{"rendered":"SQL Server-Datenbank von Access aus updaten"},"content":{"rendered":"

\"\"Wenn wir eine Access-Anwendung mit SQL Server-Frontend an einen Kunden ausgeliefert haben, müssen wir sicherstellen, dass Updates problemlos funktionieren. Updates haben hier zwei Seiten: Einerseits kann das Access-Frontend um neue Funktionen erweitert werden, andererseits können diese Funktionen eine Anpassung der SQL Server-Datenbank erfordern. Das Aktualisieren der Access-Datenbank erfolgt im einfachsten Fall durch einfaches Ersetzen der .accdb-Datei. Beim Backend wird es ein wenig aufwendiger: Wir können es nicht einfach ersetzen, da die enthaltenen Daten im laufenden Betrieb bearbeitet wurden. Hier gibt es nun zwei Wege: Wir lassen uns ein Backup des Backends zukommen, aktualisieren es und spielen es anschließend wieder ein. Wenn die Anwendung bei mehreren Kunden verwendet wird, ist dies jedoch zu aufwendig. In diesem Fall können wir das Backend aber auch automatisch durch entsprechenden Code in der neuen Version des Frontends aktualisieren lassen. Wie das gelingt, zeigen wir in diesem Artikel.<\/b><\/p>\n

Access-Entwickler wissen: Eine Access-Datenbank ist niemals fertig. Kunden haben immer neue Anforderungen, die umgesetzt werden müssen. Wenn die Anforderungen auch die Tabellen der Datenbank betreffen, müssen wir bei einer Aktualisierung des Frontends auch das Backend entsprechend erneuern, zum Beispiel indem wir Tabellen hinzufügen oder vorhandene Tabellen um Felder erweitern.<\/p>\n

Bei einer Kombination aus Access-Frontend und -Backend ist es damit bereits getan. Wenn die Backend-Datenbank jedoch eine SQL Server-Datenbank ist, können noch weitere Änderungen hinzukommen: Neue gespeicherte Views, gespeicherte Prozeduren, Trigger oder Funktionen.<\/p>\n

In den folgenden Abschnitten stellen wir die Voraussetzungen vor und zeigen auch, wie die Aktualisierung beim Start der neuen Version des Frontends automatisch durchgeführt werden kann, sodass die Anwendung direkt danach wieder in Betrieb genommen werden kann.<\/p>\n

Aktualisierung per SQL<\/h2>\n

Die Aktualisierung der Elemente einer Backend-Datenbank geschieht beispielsweise beim Hinzufügen oder Ändern des Tabellenentwurfs durch entsprechende SQL-Skripte wie CREATE TABLE<\/b>, ALTER TABLE <\/b>oder, wenn Tabellen gelöscht werden sollen, auch durch DROP TABLE<\/b>. Indizes und andere Elemente erstellen wir ebenfalls mit SQL-Anweisungen.<\/p>\n

Bei einer reinen Access-Lösung mit einem Access-Backend kommt hier der zusätzliche Aufwand auf uns zu, diese Aufrufe manuell zusammenstellen zu müssen.<\/p>\n

Es gibt keinen eingebauten Mechanismus, mit dem wir beispielsweise die Unterschiede zwischen zwei Access-Tabellen erfassen und in ein SQL-Skript gießen können.<\/p>\n

Beim SQL Server haben wir es zumindest beim Erstellen vollständig neuer Elemente etwas leichter, denn die entsprechenden Skripte können wir uns im SQL Server Management Studio generieren lassen.<\/p>\n

Schwieriger wird es, wenn wir nur ein Feld oder einen Index zu einer Tabelle hinzufügen wollen – hier müssen wir grundsätzlich erst einmal selbst das benötigte Skript schreiben.<\/p>\n

Allerdings gibt es auch Tools, mit denen man die Unterschiede zwischen zwei Datenbankversionen ermitteln kann.<\/p>\n

Eines davon stellen wir im Artikel SQL Server-Datenbanken vergleichen mit VS.Code <\/b>(www.vbentwickler.de\/472<\/b>) vorgestellt – hier können wir zumindest die Unterschiede zwischen zwei Versionen ermitteln und daraus die notwendigen Anweisungen ableiten, zum Beispiel zum Ergänzen eines Feldes in einer Tabelle.<\/p>\n

Voraussetzungen für den Abgleich<\/h2>\n

Wenn wir eine neue Version des Frontends an die Kunden verteilen und damit auch das Backend im SQL Server aktualisieren wollen, benötigen wir einige grundlegende Elemente.<\/p>\n

Das erste ist eine Tabelle im Backend, in der wir die aktuelle Version des Backends festhalten. Diese enthält lediglich das Feld Version <\/b>mit dem Datentyp integer<\/b>, in dem wir die aktuelle Versionsnummer speichern (siehe Bild 1).<\/p>\n

\"Versionstabelle<\/p>\n

Bild 1: Versionstabelle im SQL Server<\/span><\/b><\/p>\n

Außerdem benötigen wir noch zwei Tabellen im Access-Frontend, in denen wir die Informationen zum Aktualisieren des Backends speichern.<\/p>\n

Die erste heißt tblVersionen <\/b>und sieht im Entwurf wie in Bild 2 aus.<\/p>\n

\"Versionstabelle<\/p>\n

Bild 2: Versionstabelle im Access-Frontend<\/span><\/b><\/p>\n

Hier speichern wir grundlegende Informationen zur jeweiligen Version, zum Beispiel die Versionsnummer, das Datum, an dem die Version erstellt wurde, Bemerkungen, das Ausführungsdatum des Updates und den Status des Updates.<\/p>\n

Die zweite Tabelle heißt tblVersionsdetails <\/b>(siehe Bild 3). Sie speichert die einzelnen Schritte, die zum Aktualisieren auf die jeweilige Version notwendig sind.<\/p>\n

\"Tabelle<\/p>\n

Bild 3: Tabelle der Versionsdetails<\/span><\/b><\/p>\n

Hier finden wir zunächst ein Fremdschlüsselfeld namens VersionID<\/b>, mit der die Zuordnung zu der Version aus der Tabelle tblVersionen <\/b>hergestellt wird. Das Feld SQL <\/b>enthält die auszuführende Anweisung, zum Beispiel zum Anlegen oder Löschen einer Tabelle, zum Hinzufügen von Feldern oder Indizes oder auch zum Anlegen von Views, gespeicherten Prozeduren oder Funktionen. Im Feld ReihenfolgeID <\/b>legen wir fest, in welcher Reihenfolge diese Schritte ausgeführt werden sollen.<\/p>\n

Die übrigen Felder dienen der Aufzeichnung der Ergebnisse der Aktualisierung.<\/p>\n

Sie nehmen den Zeitpunkt der Aktualisierung, den Status und eine eventuelle Fehlermeldung auf, damit diese beim Fehlschlagen einer Aktualisierung ausgewertet werden können.<\/p>\n

Für die beiden Felder VersionID <\/b>und ReihenfolgeID <\/b>haben wir einen zusammengesetzten, eindeutigen Index erstellt, damit jede ReihenfolgeID <\/b>nur einmal je Version vorkommen kann.<\/p>\n

Benutzeroberfläche zum Verwalten der Versionsupdates<\/h2>\n

Die Daten dieser Tabellen wollen wir in einem Formular samt Unterformular verwalten.<\/p>\n

Der Entwurf des Hauptformulars samt Unterformular sieht wie in Bild 4 aus.<\/p>\n

\"Haupt-<\/p>\n

Bild 4: Haupt- und Unterformular zum Verwalten der Versionen und Versionsdetails<\/span><\/b><\/p>\n

Das Hauptformular ist an die Tabelle tblVersionen <\/b>gebunden und zeigt alle Felder dieser Tabelle an. Das Unterformular verwendet eine Abfrage basierend auf der Tabelle tblVersionsdetails <\/b>als Datensatzquelle, welche die enthaltenen Daten nach dem Feld ReihenfolgeID <\/b>filtert:<\/p>\n

SELECT VersionsdetailID, VersionID, Beschreibung, SQL, ReihenfolgeID, AusgefuehrtAm, Erfolgreich, Fehlermeldung FROM tblVersionsdetails ORDER BY tblVersionsdetails.ReihenfolgeID;<\/pre>\n
Damit das Unterformular nur die Datensätze anzeigt, die zu dem im Hauptformular angezeigten Datensatz gehören, sind die Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformular-Steuerelements jeweils mit dem Wert VersionID <\/b>gefüllt.<\/p>\n
Das Unterformular (siehe Bild 5) ist als Endlosformular ausgelegt.<\/p>\n
\"Unterformular<\/p>\n
Bild 5: Unterformular zum Verwalten der Versionsdetails<\/span><\/b><\/p>\n
Es enthält neben den gebundenen Feldern noch zwei Schaltflächen, die das Ändern der Reihenfolge durch Verschieben nach oben oder nach unten ermöglichen.<\/p>\n
Im Hauptformular haben wir für das Unterformular-Steuerelement das Ereignis Beim Hingehen <\/b>definiert. Hier prüfen wir, ob das Hauptformular einen vorhandenen oder einen neuen, leeren Datensatz anzeigt.<\/p>\n
Falls es sich um einen neuen, leeren Datensatz handelt, soll eine Meldung angezeigt werden, damit zunächst ein Datensatz im Hauptformular angelegt wird:<\/p>\n
Private Sub <\/span>sfmVersionen_Enter()\r\n     If <\/span>Me.NewRecord Then<\/span>\r\n         MsgBox<\/span> \"Bitte lege zuerst eine Version an.\", _\r\n             vbOkOnly + vbExclamation, \"Neue Version fehlt\"\r\n         Me.Version.SetFocus\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Ereignisse im Unterformular<\/h2>\n
Für das Ereignis Beim Anzeigen <\/b>des Unterformulars haben wir die folgende Ereignisprozedur hinterlegt:<\/p>\n
Private Sub <\/span>Form_Current()\r\n     Me.TimerInterval = 100\r\nEnd Sub<\/span><\/pre>\n
Diese startet den Timer für 100 Millisekunden, dann wird die folgende Ereignisprozedur ausgelöst:<\/p>\n
Private Sub <\/span>Form_Timer()\r\n     Me.TimerInterval = 0\r\n     If <\/span>Me.NewRecord Then<\/span>\r\n         Me.ReihenfolgeID.DefaultValue = _\r\n             Nz(DMax(\"ReihenfolgeID\", \"tblVersionsdetails\",  _\r\n             \"VersionID = \" & Me.Parent.VersionID), 1)\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Diese setzt TimerInterval <\/b>wieder auf 0 <\/b>und prüft, ob der Benutzer gerade einen neuen, leeren Datensatz aktiviert hat.<\/p>\n
In diesem Fall wird der Standardwert für das Feld ReihenfolgeID <\/b>dieses Datensatzes auf den bisher höchsten vergebenen Reihenfolge-Wert der Datensätze aus tblVersionsdetails <\/b>für die Version aus dem Hauptformular ermittelt und um eins erhöht.<\/p>\n
Dies müssen wir verzögert machen, weil das Unterformular vor dem Hauptformular geladen wird und im Hauptformular noch kein Datensatz ist, für den wir die aktuell höchste vergebene ReihenfolgeID <\/b>ermitteln können.<\/p>\n
Nach 100 Millisekunden ist dies jedoch in der Regel der Fall.<\/p>\n
Verschieben der Versionsdetails nach oben und unten<\/h2>\n
Die Schaltfläche cmdNachOben <\/b>löst die Prozedur aus Listing 1 aus.<\/p>\n
Private Sub <\/span>cmdNachOben_Click()\r\n     Dim <\/span>db As <\/span>dao.Database\r\n     Dim <\/span>lngVersionID As Long<\/span>\r\n     Dim <\/span>lngReihenfolgeZielID As Long<\/span>\r\n     Dim <\/span>lngReihenfolgeAktuellID As Long<\/span>\r\n     Dim <\/span>lngAktuellID As Long<\/span>\r\n     Dim <\/span>lngZielID As Long<\/span>\r\n     \r\n     Set<\/span> db = CurrentDb\r\n     \r\n     lngVersionID = Me.Parent!VersionID\r\n     \r\n     Call<\/span> ReihenfolgeErneuern(db, lngVersionID)\r\n     lngReihenfolgeAktuellID = Me.ReihenfolgeID\r\n     lngReihenfolgeZielID = Nz(DMax(\"ReihenfolgeID\", \"tblVersionsdetails\", \"VersionID = \" & lngVersionID _\r\n         & \" AND ReihenfolgeID < \" & Me!ReihenfolgeID), 0)\r\n     If <\/span>Not<\/span> lngReihenfolgeZielID = 0 Then<\/span>\r\n         lngZielID = DLookup(\"VersionsdetailID\", \"tblVersionsdetails\", \"VersionID = \" & lngVersionID _\r\n             & \" AND ReihenfolgeID = \" & lngReihenfolgeZielID)\r\n         lngAktuellID = Me!VersionsdetailID\r\n     \r\n         Call<\/span> ReihenfolgeVertauschen(db, lngVersionID, lngAktuellID, lngZielID, lngReihenfolgeAktuellID, _\r\n             lngReihenfolgeZielID)\r\n     \r\n         Me.Requery\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Kann nicht nach oben verschoben werden.\", vbOKOnly + vbExclamation, \"Kein Verschieben möglich\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Verschieben des aktuellen Versionsdetails nach oben<\/span><\/b><\/p>\n
Sie holt einen Verweis auf das aktuelle Database<\/b>-Objekt und liest die Version aus dem Hauptformular ein. Dann ruft sie eine Prozedur namens ReihenfolgeErneuern <\/b>auf, die eventuelle Leerstellen in den Werten für die Reihenfolge auffüllt.<\/p>\n
Danach liest sie den Wert des Feldes ReihenfolgeID <\/b>für den aktuellen und zu verschiebenden Datensatz in die Variable lngReihenfolgeAktuellID <\/b>ein. Außerdem ermittelt sie mit der DMax<\/b>-Funktion den Wert des Feldes ReihenfolgeID <\/b>für den über dem aktuellen Datensatz liegenden Eintrag.<\/p>\n
Dieser Wert kann 0 <\/b>sein, wenn wir die Schaltfläche für den obersten Eintrag anklicken. In diesem Fall erscheint eine entsprechende Meldung. Anderenfalls ermittelt die Funktion den Wert des Feldes VersionsdetailID <\/b>für den zu verschiebenden und für den Zieldatensatz.<\/p>\n
Alle ermittelten Informationen werden an die Prozedur ReihenfolgeVertauschen übergeben, die den eigentlichen Austausch durchführt. Schließlich wird das Formular aktualisiert.<\/p>\n
Die Prozedur, die durch die Schaltfläche cmdNachUnten <\/b>ausgelöst wird, funktioniert ähnlich, ermittelt aber als Ziel den unter dem aktuellen Datensatz befindlichen Datensatz.<\/p>\n
Erneuern der Reihenfolge<\/h2>\n
Sollten zwischenzeitlich Datensätze aus der Tabelle tblVersionsdetails <\/b>gelöscht worden sein, wollen wir diese auffüllen können beziehungsweise die Werte des Feldes wieder so füllen, dass keine Lücken mehr vorhanden sind.<\/p>\n
Dies erledigen wir mit der Prozedur ReihenfolgeErneuern <\/b>aus Listing 2. Die Prozedur nimmt die VersionID <\/b>für zu aktualisierende Version entgegen und durchläuft alle Datensätze der Tabelle tblVersionsdetails<\/b>, die zu dieser Version gehören.<\/p>\n
Private Sub <\/span>ReihenfolgeErneuern(db As <\/span>dao.Database, lngVersionID As Long<\/span>)\r\n     Dim <\/span>rst As <\/span>dao.Recordset\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVersionsdetails WHERE VersionID = \" & lngVersionID _\r\n         & \" ORDER BY ReihenfolgeID\", dbOpenDynaset)\r\n     Do While<\/span> Not<\/span> rst.EOF\r\n         rst.Edit\r\n         rst!ReihenfolgeID = rst.AbsolutePosition + 1\r\n         rst.Update\r\n         rst.MoveNext<\/span>\r\n     Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Erneuern der Reihenfolge<\/span><\/b><\/p>\n
Dabei wird der Wert des Feldes ReihenfolgeID <\/b>jeweils auf den Wert der Eigenschaft AbsolutePosition <\/b>des aktuellen Datensatzes plus eins eingestellt.<\/p>\n
Vertauschen der Reihenfolge<\/h2>\n
Die Prozedur ReihenfolgeVertauschen <\/b>führt drei Aktionsabfragen durch (siehe Listing 3).<\/p>\n
Private Sub <\/span>ReihenfolgeVertauschen(db As <\/span>dao.Database, lngVersionID, lngAktuellID As Long<\/span>, lngZielID As Long<\/span>, _\r\n         lngReihenfolgeAktuellID As Long<\/span>, lngReihenfolgeZielID As Long<\/span>)\r\n     Dim <\/span>strSQL As String<\/span>\r\n     strSQL = \"UPDATE tblVersionsdetails SET ReihenfolgeID = NULL WHERE VersionID = \" & lngVersionID _\r\n         & \" AND VersionsdetailID = \" & lngZielID\r\n     db.Execute strSQL, dbFailOnError\r\n     strSQL = \"UPDATE tblVersionsdetails SET ReihenfolgeID = \" & lngReihenfolgeZielID & \" WHERE VersionID = \" _\r\n         & lngVersionID & \" AND VersionsdetailID = \" & lngAktuellID\r\n     db.Execute strSQL, dbFailOnError\r\n     strSQL = \"UPDATE tblVersionsdetails SET ReihenfolgeID = \" & lngReihenfolgeAktuellID & \" WHERE VersionID = \" _\r\n         & lngVersionID & \" AND VersionsdetailID = \" & lngZielID\r\n     db.Execute strSQL, dbFailOnError\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Vertauschen der Reihenfolge<\/span><\/b><\/p>\n
Die erste ändert den Wert des Feldes ReihenfolgeID <\/b>für den Zieldatensatz auf den Wert NULL<\/b>. Dann wird der Wert des Feldes ReihenfolgeID <\/b>für den zu verschiebenden Datensatz auf den entsprechenden Wert des Zieldatensatzes eingestellt. Schließlich ändern wir den Wert von ReihenfolgeID <\/b>für den Zieldatensatz auf den Wert des entsprechenden Feldes des zu verschiebenden Datensatzes.<\/p>\n
Wir müssen diesen zwischenzeitlich auf NULL ändern, da wir über die Tabellendefinition keine doppelten Kombinationen aus den Werten für die Felder VersionID <\/b>und ReihenfolgeID <\/b>zulassen.<\/p>\n
Eingabe der Versionsdaten<\/h2>\n
In der Formularansicht sieht das Formular nun wie in Bild 6 aus. Im Hauptformular wird die Version angezeigt, im Unterformular die einzelnen Schritte. Wichtig ist, dass wir funktionierende und getestete SQL-Anweisungen für die einzelnen Schritte eingeben. Nach der Eingabe können wir dann bereits die automatische Aktualisierung des Backends programmieren.<\/p>\n
\"Eingabe<\/p>\n
Bild 6: Eingabe der Versionsdaten<\/span><\/b><\/p>\n
Backend automatisch aktualisieren<\/h2>\n
Dazu legen wir eine Prozedur namens VersionAktualisieren <\/b>an, deren ersten Teil wir in Listing 4 sehen. Wir wollen die Änderungen am Backend über die ADODB-Execute<\/b>-Methode übertragen, weshalb wir zuvor noch einen Verweis auf die ADODB-Bibliothek benötigen.<\/p>\n
Public Sub <\/span>VersionAktualisieren()\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>rstDetails As <\/span>DAO.Recordset\r\n     Dim <\/span>strVerbindungszeichenfolge As String<\/span>\r\n     Dim <\/span>lngVersionSQLServer As Long<\/span>\r\n     Dim <\/span>strSQL As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>cnn As <\/span>ADODB.Connection\r\n     Dim <\/span>rstADODB As <\/span>ADODB.Recordset\r\n     Dim <\/span>bolVersionErfolgreich As Boolean<\/span>\r\n     \r\n     strVerbindungszeichenfolge = \"Provider=MSOLEDBSQL;Data Source=amvDesktop2023;Initial Catalog=DemoDB_V1;\" _\r\n         & \"Integrated Security=SSPI;\"\r\n     Set<\/span> cnn = New<\/span> ADODB.Connection\r\n     Set<\/span> rstADODB = New<\/span> ADODB.Recordset\r\n     With<\/span> cnn\r\n         .ConnectionString = strVerbindungszeichenfolge\r\n         .Open\r\n         Set<\/span> rstADODB.ActiveConnection = cnn\r\n         rstADODB.Open \"SELECT Version FROM tblVersion\", strVerbindungszeichenfolge\r\n         lngVersionSQLServer = rstADODB!Version\r\n                 \r\n         Set<\/span> db = CurrentDb\r\n         Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVersionen WHERE Version > \" & lngVersionSQLServer _\r\n             & \" ORDER BY Version ASC\", dbOpenDynaset)\r\n         ...<\/pre>\n
Listing 4: Aktualisieren des Backends (Teil 1)<\/span><\/b><\/p>\n
In der Prozedur stellen wir als Erstes die Verbindungszeichenfolge für die ADODB-Connection zusammen. In dieser musst Du zumindest die Parameter Data Source <\/b>(SQL Server) und Initial Catalog <\/b>(Datenbank), gegebenenfalls aber auch noch die Zugriffsdaten bei Verwendung der SQL Server-Authentifizierung, hinzufügen.<\/p>\n
Danach deklarieren und erstellen wir neue Connection<\/b>– und Recordset<\/b>-Objekte. Die Connection öffnen wir nach dem Festlegen der Verbindungszeichenfolge mit der Open<\/b>-Methode. Dann legen wir die Connection als ActiveConnection <\/b>des Recordsets fest und öffnen eine Abfrage, welche das Feld Version <\/b>der Tabelle tblVersion <\/b>auf dem SQL Server in die Variable lngVersionSQLServer <\/b>einliest.<\/p>\n
Nun öffnen wir ein DAO-Recordset auf Basis der Tabelle tblVersionen <\/b>und lesen alle Datensätze ein, deren Wert im Feld Version <\/b>größer ist als der aus der Variablen lngVersionSQLServer<\/b>.<\/p>\n
Dabei sortieren wir aufsteigend nach dem Feld Version<\/b>. Außerdem stellen wir die Variable bolVersionErfolgreich <\/b>auf True <\/b>ein (siehe Listing 5).<\/p>\n
         ...\r\n         bolVersionErfolgreich = True<\/span>\r\n         Do While<\/span> Not<\/span> rst.EOF\r\n             Call<\/span> VersionInitialisieren(db, rst)\r\n             cnn.BeginTrans\r\n             bolVersionErfolgreich = True<\/span>\r\n             Set<\/span> rstDetails = db.OpenRecordset(\"SELECT * FROM tblVersionsdetails WHERE VersionID = \" _\r\n                 & rst!VersionID & \" ORDER BY ReihenfolgeID ASC\", dbOpenDynaset)\r\n             Do While<\/span> Not<\/span> rstDetails.EOF\r\n                 strSQL = rstDetails!SQL\r\n                 If <\/span>SQLAusfuehren(cnn, strSQL, strResponse) = True<\/span> Then<\/span>\r\n                     rstDetails.Edit\r\n                     rstDetails!AusgefuehrtAm = Now\r\n                     rstDetails!Erfolgreich = True<\/span>\r\n                     rstDetails.Update\r\n                 Else<\/span>\r\n                     .RollbackTrans\r\n                     bolVersionErfolgreich = False<\/span>\r\n                     rstDetails.Edit\r\n                     rstDetails!AusgefuehrtAm = Now\r\n                     rstDetails!Erfolgreich = False<\/span>\r\n                     rstDetails!Fehlermeldung = strResponse\r\n                     rstDetails.Update\r\n                     Exit Do<\/span>\r\n                 End If<\/span>\r\n                 rstDetails.MoveNext<\/span>\r\n             Loop<\/span>            \r\n             If <\/span>bolVersionErfolgreich = True<\/span> Then<\/span>\r\n                 SQLAusfuehren cnn, \"UPDATE tblVersion SET Version = \" & rst!Version, strResponse\r\n             End If<\/span>\r\n             rst.Edit\r\n             rst!AusgefuehrtAm = Now\r\n             rst!Erfolgreich = bolVersionErfolgreich\r\n             rst.Update\r\n             If <\/span>bolVersionErfolgreich = False<\/span> Then<\/span>\r\n                 Exit Do<\/span>\r\n             End If<\/span>\r\n             .CommitTrans\r\n             \r\n             rst.MoveNext<\/span>\r\n         Loop<\/span>\r\n         If <\/span>bolVersionErfolgreich = False<\/span> Then<\/span>\r\n             MsgBox<\/span> \"Update nicht erfolgreich. Bitte setzen Sie sich mit dem Hersteller in Verbindung.\", _\r\n                 vbOKOnly + vbCr<\/span>itical, \"Update nicht erfolgreich\"\r\n         End If        \r\n         .Close\r\n     End With<\/span>\r\n     Set<\/span> cnn = Nothing    \r\nEnd Sub<\/span><\/pre>\n
Listing 5: Aktualisieren des Backends (Teil 2)<\/span><\/b><\/p>\n
Dieses Recordset durchlaufen wir in einer Do While<\/b>-Schleife. Hier rufen wir zuerst die Prozedur VersionInitialisieren<\/b> auf, um eventuell bereits vorhandene Ergebnisse eines vorherigen Versuchs aus den Tabellen tblVersionen<\/b> und tblVersionsdetails <\/b>zu löschen.<\/p>\n
Danach starten wir mit BeginTrans <\/b>eine Transaktion für die Connection. Die Idee dahinter ist, die einzelnen Updates aus der Tabelle tblVersionsdetails <\/b>nur abschließend auszuführen, wenn alle Schritte erfolgreich waren.<\/p>\n
Hier lesen wir alle Versionsdetails aus der Tabelle tblVersionsdetails <\/b>in das Recordset rstDetails <\/b>ein – wiederum aufsteigend sortiert, dieses Mal nach dem Feld ReihenfolgeID<\/b>.<\/p>\n
Dieses durchlaufen wir in einer weiteren Do While<\/b>-Schleife. Die auszuführende SQL-Anweisung legen wir in der Variablen strSQL <\/b>ab.<\/p>\n
Dann rufen wir die Funktion SQLAusfuehren <\/b>auf und übergeben die Connection, den SQL-Ausdruck sowie einen Rückgabeparameter namens strResponse<\/b>. Diese Funktion, die wir im Anschluss beschreiben, führt die SQL-Anweisung aus strSQL <\/b>aus.<\/p>\n
Wenn sie das Ergebnis True <\/b>zurückliefert, war die Aktualisierung erfolgreich. Dann können wir in der Tabelle tblDetails <\/b>die Felder AusgefuehrtAm <\/b>und Erfolgreich <\/b>auf die entsprechenden Werte einstellen.<\/p>\n
Anderenfalls machen wir zunächst die Transaktion mit RollBackTrans <\/b>rückgängig. Außerdem setzen wir bolVersionErfolgreich <\/b>auf False <\/b>und tragen die gleichen Werte wie zuvor und zusätzlich die zurückgelieferte Fehlermeldung in die Tabelle tblVersionsdetails <\/b>ein. Anschließend verlassen wir die Schleife. <\/p>\n
Wenn alle Aktionen aus der Tabelle tblVersionsdetails <\/b>für diese Version erfolgreich waren, enthält bolVersionErfolgreich <\/b>nun immer noch den Wert True<\/b>.<\/p>\n
In diesem können wir die Angabe der Version in der Tabelle tblVersion <\/b>in der SQL Server-Datenbank aktualisieren. Zudem tragen wir in der Tabelle tblVersionen <\/b>des Access-Frontends die entsprechenden Werte für die Felder AusgefuehrtAm <\/b>und Erfolgreich <\/b>ein.<\/p>\n
Außerdem schließen wir die Transaktion mit CommitTrans <\/b>ab, damit die Änderungen im SQL Server gespeichert werden.<\/p>\n
Anderenfalls verlassen wir die Do While<\/b>-Schleife über die Datensätze der Tabelle tblVersionen <\/b>und geben eine Meldung aus.<\/p>\n
Funktion zum Aktualisieren der Backend-Datenbank<\/h2>\n
Die Funktion SQLAusfuehren <\/b>nutzt die Execute<\/b>-Methode des Connection<\/b>-Objekts aus cnn<\/b>, um die jeweilige SQL-Anweisung auszuführen.<\/p>\n
Tritt hierbei ein Fehler auf, wird die Fehlermeldung in den Rückgabeparameter strResponse <\/b>geschrieben und der Wert False <\/b>als Funktionsergebnis zurückgegeben:<\/p>\n
Public Function <\/span>SQLAusfuehren(cnn As <\/span>ADODB.Connection, _\r\n         strSQL As String<\/span>, Optional<\/span> strResponse As String<\/span>)  _\r\n         As Boolean<\/span>\r\n     With<\/span> cnn\r\n         On Error Resume Next<\/span>\r\n         .Execute strSQL\r\n         Select Case Err.Number\r\n             Case <\/span>0\r\n                 SQLAusfuehren = True<\/span>\r\n             Case Else<\/span>\r\n                 SQLAusfuehren = False<\/span>\r\n                 strResponse = Err.Description\r\n         End Select<\/span>\r\n         On Error GoTo<\/span> 0\r\n     End With<\/span>\r\nEnd Function<\/span><\/pre>\n
Funktion zum Initialisieren der Tabellen tblVersionen und tblVersionsdetails<\/h2>\n
Die Prozedur VersionInitialisieren <\/b>wird aufgerufen, bevor wir mit dem Aktualisieren auf eine Version starten.<\/p>\n
Es kann sein, dass wir in vorherigen Versuchen bereits Daten in die Felder dieser Tabellen eingetragen haben. Diese werden nun sowohl in der Tabelle tblVersionen <\/b>als auch in tblVersionsdetails <\/b>geleert beziehungsweise auf False<\/b> eingestellt:<\/p>\n
Public Sub <\/span>VersionInitialisieren(db As <\/span>DAO.Database, _\r\n         rst As <\/span>DAO.Recordset)\r\n     Dim <\/span>lngVersionID As Long<\/span>\r\n     lngVersionID = rst!VersionID\r\n     rst.Edit\r\n     rst!AusgefuehrtAm = Null\r\n     rst!Erfolgreich = False<\/span>\r\n     rst.Update\r\n     db.Execute \"UPDATE tblVersionsdetails \" _\r\n         & \"SET AusgefuehrtAm = NULL, \" _\r\n         & \"Erfolgreich = False, Fehlermeldung = NULL \" _\r\n         & \"WHERE VersionID = \" & lngVersionID, dbFailOnError\r\nEnd Sub<\/span><\/pre>\n
Ausprobieren der Lösung<\/h2>\n
In der Beispieldatenbank haben wir für die Version mit der Nummer 1 <\/b>die folgende Anweisung hinterlegt:<\/p>\n
CREATE TABLE tblKategorien (KategorieID INT IDENTITY(1,1) PRIMARY KEY, Kategoriebezeichnung VARCHAR(255) NOT NULL);<\/pre>\n
In der Version mit der Nummer 2 <\/b>finden wir diese Anweisungen:<\/p>\n
CREATE VIEW vwTest AS SELECT * FROM tblKategorien\r\nALTER TABLE dbo.tblKategorien\r\nADD Beschreibung VARCHAR(MAX) NULL;<\/pre>\n
Wenn wir diese für eine Datenbank, die noch keines dieser Elemente enthält, erstmalig mit der Prozedur VersionAktualisieren<\/b> ausführen, verläuft alles fehlerfrei und wir erhalten die neue Tabelle tblKategorien<\/b>, die neue View vbTest <\/b>und das neue Feld Beschreibung <\/b>in der Tabelle tblKategorien<\/b>.<\/p>\n
Außerdem wird das Feld Version <\/b>in der Tabelle tblVersion <\/b>der SQL Server-Datenbank auf 2 <\/b>eingestellt.<\/p>\n
Rufen wir die Prozedur VersionAktualisieren <\/b>nun erneut auf, geschieht nichts. Das liegt daran, dass die neueste Version der Tabelle tblVersionen <\/b>mit der Version in der SQL Server-Tabelle tblVersion <\/b>übereinstimmt.<\/p>\n
Um Fehler zu provozieren, stellen wir diesen Wert wieder auf 0 <\/b>ein.<\/p>\n
Rufen wir die Prozedur erneut auf, erhalten wir die Meldung mit dem Hinweis auf einen Fehler.<\/p>\n
Wir können dann im Formular frmVersionen <\/b>nachschauen, ob ein Fehler protokolliert wurde, und finden hier die folgende Meldung:<\/p>\n
In der Datenbank ist bereits ein Objekt mit dem Namen \"tblKategorien\" vorhanden.<\/pre>\n
Auf diese Weise kann der Benutzer im einfachsten Fall einfach die Frontenddatenbank der Anwendung an den Entwickler schicken, damit er diese korrigieren kann.<\/p>\n
Starten der Aktualisierung beim Öffnen der Datenbank<\/h2>\n
Das Update sollte direkt beim Starten der Anwendung ausgeführt werden, und zwar bevor das Frontend auf Tabellen im Backend zugreift.<\/p>\n
Anschließend kann man dann eine Routine durchlaufen lassen, welche die Tabellenverknüpfungen aktualisiert.<\/p>\n
Der einfachste Weg, die Prozedur gleich beim Start auszuführen, ist der über ein AutoExec<\/b>-Makro. Ein Makro dieses Namens wird beim Start der Access-Datenbank direkt ausgeführt und ermöglicht, die Prozedur aufzurufen.<\/p>\n
Genau genommen kann man mit der Aktion AusführenCode <\/b>des AutoExec<\/b>-Makros nur Funktionen ausführen, daher können wir entweder die Prozedur in eine Funktion ändern oder wir schalten eine Funktion dazwischen. In diesem Fall haben wir uns für den ersten Weg entschieden und das Makro wie in Bild 7 erstellt.<\/p>\n
\"Das<\/p>\n
Bild 7: Das AutoExec-Makro<\/span><\/b><\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Dieser Artikel stellt eine Lösung vor, mit der wir Aktualisieren an einem SQL Server-Backend über das Frontend auf die SQL Server-Datenbank eines Kunden übertragen können.<\/p>\n
Dabei können wir alle denkbaren Aktualisierungen und Erweiterungen durchführen:<\/p>\n