<\/p>\n
Im Beitrag „Gespeicherte Importe und Exporte per VBA“ zeigen wir, wie Sie etwa den Export oder Import von Textdateien per VBA steuern können. Mit diesen grundlegenden Techniken ausgestattet können wir noch einen Schritt weitergehen und beispielsweise auch komplette Tabelle aus einer anderen Datenbank importieren und diesen Vorgang per VBA ausführen. Wenn Sie etwa regelmäßig immer wieder die gleichen Tabellen aus einer Vorlagendatenbank in die Zieldatenbank importieren, müssen Sie normalerweise immer den entsprechenden Import-Assistenten dazu nutzen. Das können Sie von nun an auch mit ein paar Zeilen VBA-Code erledigen.<\/b><\/p>\n
Wenn Sie einen Import von Access-Objekten wie hier von Access-Tabellen aus einer anderen Datenbank automatisieren wollen, können Sie dies ganz einfach erledigen.<\/p>\n
Als Erstes führen Sie den Import einmal mit dem dafür vorgesehenen Assistenten durch. Dazu wählen Sie im Ribbon den Eintrag Externe Daten|Importieren und Verknüpfen|Neue Datenquelle|Aus Datenbank|Access <\/b>aus (siehe Bild 1).<\/p>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_001.png\")
<\/p>\n
Bild 1: Aufruf des Importassistenten für Daten aus einer Access-Datenbank<\/span><\/b><\/p>\n Im nun erscheinenden Dialog Externe Daten – Access-Datenbank <\/b>geben Sie oben zunächst den Namen der als Quelle zu verwendenden Access-Datenbank ein oder wählen diesen über die Durchsuchen…<\/b>-Schaltfläche aus. Danach entscheiden Sie sich, ob Sie die Access-Objekte importieren wollen oder, wenn Sie nur Tabellen in den Import einbeziehen wollen, ob diese verknüpft werden sollen (siehe Bild 2). Klicken Sie dann auf die Schaltfläche OK<\/b>. In diesem Beispiel wollen wir einige Tabellen der Datenbankdatei Suedsturm.accdb <\/b>in die aktuell geöffnete Datenbank importieren.<\/p>\n Bild 2: Auswahl der Import-Art und der Quelldatei für den Import<\/span><\/b><\/p>\n Im folgenden Dialog finden wir nun verschiedene Registerseiten mit den verschiedenen Objekttypen als überschriften vor. Wir interessieren uns nur für die erste Seite mit den Tabellen. Hier können wir mit einem Klick auf die Schaltfläche Optionen >> <\/b>weitere Optionen anzeigen, die im unteren Bereich des Dialogs eingeblendet werden. Wir behalten die Optionen bei und wählen alle Tabellen aus, die wir in die Zieldatenbank importieren wollen. Damit die Definitionen samt den enthaltenen Daten importiert werden, behalten wir im Bereich Tabellen importieren die Option Definitionen und Daten <\/b>bei (siehe Bild 3).<\/p>\n Bild 3: Dialog zum Auswählen der zu importierenden Daten und zu Einstellen weiterer Optionen<\/span><\/b><\/p>\n Es fehlt noch der letzte Schritt, der den Benutzer fragt, ob dieser die Importschritte speichern möchte (Importschritte speichern<\/b>). Nach dem Aktivieren dieser Option blendet der Dialog einige weitere Optionen ein, von denen wir nur das Textfeld Speichern unter: <\/b>nutzen wollen (siehe Bild 4). Hier geben wir einen sinnvollen Namen für den zu speichernden Import ein und speichern diesen dann durch einen Klick auf die Schaltfläche Import speichern<\/b>.<\/p>\n Bild 4: Optionen zum Speichern der Importvorlage<\/span><\/b><\/p>\n Nachdem wir dies erledigt haben, können wir den gespeicherten Import über einen Dialog einsehen, den wir mit dem Ribbonbefehl Externe Daten|Importieren und Verknüpfen|Gespeicherte Importe <\/b>einsehen können. Dieser öffnet den Dialog aus Bild 5, wo wir auch unseren gespeicherten Import vorfinden. Durch Markieren des gewünschten Eintrags und anschließendes Betätigen der Schaltfläche Ausführen <\/b>können Sie diesen nun erneut ausführen. Die im Navigationsbereich angezeigten Tabellen werden nun nicht direkt aktualisiert, dies geschieht erst nach dem Schließen des Dialogs.<\/p>\n Bild 5: Die gespeicherte Importvorlage in der Liste der vorhandenen Importvorlagen<\/span><\/b><\/p>\n Wenn Sie einen Import mehrmals ausführen oder aus anderen Gründen bereits Tabellen vorhanden sind, welche die Namen der zu importierenden Tabellen aufweisen, werden diese unter einem neuen Namen importiert, der aus dem vorhandenen Namen plus einer Zahl als Zusatz besteht – bei tblArtikel <\/b>also tblArtikel1<\/b>, tblArtikel2 <\/b>und so weiter.<\/p>\n Sie können nun direkt per VBA auf die Einstellungen des gespeicherten Imports zugreifen. Um etwa den Namen auszugeben, können Sie auch den Namen als Index für die Auflistung ImportExportSpecifications <\/b>verwenden:<\/p>\n Die Definition erhalten Sie über die Eigenschaft XML <\/b>dieses Elements der Auflistung ImportExportSpecifications<\/b>. Sie sieht wie in Listing 1 aus.<\/p>\n Listing 1: Definition des ImportExportSpecification-Objekts<\/span><\/b><\/p>\n Das XML-Dokument mit den Import-Daten enthält im Root-Element unter Path <\/b>wieder den Pfad zu der Datei mit den zu importierenden Daten. Darunter folgt das Element ImportAccess<\/b>. Dieses weist die folgenden Attribute auf, die im Wesentlichen die Informationen über die festgelegten Optionen enthalten:<\/p>\n Damit sind alle Optionen des Dialogs Objekte importieren <\/b>abgedeckt.<\/p>\n Darunter folgen dann mehrere Elemente mit dem Namen AccessObject<\/b>. Hier gibt es zwei Attribute:<\/p>\n Schauen wir uns an, ob wir den Import für eine einzige Tabelle selbst per VBA nachbauen können. Dazu benötigen wir nur wenige Zeilen Code, wir wie in Listing 2 sehen.<\/p>\n <\/p>\n Listing 2: Erstellen eines neuen gespeicherten Imports<\/span><\/b><\/p>\n Hier deklarieren wir eine Variable namens strXML <\/b>des Typs String <\/b>sowie eine namens objSpec <\/b>mit dem Typ ImportExportSpecification<\/b>. Die Variable strXML <\/b>füllen wir mit dem Code der zuvor erstellten Export-Spezifikation – mit dem Unterschied, dass wir diesmal nur eine Tabelle importieren wollen (hier tblArtikel<\/b>).<\/p>\n objSpec <\/b>füllen wir über die Methode Add <\/b>der Auflistung ImportExportSpecifications<\/b>, der wir als ersten Parameter den Namen der neu zu erstellenden Spezifikation übergeben (Import_tblArtikel<\/b>) und als zweiten Parameter den Inhalt der Variablen strXML<\/b>. Wenn Sie diese Prozedur mit F5 <\/b>ausführen, geschieht erst einmal nichts. Erst wenn Sie den Dialog Datentasks verwalten <\/b>aufrufen, finden Sie den neuen Eintrag namens Import_tblArtikel <\/b>vor (siehe Bild 6). Wenn Sie diesen nun markieren und aufrufen, wird genau die Tabelle tblArtikel <\/b>zur Zieldatenbank hinzugefügt.<\/p>\n Bild 6: Die neu erstellte Importvorlage im Dialog Datentasks verwalten<\/span><\/b><\/p>\n Dies könne Sie nun auch noch per VBA-Code starten, und zwar mit der folgenden Anweisung:<\/p>\n Leider fehlt dem Import-Dialog eine Option, mit der man angeben kann, ob eventuell vorhandene Objekte gleichen Namens überschrieben werden sollen. Aber dies können wir ja mit wenigen Zeilen VBA-Code nachrüsten:<\/p>\n Es kann übrigens sein, dass dies nicht funktioniert, weil der Löschvorgang fehlschlägt. Das ist beispielsweise der Fall, wenn die Tabelle tblArtikel <\/b>Beziehungen zu anderen Tabellen aufweist. Für diesen Fall können wir allerdings ebenfalls vorbeugen, indem wir die betroffenen Beziehungen vorher entfernen. Aber werden die Beziehungen zwischen der neu importierten Tabelle und den vorhandenen Tabellen wiederhergestellt Das schauen wir uns jetzt an. Die dazu verwendete Prozedur sieht wie folgt aus:<\/p>\n Sie trägt den Namen der zu ersetzenden Tabelle, hier tblArtikel<\/b>, in die Variable strTable <\/b>ein. Dann füllt sie die Variable db <\/b>mit einem Verweis auf das Database<\/b>-Objekt der aktuellen Session. Dieses weist eine Relations<\/b>-Auflistung mit allen Beziehungen der Datenbank auf. Diese durchlaufen wir und referenzieren das jeweilige Element mit der Variablen rel <\/b>des Typs Relation<\/b>. Woran erkennen wir die Beziehungen, an der unsere Tabelle beteiligt ist Oder besser gefragt: Welche Beziehungen verhindern das Löschen der Tabelle, wenn wir sie nicht vorher entfernen Das Relation<\/b>-Objekte bietet zwei Eigenschaften an, welche die an der Beziehung beteiligten Beziehungen angeben, nämlich ForeignTable <\/b>und Table<\/b>. ForeignTable <\/b>enthält die Tabelle, die das Fremdschlüsselfeld der Beziehung enthält, Table <\/b>die Tabelle mit dem Primärschlüsselfeld der Beziehung.<\/p>\n Wenn wir beispielsweise die Tabelle tblArtikel <\/b>löschen wollen, die über Fremdschlüsselfelder mit den Tabellen tblKategorien <\/b>und tblLieferanten <\/b>verknüpft ist und über das Primärschlüsselfeld mit der Tabelle tblBestelldetails<\/b>, die dann logischerweise das Fremdschlüsselfeld der Tabelle enthält, müssen wir zunächst diejenigen Beziehungen löschen, deren Fremdschlüsselfeld in der zu löschenden Tabelle vorliegt.<\/p>\n Das sind dann die Elemente der Relations<\/b>-Auflistung, deren Eigenschaft ForeignTable <\/b>den Namen der zu löschenden Tabelle enthält. Wir müssen aber auch die Beziehungen löschen, welche die zu löschende Tabelle im Feld Table <\/b>enthalten. Genau das erledigt die Prozedur TabelleImportieren-Ver-knuep-fungLoeschen <\/b>in der For Each<\/b>-Schleife. Sie prüft, ob das aktuell durchlaufene Relation<\/b>-Element entweder in der Eigenschaft Table <\/b>oder ForeignTable <\/b>den Namen der zu löschenden Tabelle aufweist und entfernt dann die relevanten Relation<\/b>-Objekte mit der Delete<\/b>-Methode aus der Auflistung Relations<\/b>.<\/p>\n Somit gelingt dann schließlich das Ersetzen der alten Version der Tabelle tblArtikel <\/b>durch die aus der Quelldatenbank. Aber haben wir nun auch den gleichen Zustand wie zuvor Nein, denn wenn wir die Prozedur TabelleImportierenVerknuepfungLoeschen <\/b>in eine neue Prozedur namens BeziehungenAnzeigen<\/b> übertragen und diese wie folgt kürzen und ausführen, erhalten wir in der Liste der Beziehungen keinen der Einträge, der die Tabelle tblArtikel <\/b>in einer der beiden Eigenschaften Table <\/b>oder ForeignTable <\/b>aufweist:<\/p>\n Das Ergebnis nach dem Ausführen der Prozedur sieht im Direktbereich wie in Bild 7 aus, die Tabelle tblArtikel <\/b>kommt in keiner der aufgelisteten Beziehungen vor.<\/p>\n Bild 7: Relations im Direktfenster<\/span><\/b><\/p>\n Beim Import einer einzigen Tabelle werden also keine der Beziehungen zu den anderen Tabellen der Originaldatenbank importiert – auch nicht, wenn die anderen an der Beziehung beteiligten Tabellen dort vorhanden sind. Also müssen wir unserer Prozedur noch ein paar Anweisungen hinzufügen, welche auch die vor dem Löschen vorhandenen Beziehungen wiederherstellen.<\/p>\n Dazu wollen wir die Eigenschaften der zu löschenden Elemente in einer Collection zwischenspeichern. Die Collection namens colRelations <\/b>soll jeweils ein Objekt auf Basis einer Klasse namens clsRelation <\/b>aufnehmen, die wir wie in Listing 3 deklarieren. Dazu deklarieren wir für die drei Felder Table<\/b>, ForeignTable <\/b>und Name <\/b>jeweils eine private Variable.<\/p>\n Listing 3: Klasse zum Zwischenspeichern von Relationen<\/span><\/b><\/p>\n Für jede dieser Variablen fügen wir der Klasse jeweils eine Property Let<\/b>– und eine Property Get<\/b>-Prozedur hinzu, über die wir die Eigenschaften schreiben und lesen können.<\/p>\n Die Prozedur AddField <\/b>dient dazu, das oder die Felder der Beziehung aufzunehmen (es gibt ja auch Beziehungen, die über mehr als ein Feld hergestellt werden). Dieses verwendet das im Kopf des Klassenmoduls deklarierte Collection<\/b>-Objekt colFields<\/b>, in der wir Instanzen auf Basis der Klasse clsField<\/b> speichern wollen. Beim Aufruf der Methode AddField <\/b>übergibt man den Namen des Feldes in der Tabelle und der Verknüpfungstabelle. Anschließend erstellt die Methode ein neues Objekt auf Basis der Klasse clsField<\/b>. Diese nimmt die beiden Eigenschaften Table <\/b>und ForeignTable <\/b>auf. Nach dem Erstellen und Füllen des Objekts wird dieses mit der Add<\/b>-Methode an die Collection colFields <\/b>angehängt. Diese Collection stellt die Klasse clsRelation <\/b>wiederum über die Eigenschaft Fields <\/b>zur Verfügung.<\/p>\n Die Klasse clsField <\/b>finden Sie in Listing 4.<\/p>\n Listing 4: Klasse zum Zwischenspeichern von Feldern<\/span><\/b><\/p>\n Die Prozedur TabelleImportierenMitBeziehung<\/b> ist die neue Version der Prozedur TabelleImportieren-Ver-knuep-fung-Loeschen<\/b>, und sie ist etwas umfangreicher (siehe Listing 5).<\/p>\n Listing 5: Prozedur zum Importieren einer Tabelle mit Wiederherstellung der Beziehungen<\/span><\/b><\/p>\n Die Prozedur deklariert neben den bekannten Elementen eine Collection namens colRelations <\/b>und instanziert diese auch gleich mit dem New<\/b>-Schlüsselwort. Außerdem deklariert sie eine Variable namens objRelation <\/b>mit dem Typ clsRelation <\/b>zum Zwischenspeichern der Eigenschaften der zu löschenden Beziehung, um diese später wiederherstellen zu können.<\/p>\n Dann geht es los: Wir speichern den Namen der auszutauschenden Tabelle in strTable<\/b>. Dann durchlaufen wir rückwärts in einer For…Next<\/b>-Schleife alle Relation<\/b>-Objekte, also alle Beziehungen und prüfen, ob diese mit der Tabelle tblArtikel <\/b>in Verbindung steht. Falls ja, erstellen wir ein neues Objekt des Typs clsRelation <\/b>und weisen diesem die Eigenschaften der Beziehung zu. Dann fügen wir es zur Collection colRelations <\/b>hinzu.<\/p>\n Anschließend können wir die Relation mit der Delete<\/b>-Methode der Relations<\/b>-Auflistung löschen. Nun folgen die bereits bekannten Schritte, also das Löschen und erneute Importieren der Tabelle. Schließlich baut die Prozedur die Beziehungen rund um diese Tabelle auf Basis der gespeicherten Informationen in der Collection colRelations <\/b>wieder auf.<\/p>\n Ein anschließender Blick in das Beziehungen-Fenster zeigt, dass die Beziehungen der Tabelle wieder vorhanden sind. Zwar fehlt hier gegebenenfalls noch das Wiederherstellungen der Einstellungen für die Löschweitergabe oder die Aktualisierungsweitergabe sowie weiterer Eigenschaften, dies würde jedoch den Rahmen dieses Beitrags sprengen.<\/p>\n Die hier vorgestellten Techniken können Sie beispielsweise nutzen, wenn Sie während der Entwicklung Tests mit einer Datenbank durchführen, welche die Daten programmatisch anpassen. Den Import könnten Sie dabei einsetzen, um die ursprünglichen Daten schnell wiederherzustellen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n TabellenimportPerVBA.accdb<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_002.png\")
<\/p>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_003.png\")
<\/p>\n![\"Optionen](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_004.png\")
<\/p>\nGespeicherten Import aufrufen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_005.png\")
<\/p>\nDirekter Zugriff auf den gespeicherten Import<\/h2>\n
CurrentProject.ImportExportSpecifications(\"Suedsturm für Import\").Name<\/pre>\n
<xml version=\"1.0\"> \r\n<ImportExportSpecification Path=\"C:\\Users\\User\\Dropbox\\_____Wichtig_______\\Suedsturm.accdb\" \r\n xmlns=\"urn:www.microsoft.com\/office\/access\/imexspec\">\r\n <ImportAccess ImportExportSpecs=\"false\" MenusAndToolbars=\"false\" Relationships=\"true\" NavPane=\"false\" \r\n StructureAndData=\"true\" QueriesAsTables=\"false\" Resources=\"false\">\r\n <AccessObject Source=\"tblArtikel\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblBestelldetails\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblBestellungen\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblKategorien\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblKunden\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblLieferanten\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblPersonal\" ObjectType=\"Table\"\/>\r\n <AccessObject Source=\"tblVersandfirmen\" ObjectType=\"Table\"\/>\r\n <\/ImportAccess>\r\n<\/ImportExportSpecification><\/pre>\n
Informationen der Import-Definition<\/h2>\n
\n
\n
Eigenen Import für nur eine Tabelle bauen<\/h2>\n
Public Sub <\/span>TabellenimportErstellen()\r\n Dim <\/span>strXML As String<\/span>\r\n Dim <\/span>objSpec As <\/span>ImportExportSpecification\r\n strXML = \"<xml version=\"\"1.0\"\">\" _\r\n & \"<ImportExportSpecification Path=\"\"C:\\Users\\User\\Dropbox\\_____Wichtig_______\\Suedsturm.accdb\"\" _\r\n & \"xmlns=\"\"urn:www.microsoft.com\/office\/access\/imexspec\"\">\" _\r\n & \"<ImportAccess ImportExportSpecs=\"\"false\"\" MenusAndToolbars=\"\"false\"\" Relationships=\"\"true\"\" \"_\r\n & \"NavPane=\"\"false\"\" StructureAndData=\"\"true\"\" QueriesAsTables=\"\"false\"\" Resources=\"\"false\"\">\" _\r\n & \" <AccessObject Source=\"\"tblArtikel\"\" ObjectType=\"\"Table\"\"\/>\" _\r\n & \" <\/ImportAccess>\" _\r\n & \"<\/ImportExportSpecification>\"\r\n Set<\/span> objSpec = CurrentProject.ImportExportSpecifications.Add(\"Import_tblArtikel\", strXML)\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_006.png\")
<\/p>\nDoCmd.RunSavedImportExport \"Import_tblArtikel\"<\/pre>\n
Bestehende Objekte zuvor löschen<\/h2>\n
Public Sub <\/span>TabelleImportieren()\r\n On Error Resume Next<\/span>\r\n DoCmd.DeleteObject acTable, \"tblArtikel\"\r\n On Error GoTo<\/span> 0\r\n DoCmd.RunSavedImportExport \"Import_tblArtikel\"\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>TabelleImportierenVerknuepfungLoeschen()\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strTable As String<\/span>\r\n strTable = \"tblArtikel\"\r\n Set<\/span> db = CurrentDb\r\n For Each rel In db.Relations\r\n Debug.Print<\/span> rel.Name\r\n If <\/span>rel.Table = strTable Or rel.ForeignTable = strTable Then<\/span>\r\n db.Relations.Delete rel.Name\r\n End If<\/span>\r\n Next<\/span> rel\r\n DoCmd.DeleteObject acTable, strTable\r\n DoCmd.RunSavedImportExport \"Import_tblArtikel\"\r\nEnd Sub<\/span><\/pre>\nFehlende Beziehungen<\/h2>\n
Public Sub <\/span>BeziehungenAnzeigen()\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strTable As String<\/span>\r\n strTable = \"tblArtikel\"\r\n Set<\/span> db = CurrentDb\r\n For Each rel In db.Relations\r\n Debug.Print<\/span> rel.Name, rel.ForeignTable, rel.Table\r\n Next<\/span> rel\r\nEnd Sub<\/span><\/pre>\n![\"Relations](\"..\/fileadmin\/_temp_\/2018_04\/pic_1141_007.png\")
<\/p>\nPrivate <\/span>m_Table As String<\/span>\r\nPrivate <\/span>m_ForeignTable As String<\/span>\r\nPrivate <\/span>m_Name As String<\/span>\r\nPrivate <\/span>colFields As <\/span>New<\/span> Collection\r\nPublic Property Let <\/span>Table(str As String<\/span>)\r\n m_Table = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>ForeignTable(str As String<\/span>)\r\n m_ForeignTable = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Name(str As String<\/span>)\r\n m_Name = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Name() As String<\/span>\r\n Name = m_Name\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Table() As String<\/span>\r\n Table = m_Table\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>ForeignTable() As String<\/span>\r\n ForeignTable = m_ForeignTable\r\nEnd Property<\/span>\r\nPublic Sub <\/span>AddField(strName As String<\/span>, _\r\n strForeignName As String<\/span>)\r\n Dim <\/span>objField As <\/span>New<\/span> clsField\r\n With<\/span> objField\r\n .Name = strName\r\n .ForeignName = strForeignName\r\n End With<\/span>\r\n colFields.Add objField\r\nEnd Sub<\/span>\r\nPublic Property Get <\/span>Fields() As <\/span>Collection\r\n Set<\/span> Fields = colFields\r\nEnd Property<\/span> <\/pre>\nPrivate <\/span>m_Name As String<\/span>\r\nPrivate <\/span>m_ForeignName As String<\/span>\r\nPublic Property Let <\/span>Name(str As String<\/span>)\r\n m_Name = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>ForeignName(str As String<\/span>)\r\n m_ForeignName = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Name() As String<\/span>\r\n Name = m_Name\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>ForeignName() As String<\/span>\r\n ForeignName = m_ForeignName\r\nEnd Property<\/span> <\/pre>\nSpeichern und Wiederherstellen der Beziehungen<\/h2>\n
Public Sub <\/span>TabelleImportierenMitBeziehung()\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strTable As String<\/span>\r\n Dim <\/span>colRelations As <\/span>New<\/span> Collection\r\n Dim <\/span>objRelation As <\/span>clsRelation\r\n Dim <\/span>i As Integer<\/span>\r\n strTable = \"tblArtikel\"\r\n Set<\/span> db = CurrentDb\r\n For i = db.Relations.Count - 1 To 0 Step -1\r\n Set<\/span> rel = db.Relations(i)\r\n Debug.Print<\/span> rel.Name, rel.ForeignTable, rel.Table\r\n If <\/span>rel.Table = strTable Or rel.ForeignTable = strTable Then<\/span>\r\n Set<\/span> objRelation = New<\/span> clsRelation\r\n With<\/span> objRelation\r\n .ForeignTable = rel.ForeignTable\r\n .Table = rel.Table\r\n .Name = rel.Name\r\n .AddField rel.Fields(0).Name, rel.Fields(0).ForeignName\r\n End With<\/span>\r\n colRelations.Add objRelation\r\n db.Relations.Delete rel.Name\r\n End If<\/span>\r\n Next<\/span> i\r\n DoCmd.DeleteObject acTable, strTable\r\n DoCmd.RunSavedImportExport \"Import_tblArtikel\"\r\n For Each objRelation In colRelations\r\n With<\/span> objRelation\r\n Set<\/span> rel = db.CreateRelation(.Name, .Table, .ForeignTable)\r\n Set<\/span> fld = New<\/span> DAO.Field\r\n fld.Name = .Fields(1).Name\r\n fld.ForeignName = .Fields(1).ForeignName\r\n rel.Fields.Append fld\r\n End With<\/span>\r\n db.Relations.Append rel\r\n Next<\/span> objRelation\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n