<\/p>\n
Während Sie eine Datenbank entwickeln, geben Sie Beispieldaten ein, testen die neu hinzugefügten Formulare und VBA-Prozeduren anhand dieser Daten, prüfen das Ergebnis und stellen die Beispieldaten gegebenenfalls wieder her, um weitere Tests mit geänderten Prozeduren durchzuführen. Bei komplizierteren Prozeduren kann dies einige Iterationen in Anspruch nehmen und das manuelle Bereitstellen der Testdaten wird zu einer hinderlichen und zeitraubenden Prozedur. Zu diesem Zweck stellen wir im vorliegenden Beitrag Techniken vor, mit denen Sie per Knopfdruck alle Daten aus definierten Tabellen sichern und diese mit einem weiteren Knopfdruck wiederherstellen.<\/b><\/p>\n
Wenn Sie eine neue Datenbank entwickeln, stehen Sie ohnehin zunächst einmal vor dem Problem, dass Sie schnell Beispieldaten für ein oder mehrere Tabellen erstellen müssen. Für diesen Fall empfiehlt sich immer noch die Nutzung des Tools aus dem Beitrag Der Beispieldaten-Assistent <\/b>(www.access-im-unternehmen.de\/745<\/b>).<\/p>\n
Wenn Sie aber damit einmal brauchbare Beispieldaten entworfen haben, möchten Sie diesen Assistenten vermutlich nicht nach jeder änderung der Daten erneut heranziehen – zumal dieser immer nur eine Tabelle gleichzeitig füllen kann und dies bei mehreren Tabellen doch aufwendig wird.<\/p>\n
Tests ändern Daten<\/b><\/p>\n
Nun haben Sie aber vielleicht eine Datenbank mit einem Datenmodell entworfen, das mehrere verknüpfte Tabellen enthält, die Sie mehr oder weniger mühsam mit Testdaten gefüllt haben. Dann führen Sie ein paar Tests mit frisch erstellten Formularen oder neu programmierten Routinen durch und ändern die Daten dabei – Sie ändern Feldinhalte, fügen neue Datensätze hinzu oder löschen vorhandene Datensätze. Wenn die zu testenden Aktionen nicht das gewünschte Ergebnis bringen, möchten Sie diese möglichst mit den gleichen Testdaten erneut durchführen. Dazu müssen Sie aber die Testdaten wiederherstellen.<\/p>\n
Programmlogik und Daten als Backup<\/b><\/p>\n
Eine Methode wäre es, vor dem Durchführen ein Backup der Datenbank herzustellen und nach missglücktem Test mit dem vorherigen Stand weiterzuarbeiten. Keine schlechte Idee, aber dadurch, dass Sie immer komplett auf eine vorherige Version zurückgreifen, verlieren Sie möglicherweise auch änderungen, die Sie beim Testen etwa beim Debuggen des Codes durchgeführt haben.<\/p>\n
Tabellenbackup per Backend<\/b><\/p>\n
Die zweite Variante wäre es, die Daten komplett in ein Backend auszulagern und dieses vor dem ändern der Daten zu kopieren und anschließend wiederherzustellen. Damit würden Sie auf jeden Fall die änderungen der Programmlogik beibehalten, da Sie das Frontend nicht austauschen müssen.<\/p>\n
Dies bedeutet allerdings auch, dass Sie die Datenbank gleich zu Beginn aufteilen müssen. Wenn allerdings auch das Datenmodell noch nicht komplett ausgereift ist, kommt weiterer Aufwand auf Sie zu:<\/p>\n
Sie müssen beispielsweise die Tabellen nach jeder änderung des Datenmodells neu mit dem Frontend verknüpfen und müssen überdies aufpassen, dass Sie keine änderungen am Backend vornehmen und dieses dann durch eine ältere Version des Backends ersetzen.<\/p>\n
Reines Datenbackup<\/b><\/p>\n
Es gibt noch eine dritte Methode, auf die wir in diesem Beitrag detaillierter eingehen. Diese soll es erlauben, per Knopfdruck eine Kopie aller aktuell in der Datenbank verwendeten Tabellen zu erstellen und die in den Kopien enthaltenen Daten ebenfalls per Knopfdruck in die Tabellen zurückzuschreiben.<\/p>\n
Das bedeutet, dass im ersten Schritt für jede Tabelle der Datenbank eine Kopie angelegt wird, deren Name beispielsweise aus dem Namen der Originaltabelle plus einem Zusatz besteht, sodass aus tblKunden <\/b>beispielsweise tblKunden_Backup <\/b>wird. Dieser Vorgang ist nicht besonders aufwendig: Mit einer SELECT INTO<\/b>-Anweisung erstellen Sie schnell eine neue Tabelle auf Basis einer bestehenden Tabelle, welche genauso aufgebaut ist wie die Originaltabelle und auch gleich mit den identischen Daten gefüllt wird.<\/p>\n
Im zweiten Schritt müssen dann nur die geänderten Inhalte der Originaltabellen gelöscht und durch die gespeicherten Inhalte ersetzt werden. Einfacher geht es doch nicht!<\/p>\n
Leider gibt es einen kleinen Haken: Wenn die Tabellen miteinander verknüpft sind und für die Beziehungen referenzielle Integrität definiert ist, dann können Sie die Daten nicht in beliebiger Reihenfolge anlegen. Angenommen, die Tabelle tblKunden <\/b>enthält ein Fremdschlüsselfeld namens AnredeID<\/b>, das zur Auswahl der Datensätze der Tabelle tblAnreden <\/b>dient, und es gibt eine Beziehung mit referenzieller Integrität zwischen dem Feld AnredeID <\/b>der Tabelle tblKunden <\/b>und dem gleichnamigen Feld der Tabelle tblAnreden<\/b>. Dann können Sie zwar erst die Datensätze der Tabelle tblAnredeID <\/b>hinzufügen und dann die Datensätze der Tabelle tblKunden<\/b>, aber nicht umgekehrt: Beim Hinzufügen eines Datensatzes zur Tabelle tblKunden<\/b>, dessen Feld AnredeID <\/b>einen Wert enthält, der noch nicht in der Tabelle tblAnreden <\/b>enthalten ist, erhalten Sie einen entsprechenden Fehler.<\/p>\n
Das bedeutet, dass wir vor dem Wiederherstellen der Tabellen dringend die richtige Reihenfolge zum Wiederherstellen ermitteln und die Wiederherstellung in dieser Reihenfolge durchführen müssen. Die Ermittlung der richtigen Reihenfolge ist der aufwendigere Teil der geplanten Lösung.<\/p>\n
Formular als Schaltzentrale<\/b><\/p>\n
Als Erstes wollen wir ein Formular erstellen, das als Schaltzentrale für die Funktionen zum Sichern und Wiederherstellen der Tabellen dient. Das Formular heißt frmSichernUndWiederherstellen <\/b>und soll zunächst zwei Schaltflächen im Fußbereich des Formulars enthalten. Die Schaltfläche cmdSichern <\/b>soll zunächst alle in der Datenbank enthaltenen Tabellen kopieren. Die Schaltfläche cmdWiederherstellen <\/b>soll die vorhandenen Tabellen mit den Daten aus den gesicherten Tabellen füllen.<\/p>\n
Das Formular sieht im derzeitigen Zustand wie in Bild 1 aus.<\/p>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_001.png\")
<\/p>\n
Bild 1: Erster Entwurf des Formulars frmSichernUndWiederherstellen<\/span><\/b><\/p>\n Tabellen sichern<\/b><\/p>\n Um die Tabellen zu sichern, benötigen wir eine entsprechende Aktionsabfrage. Diese wollen wir per VBA dynamisch für alle in der Datenbank enthaltenen Tabellen zusammensetzen und ausführen.<\/p>\n Wer unsicher in der Formulierung der entsprechenden SQL-Ausdrücke ist, kann jederzeit die Entwurfsansicht für die Erstellung von Abfragen zuhilfe nehmen. In diesem Fall legen Sie eine neue Abfrage an, fügen dieser etwa die Tabelle tblKategorien <\/b>hinzu und ziehen alle Felder in das Entwurfsraster (alternativ reicht auch das Hinzufügen des Sternchens stellvertretend für alle Felder der Tabelle).<\/p>\n Dann klicken Sie wie in Bild 2 auf die Schaltfläche Ent-wurf|Ab-frage-typ|Ta-belle er-stellen<\/b>. Dies ruft die Anzeige des Dialogs aus Bild 3 hervor, mit dem Sie den Namen der zu erstellenden Tabelle angeben und gegebenenfalls eine andere Zieldatenbank festlegen.<\/p>\n Bild 2: Angabe des Namens der zu erstellenden Tabelle<\/span><\/b><\/p>\n Bild 3: ändern einer Auswahlabfrage in eine Tabellenerstellungsabfrage<\/span><\/b><\/p>\n Es tut sich zunächst nichts, aber wenn Sie nun in die SQL-Ansicht der soeben erstellten Abfrage wechseln, erhalten Sie einen SQL-Ausdruck, der mit SELECT…INTO <\/b>beginnt und einer Tabellenerstellungsabfrage entspricht:<\/p>\n Unter Verwendung des Sternchens ginge dies noch kürzer:<\/p>\n VBA-Prozedur zum Sichern der Tabellen<\/b><\/p>\n Damit können wir nun bereits die VBA-Prozedur zum Erstellen der Tabellenkopien anlegen. Diese sieht im ersten Anlauf wie in Listing 1 aus. Die Prozedur durchläuft alle TableDef<\/b>-Objekte der Datenbank und kopiert diese mit der SELECT…INTO<\/b>-Anweisung in eine neue Tabelle, die mit dem Zusatz _Backup <\/b>ausgestattet wird.<\/p>\n Listing 1: Prozedur zum Sichern aller Tabellen der Datenbank<\/span><\/b><\/p>\n Der erste Test liefert gleich ein kleines Problem zutage, wie Bild 4 zeigt: Anscheinend enthält eine der zu kopierenden Tabellen ein mehrwertiges Feld, was zu dem angezeigten Fehler führt.<\/p>\n Bild 4: Fehler beim Kopieren einer Tabelle mit Mehrfachwertfeld<\/span><\/b><\/p>\n Mehrwertige Felder sollte man nicht unbedingt nutzen, was aber dennoch nichts an der Frage ändert, in welcher Tabelle sich dieses Feld befindet. Ein Klick auf Debuggen und die Analyse des aktuellen Wertes von tdf.Name <\/b>liefert die schuldige Tabelle: Es handelt sich um die Systemtabelle MSysResources<\/b>.<\/p>\n Bei dem Feld, das den Fehler auslöst, handelt es sich genau genommen aber nicht um ein mehrwertiges Feld, sondern um ein Anlagefeld. Diese beiden Feldtypen lassen sich also nicht mit der SELECT…INTO<\/b>-Anweisung kopieren.<\/p>\n Ein weiterer Fehler kann auftreten, wenn die Datenbank temporäre Tabellen enthält, deren Name mit dem Tilde-Zeichen (~<\/b>) beginnt (Fehlermeldung s. Bild 5). Beide schließen wir der Einfachheit halber zunächst aus, indem wir der Prozedur eine Bedingung hinzufügen, die nur noch solche Tabellen kopiert, die mit tbl <\/b>beginnen (s. Listing 2).<\/p>\n Bild 5: Fehler beim Kopieren einer temporären Tabelle<\/span><\/b><\/p>\n Auf diese Weise schließen wir aktuell Tabellen aus, die entweder als Systemtabelle oder durch die Tilde (~) als erstes Zeichen als temporäre Tabelle gekennzeichnet sind.<\/p>\n Nun haben wir zwar gesagt, dass man als professioneller Access-Entwickler keine mehrwertigen Felder verwendet (der Grund ist, dass diese Beziehungen in verborgenen Tabellen verwalten).<\/p>\n Allerdings wird man bei Verwendung der neueren Access-Versionen (ab Access 2007) nicht um die Verwendung von Anlage-Feldern herumkommen.<\/p>\n Und diese lösen, wie oben gesehen, ebenfalls Fehler aus, wenn Sie diese per SELECT…INTO<\/b>-Anweisung in eine neue Tabelle kopieren möchten.<\/p>\n Eines vorweg: Wir haben zwar Möglichkeiten gefunden, die Inhalte von Anlagefeldern von einer in die andere Tabelle zu verschieben, aber das Erstellen von Anlagefeldern per Tabellenerstellungsabfrage scheint nicht möglich zu sein. Deshalb gehen wir einen kleinen Umweg: Wir erstellen die neue Tabelle, die auch die Daten des Anlagefeldes aufnehmen soll, zwar mit SELECT INTO<\/b>.<\/p>\n Statt das Anlagefeld wie die übrigen Felder direkt zu kopieren, legen wir jedoch nur die in diesem Zusammenhang benötigten Felder der dem Anlagefeld untergeordneten Tabelle an – in diesem Fall FileData <\/b>und FileName<\/b>. Die entsprechende SELECT INTO<\/b>-Abfrage soll dann wie folgt aussehen:<\/p>\n Die Zielfelder haben wir mit dem Unterstrich statt mit dem Punkt ausgestattet, weil der Punkt nicht als Teil von Feldnamen verwendet werden darf. Aus Data.FileData <\/b>wird so in der Backuptabelle Data_FileData<\/b>. Nach dem Kopieren soll etwa die Tabelle tblResources <\/b>(welche der Systemtabelle MSysResources <\/b>entspricht, die wir zu Testzwecken in tblResources <\/b>kopiert haben) so wie die Tabelle _tblResources_Backup <\/b>aussehen (s. Bild 6).<\/p>\n Bild 6: Tabellen mit Anlagefeld und die Backup-Tabelle mit den entsprechenden Feldern<\/span><\/b><\/p>\n Schauen wir uns nun die modifizierte Variante der Prozedur cmdSichern_Click <\/b>an, die jetzt auch Anlagefelder sichert (s. Listing 3). Diese durchläuft wiederum per For Each<\/b>-Schleife alle Tabellen der Datenbank und berücksichtigt darin alle Tabellen, die mit tbl <\/b>beginnen. Die Variable strFelder <\/b>soll die Liste aller zu berücksichtenden Felder aufnehmen. Mit einem Sternchen (*) für alle Felder ist es nicht getan, da wir ja den Feldern des Anlagefeldes eine Sonderbehandlung angedeihen lassen müssen.<\/p>\n <\/p>\n Listing 3: Kopieren der Inhalte aller Tabellen inklusive Anlagefelder<\/span><\/b><\/p>\n Die folgende For Each<\/b>-Schleife durchläuft alle Felder des TableDef<\/b>-Objekts für die aktuelle Tabelle.<\/p>\n Dabei unterscheidet die Prozedur in einer Select Case<\/b>-Bedingung nach dem Typ des Feldes. Lautet dieser dbAttachment<\/b>, handelt es sich um ein Anlagefeld. Für dieses fügt die Prozedur einen Ausdruck wie den folgenden zur Variablen strFelder <\/b>hinzu:<\/p>\n Für alle anderen Felddatentypen wird strFelder <\/b>einfach nur um ein führendes Komma und den Feldnamen erweitert. Mehrwertige Felder werden nicht berücksichtigt. Wenn eine Tabelle ein mehrwertiges Feld enthält, zeigt die Prozedur lediglich einen entsprechenden Hinweis an.<\/p>\n Wenn strFelder<\/b> eine Zeichenkette mit einer Länge größer als 0 <\/b>enthält (was der Regelfall ist, aber sicher ist sicher), schneidet die Prozedur die ersten beiden Zeichen ab, welche dem führenden Komma und einem Leerzeichen entsprechen.<\/p>\n Dann fügt die Prozedur die SQL-Anweisung zum Kopieren der Daten der aktuellen Tabelle in eine neue Tabelle zusammen und speichert das Ergebnis in der Variablen strSQL<\/b>. Dabei verwendet die Prozedur als Namen der Zieltabelle den Namen der Quelltabelle mit führendem Unterstrich und nachfolgendem _Backup<\/b>. Wie die Anweisung für die Tabelle tblResources <\/b>aussieht, haben wir bereits weiter oben dargestellt. Anschließend löscht die Prozedur eine eventuell vorhandene Tabelle mit dem gleichen Namen wie die Backuptabelle und führt die in strSQL <\/b>gespeicherte SELECT INTO<\/b>-Abfrage aus.<\/p>\n Wiederherstellen der Daten<\/b><\/p>\n Nun gehen wir davon aus, dass der Benutzer mit der Sichern<\/b>-Schaltfläche eine Sicherung der Tabellen mit dem Präfix tbl<\/b> erstellt hat und dann die Daten der betroffenen Tabellen ordentlich durcheinandergebracht hat – genau so, dass er nun gern den vorherigen Stand wiederherstellen möchte.<\/p>\n Genau für diesen Zweck haben wir die Schaltfläche cmdWiederherstellen <\/b>vorbereitet. Diese löst die folgende Prozedur aus:<\/p>\n Die erste hier aufgerufene Prozedur soll die Inhalte der Originaltabellen löschen, die zweite die Inhalte aus dem Backup wiederherstellen.<\/p>\n Warum nicht einfach die Tabellen komplett löschen und dann wiederherstellen Dies ginge auch, wäre aber deutlich aufwendiger. Ein wichtiger Grund ist, dass wir mit den SELECT INTO<\/b>-Anweisungen zum Erstellen der Backup-Tabellen tatsächlich nur Tabellen mit den korrekten Felddatentypen und Inhalten erstellt haben – weitere Attribute wie etwa die Definition von Primärschlüsseln, Fremdschlüsseln, Beziehungen et cetera wurden nicht gespeichert. Wir müssen also die Originaltabellen behalten, wenn wir den Vorgang auf eine einfache Weise abschließen möchten.<\/p>\n Schauen wir uns zunächst die Prozedur TabellenLeeren <\/b>an. Im ersten Anlauf würde man diese Prozedur, die alle Tabellen mit dem Präfix tbl <\/b>leeren soll, vermutlich wie folgt definieren:<\/p>\n Dies liefert aber dummerweise die Fehlermeldung aus Bild 7, wenn die Tabelle mit den zu löschenden Daten die Mastertabelle einer mit referenzieller Integrität ohne Löschweitergabe definierten Beziehung darstellt.<\/p>\n Bild 7: Fehler beim Versuch, Daten aus verknüpften Tabellen zu löschen<\/span><\/b><\/p>\n Tabellen in der richtigen Reihenfolge leeren<\/b><\/p>\n Wir müssen in diesem Fall zuerst die Daten der Detailtabelle dieser Beziehung löschen und erst dann die Daten der Mastertabelle. Wie aber bestimmen wir die richtige Reihenfolge zum Löschen der Daten in den Tabellen Dazu haben wir im Beitrag Lösch- und Kopierreihenfolge für Tabellen <\/b>(www.access-im-unternehmen.de\/926<\/b>) eine entsprechende Funktion vorgestellt. Diese heißt TabellenreihenfolgeLoeschen <\/b>und liefert eine Collection mit den Tabellen in der richtigen Reihenfolge zurück, sodass Sie die enthaltenen Tabellen ohne Fehlermeldungen leeren können (Sie finden die Funktion im Modul mdlTools <\/b>der Beispieldatenbank).<\/p>\n Die neue Version der Prozedur TabellenLeeren <\/b>sieht nun wie folgt aus:<\/p>\n Die Prozedur füllt das Collection<\/b>-Objekt colTabellen <\/b>mit den Tabellen in der für das Löschen der Daten richtigen Reihenfolge. Die folgende For Each<\/b>-Schleife durchläuft alle Elemente der Collection.<\/p>\n Innerhalb der For Each<\/b>-Schleife löscht eine DELETE<\/b>-Abfrage jeweils alle Datensätze der aktuell in der Variablen var <\/b>gespeicherten Tabelle. Damit wäre der erste Schritt erledigt – die vermurksten Daten sind gelöscht.<\/p>\n Daten wiederherstellen<\/b><\/p>\n Damit wenden wir uns der zweiten, etwas aufwendigeren Aufgabe zu: dem Wiederherstellen der Daten aus den Backup-Tabellen.<\/p>\n Hier gibt es zwei Probleme, deren Lösung wir in andere Beiträge ausgelagert haben:<\/p>\n Die Prozedur TabelleWiederherstellen<\/b> aus Listing 5 füllt zunächst die Collection colTabellen <\/b>mithilfe der Funktion TabellenreihenfolgeKopieren<\/b>. In einer For Each<\/b>-Schleife über diese Collection durchläuft die Prozedur dann die Tabelle in der für das Einfügen von Datensätzen korrekten Reihenfolge.<\/p>\n Listing 4: Wiederherstellen der Inhalte aller Tabellen inklusive Anlagefelder<\/span><\/b><\/p>\n Dabei wird der Name der Tabelle in der Variant<\/b>-Variablen var <\/b>gespeichert, von wo aus diese gleich an die Variable strTabelle <\/b>übergeben wird. Die Prozedur leert die Variable strFelder<\/b>, welche für jede Tabelle die Feldliste der zu kopierenden Felder aufnimmt. Außerdem gibt es eine Zählervariable für eventuell enthaltene Anlagefelder namens intAnlagefelder<\/b>. Diese stellt die Prozedur für jede neue Tabelle auf den Wert 0 <\/b>ein.<\/p>\n Nun benötigen wir zum Zusammenstellen der Abfrage, welche die in einem möglicherweise enthaltenen Anlagefeld enthaltenen Daten wiederherstellt, den Namen des Primärschlüsselfeldes von Backup- und Zieltabelle, der glücklicherweise identisch ist.<\/p>\n Diesen ermitteln wir mit der Hilfsfunktion Primaerschlüssel-Ermitteln <\/b>aus Listing 4. Diese Funktion durchläuft alle Index<\/b>-Elemente der mit dem Parameter strTabelle <\/b>übergebenen Tabelle und prüft, ob ihre Eigenschaft Primary <\/b>den Wert True <\/b>hat.<\/p>\n Listing 5: Diese Prozedur ermittelt den Namen des Primärschlüsselfeldes einer Tabelle.<\/span><\/b><\/p>\n In diesem Fall ermittelt die Funktion den Namen des ersten Feldes, der an dem Index beteiligt ist, und gibt diesen an die aufrufende Routine zurück. Wir gehen an dieser Stelle davon aus, dass keine Tabellen mit mehr als einem Primärschlüsselfeld verwendet werden.<\/p>\n Der Name des Primärschlüsselfeldes landet in der Variablen strPK<\/b>.<\/p>\n Die Prozedur referenziert nun das TableDef<\/b>-Objekt auf Basis der mit strTabelle <\/b>angegebenen Tabelle mit der Variablen tdf <\/b>und durchläuft in einer For Each<\/b>-Schleife alle Felder dieser Tabellendefinition.<\/p>\n Eine Select Case<\/b>-Bedingung prüft den Datentyp des aktuell mit fld <\/b>referenzierten Feldes. Im Falle eines Anlagefeldes (dbAttachment<\/b>) redimensioniert die Prozedur die Variable strSQLAnlagefeld <\/b>auf die aktuell in intAnlagefelder <\/b>gespeicherte Anzahl von Anlagefeldern, die bisher in dieser Tabelle entdeckt wurden.<\/p>\n Dann weist die Prozedur dem String-Array strSQLAnlagefeld<\/b>() einen Ausdruck hinzu, der die SELECT INTO<\/b>-Anweisung mit der Sonderbehandlung für das Wiederherstellen der Daten des aktuell bearbeiteten Anlagefelds enthält.<\/p>\n Der resultierende Ausdruck kann beispielsweise wie folgt aussehen:<\/p>\n Informationen zur Zusammenstellung und Funktion einer solchen SQL-Anweisung finden Sie im Beitrag Datensätze mit Anlagefeld kopieren <\/b>(www.access-im-unternehmen.de\/930<\/b>).<\/p>\n Wichtig ist an dieser Stelle, dass Sie wissen, dass diese Anweisung für jedes Anlagefeld erstellt wird und nach dem Kopieren der übrigen Felder per INSERT INTO <\/b>in die Zieltabelle aufgerufen wird.<\/p>\n Wenn das Feld kein Anlagefeld ist, sondern ein mehrwertiges Feld, weist die Prozedur mit einer entsprechenden Meldung darauf hin, das mehrwertige Felder nicht unterstützt werden.<\/p>\n Schließlich folgt der Case Else<\/b>-Zweig, der alle übrigen Felder abdeckt. Hier fügt die Prozedur lediglich den Feldnamen samt führendem Komma an die Variable strFelder <\/b>an.<\/p>\n Das führende Komma der Feldliste wird im nächsten Schritt entfernt. Dann stellt die Prozedur die INSERT INTO<\/b>-Anweisung für die Felder außer den Anlagefeldern zusammen. Diese sieht etwa wie in folgendem Beispiel aus:<\/p>\n Dann führt die Prozedur diese Anweisung für die aktuelle Tabelle aus. Sollte die Variable intAnlagefelder <\/b>größer als 0 <\/b>sein, was darauf hindeutet, dass die aktuelle Tabelle mindestens ein Anlagefeld enthält, das einer Sonderbehandlung bedarf, führt die Prozedur noch weitere Schritte aus. Da die Variable strSQLAnlagefeld() <\/b>an dieser Stelle ein oder mehrere Elemente enthalten kann (eines für jedes Anlagefeld), durchläuft die Prozedur alle Elemente in einer For…Next<\/b>-Schleife. Innerhalb dieser Schleife führt die Prozedur jeweils die im Array gespeicherte INSERT INTO<\/b>-Anweisung für je ein Anlagefeld aus.<\/p>\n Wenn dieser Vorgang für alle Anlagefelder durchgeführt wurde, kümmert die Prozedur sich um die anderen Tabellen, die in der Collection colTabellen <\/b>gespeichert sind.<\/p>\n Somit sind nun alle Tabellen, deren Präfix auf tbl <\/b>lautet, mit den in den Backuptabellen gespeicherten Daten gefüllt.<\/p>\n Erweiterung: Tabellen auswählen<\/b><\/p>\n Nun gibt es im Formular frmSichernUndWiederherstellen <\/b>noch etwas freien Platz, den wir füllen müssen. Diesen nutzen wir dazu, ein Listenfeld unterzubringen, das alle Tabellen anzeigt und dem Benutzer die Möglichkeit bietet, eine oder mehrere auszuwählen und somit nur einen Teil des Datenmodells zu sichern oder wiedeherzustellen.<\/p>\n Das Listenfeld soll schlicht lstTabellen <\/b>heißen und wird wie in Bild 8 in das Formular eingefügt. Damit der Benutzer mehrere Einträge auswählen kann, stellen Sie die Eigenschaft Mehrfachauswahl <\/b>auf Einfach <\/b>ein.<\/p>\n Bild 8: Listenfeld zur Auswahl der zu sichernden oder wiederherzustellenden Tabellen<\/span><\/b><\/p>\n Die Prozedur aus Listing 6 sorgt dafür, dass die Tabellen in das Listenfeld eingetragen werden. Sie durchläuft alle Tabellen der Datenbank und fügt diejenigen zur Variablen strTabellen <\/b>hinzu, die mit dem Präfix tbl <\/b>ausgestattet sind. Diese Liste landet dann als Datensatzherkunft im Listenfeld. Für dieses stellt die Prozedur zuvor die Eigenschaft Herkunftsart <\/b>auf Wertliste <\/b>ein.<\/p>\n Listing 6: Prozedur zum Füllen des Listenfeldes mit den Namen aller Tabellen<\/span><\/b><\/p>\n Die Prozedur soll beim öffnen des Formulars ausgeführt werden, was Sie durch die folgende Ereignisprozedur realisieren:<\/p>\n![\"Angabe](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_003.png\")
<\/p>\n![\"ändern](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_002.png\")
<\/p>\nSELECT KategorieID, Kategoriename, \r\nBeschreibung, \r\nAbbildung \r\nINTO tblKategorien_Backup\r\nFROM tblKategorien;<\/pre>\n
SELECT * INTO tblKategorien_Backup\r\nFROM tblKategorien;<\/pre>\n
Private Sub <\/span>cmdSichern_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n db.Execute \"SELECT * INTO \" & tdf.Name & \"_Backup FROM \" & tdf.Name\r\n Next<\/span> tdf\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_004.png\")
<\/p>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_005.png\")
<\/p>\nSELECT Data.FileData AS Data_FileData, \r\nData.FileName AS Data_FileName, \r\nExtension, Id, Name, Type \r\nINTO _tblResources_Backup \r\nFROM tblResources<\/pre>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_006.png\")
<\/p>\nPrivate Sub <\/span>cmdSichern_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strFelder As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n strFelder = \"\"\r\n For Each fld In tdf.Fields\r\n Select Case fld.Type\r\n Case <\/span>dbAttachment\r\n strFelder = strFelder & \", \" & fld.Name & \".FileData AS \" _\r\n & fld.Name & \"_FileData, \" & fld.Name & \".FileName AS \" _\r\n & fld.Name & \"_FileName, \" & fld.Name & \".FileType AS \" _\r\n & fld.Name & \"_FileType\" \r\n Case <\/span>dbComplexByte, dbComplexDecimal, dbComplexDouble, dbComplexGUID, _\r\n dbComplexInteger, dbComplexLong, _\r\n dbComplexSingle, dbComplexText\r\n MsgBox<\/span> \"Mehrwertige Felder werden nicht unterstützt.\"\r\n Case Else<\/span>\r\n strFelder = strFelder & \", \" & fld.Name\r\n End Select<\/span>\r\n Next<\/span> fld\r\n If <\/span>Len<\/span>(strFelder) > 0 Then<\/span>\r\n strFelder = Mid<\/span>(strFelder, 3)\r\n End If<\/span>\r\n strSQL = \"SELECT \" & strFelder & \" INTO _\" & tdf.Name & \"_Backup FROM \" & tdf.Name\r\n On Error Resume Next<\/span>\r\n db.Execute \"DROP TABLE _\" & tdf.Name & \"_Backup\", dbFailOnError\r\n On Error GoTo<\/span> 0\r\n db.Execute strSQL, dbFailOnError\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n, Data.FileData AS Data_FileData\r\n, Data.FileName AS Data_FileName<\/pre>\n
Private Sub <\/span>cmdWiederherstellen_Click()\r\n TabellenLeeren\r\n TabellenWiederherstellen\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>TabellenLeeren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n db.Execute \"DELETE FROM \" _\r\n & tdf.Name, dbFailOnError\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_007.png\")
<\/p>\nPublic Sub <\/span>TabellenLeeren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>colTabellen As <\/span>Collection\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> colTabellen = _\r\n TabellenreihenfolgeLoeschen\r\n For Each var In colTabellen\r\n db.Execute \"DELETE FROM \" _\r\n & var, dbFailOnError\r\n Next<\/span> var\r\nEnd Sub<\/span><\/pre>\n\n
Public Sub <\/span>TabellenWiederherstellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>colTabellen As <\/span>Collection\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strFelder As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>intAnlagefelder As Integer<\/span>\r\n Dim <\/span>strSQLAnlagefeld() As String<\/span>\r\n Dim <\/span>strTabelle As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strPK As String<\/span>\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> colTabellen = TabellenreihenfolgeKopieren\r\n For Each var In colTabellen\r\n strTabelle = var\r\n strFelder = \"\"\r\n intAnlagefelder = 0\r\n strPK = PrimaerschluesselErmitteln(strTabelle)\r\n Set<\/span> tdf = db.TableDefs(strTabelle)\r\n For Each fld In tdf.Fields\r\n Select Case fld.Type\r\n Case <\/span>dbAttachment\r\n ReDim Preserve strSQLAnlagefeld(intAnlagefelder)\r\n strSQLAnlagefeld(intAnlagefelder) = \"INSERT INTO \" & tdf.Name & \"(\" _\r\n & fld.Name & \".FileName, \" & fld.Name & \".FileData) SELECT T1.\" _\r\n & fld.Name & \"_FileName, T1.\" & fld.Name & \"_FileData FROM (SELECT \" _\r\n & fld.Name & \"_FileName, \" & fld.Name & \"_FileData, \" & strPK _\r\n & \" FROM _\" & var & \"_Backup) AS T1 WHERE \" & var & \".\" & strPK _\r\n & \" = T1.\" & strPK & \";\"\r\n intAnlagefelder = intAnlagefelder + 1\r\n Case Else<\/span>\r\n strFelder = strFelder & \", \" & fld.Name\r\n End Select<\/span>\r\n Next<\/span> fld\r\n If <\/span>Len<\/span>(strFelder) > 0 Then<\/span>\r\n strFelder = Mid<\/span>(strFelder, 3)\r\n End If<\/span>\r\n strSQL = \"INSERT INTO \" & tdf.Name & \" SELECT \" & strFelder & \" FROM _\" & tdf.Name & \"_Backup\"\r\n db.Execute strSQL, dbFailOnError\r\n If <\/span>intAnlagefelder > 0 Then<\/span>\r\n For i = LBound<\/span>(strSQLAnlagefeld) To UBound<\/span>(strSQLAnlagefeld)\r\n db.Execute strSQLAnlagefeld(i), dbFailOnError\r\n Next<\/span> i\r\n End If<\/span>\r\n Next<\/span> var\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>PrimaerschluesselErmitteln(strTabelle As String<\/span>) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>idx As <\/span>DAO.Index\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(strTabelle)\r\n For Each idx In tdf.Indexes\r\n If <\/span>idx.Primary = True<\/span> Then<\/span>\r\n PrimaerschluesselErmitteln = idx.Fields(0).Name\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> idx\r\n Set<\/span> db = Nothing\r\nEnd Function<\/span><\/pre>\nINSERT INTO tblResources(\r\n Data.FileName, Data.FileData\r\n) SELECT \r\n T1.Data_FileName, \r\n T1.Data_FileData \r\nFROM (\r\n SELECT Data_FileName, \r\n Data_FileData, Id \r\n FROM _tblResources_Backup\r\n) AS T1 WHERE tblResources.Id = T1.Id;<\/pre>\n
INSERT INTO tblVersandfirmen \r\nSELECT FirmaID, Firma, Telefon \r\nFROM _tblVersandfirmen_Backup<\/pre>\n
![\"Listenfeld](\"..\/fileadmin\/_temp_\/2014_02\/pic_929_008.png\")
<\/p>\nPrivate Sub <\/span>TabellenEinlesen()\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>tdf As <\/span>dao.TableDef\r\n Dim <\/span>strTabellen As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n strTabellen = strTabellen & tdf.Name & \";\"\r\n End If<\/span>\r\n Next<\/span> tdf\r\n With<\/span> Me!lstTabellen\r\n Debug.Print<\/span> .RowSourceType\r\n .RowSourceType = \"Value List\"\r\n .RowSource = strTabellen\r\n End With<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n TabellenEinlesen\r\nEnd Sub<\/span><\/pre>\n