<\/p>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2020_05\/pic_1252_001.png\")
<\/p>\n
Bild 1: Datenmodell mit Beispielverknüpfungen<\/span><\/b><\/p>\n Im Beitrag „Berichte und Unterberichte konfigurieren“ haben wir die Aufgabe, für Kombinationen aus Tabellen und Abfragen herauszufinden, ob eine Beziehung zwischen den beiden Datenquellen besteht und über welche Felder diese realisiert wird. In diesem Fall nutzen wir dies, um automatisch die Verknüpfungsfelder für die Datensatzquellen von Haupt- und Unterberichten zu ermitteln. Wir erhalten also die Tabelle\/Abfrage des Hauptberichts und des Unterberichts und benötigen nun die Felder, über welche die Beziehung zwischen den beiden Datenquellen hergestellt wird. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n Als Beispiel für diesen Beitrag verwenden wir die Tabellen der Südsturm-Datenbank, einen Ausschnitt des Datenmodells sehen Sie in Bild 1.<\/p>\n Bild 1: Datenmodell mit Beispielverknüpfungen<\/span><\/b><\/p>\n Aufgabenstellung<\/b><\/p>\n Wir benötigen eine Funktion, die für zwei gegebene Tabellen oder Abfragen die folgenden Daten herausfindet:<\/p>\n Nochmal die Definition von Parent- und Childtabellen: Die Parenttabelle ist die Tabelle, deren Primärschlüsselfeld an der Beziehung beteiligt ist, die Childtabelle ist die Tabelle, deren Fremdschlüsselfeld an der Beziehung beteiligt ist.<\/p>\n Bei der Beziehung zwischen den Tabellen tblKunden <\/b>und tblBestellungen <\/b>ist also tblKunden <\/b>die Parenttabelle und tblBestellungen <\/b>die Childtabelle<\/b>. Das Parentfeld heißt KundeID<\/b>, das Childfeld ebenfalls. Genau diese Informationen wollen wir mit der geplanten Funktion ermitteln.<\/p>\n Definition der benötigten Funktion<\/b><\/p>\n Die Funktion soll also die folgenden Eingangsparameter enthalten:<\/p>\n Außerdem benötigen wir diese Ausgangsparameter für die Funktion:<\/p>\n Schließlich soll die Funktion noch einen Funktionswert zurückliefern, der angibt, ob überhaupt eine Beziehung gefunden wurde – dazu verwenden wir den Datentyp Boolean<\/b>. Der Kopf der Funktion sieht also schon einmal so aus:<\/p>\n Den Rest der Funktion sehen Sie in Listing 1. Die Funktion stellt zunächst alle Werte der Rückgabeparameter auf eine leere Zeichenkette ein (dies geschieht nur, weil wir mehrere Testaufrufe hintereinander durchführen und die Werte der Variablen in den Testaufrufen sonst beim erneutern Aufruf beibehalten würden).<\/p>\n Listing 1: Funktion zum Ermitteln von Beziehungsdaten zweier Tabellen<\/span><\/b><\/p>\n Dann durchläuft die Funktion alle Relation<\/b>-Objekte der aktuellen Datenbank, die wir mit der Relations<\/b>-Auflistung des Database<\/b>-Objekts aus CurrentDb <\/b>erhalten. In dieser For Each<\/b>-Schleife prüfen wir zunächst, ob der Name der mit strTableOrQuery1 <\/b>übergebenen Tabelle mit der Eigenschaft Table <\/b>des Relation<\/b>-Objekts übereinstimmt und der Name aus strTableOrQuery2 <\/b>mit dem Wert der Eigenschaft ForeignTable<\/b>. Table <\/b>enthält immer den Namen der Parenttabelle, ForeignTable <\/b>den Namen der Childtabelle.<\/p>\n Ist das der Fall, füllt die Funktion einfach die vier Rückgabeparameter mit folgenden Eigenschaften des Relation<\/b>-Objekts:<\/p>\n Warum Fields(0)<\/b> Es kann sein, dass zwei Tabellen über mehr als eine Beziehung verknüpft sind. Dieser Fall sollte aber in einem sauber formulierten Datenmodell nicht vorkommen, daher berücksichtigen wir nur eine Beziehung.<\/p>\n Wenn die Parameter gefüllt sind, stellen wir noch den Funktionswert auf True <\/b>ein und verlassen die Funktion mit Exit Function<\/b>.<\/p>\n Da es auch sein kann, dass die Parenttabelle mit dem Parameter strTableOrQuery2 <\/b>und die Childtabelle mit dem Parameter strTableOrQuery1 <\/b>übergeben wurde, prüfen wir in einer zweiten If…Then<\/b>-Bedingung auch noch den umgekehrten Fall. Auch hier tragen wir dann die entsprechenden Werte in die Rückgabeparameter ein und verlassen dann die Funktion.<\/p>\n Testen der Funktion<\/b><\/p>\n Um die Funktion zu testen, haben wir eine Prozedur mit einigen Testaufrufen programmiert. Diese finden Sie in gekürzter Fassung in Listing 2.<\/p>\n Listing 2: Testen der Funktion zum Ermitteln von Beziehungsdaten zweier Tabellen<\/span><\/b><\/p>\n <\/p>\n Diese Prozedur ruft die Funktion auf und übergibt beliebige Kombinationen von Tabellen. Liefert die Funktion in diesen Aufrufen den Wert True <\/b>zurück, prüfen wir in einer If…Then<\/b>-Bedingung, ob die vier Rückgabeparameter die erwarteten Werte zurückliefern.<\/p>\n Falls nicht, geben wir eine entsprechende Meldung im Direktbereich des VBA-Editors aus. Wenn schon das Funktionsergebnis entgegen den Erwartungen False <\/b>lautet, geben wir ebenfalls eine Meldung im Direktbereich aus.<\/p>\n Am Ende haben wir auch noch einen Test für die Kombination zweier Tabellen eingefügt, für die es keine Beziehung gibt. Hier soll entsprechend der Wert False <\/b>als Funktionswert zurückgegeben werden.<\/p>\n Erweiterung auf Abfragen<\/b><\/p>\n Die eingangs geschilderte Aufgabenstellung ist teilweise erledigt, allerdings kann es im Falle von Haupt- und Unterberichten (oder auch Haupt- und Unterformularen) auch einmal vorkommen, dass Abfragen statt Tabellen verwendet werden. Bei Abfragen basierend auf einer Tabelle, die nur zum Beschränken der abzufragenden Felder oder zum Sortieren der Daten dient, können wir die oben beschriebene Funktion verwenden. Wenn die Abfragen jedoch mehr als eine Tabelle verwenden, wird es etwas aufwendiger, Beziehungen zwischen den Datensatzquellen von Haupt- und Unterbericht zu ermitteln.<\/p>\n Hier müssen wir die Funktion also so erweitern, dass diese alle Tabellen der jeweiligen Abfrage untersucht und mit den Tabellen der anderen Abfrage abgleicht, um Beziehungen zu finden.<\/p>\n Anzahl der Tabellen einer Datensatzquelle ermitteln<\/b><\/p>\n Für die folgenden Schritte wollen wir Tabellen und Abfragen gleich behandeln. In diesen Schritten wollen wir also herausfinden, ob es sich um eine einzelne Tabellen oder eine Abfrage mit einer oder mehreren Tabellen handelt. Den Entwurf einer Tabelle können wir mit dem der TableDef<\/b>-Klasse untersuchen, den einer Abfrage mit der QueryDef<\/b>-Klasse. Wie aber können wir Tabellen und Abfragen auf gleiche Weise untersuchen Mit dem Recordset<\/b>-Objekt. Dieses untersuchen wir in einer Funktion namens GetTables<\/b> (siehe Listing 3). Die Funktion hat keine andere Aufgabe als ein Array aller in einer Abfrage enthaltenen Tabellen zurückzuliefern. Deshalb verwendet sie neben dem Eingangsparameter rst <\/b>den Ausgangsparameter strTables <\/b>als String<\/b>-Array.<\/p>\n Listing 3: Funktion zum Einlesen aller Tabellen einer Abfrage in ein Array<\/span><\/b><\/p>\n In einer For Each<\/b>-Schleife durchläuft die Funktion alle Field<\/b>-Elemente des Recordset-Objekts rst<\/b>. Dabei speichert sie als Erstes den Namen der Tabelle, zu dem das Feld gehört, in der Variablen strTable<\/b>. Diese Quelltabelle ermitteln wir mit der Eigenschaft SourceTable <\/b>des Field<\/b>-Objekts. Dann versuchen wir, die aktuelle Anzahl der Tabellen im Array strTables <\/b>zu ermitteln, und zwar durch Subtraktion der Ergebnisse der Funktionen UBound <\/b>und LBound <\/b>des Arrays. Dies erledigen wir bei deaktivierter Fehlerbehandlung, denn diese würde einen Fehler liefern, wenn das Array noch keinen Eintrag enthält. Ist intTableCount <\/b>danach 0<\/b>, stellen wir die Variable bolTableExists<\/b>, die schlicht angibt, ob die aktuelle Tabelle aus strTable <\/b>bereits im Array enthalten ist – und wenn dieses noch keinen Eintrag hat, ist das definitiv noch nicht der Fall.<\/p>\n Ist intTableCount <\/b>nicht 0<\/b>, müssen wir genauer prüfen, ob die Tabelle aus strTable <\/b>schon im Array enthalten ist, denn wir prüfen dies ja für jedes Feld der Abfrage, und es kann vorkommen, das mehr als ein Feld zur gleichen Tabelle gehört.<\/p>\n Also durchlaufen wir in diesem Fall in einer For…Next<\/b>-Schleife alle Elemente des Arrays. Dabei prüfen wir, ob der aktuelle Wert des Arrays gleich dem Inhalt von strTable <\/b>ist. Ist das der Fall, existiert die Tabelle bereits im Array und wir stellen bolTableExists <\/b>auf True <\/b>ein und verlassen die Schleife. Ist die Tabelle nicht im Array vorhanden, verlassen wir die Schleife und bolTableExists <\/b>behält den Wert False<\/b>.<\/p>\n Diesen prüfen wir in der folgenden If…Then<\/b>-Bedingung. Hat bolTableExists <\/b>den Wert False<\/b>, erhöhen wir intTableCount <\/b>um eins, erweitern das Array auf den Wert von intTableCount <\/b>und weisen dem Element mit dem neuen Index den Wert von strTable <\/b>zu. Nachdem wir auf diese Weise alle Felder durchlaufen haben, ist das Array strTables <\/b>mit allen Tabellen der Abfrage gefüllt und wir können die Prozedur verlassen. Danach passen wir noch die Funktion GetReference <\/b>so an, dass diese nicht nur für Tabellen funktioniert, sondern auch für Abfragen, die eine oder mehrere Tabellen enthalten (siehe Listing 4).<\/p>\n Listing 4: Tabellen und beteiligte Felder einer Beziehung ermitteln<\/span><\/b><\/p>\n Die Funktion nimmt die gleichen Parameter entgegen wie zuvor. Sie verwendet allerdings weitere Variablen, zum Beispiel die beiden Arrays strTables1 <\/b>und strTables2<\/b>, welche die Namen der Tabelle oder der Tabellen (falls eine Abfrage mit strTableOrQuery1 <\/b>und strTableOrQuery2 <\/b>übergeben wurde). Auch die Recordset-Variablen rst1 <\/b>und rst2 <\/b>sind neu sowie die Variablen strTable1<\/b>, strTable2<\/b>, intTable1 <\/b>und intTable2<\/b>.<\/p>\n Wir erstellen ein Recordset namens rst1 <\/b>auf Basis der mit strTableOrQuery1 <\/b>übergebenen Tabelle oder Abfrage, analog für rst2 <\/b>und strTableOrQuery2<\/b>. <\/p>\n Dann ruft die Funktion für beide Recordsets die Funktion GetTables <\/b>auf, um die am Recordset beteiligten Tabellen jeweils in einem Array zurückzuliefern. Um den eigentlichen Kern der Prozedur herum fügen wir nun zwei verschachtelte Schleifen hinzu. Die äußere durchläuft alle Elemente des Arrays strTables1<\/b>, die innere alle Elemente des Arrays strTables2<\/b>. Innerhalb der Schleifen weisen wir den Variablen strTable1 <\/b>und strTable2 <\/b>die jeweils aktuellen Elemente der Arrays strTables1 <\/b>und strTables2 <\/b>hinzu und führen dann die Schritte aus, die wir auch in der vorherigen Version der Funktion GetReference <\/b>erledigt haben.<\/p>\n Testen der Suche von Beziehungen in verknüpften Abfragen<\/b><\/p>\n Damit brauchen wir nur noch einige Abfragen zum Testen der neu hinzugekommenen Funktionalität zu erstellen und neue Testfälle zur Prozedur Test_GetReference hinzuzufügen. Der Vorteil der Nutzung unserer Testprozedur ist: Die Änderungen der Funktion GetReference <\/b>können wir für die bereits vorhandenen Fälle ganz einfach durch einen erneuten Aufruf der Testprozedur testen. Wenn keine Fehlermeldungen im Direktfenster auftauchen, liefert die Funktion auch nach der Änderung noch die erwarteten Ergebnisse.<\/p>\n Um die neuen Funktionen zu testen, legen wir also zwei Abfragen an: die erste enthält die beiden Tabellen tblArtikel <\/b>und tblKategorien<\/b>, die zweite die beiden Tabellen tblBestellungen <\/b>und tblBestelldetails<\/b>. Wichtig ist natürlich, dass das Primärschlüsselfeld und das Fremdschlüsselfeld der beiden Tabellen, über welche die Beziehung zwischen den beiden Abfragen hergestellt wird, im Abfrageergebnis erscheinen – hier also das Feld ArtikelID <\/b>der beiden Tabellen tblBestelldetails <\/b>und tblArtikel<\/b>.<\/p>\n Mit dem neuen Testfall (siehe Listing 5) können wir nun auch die an einer Beziehung zwischen zwei Abfragen beteiligten Felder ermitteln.<\/p>\n Listing 5: Neuer Testfall für das Ermitteln von Verknüpfungsfeldern zwischen zwei Abfragen<\/span><\/b><\/p>\n Erweiterung für mehrere Beziehungen<\/b><\/p>\n Wir haben noch eine weitere Version der Funktion GetReference <\/b>erstellt, die wir GetReferences<\/b> genannt haben. Diese erlaubt die Behandlung des eher seltenen Falls von mehreren Beziehungen zwischen zwei Tabellen oder den Tabellen zweier Abfragen.<\/p>\n Diese Funktion verwendet Arrays für die Rückgabe der Tabellen und Felder der Beziehungen (siehe Listing 6). Diese können nun nicht mehr geleert werden, indem man sie einfach auf eine leere Zeichenkette einstellt. Stattdessen leeren wir diese mit der Erase<\/b>-Funktion. Wenn die Funktion innerhalb der beiden Schleifen eine Beziehung findet, werden die Arrays mit Redim Preserve <\/b>um einen Eintrag erweitert und die neuen Daten werden für den Eintrag mit dem entsprechenden Index hinzugefügt. Der Test beziehungsweise der Aufruf ändert sich entsprechend:<\/p>\n Listing 6: Funktion zum Ermitteln mehrerer Beziehungen zwischen zwei Datensatzquellen<\/span><\/b><\/p>\n<\/p>\n\n
\n
\n
Public Function <\/span>GetReference(strTableOrQuery1 As String<\/span>, strTableOrQuery2 As String<\/span>, strParenttable As String<\/span>, strParentfield As String<\/span>, strChildtable As String<\/span>, strChildfield As String<\/span>) As Boolean<\/span><\/pre>\nPublic Function <\/span>GetReference(strTableOrQuery1 As String<\/span>, strTableOrQuery2 As String<\/span>, strParenttable As String<\/span>, \r\n strParentfield As String<\/span>, strChildtable As String<\/span>, strChildfield As String<\/span>) As Boolean<\/span>\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 strParenttable = \"\"\r\n strParentfield = \"\"\r\n strChildtable = \"\"\r\n strChildfield = \"\"\r\n For Each rel In db.Relations\r\n If <\/span>rel.Table = strTableOrQuery1 And rel.ForeignTable = strTableOrQuery2 Then<\/span>\r\n strParenttable = rel.Table\r\n strChildtable = rel.ForeignTable\r\n strParentfield = rel.Fields(0).Name\r\n strChildfield = rel.Fields(0).ForeignName\r\n GetReference = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>rel.Table = strTableOrQuery2 And rel.ForeignTable = strTableOrQuery1 Then<\/span>\r\n strParenttable = rel.Table\r\n strChildtable = rel.ForeignTable\r\n strParentfield = rel.Fields(0).Name\r\n strChildfield = rel.Fields(0).ForeignName\r\n GetReference = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> rel\r\nEnd Function<\/span><\/pre>\n\n
Public Sub <\/span>Test_GetReference()\r\n Dim <\/span>strParenttable As String<\/span>\r\n Dim <\/span>strParentfield As String<\/span>\r\n Dim <\/span>strChildtable As String<\/span>\r\n Dim <\/span>strChildfield As String<\/span>\r\n If GetReference(\"tblArtikel\", \"tblBestelldetails\", strParenttable, strParentfield, strChildtable, strChildfield) _\r\n = True<\/span> Then\r\n If Not<\/span> (strParenttable = \"tblArtikel\" And strParentfield = \"ArtikelID\" _\r\n And strChildtable = \"tblBestelldetails\" And strChildfield = \"ArtikelID\") Then\r\n Debug.Print<\/span> \"Test 1a fehlgeschlagen 1\"\r\n End If<\/span>\r\n Else<\/span>\r\n Debug.Print<\/span> \"Test 1a: fehlgeschlagen 2\"\r\n End If<\/span>\r\n If GetReference(\"tblBestelldetails\", \"tblArtikel\", strParenttable, strParentfield, strChildtable, strChildfield) _\r\n = True<\/span> Then\r\n If Not<\/span> (strParenttable = \"tblArtikel\" And strParentfield = \"ArtikelID\" _\r\n And strChildtable = \"tblBestelldetails\" And strChildfield = \"ArtikelID\") Then\r\n Debug.Print<\/span> \"Test 1b fehlgeschlagen 1\"\r\n End If<\/span>\r\n Else<\/span>\r\n Debug.Print<\/span> \"Test 1b: fehlgeschlagen 2\"\r\n End If<\/span>\r\n If GetReference(\"tblArtikel\", \"tblPersonal\", strParenttable, strParentfield, strChildtable, strChildfield) _\r\n = True<\/span> Then\r\n Debug.Print<\/span> \"Test 5 fehlgeschlagen\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>GetTables(rst As <\/span>DAO.Recordset, strTables() As String<\/span>)\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strTable As String<\/span>\r\n Dim <\/span>intTableCount As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>bolTableExists As Boolean<\/span>\r\n For Each fld In rst.Fields\r\n strTable = fld.SourceTable\r\n On Error Resume Next<\/span>\r\n intTableCount = UBound<\/span>(strTables) - LBound<\/span>(strTables)\r\n On Error GoTo<\/span> 0\r\n If <\/span>intTableCount = 0 Then<\/span>\r\n bolTableExists = False<\/span>\r\n Else<\/span>If intTableCount > 0 Then\r\n bolTableExists = False<\/span>\r\n For i = LBound<\/span>(strTables) To UBound<\/span>(strTables)\r\n If <\/span>strTables(i) = strTable Then<\/span>\r\n bolTableExists = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n If <\/span>bolTableExists = False<\/span> Then<\/span>\r\n intTableCount = intTableCount + 1\r\n ReDim Preserve strTables(intTableCount)\r\n strTables(intTableCount - 1) = strTable\r\n End If<\/span>\r\n Next<\/span> fld\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetReference(strTableOrQuery1 As String<\/span>, strTableOrQuery2 As String<\/span>, strParenttable As String<\/span>, _\r\n strParentfield As String<\/span>, strChildtable As String<\/span>, strChildfield As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst1 As <\/span>DAO.Recordset\r\n Dim <\/span>rst2 As <\/span>DAO.Recordset\r\n Dim <\/span>rel As <\/span>DAO.Relation\r\n Dim <\/span>strTables1() As String<\/span>\r\n Dim <\/span>strTables2() As String<\/span>\r\n Dim <\/span>strTable1 As String<\/span>\r\n Dim <\/span>strTable2 As String<\/span>\r\n Dim <\/span>intTable1 As Integer<\/span>\r\n Dim <\/span>intTable2 As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n strParenttable = \"\"\r\n strParentfield = \"\"\r\n strChildtable = \"\"\r\n strChildfield = \"\"\r\n Set<\/span> rst1 = db.OpenRecordset(\"SELECT TOP 1 * FROM (\" & strTableOrQuery1 & \")\", dbOpenSnapShot)\r\n Set<\/span> rst2 = db.OpenRecordset(\"SELECT TOP 1 * FROM (\" & strTableOrQuery2 & \")\", dbOpenSnapShot)\r\n GetTables rst1, strTables1\r\n GetTables rst2, strTables2\r\n For intTable1 = LBound<\/span>(strTables1) To UBound<\/span>(strTables1)\r\n For intTable2 = LBound<\/span>(strTables2) To UBound<\/span>(strTables2)\r\n For Each rel In db.Relations\r\n strTable1 = strTables1(intTable1)\r\n strTable2 = strTables2(intTable2)\r\n If (rel.Table = strTable1 And rel.ForeignTable = strTable2) Or (rel.Table = strTable2 _\r\n And rel.ForeignTable = strTable1) Then\r\n strParenttable = rel.Table\r\n strChildtable = rel.ForeignTable\r\n strParentfield = rel.Fields(0).Name\r\n strChildfield = rel.Fields(0).ForeignName\r\n GetReference = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> rel\r\n Next<\/span> intTable2\r\n Next<\/span> intTable1\r\nEnd Function<\/span><\/pre>\nIf GetReference(\"qryBestelldetailsBestellungen\", \"qryArtikelKategorien\", strParenttable, strParentfield, _\r\n strChildtable, strChildfield) = True<\/span> Then\r\n If Not<\/span> (strParenttable = \"tblArtikel\" And strParentfield = \"ArtikelID\" And strChildtable = \"tblBestelldetails\" _\r\n And strChildfield = \"ArtikelID\") Then\r\n Debug.Print<\/span> \"Test 6 fehlgeschlagen 1\"\r\n End If<\/span>\r\nElse<\/span>\r\n Debug.Print<\/span> \"Test 6: fehlgeschlagen 2\"\r\nEnd If<\/span>\r\nIf <\/span>GetReference(\"tblArtikel\", \"tblPersonal\", strParenttable, strParentfield, strChildtable, strChildfield) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Test 5 fehlgeschlagen\"\r\nEnd If<\/span><\/pre>\nPublic Function <\/span>GetReferences(strTableOrQuery1 As String<\/span>, strTableOrQuery2 As String<\/span>, strParenttables() As String<\/span>, _\r\n strParentfields() As String<\/span>, strChildtables() As String<\/span>, strChildfields() As String<\/span>) As Boolean<\/span>\r\n ...\r\n Erase strParenttables\r\n Erase strParentfields\r\n Erase strChildtables\r\n Erase strChildfields\r\n For intTable1 = LBound<\/span>(strTables1) To UBound<\/span>(strTables1)\r\n For intTable2 = LBound<\/span>(strTables2) To UBound<\/span>(strTables2)\r\n For Each rel In db.Relations\r\n strTable1 = strTables1(intTable1)\r\n strTable2 = strTables2(intTable2)\r\n If (rel.Table = strTable1 And rel.ForeignTable = strTable2) Or (rel.Table = strTable2 _\r\n And rel.ForeignTable = strTable1) Then\r\n intRelations = intRelations + 1\r\n ReDim Preserve strParenttables(intRelations)\r\n ReDim Preserve strChildtables(intRelations)\r\n ReDim Preserve strParentfields(intRelations)\r\n ReDim Preserve strChildfields(intRelations)\r\n strParenttables(intRelations - 1) = rel.Table\r\n strChildtables(intRelations - 1) = rel.ForeignTable\r\n strParentfields(intRelations - 1) = rel.Fields(0).Name\r\n strChildfields(intRelations - 1) = rel.Fields(0).ForeignName\r\n GetReferences = True<\/span>\r\n End If<\/span>\r\n Next<\/span> rel\r\n Next<\/span> intTable2\r\n Next<\/span> intTable1\r\nEnd Function<\/span><\/pre>\nIf <\/span>GetReferences(\"qryKundenPersonal\", \"tblBestellungen\", strParenttables, strParentfields, strChildtables, strChildfields) = True<\/span> Then<\/span>\r\n If <\/span>