<\/p>\n
Im Beitrag „Kopier- und Löschreihenfolge für Tabellen“ (www.access-im-unternehmen.de\/926) haben wir ermittelt, wie wir die richtige Reihenfolge für das Löschen von Tabellen und das Kopieren von Tabelleninhalten von einer Datenbank in die nächste ermitteln. Wenn Sie die Reihenfolge nicht beachten, kann es nämlich sein, dass Datensätze wegen Fremdschlüsselverletzungen nicht gelöscht und auch nicht kopiert werden können. Im vorliegenden Beitrag zeigen wir, wie Sie die vorgestellte Lösung für das Löschen und Kopieren von Tabellen in MySQL-Datenbanken nutzen können.<\/b><\/p>\n
In oben genanntem Beitrag haben wir bereits erläutert, in welcher Reihenfolge die Tabellen gelöscht und deren Daten kopiert werden müssen, damit dies ohne Fehlermeldungen durch Restriktionen möglich ist. Wir fassen das noch einmal zusammen: Wenn Sie etwa nur die beiden Tabellen tblKunden <\/b>und tblAnreden <\/b>verwenden, bei denen die Tabelle über das Fremdschlüsselfeld AnredeID <\/b>mit dem Feld AnredeID <\/b>der Tabelle tblAnreden <\/b>verknüpft ist, gelten folgende Regeln:<\/p>\n Auf die gleiche Weise können Sie bei komplexeren Datenmodellen vorgehen. Um das zu automatisieren, sucht man sich zum Löschen der Daten zunächst die Tabellen heraus, auf die keine andere Tabelle per Fremdschlüsselfeld verweist. Im zweiten Schritt ermitteln wir alle Tabellen, die nicht bereits ermittelt wurden und auf die keine andere der noch übrigen Tabellen per Fremdschlüsselfeld verweist und so weiter.<\/p>\n Beim Kopieren von Daten suchen wir im ersten Schritt zuerst die Tabellen heraus, die nicht per Fremdschlüsselfeld auf andere Tabellen verweisen. Dann suchen wir im zweiten Schritt die Tabellen heraus, die per Fremdschlüsselfeld nur auf die im ersten Schritt ermittelten Tabellen verweisen und so weiter.<\/p>\n Im weiter oben erwähnten Beitrag haben wir bereits einen Algorithmus definiert, mit dem wir die Reihenfolge der Tabellen beim Löschen und beim Kopieren der Daten der Tabellen ermitteln. Dabei haben wir die Elemente der DAO-TableDefs<\/b>-Auflistung durchlaufen und für die Informationen bezüglich der Beziehungen die Daten der Relations-Auflistung genutzt.<\/p>\n Unter MySQL stehen uns diese Elemente nicht zur Verfügung. Wenn Sie zwei miteinander in Beziehung stehende und per ODBC eingebundene MySQL-Tabellen in das Beziehungen-Fenster ziehen, sehen Sie bereits, dass die für diese Tabellen definierte Beziehung nicht in Access verfügbar ist (siehe Bild 1).<\/p>\n Bild 1: Keine Beziehungen von ODBC-verknüpften Tabellen sichtbar<\/span><\/b><\/p>\n Hier stehen wir am Scheideweg, denn nun gibt es zwei Möglichkeiten:<\/p>\n Das Durchlaufen der Tabellen erfolgt nicht über eine Auflistung wie TableDefs<\/b>, sondern wir nutzen die Anweisung SHOW TABLES<\/b>, mit der wir wie mit einer SELECT<\/b>-Anweisung auf die Daten der MySQL-Datenbank zugreifen. Show Tables <\/b>liefert uns ebenfalls ein Ergebnis in Form eines Recordsets zurück. In den folgenden Codezeilen nutzen wir eine Hilfsfunktion namens GetRecordset<\/b>, deren ersten Parameter wir mit einer Konstanten füllen, welche die Verbindungszeichenfolge zu der gewünschten Datenbank enthält:<\/p>\n Hier füllen wir so ein Recordset namens rstTabellen <\/b>mit allen Einträgen, die der Befehl SHOW TABLES <\/b>zurückliefert und geben diese im Direktbereich des VBA-Fensters aus. Für die verwendeten Hilfsfunktionen benötigen wir noch einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects x.y Library<\/b>, den Sie über den Verweise<\/b>-Dialog hinzufügen (VBA-Editor, Menüeintrag Extras|Verweise<\/b>).<\/p>\n Nun wollen wir wissen, ob eine Tabelle über ein Fremdschlüsselfeld mit einer anderen Tabelle verknüpft ist oder ob eine Tabelle vom Fremdschlüsselfeld einer anderen Tabelle referenziert wird.<\/p>\n Dazu verwenden wir testweise die Prozedur Relationinfo<\/b> aus Listing 1. In dieser weisen wir der Variablen strSQL <\/b>die folgende Abfrage zu:<\/p>\n Listing 1: Ermitteln aller Beziehungen mit beteiligten Tabellen und Feldern<\/span><\/b><\/p>\n Hier ermitteln wir die Felder mit den relevanten Informationen aus der Tabelle INFORMATION_SCHEMA.KEY_COLUMN_USAGE<\/b> für die Bedingung REFERENCED_TABLE_NAME IS NOT NULL<\/b>. Danach durchlaufen wir alle Felder der Tabelle und geben die Namen der Felder als Kopfzeile im Direktbereich des VBA-Editors aus und liefern direkt anschließend die Werte dieser Felder für alle gefundenen Datensätze.<\/p>\n Das sieht dann etwa wie folgt aus:<\/p>\n Damit kommen wir nun zumindest an alle Informationen heran, die wir theoretisch benötigen, um die Reihenfolge der Tabellen für das Löschen und das Kopieren zu bestimmen. Wir müssen die Informationen nur noch geschickt kombinieren, was wir in den folgenden Schritten erledigen werden.<\/p>\n Die Reihenfolge der Tabellen für das Kopieren der Daten ermitteln wir in der Funktion TabellenreihenfolgeKopieren <\/b>aus Listing 2. In dieser Funktion, welche die zu verwendende Verbindungszeichenfolge als Parameter erwartet und die ein Collection<\/b>-Objekt als Ergebnis zurückliefert, erstellen wir zwei Collections. Die erste heißt colOffen <\/b>und speichert alle Tabellen, die noch nicht in die Reihenfolge eingearbeitet wurden. Die zweite heißt colReihenfolge <\/b>und enthält die Tabellen in der ermittelten Reihenfolge.<\/p>\n <\/p>\n Listing 2: Ermitteln der Reihenfolge für das Kopieren von Daten<\/span><\/b><\/p>\n Um die Collection colOffen <\/b>zu füllen, erstellen wir ein Recordset namens rstTabellen <\/b>auf Basis der Abfrage SHOW TABLES<\/b>. Dieses durchlaufen wir und tragen den Namen der Tabelle für jeden Datensatz in die Collection colOffen <\/b>ein.<\/p>\n Dann verwenden wir die weiter oben vorgestellte SQL-Abfrage zum Ermitteln aller Beziehungen der Datenbank, um ein weiteres Recordset namens rstBeziehungen <\/b>zu füllen. <\/p>\n Dann starten wir in eine Do While<\/b>-Schleife, die solange läuft, bis die Anzahl der Einträge der Collection colOffen <\/b>gleich 0 <\/b>ist. Innerhalb der Do While<\/b>-Schleife gibt es als Erstes eine Bedingung, die prüft, ob die Anzahl der Einträge in colOffen <\/b>nicht dem in der Variablen intCountVorher <\/b>entspricht. Das ist beim ersten Durchlauf nicht der Fall, da intCountVorher <\/b>noch nicht gefüllt wurde und somit den Wert 0 <\/b>enthält.<\/p>\n Da wir davon ausgehen, dass die MySQL-Datenbank immer mindestens eine Tabelle enthält, werden die Anweisungen innerhalb der If…Then<\/b>-Bedingung auch ausgeführt. Direkt danach stellen wir intCountVorher <\/b>auf den aktuellen Wert von colOffen <\/b>ein. Danach beginnen Anweisungen, die sukzessive Einträge von colOffen <\/b>nach colReihenfolge <\/b>verschieben sollen, sodass colOffen.Count <\/b>mit jedem Schleifendurchlauf kleiner wird und erst dann mit intCountVorher <\/b>übereinstimmt, wenn innerhalb der Schleife keine Elemente mehr aus colOffen <\/b>entnommen wurden.<\/p>\n Das geschieht nur, wenn über die Beziehung zweier Tabellen ein Zirkelbezug hergestellt wurde. In diesem Fall sollen diese Tabellen zum Schluss an die Auflistung angehängt werden – mit einem entsprechenden Hinweis auf die Anzahl der Tabellen mit nicht auswertbaren Beziehungen.<\/p>\n Innerhalb der Bedingung durchlaufen wir in einer For Each<\/b>-Schleife alle Einträge von colOffen<\/b>. Darin stellen wir die Variable bolIstDetailtabelle <\/b>zunächst auf den Wert False <\/b>ein, das heißt, wir gehen davon aus, dass die Tabelle nicht die Detailtabelle einer Beziehung ist. Zur Erinnerung: die Detailtabelle ist die Tabelle mit dem an der Beziehung beteiligten Fremdschlüsselfeld, die Mastertabelle ist die Tabelle mit dem an der Beziehung beteiligten Primärschlüsselfeld.<\/p>\n Dann stellen wir den Datensatzzeiger des Recordsets rstBeziehungen <\/b>auf den ersten Datensatz ein (rstBeziehungen.MoveFirst<\/b>). In einer Do While<\/b>-Schleife über alle Datensätze des Recordsets rstBeziehungen <\/b>prüfen wir nun, ob das Feld TABLE_NAME<\/b> des aktuellen Datensatzes, welches der Tabelle mit dem Fremdschlüsselfeld (also der Detailtabelle) entspricht, mit der aktuellen Tabelle aus colOffen <\/b>übereinstimmt. Das bedeutet, dass die Tabelle offensichtlich als Detailtabelle an einer Beziehung beteiligt ist und wir stellen den Wert der Eigenschaft bolIstDetailtabelle <\/b>auf den Wert True <\/b>ein.<\/p>\n Dann durchlaufen wir in einer weiteren For Each<\/b>-Schleife alle Einträge der Tabellen, die bereits in der Collection namens colReihenfolge <\/b>gelandet sind. Befindet sich dort die Tabelle, die in der Beziehung als Mastertabelle angegeben ist, wird bolIstDetailtabelle <\/b>wieder auf False <\/b>eingestellt. Der Grund: In der Reihenfolge müssen zuerst die Tabellen auftauchen, die als Mastertabelle der Beziehung dienen – und das ist der Fall, wenn die in rstBeziehungen!REFERENCED_TABLE_NAME <\/b>angegeben Tabelle bereits in colReihenfolge <\/b>vorhanden ist.<\/p>\n Hat bolIstDetailtabelle <\/b>nach dem Durchlaufen dieser Schleifen den Wert False<\/b>, dann kann die Tabelle in die Collection colReihenfolge <\/b>aufgenommen werden und aus der Collection colOffen <\/b>entfernt werden.<\/p>\n Auf diese Weise durchlaufen wir die äußere Do While<\/b>-Schleife, bis keine weiteren Elemente mehr aus colOffen <\/b>in colReihenfolge <\/b>übertragen werden können oder die Collection colOffen <\/b>leer ist. Danach gibt die Funktion eine Meldung aus, wieviele Tabellen nicht verarbeitet werden konnten und hängt diese dann dennoch der Vollständigkeit halber an die Collection colReihenfolge <\/b>an. Die Collection colReihenfolge <\/b>wird dann dem Rückgabewert der Funktion zugewiesen.<\/p>\n Die soeben beschriebene Funktion rufen wir dann beispielsweise wie folgt auf:<\/p>\n Dabei werden die gefundenen Tabellen in der korrekten Reihenfolge im Direktfenster ausgegeben. Sie können natürlich auch andere Dinge damit erledigen – zum Beispiel wie im Beitrag Von Version zu Version <\/b>(www.access-im-unternehmen.de\/1208<\/b>) die SQL-Anweisungen zum Kopieren der Datensätze zusammenstellen.<\/p>\n Für das Kopieren der Daten verwenden wir die Funktion TabellenreihenfolgeLoeschen<\/b> aus Listing 3. Diese Funktion ist prinzipiell genauso aufgebaut wie die Funktion zum Ermitteln der Kopierreihenfolge.<\/p>\n Listing 3: Ermitteln der Reihenfolge für das Löschen von Daten<\/span><\/b><\/p>\n Allerdings gibt es einen entscheidenden Unterschied: In der inneren Do While<\/b>-Schleife suchen wir zuerst nach den Einträgen des Recordsets rstBeziehungen<\/b>, deren Feld REFERENCED_TABLE_NAME <\/b>mit der Tabelle aus varOffen <\/b>übereinstimmt, also den Tabellen, welche das Primärschlüsselfeld der Beziehung enthalten und somit der Mastertabelle entsprechen.<\/p>\n Und in der inneren If…Then<\/b>-Bedingung prüfen wir dann, ob die Tabelle aus TABLE_NAME<\/b>, also die Detailtabelle, zu der Tabelle aus varReihenfolge <\/b>passt. Dann können wir bolIstMastertabelle <\/b>auf False <\/b>einstellen und später dann die aktuelle Tabelle aus varOffen <\/b>zu colReihenfolge <\/b>hinzufügen.<\/p>\n Der Testaufruf dieser Funktion könnte dann etwa wie folgt aussehen:<\/p>\n Wenn Sie die zu löschenden oder zu kopierenden Tabellen ermitteln, können Sie das nur auf Basis der Tabellen der Quelldatenbank erledigen, auf Basis der Zieldatenbank oder auf Basis der Tabellen, die sowohl in der Quell- als auch in der Zieldatenbank vorkommen.<\/p>\n In allen Fällen können Probleme auftauchen. Beim Löschen kann es sein, dass die Tabelle der Zieldatenbank, deren Daten gelöscht werden sollen, möglicherweise gar nicht vorhanden sind. Oder die Zieldatenbank enthält Tabellen, die nicht in der Quelldatenbank enthalten sind – was zum Problem führt, wenn eine berücksichtigte Tabelle mit einer nicht berücksichtigten Tabelle so verknüpft ist, dass ein Löschen aus der Tabelle wegen der Beziehung nicht möglich ist.<\/p>\n Beim Kopieren kann es ebenfalls sein, dass Daten aus der Quelldatenbank nicht in der Zieldatenbank vorhanden sind, was zu Fehlern führt, wenn man einen Kopiervorgang auf Basis der Tabellen in der ermittelten Reihenfolge durchführt. Und wenn in der Reihenfolge berücksichtigte Tabellen der Zieldatenbank mit nicht berücksichtigten Tabellen so verknüpft sind, dass die zu kopierende Tabelle das Fremdschlüsselfeld enthält, kommt es ebenfalls zu Problemen, wenn das Fremdschlüsselfeld einen Primärschlüsselwert der nicht berücksichtigten Tabelle enthalten muss.<\/p>\n Wie Sie mit solchen Konstellationen umgehen, beschreiben wir im Beitrag Von Version zu Version <\/b>(www.access-im-unternehmen.de\/1208<\/b>).<\/p>\n Enthaltene Beispieldateien:<\/p>\n KopierUndLoeschreihenfolgeInMySQL.accdb<\/p>\n\n
Reihenfolge per VBA bestimmen<\/h2>\n
![\"Keine](\"..\/fileadmin\/_temp_\/2019_05\/pic_1207_001.png\")
<\/p>\nAlle Tabellen einbinden<\/h2>\n
\n
Tabellen durchlaufen<\/h2>\n
Dim <\/span>rstTabellen As <\/span>ADODB.Recordset\r\nSet<\/span> rstTabellen = GetRecordset(GetConnection( cStrVerbindungszeichenfolgeAlt), \"SHOW TABLES\")\r\nDo While<\/span> Not<\/span> rstTabellen.EOF\r\n Debug.Print<\/span> rstTabellen.Fields(0)\r\n rstTabellen.MoveNext<\/span>\r\nLoop<\/span><\/pre>\nBeziehungen ermitteln<\/h2>\n
Public Sub <\/span>Relationinfo()\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>fld As <\/span>ADODB.Field\r\n strSQL = \"SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME \" & vbCrLf<\/span> _\r\n & \"FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE\" & vbCrLf<\/span> _\r\n & \"WHERE REFERENCED_TABLE_NAME IS NOT NULL;\"\r\n Set<\/span> rst = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeAlt), strSQL)\r\n For Each fld In rst.Fields\r\n Debug.Print<\/span> fld.Name,\r\n Next<\/span> fld\r\n Debug.Print<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n For Each fld In rst.Fields\r\n Debug.Print<\/span> fld.Value,\r\n Next<\/span> fld\r\n Debug.Print<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nSELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME \r\nFROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE \r\nWHERE REFERENCED_TABLE_NAME IS NOT NULL;<\/pre>\n
TABLE_NAME COLUMN_NAME REFERENCED_TABLE_NAME REFERENCED_COLUMN_NAME \r\ns_order_basket_attributes basketID s_order_basket id \r\ns_core_auth_attributes authID s_core_auth id \r\ns_articles_attributes articleID s_articles id <\/pre>\n
Reihenfolge für das Kopieren ermitteln<\/h2>\n
Public Function <\/span>TabellenreihenfolgeKopieren(strVerbindungszeichenfolge As String<\/span>) As <\/span>Collection\r\n Dim <\/span>colOffen As <\/span>Collection, colReihenfolge As <\/span>Collection, bolIstDetailtabelle As Boolean<\/span>\r\n Dim <\/span>varOffen As Variant<\/span>, varReihenfolge As Variant<\/span>, intCountVorher As Integer<\/span>\r\n Dim <\/span>rstTabellen As <\/span>ADODB.Recordset, rstBeziehungen As <\/span>ADODB.Recordset, strSQL As String<\/span>\r\n Set<\/span> colOffen = New<\/span> Collection\r\n Set<\/span> colReihenfolge = New<\/span> Collection\r\n Set<\/span> rstTabellen = GetRecordset(GetConnection(strVerbindungszeichenfolge), \"SHOW TABLES\")\r\n Do While<\/span> Not<\/span> rstTabellen.EOF\r\n colOffen.Add rstTabellen.Fields(0).Value, rstTabellen.Fields(0).Value\r\n rstTabellen.MoveNext<\/span>\r\n Loop<\/span>\r\n strSQL = \"SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME \" & vbCrLf<\/span> _\r\n & \"FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE\" & vbCrLf<\/span> & \"WHERE REFERENCED_TABLE_NAME IS NOT NULL;\"\r\n Set<\/span> rstBeziehungen = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeAlt), strSQL)\r\n Do While<\/span> colOffen.Count > 0\r\n If <\/span>Not<\/span> intCountVorher = colOffen.Count Then<\/span>\r\n intCountVorher = colOffen.Count\r\n For Each varOffen In colOffen\r\n bolIstDetailtabelle = False<\/span>\r\n rstBeziehungen.MoveFirst\r\n Do While<\/span> Not<\/span> rstBeziehungen.EOF\r\n If <\/span>rstBeziehungen!TABLE_NAME = varOffen Then<\/span>\r\n bolIstDetailtabelle = True<\/span>\r\n For Each varReihenfolge In colReihenfolge\r\n If <\/span>rstBeziehungen!REFERENCED_TABLE_NAME = varReihenfolge Then<\/span>\r\n bolIstDetailtabelle = False<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> varReihenfolge\r\n End If<\/span>\r\n rstBeziehungen.MoveNext<\/span>\r\n Loop<\/span>\r\n If <\/span>bolIstDetailtabelle = False<\/span> Then<\/span>\r\n colReihenfolge.Add varOffen, varOffen\r\n colOffen.Remove varOffen\r\n End If<\/span>\r\n DoEvents\r\n Next<\/span> varOffen\r\n Else<\/span>\r\n Exit Do<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n MsgBox<\/span> \"Anzahl offener Tabellen (da Zirkelbezug): \" & colOffen.Count & vbCrLf<\/span> _\r\n & \"Die Tabellen werden an die Collection angehängt.\"\r\n For Each varOffen In colOffen\r\n colReihenfolge.Add varOffen, varOffen\r\n Next<\/span> varOffen\r\n Set<\/span> TabellenreihenfolgeKopieren = colReihenfolge\r\nEnd Function<\/span><\/pre>\nFunktion TabellenreihenfolgeKopieren aufrufen<\/h2>\n
Public Sub <\/span>Test_TabellenreihenfolgeKopieren()\r\n Dim <\/span>colReihenfolge As <\/span>Collection\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> colReihenfolge = TabellenreihenfolgeKopieren\r\n For Each var In colReihenfolge\r\n Debug.Print<\/span> var\r\n Next<\/span> var\r\nEnd Sub<\/span><\/pre>\nReihenfolge zum Löschen ermitteln<\/h2>\n
Public Function <\/span>TabellenreihenfolgeLoeschen(strVerbindungszeichenfolge As String<\/span>) As <\/span>Collection\r\n Dim <\/span>colOffen As <\/span>Collection, colReihenfolge As <\/span>Collection, bolIstMastertabelle As Boolean<\/span>\r\n Dim <\/span>varOffen As Variant<\/span>, varReihenfolge As Variant<\/span>, intCountVorher As Integer<\/span>\r\n Dim <\/span>rstTabellen As <\/span>ADODB.Recordset, rstBeziehungen As <\/span>ADODB.Recordset, strSQL As String<\/span>\r\n Set<\/span> colOffen = New<\/span> Collection\r\n Set<\/span> colReihenfolge = New<\/span> Collection\r\n Set<\/span> rstTabellen = GetRecordset(GetConnection(strVerbindungszeichenfolge), \"SHOW TABLES\")\r\n Do While<\/span> Not<\/span> rstTabellen.EOF\r\n colOffen.Add rstTabellen.Fields(0).Value, rstTabellen.Fields(0).Value\r\n rstTabellen.MoveNext<\/span>\r\n Loop<\/span>\r\n strSQL = \"SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME \" & vbCrLf<\/span> _\r\n & \"FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE\" & vbCrLf<\/span> & \"WHERE REFERENCED_TABLE_NAME IS NOT NULL;\"\r\n Set<\/span> rstBeziehungen = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeAlt), strSQL)\r\n Do While<\/span> colOffen.Count > 0\r\n If <\/span>Not<\/span> intCountVorher = colOffen.Count Then<\/span>\r\n intCountVorher = colOffen.Count\r\n For Each varOffen In colOffen\r\n bolIstMastertabelle = False<\/span>\r\n rstBeziehungen.MoveFirst\r\n Do While<\/span> Not<\/span> rstBeziehungen.EOF\r\n If <\/span>rstBeziehungen!REFERENCED_TABLE_NAME = varOffen Then<\/span>\r\n bolIstMastertabelle = True<\/span>\r\n For Each varReihenfolge In colReihenfolge\r\n If <\/span>rstBeziehungen!TABLE_NAME = varReihenfolge Then<\/span>\r\n bolIstMastertabelle = False<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> varReihenfolge\r\n End If<\/span>\r\n rstBeziehungen.MoveNext<\/span>\r\n Loop<\/span>\r\n If <\/span>bolIstMastertabelle = False<\/span> Then<\/span>\r\n colReihenfolge.Add varOffen, varOffen\r\n colOffen.Remove varOffen\r\n End If<\/span>\r\n DoEvents\r\n Next<\/span> varOffen\r\n Else<\/span>\r\n Exit Do<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n MsgBox<\/span> \"Anzahl offener Tabellen (da Zirkelbezug): \" & colOffen.Count & vbCrLf<\/span> _\r\n & \"Die Tabellen werden an die Collection angehängt.\"\r\n For Each varOffen In colOffen\r\n colReihenfolge.Add varOffen, varOffen\r\n Next<\/span> varOffen\r\n Set<\/span> TabellenreihenfolgeLoeschen = colReihenfolge\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>Test_TabellenreihenfolgeLoeschen()\r\n Dim <\/span>colReihenfolge As <\/span>Collection\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> colReihenfolge = TabellenreihenfolgeLoeschen( cStrVerbindungszeichenfolgeNeu)\r\n For Each var In colReihenfolge\r\n Debug.Print<\/span> var\r\n Next<\/span> var\r\nEnd Sub<\/span><\/pre>\nMögliche Probleme<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n