<\/p>\n
Bei der einen oder anderen Gelegenheit werden Sie die Daten von Tabellen von einer Datenbank zur nächsten kopieren wollen oder einfach den Inhalt aller Tabellen löschen. Wenn die Tabellen mit referenziellen Beziehungen versehen sind, ist sowohl das Kopieren als auch das Löschen der enthaltenen Daten nicht trivial: Sie müssen nämlich in beiden Fällen in einer bestimmten Reihenfolge vorgehen. Beim Löschen müssen Sie erst alle verknüpften Daten aus der Detailtabelle einer Beziehung entfernen, bevor Sie die Daten der Mastertabelle löschen können. Beim Kopieren sind hingegen erst die Daten in den Mastertabellen einzufügen, bevor Sie die Detailtabellen samt Fremdschlüsselfeldinhalt füllen können.<\/b><\/p>\n
In welcher Reihenfolge können die Daten von Tabellen überhaupt gelöscht werden, und in welcher Reihenfolge muss man Daten kopieren, wenn man keine Fehler durch fehlende Datensätze in den verknüpften Tabellen erhalten möchte<\/p>\n
Beim Löschen entfernt man zunächst die Daten aus den Tabellen, die selbst von keiner anderen Tabelle referenziert werden. Wenn Sie also nur zwei Tabellen namens tblKunden <\/b>und tblAnreden <\/b>in einer Tabelle verwenden, wobei die Tabelle tblKunden <\/b>mit einem Fremdschlüsselfeld namens AnredeID <\/b>auf die Datensätze der Tabelle tblAnreden <\/b>verweist, müssten Sie zunächst die Daten der Tabelle tblKunden <\/b>löschen und dann die der Tabelle tblAnreden<\/b>.<\/p>\n
Sie löschen also immer die Daten der Tabelle, mit der keine andere Tabelle per Fremdschlüsselfeld verknüpft ist, und arbeiten sich so Tabelle für Tabelle durch das Datenmodell. Eine exakte Reihenfolge gibt es dabei nur, wenn immer eine Tabelle genau eine weitere Tabelle referenziert. Anderenfalls kann man einfach immer die Daten der Tabellen löschen, für die keine Datensätze mehr in anderen Tabellen vorliegen, die per Fremdschlüsselfeld auf die Datensätze der Mastertabelle verweisen.<\/p>\n
Wenn Sie die Daten in einer solchen Beziehung von einer Datenbank in die andere übertragen wollten, müssten Sie die umgekehrte Reihenfolge wie beim Löschen wählen: Dann kopieren Sie erst die Daten der Tabellen, die selbst keine weitere Tabelle per Fremdschlüsselfeld referenzieren. In dem kleinen Mini-Beispiel von oben mit den Tabellen tblKunden <\/b>und tblAnreden <\/b>übertragen Sie also erst die Datensätze der Tabelle tblAnreden <\/b>und dann die Datensätze der Tabelle tblKunden<\/b>. Hierbei müssen Sie natürlich darauf achten, dass Sie entweder die Werte der Primärschlüsselfelder der Tabelle tblAnreden <\/b>genau übertragen und dann die Inhalte des Fremdschlüsselfeldes der Tabelle tblKunden <\/b>übernehmen oder dass Sie die Werte der Fremdschlüsselfelder an die geänderten Werte der verknüpften Primärschlüsselfelder anpassen.<\/p>\n
Bei umfangreicheren Datenmodellen würden Sie also zunächst die Daten aller Tabellen kopieren, die selbst keine Fremdschlüsselfelder zur Verknüpfung mit anderen Tabellen enthalten. Dann folgen die Tabellen, die nur eine oder mehrere der bereits kopierten Tabellen referenzieren und so weiter.<\/p>\n
Reihenfolge per VBA bestimmen<\/b><\/p>\n
Ziel dieses Beitrags ist es, per VBA die Reihenfolge für die beiden zuvor beschriebenen Vorgänge, also das Löschen aller Tabellen und das Kopieren der Daten aller Tabellen von einer Datenbank in eine andere Datenbank mit identischem Datenmodell, zu ermitteln und beispielsweise per Array bereitzustellen.<\/p>\n
Dazu benötigen wir im Wesentlichen den Zugriff auf die Tabellen des Datenmodells, den wir uns mit der TableDefs<\/b>-Auflistung und den enthaltenen Elementen verschaffen. Darüber hinaus greifen wir auf die Informationen über die Verknüpfungen zwischen den einzelnen Tabellen zu. Diese liefert die Relations<\/b>-Auflistung des Database<\/b>-Objekts der betroffenen Datenbank. Das Relation<\/b>-Objekt als ein Objekt dieser Auflistung enthält beispielsweise die Namen der beiden an der Beziehung beteiligten Tabellen sowie die Namen der Felder, über welche die Beziehung herstellt wird.<\/p>\n
Grundlegende Techniken sind beispielsweise das Durchlaufen aller Tabellendefinitionen der Datenbank. Dies geschieht in einer For Each<\/b>-Schleife wie folgt:<\/p>\n Gegebenenfalls legt man bestimmte Regeln über die zu untersuchenden Tabellen fest. Zum Beispiel sollen nur solche Tabellen untersucht werden, die mit dem Präfix tbl <\/b>beginnen. Dann bauen Sie eine If…Then<\/b>-Bedingung in die Schleife ein:<\/p>\n Auf die Beziehungen zwischen den Tabellen greifen Sie über die Relations<\/b>-Auflistung zu – etwa so wie in Listing 1. Dies gibt jeweils die Mastertabelle und die Detailtabelle aus sowie die beiden Felder, die an der Beziehung beteiligt sind. Die Detailtabelle entspricht dabei der Tabelle, welche das Fremdschlüsselfeld enthält, die Mastertabelle der Tabelle mit dem an der Beziehung beteiligten Primärschlüsselfeld.<\/p>\n Listing 1: Beispielprozedur zum Ausgeben aller Beziehungen samt der betroffenen Tabellen und Felder<\/span><\/b><\/p>\n Referenzielle Integrität ermitteln<\/b><\/p>\n Wichtig ist im Zusammenhang mit der Ermittlung der Reihenfolge zum Kopieren von Daten, ob für die Beziehung referenzielle Integrität definiert ist. Ist das der Fall, können Sie für das Fremdschlüsselfeld nur solche Werte eingeben, die auch im Primärschlüsselfeld der an der Beziehung beteiligten Mastertabelle enthalten sind. Wenn keine referenzielle Integrität definiert ist, können Sie beliebige Werte in das Fremdschlüsselfeld eintragen, auch solche, die gar nicht in dem verknüpften Primärschlüsselfeld enthalten sind.<\/p>\n Reihenfolge zum Kopieren bestimmen<\/b><\/p>\n Das Kopieren aller Daten von einer Datenbank in eine weitere Datenbank mit identischem Datenmodell erfolgt beispielsweise in der Reihenfolge aus Bild 1. Dort werden erst alle Tabellen kopiert, die selbst keine Fremdschlüsselfelder enthalten, dann die Tabellen, die nur Fremdschlüsselfelder enthalten, die auf bereits in die Reihenfolge aufgenommene Tabellen verweisen und so weiter.<\/p>\n Bild 1: Reihenfolge beim Löschen der Tabellen dieses Datenmodells<\/span><\/b><\/p>\n Im ersten Schritt würden wir hier also zunächst alle Tabellen ermitteln, die selbst nicht als Detailtabelle an einer Beziehung beteiligt sind. Eine weitere Voraussetzung ist es, dass die zu untersuchenden Beziehungen mit referenzieller Integrität definiert wurden. Alle anderen spielen bei der Reihenfolge des Kopierens keine Rolle.<\/p>\n Für ein Datenmodell wie etwa das der Beispieldatenbank liefert die Funktion TabellenreihenfolgeKopieren <\/b>aus Listing 2 ein Collection<\/b>-Objekt mit der richtigen Reihenfolge zum Kopieren der Daten. Diese Prozedur füllt zunächst die Variable db <\/b>mit einem Verweis auf die aktuelle Datenbank und instanziert zwei Collection<\/b>-Objekte. Das erste namens colOffen <\/b>nimmt zunächst die Tabellen aller zu untersuchenden Tabellen auf. Das zweite heißt colReihenfolge <\/b>und wird Schritt für Schritt mit den Tabellen in der für das Kopieren benötigten Reihenfolge gefüllt.<\/p>\n <\/p>\n Listing 2: Prozedur, welche die Reihenfolge der Tabellen zum Kopieren von Daten ermittelt<\/span><\/b><\/p>\n Zunächst liest die Prozedur die Namen aller Tabellen in die Collection colOffen <\/b>ein. Dazu durchläuft sie die TableDefs<\/b>-Auflistung und fügt alle Tabellennamen mit der Add<\/b>-Methode hinzu, die mit tbl <\/b>beginnen – und zwar als Item <\/b>und als Key<\/b>.<\/p>\n Dann durchläuft die Prozedur so lange eine Schleife, bis die Anzahl der in der Collection colOffen <\/b>enthaltenen Elemente nicht mehr größer als 0 <\/b>ist. Dies bedeutet gleichzeitig, dass wir die Elemente innerhalb der Do While<\/b>-Schleife entfernen müssen – sonst endet die Schleife nie.<\/p>\n In dieser Schleife folgt gleich eine weitere For Each<\/b>-Schleife über alle Elemente der Collection colOffen<\/b>. Darin stellt die Prozedur zunächst den Wert der Variablen bolIstDetailtabelle <\/b>auf den Wert False <\/b>ein. Anschließend folgen einige Prüfungen, in denen diese Variable möglicherweise auf den Wert True <\/b>eingestellt wird. Ist dies am Ende der For Each<\/b>-Schleife der Fall, wird das aktuelle mit der Variablen varOffen <\/b>referenzierte Element in die Collection colReihenfolge <\/b>eingetragen und aus der Collection colOffen <\/b>gelöscht.<\/p>\n Doch zunächst zu den einzelnen Prüfungen. Die Variable varOffen <\/b>enthält zu diesem Zeitpunkt den Namen der zu untersuchenden Tabelle aus der Collection colOffen<\/b>. In einer weiteren For Each<\/b>-Schleife durchläuft die Prozedur alle Relation<\/b>-Objekte der Relations<\/b>-Auflistung des aktuellen Database<\/b>-Objekts. Darin vergleicht die Prozedur den in varOffen <\/b>gespeicherten Tabellennamen mit der Detailtabelle der jeweiligen mit rel <\/b>referenzierten Beziehung – sie prüft also, ob die Tabelle in der aktuell untersuchten Beziehung die Rolle der Detailtabelle einnimmt. Sprich: Enthält die Tabelle ein Fremdschlüsselfeld zur Herstellung einer Beziehung zu einer anderen Tabelle Falls dies für eine der Beziehungen der Fall ist, folgt eine weitere Untersuchung – nämlich die, ob es sich bei der Beziehung um eine mit referenzieller Integrität handelt. Die Eigenschaft Attributes <\/b>enthält einen Zahlenwert, der aus mehreren Zahlen zusammengesetzt sein kann. Durch einen Binärvergleich dieses Wertes mit dem in der Konstanten dbRelationDontEnforce <\/b>enthaltenen Zahlenwert 2 <\/b>ermitteln wir, ob referenzielle Integrität vorliegt. Ist dies der Fall, stellen wir den Wert der Variablen bolIstDetailtabelle <\/b>auf den Wert True <\/b>ein – zu diesem Zeitpunkt gehen wir also davon aus, dass die Tabelle als Detailtabelle einer Beziehung mit einer als Mastertabelle verwendeten Tabelle dient.<\/p>\n Wir könnten diese Tabelle also zu diesem Zeitpunkt nicht in die Collection colReihenfolge <\/b>übernehmen, da zuvor erst alle Tabellen aus der Collection colOffen <\/b>entfernt werden müssen, die für diese Detailtabelle als Mastertabelle dienen. Gehen wir also davon aus, dass dies der erste Durchlauf durch die Do While<\/b>-Schleife ist und noch alle Mastertabellen in colOffen <\/b>enthalten sind. Dann bleibt die aktuelle Tabelle, die wir als Detailtabelle einer Beziehung definiert haben, vorerst in der Collection colOffen<\/b>.<\/p>\n Wenn es sich bei der Tabelle hingegen um eine Mastertabelle handelt, dann finden wir beim Durchlaufen der Elemente der Relations<\/b>-Auflistung per For Each<\/b>-Schleife keinen Eintrag, dessen Detailtabelle mit der in varOffen<\/b> gespeicherten Tabelle übereinstimmt. Dies ist bei unserem Beispieldatenmodell etwa bei der Tabelle tblKunden <\/b>der Fall, aber auch bei tblPersonal<\/b>, tblVersandfirmen<\/b>, tblLieferanten <\/b>und tblKategorien<\/b>.<\/p>\n Dann ist der Wert von bolIstDetailtabelle <\/b>nach dem Durchlaufen der For Each<\/b>-Schleife über die Relations<\/b>-Auflistung immer noch False<\/b>. Im Anschluss an diese For Each<\/b>-Schleife prüft die Funktion den Wert von bolIstDetailtabelle<\/b>. Hat diese dann den Wert False<\/b>, trägt die Funktion den Wert von varOffen <\/b>als neues Element in die Collection colReihenfolge <\/b>ein. Anschließend löscht sie den betreffenden Eintrag aus der Collection colOffen<\/b>, damit dieser nicht nochmals untersucht werden muss.<\/p>\n Gehen wir also an dieser Stelle davon aus, dass wir in einem ersten Durchlauf alle Tabellen, die nur als Mastertabellen in Beziehungen dienen, aber nicht als Detailtabellen, aus der Collection colOffen <\/b>gelöscht haben. Dann gehen wir damit in den nächsten Durchlauf der äußeren Do While<\/b>-Schleife. Diese findet dann beispielsweise für die Tabelle tblBestellungen <\/b>heraus, dass diese als Detailtabelle für die Tabelle tblKunden <\/b>dient.<\/p>\n Jetzt wird die innerste For Each<\/b>-Schleife interessant: Diese durchläuft nämlich die Elemente, die schon in der Collection colReihenfolge <\/b>enthalten sind. Wenn die aktuelle Tabelle aus der Variablen varOffen <\/b>nun zwar als Detailtabelle identifiziert wurde, aber als Mastertabelle dieser Beziehung (rel.Table<\/b>) eine Tabelle dient, die bereits in die Collection colReihenfolge <\/b>übertragen wurde, wird die Variable bolIstDetailtabelle <\/b>wieder auf den Wert False <\/b>eingestellt und die innere For Each<\/b>-Schleife verlassen. Die gleiche Prüfung erfolgt für alle Beziehungen dieser Tabelle mit anderen Tabellen, im Falle der Tabelle tblBestellungen <\/b>also für die Beziehungen mit den Tabellen tblKunden<\/b>, tblPersonal <\/b>und tblVersandfirmen<\/b>. Nur wenn alle drei Beziehungen mit dem Wert False <\/b>für die Variable bolIstDetailtabelle <\/b>geprüft wurden, hat bolIstDetailtabelle <\/b>nach dem Verlassen der For Each<\/b>-Schleife über die Elemente der Relations<\/b>-Auflistung den Wert False <\/b>und die Tabelle, hier tblBestellungen<\/b>, kann in die Collection colReihenfolge <\/b>übernommen und aus der Collection colOffen <\/b>gelöscht werden. Dies geschieht im zweiten Durchlauf der äußeren Do While<\/b>-Schleife für die beiden Tabellen tblBestellungen <\/b>und tblArtikel<\/b>. Die Tabelle tblBestelldetails <\/b>bleibt übrig, weil sie zu diesem Zeitpunkt noch mit den beiden Tabellen tblBestellungen <\/b>und tblArtikel <\/b>verknüpft ist und die noch nicht in die Collection colReihenfolge <\/b>übernommen wurden. Für die Tabelle tblBestelldetails <\/b>ist also im vorliegenden Beispiel ein dritter Durchlauf der äußeren Do While<\/b>-Schleife nötig. Es kann passieren, dass weniger Durchläufe nötig sind. Dies hängt davon ab, wie die Tabellen in der Auflistung relOffen <\/b>sortiert sind. Wenn im zweiten Durchgang beispielsweise erst die Tabellen tblArtikel <\/b>und tblBestellungen <\/b>behandelt und in die Collection colReihenfolge <\/b>verschoben worden wären und erst dann die Tabelle tblBestelldetails <\/b>untersucht worden wäre, hätte die Funktion diese gleich in diesem Durchlauf ebenfalls in die Col-lection colReihenfolge <\/b>verschoben. Dies ist jedoch nicht der Fall, da colOffen <\/b>aus der TableDefs<\/b>-Auflistung gefüllt wird, und diese liefert ihre Einträge in alphabetischer Reihenfolge.<\/p>\n Die Collection colReihenfolge <\/b>wird schließlich als Funktionsergebnis zurückgeliefert.<\/p>\n Wenn Sie die Funktion ausprobieren möchten, können Sie dies etwa mit der folgenden Testprozedur durchführen:<\/p>\n Die Prozedur ruft die Funktion TabellenreihenfolgeKopieren <\/b>auf und durchläuft die mit einer Collection zurückgegebenen Elemente in einer For Each<\/b>-Schleife. Das Ergebnis sieht im Direktbereich wie folgt aus:<\/p>\n Reihenfolge zum Löschen bestimmen<\/b><\/p>\n Die Bestimmung der Reihenfolge zum Löschen der Daten aller Tabellen eines Datenmodells startet mit einem ersten Schritt, bei dem alle Tabellen ermittelt werden, die von keiner anderen Tabelle referenziert werden – also solche Tabellen, die ausschließlich Fremdschlüsselfelder zu anderen Tabellen aufweisen, aber nicht mit ihrem Primärschlüsselfeld an einer Beziehung beteiligt sind. Die Funktion zum Zusammenstellen einer Collection mit diesen Tabellen in der richtigen Reihenfolge zum Löschen der Daten aller Tabellen sieht ähnlich aus wie die zuvor beschriebene Funktion zum Ermitteln der Reihenfolge beim Hineinkopieren von Daten in verknüpfte Tabellen eines Datenmodells.<\/p>\n Die Funktion aus Listing 3 heißt TabellenreihenfolgeLoeschen <\/b>und liefert wiederum eine Collection mit den betroffenen Tabellen in der richtigen Reihenfolge zurück. Sie ist fast identisch aufgebaut wie die zuvor beschriebene Funktion TabellenreihenfolgeKopieren<\/b>, allerdings prüft sie jeweils, ob die aktuell untersuchte Tabelle eine Mastertabelle ist, und übernimmt diese nur in die Collection colReihenfolge<\/b>, wenn dies nach Abschluss der entsprechenden Prüfungen nicht der Fall ist. Auf diese Weise durchläuft auch diese Funktion die in der Collection colOffen <\/b>enthaltenen Tabellen ein- oder mehrmals, bis alle Tabellen aus dieser Auflistung in der richtigen Reihenfolge in der Collection colReihenfolge <\/b>gelandet sind und diese an die aufrufende Routine zurückgegeben werden kann.<\/p>\nPublic Sub <\/span>TabellenDurchlaufen()\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 Debug.Print<\/span> tdf.Name\r\n Next<\/span> tdf\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nFor Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n Debug.Print<\/span> tdf.Name\r\n End If<\/span>\r\nNext<\/span> tdf<\/pre>\nPublic Sub <\/span>BeziehungenDurchlaufen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Set<\/span> db = CurrentDb\r\n For Each rel In db.Relations\r\n Debug.Print<\/span> \"Mastertabelle: \" & rel.Table & \" (\" & rel.Fields(0).Name & \")\"\r\n Debug.Print<\/span> \"Detailtabelle: \" & rel.ForeignTable & \" (\" & rel.Fields(0).ForeignName & \")\"\r\n Debug.Print<\/span> \"==============================\"\r\n Next<\/span> rel\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Reihenfolge](\"..\/fileadmin\/_temp_\/2014_02\/pic_926_001.png\")
<\/p>\nPublic Function <\/span>TabellenreihenfolgeKopieren() As <\/span>Collection\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>colOffen As <\/span>Collection, colReihenfolge As <\/span>Collection\r\n Dim <\/span>bolIstDetailtabelle As Boolean<\/span>\r\n Dim <\/span>varOffen As Variant<\/span>, varReihenfolge As Variant<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> colOffen = New<\/span> Collection\r\n Set<\/span> colReihenfolge = New<\/span> Collection\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n colOffen.Add tdf.Name, tdf.Name\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Do While<\/span> colOffen.Count > 0\r\n For Each varOffen In colOffen\r\n bolIstDetailtabelle = False<\/span>\r\n For Each rel In db.Relations\r\n If <\/span>rel.ForeignTable = varOffen Then<\/span>\r\n If <\/span>Not<\/span> ((rel.Attributes And dbRelationDontEnforce) = dbRelationDontEnforce) Then<\/span>\r\n bolIstDetailtabelle = True<\/span>\r\n For Each varReihenfolge In colReihenfolge\r\n If <\/span>rel.Table = 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 End If<\/span>\r\n Next<\/span> rel\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 Next<\/span> varOffen\r\n Loop<\/span>\r\n Set<\/span> db = Nothing\r\n Set<\/span> TabellenreihenfolgeKopieren = colReihenfolge\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>Test_Tabellenreihenfolge()\r\n Dim <\/span>colReihenfolge As <\/span>Collection\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> colReihenfolge = _\r\n TabellenreihenfolgeKopieren\r\n For Each var In colReihenfolge\r\n Debug.Print<\/span> var\r\n Next<\/span> var\r\nEnd Sub<\/span><\/pre>\ntblKategorien\r\ntblKunden\r\ntblLieferanten\r\ntblPersonal\r\ntblVersandfirmen\r\ntblArtikel\r\ntblBestellungen\r\ntblBestelldetails<\/pre>\n
Public Function <\/span>TabellenreihenfolgeLoeschen() As <\/span>Collection\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>colOffen As <\/span>Collection, colReihenfolge As <\/span>Collection\r\n Dim <\/span>bolIstMastertabelle As Boolean<\/span>\r\n Dim <\/span>varOffen As Variant<\/span>, varReihenfolge As Variant<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> colOffen = New<\/span> Collection\r\n Set<\/span> colReihenfolge = New<\/span> Collection\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name Like \"tbl*\" Then<\/span>\r\n colOffen.Add tdf.Name, tdf.Name\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Do While<\/span> colOffen.Count > 0\r\n For Each varOffen In colOffen\r\n bolIstMastertabelle = False<\/span>\r\n For Each rel In db.Relations\r\n If <\/span>rel.Table = varOffen Then<\/span>\r\n If <\/span>Not<\/span> ((rel.Attributes And dbRelationDontEnforce) = dbRelationDontEnforce) Then<\/span>\r\n bolIstMastertabelle = True<\/span>\r\n For Each varReihenfolge In colReihenfolge\r\n If <\/span>rel.ForeignTable = 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 End If<\/span>\r\n Next<\/span> rel\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 Next<\/span> varOffen\r\n Loop<\/span>\r\n Set<\/span> db = Nothing\r\n Set<\/span> TabellenreihenfolgeLoeschen = colReihenfolge\r\nEnd Function<\/span><\/pre>\n