<\/p>\n
Füllen Sie das Treeview-Steuerelement mit Daten aus einer oder mehreren Tabellen.<\/p>\n
Formulare, Treeview-Steuerelement, VBA<\/p>\n
Access 2002 und höher oder Access 97\/2000 und Developer Edition oder Visual Studio 6.0<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Das Treeview-Steuerelement eignet sich wie kein anderes zur Anzeige von hierarchischen Daten. Dieser Beitrag zeigt Ihnen, wie Sie es mit Daten aus einer oder mehreren Tabellen füllen und wie Sie mit kleinen Tricks einiges an Performance herausholen können. Dabei kommen nicht nur Daten aus mehreren verknüpften Tabellen zum Zuge, sondern auch solche aus reflexiven Beziehungen.<\/b><\/p>\n
Der Beitrag Das Treeview-Steuerelement (s. Shortlink 319) zeigt, wie Sie die Add-Methode der Nodes-Auslistung eines Treeview-Steuerelements verwenden, um Knoten an einen Baum anzufügen.<\/p>\n
Das Ganze macht natürlich nur wenig Sinn, wenn Sie keine Daten haben, die Sie in das Treeview einpflegen können. Die bekannteste Anwendung des Treeview-Steuerelements ist wohl der Windows Explorer. Hier finden Sie auf der linken Seite das Treeview-Steuerelement zur Anzeige der Verzeichnisse und auf der rechten Seite das ListView-Steuerelement für die im aktuell markierten Verzeichnis enthaltenen Unterverzeichnisse und Dateien.<\/p>\n
Vermutlich wollen Sie unter Access nicht gerade den Windows Explorer nachbauen, sondern die in Ihrer Datenbank enthaltenen Daten anzeigen.<\/p>\n
Das macht nur Sinn, wenn der anzuzeigende Ausschnitt der Daten hierarchisch aufgebaut ist. Die Daten können dabei aus einer einzelnen oder auch aus mehreren Tabellen stammen.<\/p>\n
Wenn die Daten mehrerer Tabellen angezeigt werden sollen, müssen diese per 1:n-Beziehung miteinander verknüpft sein.<\/p>\n
Auf diese Weise können Sie dann beispielsweise Kunden, Bestellungen und bestellte Artikel abbilden.<\/p>\n
Bei einer einzelnen Tabelle kann es sich beispielsweise um eine Mitarbeitertabelle handeln, die etwa über ein Feld namens VorgesetzterID mit sich selbst verknüpft ist und die Hierarchie der Mitarbeiter abbildet.<\/p>\n
In dem Fall zeigt das Treeview-Steuerelement nur die Mitarbeiter an. Die Verknüpfung einer Tabelle mit sich selbst heißt reflexive Verknüpfung.<\/p>\n
Beim Anzeigen von Daten aus verknüpften Tabellen werden die in den Tabellen enthaltenen Datensätze entsprechend der Abbildung im Treeview-Steuerelement durchlaufen.<\/p>\n
Bei zwei Tabellen bedeutet dies, dass in einer äußeren Schleife die Datensätze der Haupttabelle und in einer inneren Schleife die Datensätze der untergeordneten Tabelle durchlaufen werden.<\/p>\n
Am besten lässt sich das an einem Beispiel erklären. Dazu fügen Sie einem leeren Formular ein neues Treeview-Steuerelement hinzu und nennen es tvwTreeview.<\/p>\n
Anschließend benötigen Sie nur noch eine Routine, die beim öffnen des Formulars ausgelöst wird und die Kunden- und Bestelldaten in das Treeview-Steuerelement schreibt. Diese Routine sieht wie in Quellcode 1 aus.<\/p>\n
Die Routine deklariert und instanziert ein Database- und zwei Recordset-Objekte zum Referenzieren der beiden Tabellen Kunden und Bestellungen.<\/p>\n
In der ersten Do While-Schleife werden die Kunden durchlaufen. Dabei wird für jeden Kunden ein Knoten im Treeview angelegt. Innerhalb dieser Schleife wird außerdem das Recordset-Objekt rstBestellungen mit den Bestellungen gefüllt, die zum aktuellen Kunden gehören. Diese werden in einer weiteren Do While-Schleife unterhalb des aktuellen Kunden in das Treeview-Steuerelement eingefügt.<\/p>\n
Zu beachten ist dabei die Benennung der Key-Eigenschaft eines jeden Knotens. Dieser muss aus einer Zeichenkette mit einem Buchstaben am Anfang bestehen und eindeutig sein. Außerdem sollte man aus dieser Eigenschaft möglichst den zugrunde liegenden Datensatz identifizieren können, also den Primärschlüssel oder einen anderen eindeutigen Wert in den Key-Wert integrieren.<\/p>\n
Normalerweise könnte man einfach einen beliebigen Buchstaben (etwa „a“) verwenden und hinten den Wert des Primärschlüsselfeldes der Tabelle anhängen:<\/p>\n
\"a\" & rst!ID<\/pre>\nWenn Sie es aber wie im vorliegenden Fall mit mehr als einer Tabelle zu tun haben, ist die Eindeutigkeit der Primärschlüsselfelder nicht mehr gewährleistet: Es kann ja durchaus in beiden Tabellen einen Primärschlüssel mit dem Wert 1 geben.<\/p>\n
Also müssen Sie sich etwas anderes einfallen lassen. Die Lösung ist allerdings recht einfach: Da der Key-Wert eine beliebige Zeichenkette beinhalten darf, können Sie diesen einfach je Tabelle mit einem anderen Wert beginnen lassen. Im vorliegenden Fall beginnen die Key-Werte dementsprechend mit „Kunde“ und „Bestellung“.<\/p>\n
Das Ergebnis der Routine sieht wie in Bild 1 aus. Per Doppelklick auf einen der Kunden zeigen Sie die zu dem Kunden gehörenden Bestellungen an.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 1: Einfache hierarchische Daten im Treeview-Steuerelement<\/span><\/b><\/p>\n
Die Tabelle Personal der Nordwind-Datenbank liefert ein gutes Beispiel für eine reflexive Beziehung. Einige der Datensätze sind über das Feld Vorgesetzte(r) mit Feldern der gleichen Tabelle verknüpft und liefern damit Informationen über die Hierarchie der Mitarbeiter.<\/p>\n
<\/p>\n
Diese lässt sich natürlich in einem Treeview-Steuerelement weitaus besser veranschaulichen als in einer Tabelle (siehe Bild 2).<\/p>\n
Quellcode 1: Treeview-Steuerelement mit Daten aus zwei verknüpften Tabellen füllen<\/b><\/p>\n
Dim objTreeview As MSComctlLib.Treeview\r\nPrivate Sub Form_Open(Cancel As Integer)\r\n Dim db As DAO.Database\r\n Dim rstKunden As DAO.Recordset\r\n Dim rstBestellungen As DAO.Recordset\r\n Dim objNode As MSComctlLib.Node\r\n Set db = CurrentDb\r\n Set rstKunden = db.OpenRecordset(\"Kunden\")\r\n Set objTreeview = Me.ctlTreeview.Object\r\n Do While Not rstKunden.EOF\r\n Set objNode = objTreeview.Nodes.Add(, , \"Kunde\" & rstKunden![Kunden-Code], _ rstKunden!Firma)\r\n Set rstBestellungen = db.OpenRecordset _ (\"SELECT * FROM Bestellungen WHERE [Kunden-Code] = ''\" & rstKunden![Kunden-Code] & \"''\")\r\n Do While Not rstBestellungen.EOF\r\n objTreeview.Nodes.Add \"Kunde\" & rstKunden![Kunden-Code], tvwChild, \"Bestellung\" _ & rstBestellungen![Bestell-Nr], rstBestellungen![Bestell-Nr] & \"\/\" _ & rstBestellungen!Bestelldatum\r\n rstBestellungen.MoveNext\r\n Loop\r\n rstKunden.MoveNext\r\n Loop\r\n Set objNode = Nothing\r\n rst.Close\r\n Set rst = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Bild 2: Mitarbeiter und ihre Untergebenen<\/span><\/b><\/p>\n
Für das Füllen des Treeview-Steuerelements mit Daten aus einer reflexiven Beziehung ist im Prinzip Rekursion erforderlich, das heißt, dass eine Funktion sich entsprechend der Hierarchie immer wieder selbst aufruft und dabei untergeordnete Objekte abarbeitet, bis schließlich alle Daten berücksichtigt wurden.<\/p>\n
Quellcode 2 zeigt die für diesen Fall notwendigen Routinen. Die Beim Laden-Ereignisprozedur weist der Objektvariablen objTreeview das Treeview-Steuerelement des Formulars zu und ruft das erste Mal die Routine TreeviewRekursivFuellen auf. Der einzige Parameter der Routine erhält hier den Wert 0.<\/p>\n
Beim ersten Aufruf erzeugt die Routine TreeviewRekursivFuellen eine Datensatzgruppe, die alle Mitarbeiter ohne Vorgesetzten enthält. Dafür sorgt der Parameter lngPersonalNr; hat dieser den Wert 0, wird die entsprechende SELECT-Abfrage ausgeführt.<\/p>\n
Die Routine legt dann zunächst einen Knoten für den ersten Mitarbeiter an (für lngPersonalNr = 0 ohne Referenz auf bestehende Knoten) und ruft sich selbst dann mit einem anderen Wert für den Parameter lngPersonalNr auf – nämlich der Personalnummer des soeben angelegten Mitarbeiters.<\/p>\n
Quellcode 2: Füllen eines Treeview-Steuerelements mit einer rekursiven Funktion<\/b><\/p>\n
Dim objTreeview As MSComctlLib.Treeview\r\nPrivate Sub Form_Load()\r\n Set objTreeview = Me.ctlTreeview.Object\r\n TreeviewRekursivFuellen 0\r\nEnd Sub\r\nPrivate Sub TreeviewRekursivFuellen(lngPersonalNr As Long)\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim objNode As MSComctlLib.Node\r\n Set db = CurrentDb\r\n If lngPersonalNr = 0 Then\r\n Set rst = db.OpenRecordset(\"SELECT * FROM Personal WHERE [Vorgesetzte(r)] IS NULL\")\r\n Else\r\n Set rst = db.OpenRecordset(\"SELECT * FROM Personal WHERE [Vorgesetzte(r)] = \" _ & lngPersonalNr)\r\n End If\r\n Do While Not rst.EOF\r\n If lngPersonalNr = 0 Then\r\n Set objNode = objTreeview.Nodes.Add(, , \"Personal\" & rst![Personal-Nr], _ rst!Vorname & \" \" & rst!Nachname)\r\n Else\r\n Set objNode = objTreeview.Nodes.Add(\"Personal\" & lngPersonalNr, tvwChild, _ \"Personal\" & rst![Personal-Nr], rst!Vorname & \" \" & rst!Nachname)\r\n End If\r\n TreeviewRekursivFuellen rst![Personal-Nr]\r\n rst.MoveNext\r\n Loop\r\n Set objNode = Nothing\r\n rst.Close\r\n Set rst = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\nDiesmal prüft die Routine, ob es Mitarbeiter gibt, die dem Mitarbeiter mit der übergebenen Personalnummer untergeordnet sind. <\/p>\n
Ist das der Fall, werden diese ebenfalls angelegt. Dabei wird allerdings eine Referenz auf den übergeordneten Mitarbeiter-Knoten erzeugt.<\/p>\n
Anschließend wird die Routine erneut mit der aktuellen Personalnummer aufgerufen – dieser Vorgang wiederholt sich, bis es keine weiteren untergeordneten Mitarbeiter mehr gibt.<\/p>\n
In diesem Fall wird die aufrufende Instanz der Routine TreeviewRekursivFuellen weiter abgearbeitet.<\/p>\n
Das Füllen von Treeview-Steuerelementen kann je nach der Menge der anzuzeigenden Daten eine Weile dauern.<\/p>\n
Es gibt verschiedene Möglichkeiten, den Aufbau des Baumes zu beschleunigen. Bei bekannter Verschachtelungstiefe können Sie etwa folgende Variante verwenden: Die Anzeige von Kunden und Bestellungen aus dem weiter oben beschriebenen Beispiel erzeugt beispielsweise für jeden Kunden ein neues Recordset-Objekt mit den passenden Bestellungen.<\/p>\n
Dies können Sie sich sparen, indem Sie direkt alle benötigten Informationen in einer einzigen Abfrage zusammenfassen. Diese enthält im vorliegenden Fall die beiden Tabellen Kunden und Bestellungen und die in Bild 3 abgebildeten Felder, wobei diese nach den Primärschlüsselfeldern der beiden Tabellen sortiert sind.<\/p>\n
Quellcode 3: Schnellere Variante zum Füllen eines Treeviews mit Kunden und Bestellungen<\/b><\/p>\n
Private Sub Form_Load()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim objNode As MSComctlLib.Node\r\n Dim strVorherigerKunde As String\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset(\"qryKundenBestellungen\")\r\n Set objTreeview = Me.ctlTreeview.Object\r\n Do While Not rst.EOF\r\n If Not rst![Kunden-Code] = strVorherigerKunde Then\r\n Set objNode = objTreeview.Nodes.Add(, , \"Kunde\" & rst![Kunden-Code], rst!Firma)\r\n End If\r\n Set objNode = objTreeview.Nodes.Add(\"Kunde\" & rst![Kunden-Code], tvwChild, \"Bestellung\" _ & rst![Bestell-Nr], rst![Bestell-Nr] & \"\/\" & rst!Bestelldatum)\r\n strVorherigerKunde = rst![Kunden-Code]\r\n rst.MoveNext\r\n Loop\r\n Set objNode = Nothing\r\n rst.Close\r\n Set rst = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\nDie Routine aus Quellcode 3 durchläuft alle enthaltenen Datensätze. Dabei speichert sie jeweils den Kunden-Code des aktuellen Kunden in der Variablen strVorherigerKunde zwischen. Für das Folgende ist ein Blick auf Abb. 4 hilfreich.<\/p>\n
Im ersten Durchlauf ist strVorherigerKunde noch leer, also wird der Kunden-Knoten angelegt. Im gleichen Zuge wird der erste Bestellungs-Knoten angelegt – alles mit den Daten des ersten Datensatzes.<\/p>\n
Beim zweiten Datensatz stellt die Routine fest, dass der Kunden-Code dem Wert von strVorherigerKunde entspricht, und legt keinen neuen Knoten für diesen Knoten, sondern nur die im zweiten Datensatz enthaltene Bestellung an.<\/p>\n
Die beiden Beispielformulare frmKundenBestellungen und frmKundenBestellungenSchnell geben beim Anzeigen die für den Aufbau des Baumes benötigte Zeit im Direktfenster aus – werfen Sie einmal einen Blick darauf. Bei Verwendung der in der Beispieldatenbank enthaltenen Daten benötigt die zuletzt vorgestellte Variante nur die Hälfte der Zeit der langsameren Version.<\/p>\n
Nicht sichtbare Knoten nicht anlegen<\/h3>\n
Wenn der Aufbau des Baumes definitiv zu lange benötigt, könnte man auch dafür sorgen, dass nicht sichtbare oder untergeordnete Knoten erst bei Verwendung nachgeladen werden. Aus Platzgründen ist eine Vorstellung dieser Variante an dieser Stelle aber leider nicht mehr möglich.<\/p>\n
Neuzeichnen des Baumes verhindern<\/h3>\n
Ein weiteres Problem bei vielen Einträgen im Baum ist, dass das Treeview-Steuerelement sich beim Hinzufügen jedes Knotens komplett neu zeichnet, was umso mehr Zeit kostet, je länger der Baum wird.<\/p>\n
Dieses Neuzeichnen lässt sich mit einer API-Funktion verhindern (in einer Zeile):<\/p>\n
Private Declare Function LockWindowUpdate Lib \"user32.dll\" (ByVal hwndLock As Long) As Long<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Bild 3: Abfrage über alle Kunden und Bestellungen<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n