<\/p>\n
Wenn Sie eine Datenbank entwickeln, die Sie an einen oder mehrere Kunden weitergeben, enthält diese oft noch Testdaten, Tools, die Sie zur Entwicklung benötigen et cetera. Vielleicht entwickeln Sie sogar Datenbanken für mehrere Zielversionen von Access, die unterschiedliche Anforderungen haben. Oder Sie wollen schnell Versionen mit unterschiedlichen Funktionsumgängen exportieren. Die hier vorgestellte Lösung zeigt einige Techniken, um dies zu bewerkstelligen. Der Vorteil etwa gegenüber den eingebauten Importieren-Funktionen ist, dass Sie hier vollständige Konfigurationen speichern können.<\/b><\/p>\n
Gerade in der Startphase einer Anwendung, die Sie für einen oder mehrere Kunden oder Arbeitsplätze entwickeln, werden Sie des öfteren neue Versionen mit Erweiterungen oder Fehlerkorrekturen ausliefern. Wenn Sie die Anwendung dabei von Objekten befreien möchten oder diese in verschiedenen Fassungen herausgeben möchten, steht mit jeder neuen Version eine Menge Handarbeit an, um aus der Entwicklungsversion die Version für den Kunden zu extrahieren.<\/p>\n
Und es gibt eine ganze Reihe von Anwendungsfällen, die unsere Lösung, deren Benutzeroberfläche etwa wie in Bild 1 aussieht, enthalten könnte:<\/p>\n
![\"Der](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_001.png\")
<\/p>\n
Bild 1: Der Export-Helfer für Access-Datenbanken<\/span><\/b><\/p>\n Nicht alle Funktionen werden in diesem Beitrag beziehungsweise in der mit diesem Beitrag veröffentlichten Lösung umgesetzt.<\/p>\n Art der Lösung<\/b><\/p>\n Diese Lösung ließe sich prima als Add-In programmieren und dann von allen Datenbanken aus aufrufen, die exportiert werden sollen. Allerdings beziehen sich die Konfigurationsdaten jeweils auf die eine Datenbank, auf deren Objekte und Eigenschaften der Export zugeschnitten ist – daher haben wir uns entschieden, die Lösung als Satz von Objekten zu programmieren, die Sie in die Zieldatenbank importieren. Dort können Sie in den dazugehörenden Tabellen dann problemlos genau die Konfiguration für die jeweilige Datenbank speichern.<\/p>\n Die Lösung besteht aus einigen Tabellen, Formularen und Modulen, die alle mit dem üblichen Präfix beginnen, dann den Text Export_ <\/b>und schließlich die eigentliche Bezeichnung des Inhalts enthalten (bei Unterformularen zusätzlich sfm<\/b>).<\/p>\n Dies sind die Tabellen, die Sie in die Zieldatenbank importieren müssen, um die Lösung darin zu nutzen:<\/p>\n Und diese Formulare benötigen Sie:<\/p>\n Außerdem benötigen Sie noch das Modul mdlExport_Tools<\/b>.<\/p>\n Basis: Die Konfiguration<\/b><\/p>\n Die Basis der in der Lösung verwalteten Daten bildet eine einzelne Konfiguration. Eine neue Konfiguration legen Sie mit der Schaltfläche rechts neben dem Kombinationsfeld Bezeichnung <\/b>an. Vorhandene Konfigurationen wählen Sie mit diesem Kombinationsfeld aus – s. Bild 2. Dieses Kombinationsfeld bezieht seine Daten aus der Tabelle tblExporte_Exporte<\/b>, deren Entwurf Sie in Bild 3 finden.<\/p>\n Bild 2: Auswahl einer Konfiguration<\/span><\/b><\/p>\n Bild 3: Entwurf der Tabelle zum Speichern der Konfigurationen<\/span><\/b><\/p>\n Das Feld Exportbezeichnung <\/b>dieser Tabelle ist mit einem eindeutigen Index versehen, damit der Benutzer keine Bezeichnung doppelt anlegen kann.<\/p>\n Das Kombinationsfeld cboBezeichnungen <\/b>verwendet die folgende Abfrage als Datensatzherkunft:<\/p>\n Damit es nur die zweite Spalte des Abfrageergebnisses anzeigt, stellen Sie die Eigenschaft Spaltenanzahl <\/b>auf den Wert 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>ein. <\/p>\n Die Schaltfläche rechts vom Kombinationsfeld dient dazu, einen neuen Export und somit einen neuen Eintrag in der Tabelle tblExport_Exporte <\/b>anzulegen.<\/p>\n Sie löst die folgende Prozedur aus:<\/p>\n Die hier aufgerufene Funktion ExportAnlegen<\/b> erledigt die eigentliche Arbeit (s. Listing 1). Sie fragt zunächst mit einer InputBox <\/b>die Bezeichnung für die neue Exportkonfiguration ab und speichert das Ergebnis in der Variablen strExport<\/b>. Eine per Execute<\/b>-Methode ausgeführte INSERT INTO<\/b>-SQL-Abfrage legt dann einen neuen Datensatz mit der soeben ermittelten Bezeichnung in der Tabelle tblExport_Exporte <\/b>an. Die folgende Anweisung ermittelt dann mit SELECT @@IDENTITY <\/b>den Primärschlüsselwert des neuen Datensatzes und schreibt diesen in die Variable lngExportID<\/b>.<\/p>\n Listing 1: Diese Prozedur fragt die notwendigen Informationen zum Anlegen eines neuen Exports ab.<\/span><\/b><\/p>\n Dann aktualisiert die Prozedur die Datensatzherkunft des Kombinationsfeldes und stellt dieses auf den neuen Eintrag ein. Auch die Datenherkunft des Formulars wird aktualisiert und entsprechend mit FindFirst <\/b>auf den neuen Datensatz eingestellt.<\/p>\n Datenherkunft des Formulars<\/b><\/p>\n Damit kommen wir zur Datenherkunft des Formulars frmExport_Exporte <\/b>selbst. Diese besteht schlicht und einfach aus der Tabelle tblExport_Exporte<\/b>.<\/p>\n Beim Laden des Formulars<\/b><\/p>\n Gleich nach dem öffnen des Formulars wird das Ereignis Beim Laden <\/b>ausgelöst. Die dadurch aufgerufene Prozedur sieht wie folgt aus:<\/p>\n Hier findet sich also ein weiterer Aufruf der Funktion ExportAnlegen<\/b>, der aber nur aufgerufen wird, wenn das Feld ExportID <\/b>den Wert Null <\/b>enthält. Dies ist aber nur der Fall, wenn die Datenherkunft des Formulars noch gar keinen Datensatz enthält – also dann, wenn Sie die Objekte der Lösung frisch in die Zielanwendung importiert haben und die Tabelle tblExport_Exporte <\/b>leer ist.<\/p>\n Anschließend ruft die Prozedur die Routine ObjekteEinlesen <\/b>auf, welche – kurz zusammengefasst – alle Objekte der Datenbank ermittelt und in einige weitere Tabellen einträgt.<\/p>\n Schließlich stellt die Prozedur das Kombinationsfeld cboBezeichnungen <\/b>auf den aktuellen Wert des Feldes ExportID <\/b>des Formulars ein. Auf diese Weise werden Daten im Formular und im Kombinationsfeld synchronisiert.<\/p>\n Objekte einlesen<\/b><\/p>\n Die Prozedur ObjekteEinlesen<\/b> wird sowohl beim öffnen des Formulars ausgelöst als auch durch eine eigene Schaltfläche im Fuß des Formulars. Dies dient dem Benutzer als Möglichkeit, die im Formular angezeigten Daten etwa nach dem Anlegen oder Löschen von Objekten zu aktualisieren. Die Schaltfläche heißt cmdObjekteAktualisieren <\/b>und enthält lediglich den Aufruf der Routine ObjekteEinlesen<\/b>:<\/p>\n Die Prozedur ObjekteEinlesen<\/b> selbst finden Sie in Listing 2. Die Prozedur füllt eine Database<\/b>-Variable mit einem Verweis auf die aktuelle Datenbank und speichert die ID des aktuell angezeigten Exports in der Variablen lngExportID<\/b>. Dann beginnt sie mit der Bearbeitung einer Tabelle, die wir bisher noch nicht vorgestellt haben. Sie heißt tblExport_Objekte <\/b>und erfasst alle in der aktuellen Datenbank enthaltenen Objekte. Den Entwurf finden Sie in Bild 4, die Erläuterungen dazu folgen gleich im Anschluss.<\/p>\n Bild 4: Entwurf der Tabelle zum Speichern der Objekte<\/span><\/b><\/p>\n Listing 2: Diese Routine startet das Einlesen aller Objekte der aktuellen Datenbank<\/span><\/b><\/p>\n Die Prozedur aktualisiert nun zunächst eventuell in der Tabelle enthaltene Datensätze, indem sie den Wert des Feldes Loeschen <\/b>für jeden Datensatz auf den Wert -1 <\/b>setzt, was dem Wert True <\/b>entspricht. Der Hintergrund ist, dass die folgenden Prozeduren ja nicht nur alle vorhandenen Objekte in die Tabelle tblExport_Objekte <\/b>eintragen sollen, sondern dass eventuell gelöschte Objekte, die aber noch in der Tabelle enthalten sind, dort entfernt werden sollen. Anschließend prüfen die folgenden Methoden, ob ein in der Datenbank enthaltenes Objekt bereits in der Tabelle tblExport_Objekte <\/b>enthalten ist. Falls ja, wird das Feld Geloescht <\/b>für dieses Objekt auf den Wert False <\/b>einstellt, falls nicht, wird ein neuer Datensatz für das Objekt angelegt. Datensätze, die dann noch den Wert True <\/b>im Feld Geloescht <\/b>aufweisen, sind offensichtlich nicht mehr in der Tabelle enthalten (oder unter einem anderen Namen gespeichert) und können gelöscht werden.<\/p>\n Schließlich aktualisiert die Prozedur die Datenherkünfte des Formulars und somit auch die der Unterformulare mit der Requery<\/b>-Methode und stellt das Formular auf den zuletzt aktiven Datensatz ein.<\/p>\n Bei dieser Gelegenheit wird auch das Ereignis Beim Anzeigen <\/b>ausgelöst, das noch das Kombinationsfeld cboBezeichnungen <\/b>auf den aktuellen Datensatz des Formulars einstellt:<\/p>\n Tabellen einlesen<\/b><\/p>\n Die Prozedur TabellenEinlesen <\/b>wird von der zuvor beschriebenen Prozedur ObjekteEinlesen <\/b>aufgerufen und erwartet zwei Parameter – einen Verweis auf die zu untersuchende Datenbank sowie den Primärschlüsselwert für den aktuellen Export (s. Listing 3).<\/p>\n Listing 3: Einlesen der Tabellen der aktuellen Datenbank und eintragen in die Tabelle tblExport_Objekte<\/span><\/b><\/p>\n Die Prozedur soll nicht alle Tabellen einlesen, sondern nur solche, die nicht über spezielle Optionen von der Erfassung ausgeschlossen werden sollen – mehr zum Dialog, mit dem Sie diese Optionen festlegen, weiter unten.<\/p>\n Deshalb ermittelt die Prozedur nun zunächst einen entsprechenden Filterstring, der im Feld Tabellenfilter <\/b>der Tabelle tblExport_Exporte <\/b>für den Datensatz mit dem entsprechenden Wert im Fremdschlüsselfeld ExportID <\/b>gespeichert ist. Der Wert, der hier ermittelt und in der Variablen strFilterstring <\/b>gespeichert wird, könnte etwa wie folgt aussehen (wenn das Feld Tabellenfilter leer ist, wird strFilterstring <\/b>mit dem Ausdruck * <\/b>gefüllt):<\/p>\n Das bedeutet, dass alle Tabellen, die mit tbl <\/b>und usys <\/b>beginnen, und die Tabelle msysresources <\/b>berücksichtigt werden sollen. Die Tabellennamen, die mit einem vorangestellten Minuszeichen versehen wurden, sollen nicht berücksichtigt werden. In diesem Fall sollen also beispielsweise die Tabellen dieser Lösung, deren Namen alle mit tblExport_ <\/b>beginnen, nicht eingelesen werden.<\/p>\n Die einzelnen Elemente aus strFilterstring <\/b>werden nun mit der Split<\/b>-Funktion an der Stelle der Kommata (,<\/b>) auseinander genommen und jeweils als eigenes Element zum Array strFilter() <\/b>hinzugefügt.<\/p>\n Die Prozedur durchläuft nun die TableDefs<\/b>-Auflistung der aktuellen Datenbank in einer For Each<\/b>-Schleife, wobei die Variable tdf <\/b>jeweils die aktuelle Tabelle referenziert.<\/p>\n Für jedes Element durchläuft die Prozedur dann in einer untergeordneten For…Next<\/b>-Schleife alle Einträge des Arrays mit den Filterausdrücken. Stimmt der Name der aktuellen Tabelle mit dem Filterausdruck überein, stellt die Prozedur die Variable bolEinlesen <\/b>auf den Wert True <\/b>ein und verlässt die Schleife. Nun kann es sein, dass etwa der Eintrag tblExport_Exporte <\/b>dem Kriterium tbl* <\/b>entspricht, aber auch -tblExport_*<\/b>. Dann durchläuft die Prozedur im nächsten Schritt in einer weiteren Schleife alle Filterausdrücke und stellt dem Tabellennamen diesmal ein Minuszeichen voran (also etwa -tblExport_Exporte<\/b>). Liegt hier ein Treffer vor, wird bolEinlesen <\/b>wieder auf False <\/b>eingestellt und die Schleife wird ebenfalls mit Exit For <\/b>verlassen.<\/p>\n Die folgende If…Then<\/b>-Bedingung prüft den Wert von bolEinlesen <\/b>für dieses TableDef<\/b>-Objekt. Ist dieser True, versucht die Prozedur, den Tabellennamen in die Tabelle tblExport_Objekte <\/b>einzutragen – samt dem Wert False <\/b>im Feld Loeschen<\/b>. Ist bereits eine Tabelle gleichen Namens vorhanden, bleibt es bei dem Versuch – die resultierende Fehlermeldung wird durch das vorhergehende On Error Resume Next <\/b>unterbunden. In diesem Fall ermittelt die Prozedur den Primärschlüsselwert für diesen Eintrag und aktualisiert für den gefundenen Datensatz das Feld Loeschen <\/b>auf den Wert False<\/b>. Diese Tabelle ist also bereits in tblExport_Objekte <\/b>gespeichert, es muss nur noch das zuvor auf True <\/b>eingestellte Feld Loeschen <\/b>auf False <\/b>geändert werden, weil die Tabelle ja noch vorhanden ist. War der Eintrag für diese Tabelle noch nicht vorhanden, ermittelt die Prozedur nun den Primärschlüsselwert des neuen Eintrags und speichert diesen in der Variablen lngObjektID<\/b>.<\/p>\n Möglicherweise fragen Sie sich, warum wir diesen aufwendigen Weg gehen und nicht einfach alle Objekte vor dem erneuten Einlesen löschen. Der Grund ist einfach: Wir sind faul und wollen unnötige Schritte nicht wiederholen, und wir gehen davon aus, dass dies auch bei Ihnen der Fall ist. In diesem Fall wird ja später festgelegt, welche Objekte mit welcher Exportkonfiguration verknüpft werden. Damit wir diese Information nicht nach jedem Einlesen erneut angeben müssen, werden vorhandene Objekte beibehalten und nur nicht mehr vorhandene Objekte aus den Konfigurationstabellen gelöscht.<\/p>\n <\/p>\n Den Wert von lngObjektID<\/b> verwendet die Prozedur, um einen neuen Eintrag zur Tabelle tblExport_ExporteObjekte <\/b>hinzuzufügen. Dabei erhält das Feld ExportID <\/b>den in lngExportID <\/b>enthaltenen Wert und ObjektID <\/b>den soeben ermittelten Wert der Variablen lngObjektID<\/b>. Auf diese Weise wird der Eintrag für das Objekt der aktuell im Formular ausgewählten Export-Konfiguration zugeordnet.<\/p>\n Die übrigen Tabellen werden auf die gleiche Weise erfasst und gegebenenfalls zur Tabelle tblExport_Objekte <\/b>hinzugefügt.<\/p>\n Objekte und Exporte<\/b><\/p>\n Die Tabelle tblExport_ExporteObjekte <\/b>haben wir uns noch nicht angesehen. Der Zweck dieser Tabelle ist es, für jede Export-Konfiguration der Anwendung festzulegen, welche Objekte exportiert werden sollen. Da wir eine Tabelle namens tblExport_Exporte <\/b>zum Speichern der Exportkonfigurationen verwenden und eine weitere namens tblExport_Objekte<\/b> (s. Bild 5), welche die Daten zu Tabellen, Abfragen et cetera speichert, benötigen wir noch eine Möglichkeit, diese Daten miteinander zu verknüpfen. Da jedes Objekt mit jeder Export-Konfiguration verknüpft werden soll, ist eine Verknüpfungstabelle zur Herstellung einer m:n-Beziehung gefragt.<\/p>\n Bild 5: In der Tabelle tblExport_Objekte gespeicherte Objekte<\/span><\/b><\/p>\n Diese sieht im Entwurf wie in Bild 6 aus und enthält die beiden Fremdschlüsselfelder ObjektID <\/b>und ExportID<\/b>, für die ein zusammengesetzter, eindeutiger Index festgelegt ist – schließlich soll jedes Objekt jeder Exportkonfiguration nur einmal zugeordnet werden können. Das Feld Exportieren <\/b>ist ein Ja\/Nein<\/b>-Feld, das festlegt, ob dieses Objekt in der angegebenen Exportkonfiguration berücksichtigt wird. Bei den Tabellen kann der Benutzer zusätzlich festlegen, ob er diese mit oder ohne Daten exportieren möchte. Dies stellt er, ebenfalls konfigurationsabhängig, im Feld MitDaten <\/b>der Tabelle tblExport_ExporteObjekte <\/b>ein.<\/p>\n Bild 6: Entwurf der Tabelle tblExport_ExporteObjekte<\/span><\/b><\/p>\n Nach dem Aufruf der Prozeduren zum Einlesen der Objekte sieht diese Tabelle in der Datenblattansicht etwa wie in Bild 7 aus.<\/p>\n Bild 7: Daten der Tabelle tblExport_ExporteObjekte<\/span><\/b><\/p>\n Abfragen einlesen<\/b><\/p>\n Die Prozedur AbfragenEinlesen<\/b> ist prinzipiell wie die Prozedur TabellenEinlesen <\/b>aufgebaut – daher wollen wir diese hier nicht ausführlich beschreiben.<\/p>\n Die Unterschiede liegen im Wesentlichen darin, dass diese Prozedur ihren Filter aus dem Feld Abfragefilter<\/b> der Tabelle tblExport_Exporte <\/b>bezieht und die QueryDefs<\/b>-Auflistung zur Ermittlung der Abfragen durchläuft.<\/p>\n Außerdem stellt sie beim Eintragen der Abfragen in die Tabelle tblExport_Objekte <\/b>für das Feld ObjekttypID <\/b>den dem Objekttyp entsprechenden Wert ein.<\/p>\n Formulare und Berichte einlesen<\/b><\/p>\n Das Einlesen der Formulare und Berichte verläuft ebenfalls so ähnlich wie das der Tabellen und Abfragen. Allerdings gibt es ein paar Unterschiede, die Sie auch in Listing 4 ablesen können. Die dort dargestellte Prozedur FormulareEinlesen <\/b>verwendet den Filterausdruck aus dem Feld Formularfilter<\/b>. Um die richtigen Objekte zu ermitteln, verwendet diese Prozedur allerdings keine Auflistung der DAO-Bibliothek wie TableDefs <\/b>oder QueryDefs<\/b>, sondern diesmal die AllForms<\/b>-Auflistung des CurrentProject<\/b>-Objekts. Beim Eintragen der Daten in die Tabelle tblExport_Objekte <\/b>verwendet die Prozedur für das Feld ObjekttypID <\/b>den Wert 3<\/b>. Die Werte für den Objekttyp beziehungsweise für das Fremdschlüsselfeld ObjekttypID <\/b>stammen übrigens aus der Tabelle tblExport_Objekttypen<\/b>, die Sie in Bild 8 finden. Das Einlesen der Berichte erfolgt analog zu den Formularen, Gleiches gilt für die Makros und Module.<\/p>\n Bild 8: Die Tabelle tblExport_Objekttypen<\/span><\/b><\/p>\n Verweise einlesen<\/b><\/p>\n Neben den Objekten sollen auch die Verweise der aktuellen Datenbank eingelesen werden. Dies erledigt die Prozedur VerweiseEinlesen<\/b>, welche die gleichen Parameter erwartet wie die zuvor beschriebenen Prozeduren (s. Listing 5).<\/p>\n Listing 5: Einlesen der Verweise der aktuellen Datenbank und eintragen in die Tabelle tblExport_Verweise<\/span><\/b><\/p>\n Die Prozedur stellt zunächst den Wert des Feldes Loeschen <\/b>der Tabelle tblExport_Verweise <\/b>auf den Wert True <\/b>ein. Hier wird gleich deutlich: Die Verweise speichern wir nicht gemeinsam mit den übrigen Objekten in der Tabelle tblExport_Objekte<\/b>, sondern in einer eigenen Tabelle. Diese sieht im Entwurf wie in Bild 9 aus. Sie enthält neben dem Feld Verweisname, für das übrigens wieder ein eindeutiger Index definiert ist, noch ein weiteres Feld namens VerweisGUID<\/b>. Dieses ist wichtig, wenn Sie die Verweise zur Zieldatenbank hinzufügen. Schließlich finden Sie auch hier das Feld Loeschen<\/b>, mit dem zu löschende Verweise markiert werden.<\/p>\n Bild 9: Die Tabelle tblExport_Verweise<\/span><\/b><\/p>\n Die Prozedur VerweiseEinlesen <\/b>durchläuft in einer For Each<\/b>-Schleife alle Elemente der Auflistung References <\/b>für das mit dem Objekt ActiveVBProject <\/b>referenzierte Projekt der aktuellen Anwendung. Der jeweilige Verweis landet in der Variablen ref<\/b>. Innerhalb der Schleife versucht die Prozedur, einen Datensatz mit den entsprechenden Informationen zur Tabelle tblExport_Verweise <\/b>hinzuzufügen. Gelingt dies nicht, weil es bereits einen Eintrag mit gleichem Verweisnamen gibt, aktualisiert die Prozedur diesen Eintrag, indem sie den Wert des Feldes Loeschen <\/b>von True <\/b>auf False <\/b>ändert.<\/p>\n Sie ermittelt in beiden Fällen den Wert des Primärschlüssels des betroffenen Eintrags, um einen entsprechenden Eintrag zur Verknüpfungstabelle tblExport_ExporteVerweise <\/b>hinzuzufügen (den Entwurf dieser Tabelle finden Sie in Bild 10). Diese Tabelle hat den gleichen Zweck wie die Tabelle tblExport_ExporteObjekte<\/b>: Sie soll festlegen, welcher Verweis für die entsprechende Exportkonfiguration verwendet werden soll. Auch hier werden nur noch nicht vorhandene Datensätze neu angelegt, für bereits vorhandene Kombinationen aus ExportID <\/b>und VerweisID <\/b>aktualisiert die Prozedur lediglich die Version der Verweise in den beiden Feldern Major <\/b>und Minor<\/b>.<\/p>\n Bild 10: Die Tabelle tblExport_VerweiseExporte<\/span><\/b><\/p>\n Damit haben wir soweit alle Informationen gesammelt, die sich auf die Objekte und Verweise beziehen.<\/p>\n Objekte für den Export auswählen<\/b><\/p>\n Im Formular frmExport_Main <\/b>lassen sich diese Daten natürlich nicht direkt darstellen – dazu benötigen wir einen Rutsch Unterformulare. Da auch diese nicht alle gleichzeitig in einem Formular abgebildet werden sollen, fügen Sie dem Formular frmExport_Main <\/b>ein Registersteuerelement namens regObjekte<\/b> hinzu. Dieses nimmt für jeden Objekttyp eine eigene Seite auf, also beispielsweise pgeTabellen<\/b>, pgeAbfragen<\/b>, pgeFormulare <\/b>und so weiter. Später kommen noch weitere hinzu.<\/p>\n Für jeden Objekttyp legen Sie ein eigenes Unterformular an. Das Unterformular für die Anzeige der Tabellen heißt beispielsweise frmExport_sfmTabellen<\/b> und verwendet die Abfrage aus Bild 11 als Datenherkunft.<\/p>\n Bild 11: Datenherkunft des Unterformulars frmExport_sfmTabellen<\/span><\/b><\/p>\n Diese führt die beiden Tabellen tblExport_Objekte <\/b>und tblExport_ObjekteExporte <\/b>zusammen. Dies ist wichtig, da so auch der Inhalt des Feldes ExportID <\/b>mit in die Datenherkunft gelangt. Da es mehrere Exportkonfigurationen gibt, bei denen jede möglicherweise andere Objekte der Datenbank exportieren soll, darf das Unterformular auch nur diejenigen Datensätze der Verknüpfungs-tabelle tblExport_ExporteObjekte <\/b>samt dem Wert im Feld Exportieren <\/b>und MitDaten <\/b>anzeigen, die zu dem aktuell im Hauptformular angezeigten Datensatz gehören.<\/p>\n Das Unterformular frmExport_sfmTabellen <\/b>soll aus dieser Datenherkunft lediglich die drei Felder Objektbezeichnung<\/b>, Exportieren <\/b>und MitDaten <\/b>anzeigen (s. Bild 12).<\/p>\n Bild 12: Das Unterformular frmExport_sfmTabellen<\/span><\/b><\/p>\n Nun müssen Sie dieses Formular noch auf die entsprechende Seite des Registersteuerelements im Hauptformular einfügen. Dazu fügen Sie das Unterformular zunächst auf die schnellstmögliche Weise zum Hauptformular hinzu – nämlich, indem Sie dieses aus dem Navigationsbereich in den Entwurf des Formulars frmExport_Main <\/b>ziehen.<\/p>\n Dort schneiden Sie es dann aus (etwa mit Strg + X<\/b>), markieren dann die entsprechende Registerseite, sodass diese hervorgehoben wird, und fügen das ausgeschnittene Unterformular mit dem Kontextmenübefehl Einfügen <\/b>an dieser Stelle ein. Nach dem Einstellen der Position des Unterformular-Steuerelements sieht das Formular wie in Bild 13 aus.<\/p>\n Bild 13: Das Unterformular frmExport_sfmTabellen im Registersteuerelement des Hauptformulars<\/span><\/b><\/p>\n Stellen Sie sicher, dass die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformular-Steuerelements wie in der Abbildung beide den Wert ObjektID <\/b>aufweisen. Die Unterformular-Steuerelemente haben wir der Einfachheit halber übrigens sfmTabellen<\/b>, sfmAbfragen<\/b>, sfmFormulare <\/b>und so weiter benannt.<\/p>\n Die Unterformulare für die übrigen Tabellen, also für tblExport_Abfragen<\/b>, tblExport_Formulare<\/b>, tblExport_Berichte<\/b>, tblExport_Makros <\/b>und tblExport_Module <\/b>haben wir auf die gleiche Weise angelegt. Einziger Unterschied: Das Feld MitDaten <\/b>muss dort natürlich nicht berücksichtigt werden, denn nur die Tabellen enthalten Daten (s. Bild 14).<\/p>\n Bild 14: Das Unterformular frmExport_sfmAbfragen soll nur diese beiden Felder anzeigen.<\/span><\/b><\/p>\n Beim Unterformular frmExport_sfmVerweise <\/b>sollen zusätzlich noch die beiden Felder Major <\/b>und Minor <\/b>zur Angabe der Version hinzugefügt werden sowie das Feld VerweisGUID<\/b> (s. Bild 15).<\/p>\n Bild 15: Beim Unterformular frmExport_sfmVerweise kommen noch die beiden Felder zur Anzeige der Version hinzu.<\/span><\/b><\/p>\n Weitere Formularelemente<\/b><\/p>\n Bevor wir uns um den tatsächlichen Export und somit um die Erstellung einer neuen Datenbank beschäftigen können, müssen wir noch einige Elemente im Hauptformular frmExport_Main <\/b>erläutern.<\/p>\n Zieldatenbank auswählen<\/b><\/p>\n Da wäre zunächst einmal die Zieldatenbank, die Sie entweder direkt in das Textfeld txtZiel <\/b>eintragen oder über einen Klick auf die Schaltfläche cmdDateiauswahl <\/b>rechts von diesem Textfeld auswählen. Letzteres würde einen Datei speichern<\/b>-Dialog öffnen, mit dem Sie entweder eine vorhandene Datei auswählen oder aber den Namen für eine neu zu erstellende Datei angeben. Der Code, der durch einen Klick auf die Schaltfläche cmdDateiauswahl <\/b>ausgeführt wird, ist schnell erläutert (s. Listing 6):<\/p>\n\n
\n
\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_002.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_003.png\")
<\/p>\nSELECT ExportID, -Exportbezeichnung \r\nFROM tblExport_Exporte \r\nORDER BY Exportbezeichnung;<\/pre>\n
Private Sub <\/span>cmdNeuerExport_Click()\r\n ExportAnlegen\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>ExportAnlegen() As Long<\/span>\r\n Dim <\/span>strExport As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngExportID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n strExport = InputBox(\"Bitte geben Sie eine Bezeichnung für den Export ein.\", \"Exportbezeichnung\", \"[Exportbezeichnung]\")\r\n db.Execute \"INSERT INTO tblExport_Exporte(Exportbezeichnung) VALUES(''\" & strExport & \"'')\", dbFailOnError\r\n lngExportID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Me!cboBezeichnungen.Requery\r\n Me!cboBezeichnungen = lngExportID\r\n Me.Requery\r\n Me.Recordset.FindFirst \"ExportID = \" & lngExportID\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n If <\/span>IsNull(Me!ExportID) Then<\/span>\r\n ExportAnlegen\r\n End If<\/span>\r\n ObjekteEinlesen\r\n Me!cboBezeichnungen = Me!ExportID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdObjekteAktualisieren_ Click()\r\n ObjekteEinlesen\r\nEnd Sub<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_004.png\")
<\/p>\nPrivate Sub <\/span>ObjekteEinlesen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngExportID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngExportID = Me!ExportID\r\n db.Execute \"UPDATE tblExport_Objekte AS t1 INNER JOIN \" _\r\n & \"tblExport_ObjekteExporte AS t2 ON t1.ObjektID = t2.ObjektID \" _\r\n & \"SET t1.Loeschen = -1 WHERE t2.ExportID = \" & Me!ExportID, dbFailOnError\r\n TabellenEinlesen db, lngExportID\r\n AbfragenEinlesen db, lngExportID\r\n FormulareEinlesen db, lngExportID\r\n BerichteEinlesen db, lngExportID\r\n MakrosEinlesen db, lngExportID\r\n ModuleEinlesen db, lngExportID\r\n VerweiseEinlesen db, lngExportID\r\n db.Execute \"DELETE FROM tblExport_Objekte WHERE Loeschen = -1\", dbFailOnError\r\n Me.Requery\r\n Me.Recordset.FindFirst \"ExportID = \" & lngExportID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n Me!cboBezeichnungen = Me!ExportID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>TabellenEinlesen(db As <\/span>DAO.Database, lngExportID As Long<\/span>)\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strFilter() As String<\/span>\r\n Dim <\/span>strFilterstring As String<\/span>\r\n Dim <\/span>bolEinlesen As Boolean<\/span>\r\n Dim <\/span>lngObjektID As Long<\/span>\r\n strFilterstring = Nz(DLookup(\"Tabellenfilter\", \"tblExport_Exporte\", \"ExportID = \" & lngExportID), \"*\")\r\n strFilter = Split<\/span>(strFilterstring, \",\")\r\n For Each tdf In db.TableDefs\r\n bolEinlesen = False<\/span>\r\n For i = LBound<\/span>(strFilter) To UBound<\/span>(strFilter)\r\n If <\/span>tdf.Name Like strFilter(i) Then<\/span>\r\n bolEinlesen = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n For i = LBound<\/span>(strFilter) To UBound<\/span>(strFilter)\r\n If <\/span>\"-\" & tdf.Name Like strFilter(i) And Left<\/span>(strFilter(i), 1) = \"-\" Then<\/span>\r\n bolEinlesen = False<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n If <\/span>bolEinlesen = True<\/span> Then<\/span>\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblExport_Objekte(Objektbezeichnung, ObjekttypID, Loeschen) VALUES(''\" & tdf.Name _\r\n & \"'', 1, 0)\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n lngObjektID = DLookup(\"ObjektID\", \"tblExport_Objekte\", \"Objektbezeichnung = ''\" & tdf.Name _\r\n & \"'' AND ObjekttypID = 1\")\r\n db.Execute \"UPDATE tblExport_Objekte SET Loeschen = 0 WHERE ObjektID = \" & lngObjektID, dbFailOnError\r\n Else<\/span>\r\n lngObjektID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n End If<\/span>\r\n db.Execute \"INSERT INTO tblExport_ObjekteExporte(ObjektID, ExportID) VALUES(\" & lngObjektID & \", \" _\r\n & lngExportID & \")\", dbFailOnError\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\ntbl*,usys*,msysresources,-frmExport_*<\/pre>\n
![\"In](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_006.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_008.png\")
<\/p>\n![\"Daten](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_007.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_009.png\")
<\/p>\nPrivate Sub <\/span>VerweiseEinlesen(db As <\/span>DAO.Database, lngExportID As Long<\/span>)\r\n Dim <\/span>ref As <\/span>VBIDE.Reference\r\n Dim <\/span>lngVerweisID As Long<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n db.Execute \"UPDATE tblExport_Verweise SET Loeschen = True\", dbFailOnError\r\n For Each ref In VBE.ActiveVBProject.References\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblExport_Verweise(Verweisname, VerweisGUID) VALUES(''\" & ref.Name & \"'', ''\" _\r\n & ref.GUID & \"'')\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n db.Execute \"UPDATE tblExport_Verweise SET Loeschen = False<\/span> WHERE Verweisname = ''\" & ref.Name & \"''\", dbFailOnError\r\n lngVerweisID = db.OpenRecordset(\"SELECT VerweisID FROM tblExport_Verweise WHERE Verweisname = ''\" _\r\n & ref.Name & \"''\").Fields(0)\r\n Else<\/span>\r\n lngVerweisID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblExport_VerweiseExporte(VerweisID, ExportID, Major, Minor) VALUES(\" _\r\n & lngVerweisID & \", \" & lngExportID & \", \" & ref.Major & \", \" & ref.Minor & \")\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n On Error GoTo<\/span> 0\r\n lngID = DLookup(\"VerweisExportID\", \"tblExport_VerweiseExporte\", \"ExportID = \" & lngExportID _\r\n & \" AND VerweisID = \" & lngVerweisID)\r\n db.Execute \"UPDATE tblExport_VerweiseExporte SET Major = \" & ref.Major & \", Minor = \" & ref.Minor _\r\n & \" WHERE VerweisExportID = \" & lngID, dbFailOnError\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Next<\/span> ref\r\n db.Execute \"DELETE FROM tblExport_Verweise WHERE Loeschen = True\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_010.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_011.png\")
<\/p>\n![\"Datenherkunft](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_012.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_013.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_014.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_015.png\")
<\/p>\n![\"Beim](\"..\/fileadmin\/_temp_\/2014_03\/pic_939_016.png\")
<\/p>\nPrivate Sub <\/span>cmdDateiauswahl_Click()\r\n Dim <\/span>strVerzeichnis As String<\/span>\r\n Dim <\/span>strDatei As String<\/span>\r\n