Der SQL Server-Tabellenverknüpfungsassistent, den wir im Beitrag „SQL Server-Tabellenverknüpfungsassistent“ (www.access-im-unternehmen.de/1540) vorgestellt haben, funktioniert in vielen Settings bereits recht gut. In vielen Fällen zeigt sich die Praxistauglich jedoch erst, wenn die Anwendung einmal auf andere Benutzer und/oder Verwendungszwecke stößt. Da dies nun geschehen ist, wollen wir im zweiten Teil der Beitragsreihe zum Thema SQL Server-Tabellenverknüpfungsassistent einige Ändeurngen und Erweiterungen nachreichen. Dabei geht es im Wesentlichen um die Benennung der Tabellenverknüpfungen, die von dem Assistenten entweder initial angelegt oder aktualisiert werden sollen.
Probleme beim Einsatz des Tabellenverknüpfungsassistenten
Das Hauptproblem, dass uns zurückgemeldet wurde, ist die Unflexibilität bei der Verwendung der Bezeichnungen für die Tabellenverknüpfungen. Im ersten Teil gingen wir davon aus, dass wir mit dem Namen der Tabelle allein auskommen – so sah auch das Formular zum Verwalten der zu verknüpfenden Tabellen aus (siehe Bild 1).
Bild 1: Hauptformular Access-Add-Ins
Das Add-In erledigt die folgenden Aufgaben:
- Wenn die Access-Anwendung erstmals mit den Tabellen einer SQL Server-Datenbank verknüpft werden soll, legt es diese einfach unter dem gleichen Namen an, unter dem diese auch in der SQL Server-Datenbank gespeichert sind – ohne Berücksichtigung von dbo oder anderen Schemabezeichnungen.
- Wenn die Tabellenverknüpfungen aktualisiert werden sollen, beispielsweise wenn sich der Name der Datenbank oder sich Name/Adresse des SQL Servers geändert haben, werden auch die Tabellennamen aus dem SQL Server verwendet. Wenn bereits eine Tabelle oder Tabellenverknüpfung gleichen Namens vorhanden ist, erscheint eine Inputbox, die dem Benutzer die Möglichkeit bietet, einen anderen Namen zu wählen oder die vorhandene Tabelle oder Tabellenverknüpfung zu überschreiben.
Das initiale Verknüpfen ist somit normalerweise immer funktional, außer man möchte, dass die Tabellenverknüpfung anders benannt werden als die Tabellen auf dem SQL Server.
Das Aktualisieren der Tabellenverknüpfungen offenbart allerdings weitere Schwachstellen:
- Je nachdem, mit welcher Methode man initial die Tabellenverknüpfungen erstellt hat, wird eine Tabellenverknüpfung beispielsweise für eine Tabelle wie tblKunden auch einmal dbo_tblKunden genannt. Damit kommt das Add-In grundsätzlich nicht zurecht: Es soll die Tabelle tblKunden als Tabellenverknüpfung anlegen und prüft, ob bereits eine Verknüpfung namens tblKunden vorhanden ist. Falls nicht, wird die Tabellenverknüpfung unter dem Namen tblKunden hinzugefügt. Das ist natürlich nicht zielführend, denn dann gibt es zwei Tabellenverknüpfungen für die gleiche Tabelle, nämlich dbo_tblKunden und tblKunden. Da Abfragen, Formulare, Berichte und VBA in diesem Fall auf die Tabellenverknüpfung dbo_tblKunden eingestellt sind, greifen diese weiterhin auf die alte Tabellenverknüpfung zu, die nicht geändert wurde und gegebenenfalls auf die falsche Datenbank oder den falschen Server verweist.
- Eines der Probleme hierbei ist, dass das Add-In die vorhandenen Tabellenverknüpfungen nicht den Tabellen der SQL Server-Datenbank zuordnen kann, da es nur den Namen der Tabellenverknüpfung mit dem Namen der Tabelle vergleicht.
- Außerdem prüft das Add-In in der Version aus dem ersten Teil der Beitragsreihe immer nur, ob es bereits eine Tabelle oder Tabellenverknüpfung mit dem Namen der anzulegenden Tabellenverknüpfung gibt. Das ist eigentlich nur sinnvoll, wenn es bereits Tabellen gleichen Namens gibt, da diese gegebenenfalls nicht überschrieben werden sollen. Wenn es eine Verknüpfung gleichen Namens gibt, sollte diese eigentlich direkt überschrieben werden.
Diese Probleme adressieren wir in der Überarbeitung des Assistenten im vorliegenden Beitrag.
Ziele der Anpassung
Wir wollen also folgende Änderungen erreichen:
- Das Add-In soll zuverlässig erkennen, ob eine Tabellenverknüpfung sich auf eine in der SQL Server-Datenbank enthaltene Tabelle bezieht und diese dann einfach ersetzen.
- Dabei soll dann der Name der Tabellenverknüpfung übernommen werden, den die zu ersetzende Verknüpfung hatte.
- Außerdem wollen wir dem Benutzer die Möglichkeit geben, beim initialen Erstellen einer Tabellenverknüpfung festzulegen, wie die Tabellenverknüpfungen benannt werden sollen. Dazu stehen die beiden Platzhalter Schema und Name zur Verfügung, die man in eckigen Klammern neben weiteren Zeichen angeben kann.
Erster Schritt: Tabelle zum Speichern der Tabelleninformationen
Da wir nun nicht mehr nur mit den Tabellennamen arbeiten wollen, wie sie im SQL Server vorkommen, sondern auch noch die Namen der vorhandenen Tabellenverknüpfungen berücksichtigen wollen, nutzen wir der Übersichtlichkeit halber eine Tabelle namens tblTablesTemp. Diese ist wie in Bild 2 aufgebaut. Hier speichern wir neben dem Namen der Tabelle im SQL Server auch den Namen der Taellenverknüpfung in der Access-Datenbank. Außerdem wollen wir auch noch das Schema (zum Beispiel dbo) und den Tabellennamen ohne Schema in eigenen Feldern speichern.
Bild 2: Tabelle zum Speichern der Tabelleninformationen
Füllen der Tabelle tblTempTables
Beim Laden des Formulars wird in der Ereignisprozedur Form_Load die Methode cboVerbindung_AfterUpdate aufgerufen. Diese wird auch als Ereignis ausgelöst, wenn der Benutzer eine neue Verbindung über das Kombinationsfeld cboVerbindung auswählt.
Die Prozedur cboVerbindung_AfterUpdate haben wir so angepasst, dass alle für die Tabelle tblTablesTemp benötigten Daten eingelesen werden (siehe Listing 1).
Public Sub cboVerbindung_AfterUpdate() '' ... Deklarationen ... Set dbc = CodeDb Set db = CurrentDb dbc.Execute "DELETE FROM tblTablesTemp", dbFailOnError If Len(strBenutzername) = 0 Then strBenutzername = Nz(dbc.OpenRecordset("SELECT Benutzername FROM tblVerbindungszeichenfolgen " _ & "WHERE VerbindungszeichenfolgeID = " & Me!cboVerbindung).Fields(0), "") End If If Len(strKennwort) = 0 Then strKennwort = Nz(dbc.OpenRecordset("SELECT Kennwort FROM tblVerbindungszeichenfolgen " _ & "WHERE VerbindungszeichenfolgeID = " & Me!cboVerbindung).Fields(0), "") End If If VerbindungTesten(Me!cboVerbindung, strVerbindungszeichenfolge, lngErrorNumber, strErrorDescription) = True Then Set qdf = db.CreateQueryDef("") With qdf .SQL = "SELECT TABLE_SCHEMA, TABLE_NAME, CONCAT(TABLE_SCHEMA, ''.'', TABLE_NAME) AS TABLE_SCHEMA_NAME " _ & "FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE IN (''BASE TABLE'', ''VIEW'') ORDER BY TABLE_TYPE, TABLE_NAME" .Connect = strVerbindungszeichenfolge .ReturnsRecords = True End With Set rstTablesSQL = qdf.OpenRecordset Set rstTablesLocal = db.OpenRecordset("SELECT Name FROM MSysObjects WHERE NOT Connect IS NULL " _ & "AND NOT Name LIKE ''~*''", dbOpenDynaset) Do While Not rstTablesSQL.EOF strTableSQL = rstTablesSQL!TABLE_SCHEMA_NAME Do While Not rstTablesLocal.EOF strTableSource = db.TableDefs(rstTablesLocal!Name).SourceTableName strTableLink = "" If rstTablesSQL!TABLE_SCHEMA_NAME = strTableSource Then strTableLink = rstTablesLocal!Name Exit Do End If rstTablesLocal.MoveNext Loop dbc.Execute "INSERT INTO tblTablesTemp(TableSQL, TableLink, [Schema], [Table]) VALUES(''" & strTableSQL & "'', ''" _ & strTableLink & "'', ''" & rstTablesSQL!TABLE_SCHEMA & "'', ''" & rstTablesSQL!TABLE_NAME & "'')", dbFailOnError If Not rstTablesLocal.BOF Then rstTablesLocal.MoveFirst End If rstTablesSQL.MoveNext Loop Me.lstTabellen.RowSource = "SELECT TableSQL, TableLink, Schema, Table FROM tblTablesTemp ORDER BY TableSQL, TableLink" For i = 0 To Me.lstTabellen.ListCount If Not Len(Me.lstTabellen.Column(1, i)) = 0 Then Me.lstTabellen.Selected(i) = True End If Next i Else MsgBox "Keine gültige Verbindung." & vbCrLf & vbCrLf & strErrorDescription End If End Sub
Listing 1: Einlesen der Tabellendaten beim Laden des Formulars
Wir deklarieren und initialisieren zwei DAO.Database-Variablen namens dbc und db, mit denen wir das Database-Objekt der Add-In-Datenbank und der geöffneten Datenbank referenzieren.
Im ersten Schritt leeren wir die Tabelle tblTablesTemp. Dann folgen die bereits bekannten Schritte, um den aktuellen Benutzer uns sein Kennwort zu ermitteln, die wir zum Testen der Verbindung mit der Funktion VerbindungTesten benötigen.
Ist dieser Aufruf erfolgreich, haben wir in strVerbindungszeichenfolge eine funktionierende Verbindungszeichenfolge.
Dafür erstellen wir nun mit CreateQueryDef eine temporäre Abfrage, die wir mit qdf referenzieren.
Diese versehen über die SQL-Eigenschaft wir mit einer Abfrage, die uns die Felder TABLE_SCHEMA, TABLE_NAME und den mit dem Schema versehenen Tabellennamen (CONCAT(TABLE_SCHEMA, “.“, TABLE_NAME) für das Feld TABLE_SCHEMA_NAME aus der Systemtabelle INFORMATION_SCHEMA.TABLES des SQL Servers, bei denen der Tabellentyp über das Kriterium TABLE_TYPE IN (“BASE TABLE“, “VIEW“) als Tabelle oder View erkannt wird.
Die Verbindungszeichenfolge stellen wir auf den Inhalt der Variablen strVerbindungszeichenfolge ein und legen mit .ReturnsRecords = True fest, dass diese Abfrage Datensätze zurückliefern soll.
Auf Basis dieser Abfrage erstellen wir mit OpenRecordset ein Recordset, das wir mit rstTablesSQL referenzieren.
Danach erstellen wir noch ein zweites Recordset namens rstTablesLocal, das wir mit den Daten der Access-Systemtabelle MSysObjects füllen, bei denen das Feld Connect gefüllt ist.
Dies weist darauf hin, dass es sich um eine Tabellenverknüpfung handelt. Die Abfrage enthält einen weiteren Parameter, nämlich NOT Name Like “~*“.
Er sorgt für den Fall vor, dass wir in der aktuellen Session, also seit dem Öffnen der Access-Datenbank, bereits manuell Tabellenverknüpfungen gelöscht haben.
Diese werden nicht direkt vollständig gelöscht, sondern sind noch unter einem temporären Namen wie ~TMPCLP215381 in der Datenbank vorhanden.
Diese enthalten wie die gelöschte Tabellenverknüpfung noch die Eigenschaft Connect und werden so zu der entsprechenden SQL Server-Tabelle zugeordnet. Damit diese in der Liste nicht angezeigt werden, geben wir den entsprechenden zusätzlichen Filter an.
In der folgenden Do While-Schleife durchlaufen wir alle Datensätze des Recordsets rstTableSQL und schreiben dort den Namen der Tabelle in die Variable strTableSQL.
Damit durchlaufen wir in einer inneren Do While-Schleife alle Datensätze des Recordsets mit den Tabellenverknüpfungen. Hier lesen wir aus der Eigenschaft SourceTableName den Namen der Tabelle ein, die als Quelle für die Tabellenverknüpfung dient. Dazu greifen wir über die TableDefs-Auflistung auf die entsprechende Tabellendefinition zu und speichern das Ergebnis in der Variablen strTableSource.
Wenn nun der Wert der in der äußeren Do While-Schleife ermittelten SQL Server-Tabelle mit dem Namen der Quelltabelle der in der inneren Schleife durchlaufenen Tabelle entspricht, haben wir einen Treffer: Dann tragen wir in die Variable strTableLink (für die Tabellenverknüpfung) den Namen der Tabellenverknüpfung ein und verlassen die innere Schleife.
Anderenfalls durchlaufen wir die lokalen Tabellen solange, bis wir eine Übereinstimmung finden oder alle Tabellen durchlaufen wurden. Damit können wir einen neuen Datensatz in die Tabelle tblTablesTemp – unabhängig davon, ob wir eine passende Tabellenverknüpfung gefunden haben.
Es kann schließlich auch vorkommen, dass eine Tabelle der SQL Server-Datenbank noch nicht als Tabellenverknüpfung in der Access-Datenbank repräsentiert ist.
Wir tragen also den Namen der SQL Server-Tabelle, den Namen der Tabellenverknüpfung, das Schema und den reinen Tabellennamen in die Tabelle tblTablesTemp ein.
Damit stellen wir das Recordset für die innere Schleife wieder auf den ersten Datensatz zurück und bewegen den Datensatzzeiger für das Recordset der äußeren Schleife zum nächsten Datensatz.
SQL Server-Tabellen und Tabellenverknüpfungen im Listenfeld anzeigen
Bevor wir den Rest der Prozedur betrachten, schauen wir uns die notwendigen Änderungen am Listenfeld lstTabellen zur Anzeige der Tabellen im Formular frmTabellenverknuepfungen an (siehe Bild 3).
Bild 3: Neuer Entwurf des Formulars frmTabellenVerknuepfen
Hier haben wir zunächst eine Datensatzherkunft zugewiesen:
SELECT TableSQL, TableLink, Schema, Table FROM tblTablesTemp ORDER BY TableSQL, TableLink;
Damit hier nur die beiden Felder TableSQL und TableLink angezeigt werden, haben wir die Eigenschaften Spaltenanzahl auf 4 und Spaltenbreiten auf ;;0cm;0cm eingestellt. Die übrigen beiden Felder Schema und Table landen unsichtbar im Listenfeld, wodurch wir sie zwar nicht sehen, aber dennoch auf diese zugreifen können, sollte dies beispielsweise zum Verknüpfen erforderlich sein.
In der Formularansicht sieht das nun beispielsweise wie in Bild 4 aus.
Bild 4: Formularansicht des Formulars frmTabellenVerknuepfen
Es fehlt noch der Teil des Codes, der dafür sorgt, dass solche Tabellen, für die bereits eine Verknüpfung vorliegt, automatisch markiert werden.
Dazu durchlaufen wir die Elemente des Listenfeldes in einer For…Next-Schleife über die Werte 0 bis zur Anzahl der Listenelemente minus 1.
Wir prüfen, ob die erste Spalte der aktuellen Zeile einen Eintrag mit einer Länge größer als 0 enthält.
Ist das der Fall, wird der Eintrag durch Einstellen der Selected-Auflistung für die Zeile mit dem entsprechenden Index auf True eingestellt.
Damit haben wir den Teil zum Darstellen der vorliegenden SQL Server-Tabellen und der entsprechenden Tabellenverknüpfungen bereits erledigt.
Erweiterte Optionen zum Verknüpfen von Tabellen
Wie oben beschreiben, wollen wir nun das Verknüpfen von Tabellen optimieren. Nochmal kurz zusammengefasst:
- Wenn eine Verknüpfung vorhanden ist, soll diese je nach den Vorgaben des Benutzers entweder neu erstellt oder beibehalten werden.
- Wenn eine Verknüpfung noch nicht vorhanden ist, soll die Verknüpfung nach bestimmten Regeln neu erstellt werden. Diese Regeln beziehen sich auf den Namen der neuen Tabellenverknüpfung.
Damit der Benutzer Regeln für die zu verwendenden Namen aufstellen kann, haben wir dem Formular frmTabellenVerknuepfen weitere Steuerelemente hinzugefügt.
Hier sehen wir als Erstes ein Textfeld mit der Beschriftung Name für neue Tabellenverknüpfungen. Hier können wir beliebige Texte einfügen, aber wir sollten die Platzhalter [Name] und gegebenenfalls zusätzlich [Schema] hinzufügen.
Wichtig: Wenn wir hier keinen Wert angeben, wird der Name der Tabelle ohne Schema verwendet, bei dbo.tblAnlagen also beispielsweise nur tblAnlagen.
Beispiele für die Benennung der neuen Tabellenverknüpfungen
Hier sind einige Beispiele für die Ausdrücke, die im Feld Name für neue Tabellenverknüpfungen angegeben werden können:
- [Name]: Legt nur den Namen der SQL Server-Tabelle ohne Schema als Bezeichnung der Tabellenverknüpfung fest.
- Keine Angabe: Legt ebenfalls den Namen der SQL Server-Tabelle ohne Schema als Bezeichnung der Tabellenverknüpfung fest.
- [Schema]_[Name]: Legt die SQL Server-Tabelle dbo.tblAnlagen unter dem Namen dbo_tblAnlagen als Tabellenverknüpfung an.
- sql_[Name]: Legt die SQL Server-Tabelle dbo.tblAnlagen unter dem Namen sql_tblAnlagen als Tabellenverknüpfung an.
Beachten Sie, dass die Regeln für die Benennung von Access-Objekten hier berücksichtigt werden – also nur alphanumerische Zeichen und der Unterstrich. Es sind zwar auch andere Zeichen möglich, aber ungünstig.
Option „Vorhandene Tabellen immer überschreiben“
Diese Option sorgt dafür, dass alle Tabellenverknüpfungen, die im Listenfeld markiert sind, gelöscht und neu angelegt werden. Das führt auch dazu, dass die neuen Tabellenverknüpfungen unter Berücksichtigung der angegebenen Benennungskonvention erstellt werden.
Wenn man also beispielsweise eine Migration der Datenbank mit dem SQL Server Migration Assistant durchgeführt hat, wurden die Tabellenverknüpfungen üblicherweise mit dbo_Tabellenname benannt.
Dann sollte man, wenn man die Tabellen mit der hier vorgestellten Lösung neu verknüpft, auch das Format [Schema]_[Name] einstellen.
Durchführung der Verknüpfung
Nachdem wir festgelegt haben, welche Tabellen verknüpft werden sollen und nach welchem Schema, können wir auf die Schaltfläche cmdTabellenVerknuepfen klicken. Diese ruft die Prozedur aus Listing 2 auf.
Private Sub cmdTabellenVerknuepfen_Click() Dim strTableLocal As String Dim strTableSQL As String Dim strTableNew As String Dim lngIndex As Long Dim lngConnected As Long Dim lngSelected As Long Dim strVerbindungszeichenfolge As String If Not Len(Nz(Me.txtNeuerName, "")) = 0 Then If InStr(1, Me.txtNeuerName, "[Name]") = 0 Then If Me.lstTabellen.ItemsSelected.Count > 1 Then MsgBox "Der Ausdruck für den neuen Namen der Verknüpfung muss zumindest den Platzhalter [Name] " _ & "enthalten." & vbCrLf & vbCrLf & "Wenn das nicht der Fall ist, kann nur eine Verknüpfung " _ & "angelegt werden." & vbCrLf & vbCrLf & " Der Vorgang wird abgebrochen.", vbOKOnly + _ vbExclamation, "Fehlender Platzhalter" Exit Sub End If End If End If If VerbindungTesten(Me!cboVerbindung, strVerbindungszeichenfolge) = True Then For lngSelected = 0 To Me!lstTabellen.ItemsSelected.Count - 1 lngIndex = Me.lstTabellen.ItemsSelected(lngSelected) strTableSQL = Me.lstTabellen.Column(0, lngIndex) strTableLocal = Me.lstTabellen.Column(1, lngIndex) strTableNew = Replace(Replace(Nz(Me.txtNeuerName, ""), "[Schema]", Me.lstTabellen.Column(2, lngIndex)), _ "[Name]", Me.lstTabellen.Column(3, lngIndex)) If Len(strTableNew) = 0 Then strTableNew = Me.lstTabellen.Column(3, lngIndex) End If If TabelleVerknuepfen(strTableLocal, strTableNew, strTableSQL, strVerbindungszeichenfolge, _ Me!chkImmerUeberschreiben) = True Then lngConnected = lngConnected + 1 End If Next lngSelected Call cboVerbindung_AfterUpdate MsgBox lngConnected & " Tabellen wurden verknüpft." Else MsgBox "Verbindung konnte nicht hergestellt werden." End If Call VerknuepfungInDatenbankSpeichern(Me.cboVerbindung) End Sub
Listing 2: Aufruf der Verknüpfung von Tabellen
Die Prozedur deklariert drei Variablen für die Benennung von Tabellen:
- strTableSQL: Name der Tabelle im SQL Server (siehe erste Spalte im Listenfeld)
- strTableLocal: Name der Tabellenverknüpfung, die mit der Tabelle aus strTableSQL verknüpft ist – sofern vorhanden, sonst leer.
- strTableNew: Neuer Name für die Tabellenverknüpfung mit der Tabelle aus strTableSQL. Kann mit strTableLocal übereinstimmen, muss es aber nicht.
Als Erstes prüft die Prozedur, ob die Bedingungen für das Ersetzen der Tabellenverknüpfungen erfüllt sind. Wenn der Benutzer im Textfeld txtNeuerName nicht den Platzhalter [Name] einträgt, der den Tabellennamen aus dem SQL Server widerspiegelt und dieses Textfeld auch nicht leer lässt, kann er nur eine Verknüpfung neu erstellen.
Der Grund ist, dass mit dem statischen Namen für die neue Verknüpfung sonst mehrere neue Verknüpfungen den gleichen Namen erhalten würden, was beim Anlegen des ersten doppelten Objekts zu einem Fehler führen würde.
Also prüfen wir zuerst, ob txtNeuerName nicht leer ist. Ist es leer, verwendet das Formular automatisch den Namen der SQL Server-Tabelle für die Tabellenverknüpfung und wir haben individuelle Namen je Tabellenverknüpfung.
Ist es nicht leer, prüft die Prozedur, ob der Benutzer den Platzhalter [Name] in den Ausdruck für den Namen der neuen Tabellenverknüpfungen integriert hat.
Anderenfalls prüft sie, ob der Benutzer mehr als einen Eintrag der Liste zum Aktualisieren der Verknüpfung ausgewählt hat. Ist das der Fall, erscheint eine Meldung, dass dies nicht möglich ist und die Prozedur wird abgebrochen.
Ist ds nicht der Fall, prüft die Prozedur mit einem Aufruf der Funktion VerbindungTesten wieder, ob die Verbindung funktioniert, und liefert mit strVerbindungszeichenfolge die aktuelle Verbindungszeichenfolge zurück.
Dann durchläuft die Prozedur in einer For…Next-Schleife alle Elemente des Listenfeldes lstTabellen. Dabei werden die Werte von 0 bis zur Anzahl der Listenelement minus 1 verwendet.
In die Variable strTableSQL liest die Prozedur den Wert der ersten Spalte mit dem Index 0 des Listenfeldes ein, also den Namen der SQL Server-Tabelle. In strTableLocal landet der Wert der zweiten Spalte. Dieser kann auch leer sein, wenn es noch keine Tabellenverknüpfung gibt, die sich auf die aktuelle SQL Server-Tabelle bezieht. Schließlich schreiben wir in die Variable strTableNew den durch den Benutzer definierten Namen für die neu anzulegende Tabellenverknüpfung.
Dabei verwendet die Prozedur den Text des Feldes txtNeuerName, indem sich beispielsweise ein Ausdruck wie [Schema]_[Name] befindet, und ersetzt die Platzhalter [Schema] und [Name] durch die Werte der dritten und vierten Spalte des Listenfeldes für den aktuellen Eintrag.
Wenn strTableNew danach noch leer sein sollte, was der Fall ist, wenn der Benutzer keinen Wert in das Textfeld txtNeuerName eingetragen hat, trägt die Prozedur einfach den Namen der SQL Server-Tabelle als Namen der anzulegenden Tabellenverknüpfung an.
Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...
den kompletten Artikel im PDF-Format mit Beispieldatenbank
diesen und alle anderen Artikel mit dem Jahresabo