<\/p>\n
Ein Kombinationsfeld soll zur schnellen Auswahl von Daten dienen. Wenn es aber sehr viele Daten enthält, stoßen Sie einerseits an die maximal mögliche Anzahl anzuzeigender Daten, zweitens geht die Performance beim Laden der Daten in die Knie. Wir haben ein Beispiel mit sehr vielen Datensätzen erstellt und zeigen Ihnen in diesem Beitrag, wie Sie mit den Begrenzungen umgehen und dem Benutzer dennoch ein ergonomisches Arbeiten ermöglichen.<\/b><\/p>\n
Da nicht jeder Entwickler eine Tabelle mit um die 100.000 Datensätzen zur Verfügung hat, um damit die Grenzen eines Kombinationsfeldes auszuloten und passende Lösungen für solche Fälle zu finden, erstellen wir uns auf die Schnelle eine neue Tabelle mit der entsprechenden Menge Datensätze.<\/p>\n
Die Tabelle heißt tblBeispieldaten <\/b>und sieht im Entwurf wie in Bild 1 aus.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_001.png\")
<\/p>\n
Bild 1: Die Tabelle mit den Beispieldaten in der Entwurfsansicht<\/span><\/b><\/p>\n Nach dem Hinzufügen der Beispieldaten sieht die Tabelle in der Datenblattansicht wie in Bild 2 aus. Wir haben erst einmal 100.000 Datensätze hinzugefügt, um etwas Beispielmaterial zu haben. Aber wie haben wir das erledigt Mit einer kleinen Prozedur, die sich einiger Hilfsfunktionen zum Erstellen von GUIDs bedient und so die entsprechenden Werte zum Einfügen in das Feld Beispielwert ermittelt hat.<\/p>\n Bild 2: Die Tabelle mit den Beispieldaten<\/span><\/b><\/p>\n Diese Prozedur finden Sie in Listing 1. Sie durchläuft eine Schleife mit Werten von 1 bis 100.000 und erzeugt bei jedem Durchlauf eine neue GUID mit der Funktion CreateGUID <\/b>(siehe Modul mdlTools<\/b>). Die folgende Anweisung legt jeweils einen neuen Datensatz mit der frisch ermittelten GUID in der Tabelle tblBeispieldaten <\/b>an. Und das dauerte noch nicht einmal besonders lang – gerade mal eine gute Minute.<\/p>\n Listing 1: Diese Prozedur legt schnell 100.000 verschiedene Datensätze in einer Tabelle an.<\/span><\/b><\/p>\n Kombinationsfeld anlegen<\/b><\/p>\n Im ersten Versuch soll das Kombinationsfeld zunächst ohne Rücksicht alle Datensätze der Tabelle anzeigen. Dazu fügen Sie einem neuen, leeren Formular ein Kombinationsfeld namens cboBeispielwerte <\/b>hinzu. Stellen Sie die Eigenschaft Datensatzherkunft <\/b>auf den Wert tblBeispieldaten <\/b>ein (s. Bild 3).<\/p>\n Bild 3: Das Kombinationsfeld zum Ausprobieren in der Entwurfsansicht<\/span><\/b><\/p>\n Klicken Sie dann auf die Schaltfläche mit den drei Punkten, um den Abfrage-Generator zu öffnen. Wir benötigen zwar die Daten der Tabelle tblBeispieldaten<\/b>, aber wir wollen diese noch nach dem Inhalt des Feldes Beispielwert <\/b>in aufsteigender Reihenfolge sortieren. Dazu passen Sie die Datensatzherkunft wie in Bild 4 an.<\/p>\n Bild 4: Die Datensatzherkunft des Kombinationsfeldes<\/span><\/b><\/p>\n Da die Datensatzherkunft nun aus dem Primärschlüsselfeld und dem Feld mit den anzuzeigenden Daten besteht, stellen wir noch die beiden Eigenschaften Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>ein. Auf diese Weise wird nur der Wert des Feldes Beispielwert <\/b>angezeigt, gleichzeitig können wir aber den Primärschlüsselwert des Kombinationsfeldes auslesen.<\/p>\n In der Formularansicht zeigt das Kombinationsfeld nun die Einträge der Datensatzherkunft an (s. Bild 5).<\/p>\n Bild 5: Kombinationsfeld mit Daten<\/span><\/b><\/p>\n Aber wie viele Datensätze zeigt es an Dass es nicht alle Datensätze der Datensatzherkunft sind, können wir leicht ermitteln, indem wir im Kombinationsfeld mit der Bildlaufleiste nach ganz unten scrollen. Aber aufgepasst: Wenn Sie den Balken im ersten Anlauf ganz nach unten ziehen, springt es kurz darauf wieder weiter nach oben. Sie können den Balken noch mehrmals bis ganz nach unten ziehen – es dauert eine Weile, bis das Kombinationsfeld alle Datensätze erfasst hat und tatsächlich bis ganz nach unten springt.<\/p>\n Dies gelingt wesentlich schneller, wenn Sie das Kombinationsfeld aufklappen (beispielsweise mit der Taste F4<\/b>) und dann die Tastenkombination Strg + Ende <\/b>betätigen.<\/p>\n In unserem Beispiel landen wir dann zwar ganz unten (weiter runter geht es nicht), aber wir treffen dort sicher nicht den letzten Datensatz an – dieser müsste eigentlich mit dem Buchstaben F <\/b>beginnen.<\/p>\n Stattdessen sind wir aber noch nicht einmal über die Zahl 5 hinaus (s. Bild 6). Dabei sei angemerkt, dass die Tabelle nach einem Test nun 200.000 Datensätze enthält.<\/p>\n Bild 6: Der letzte angezeigte Datensatz im Kombinationsfeld<\/span><\/b><\/p>\n Um herauszufinden, wie viele Datensätze das Kombinationsfeld enthält, verwenden wir die Eigenschaft ListCount <\/b>des Kombinationsfeldes.<\/p>\n Wenn Sie, wie ich, auch keine Lust haben, solch lange Ausdrücke einzugeben, können Sie das Kombinationsfeld auch direkter referenzieren – Sie müssen lediglich sicherstellen, dass es im aktuellen Access-Fenster den Fokus hat:<\/p>\n <\/p>\n Und siehe da – wir finden genau 65.536 Datensätze vor, also 2 hoch 16. Nun haben wir ein Problem: Dank der Begrenzung kann der Benutzer die Datensätze im hinteren Bereich der Datensatzherkunft überhaupt nicht auswählen, denn diese sind schlicht nicht im Kombinationsfeld enthalten.<\/p>\n Datensatzherkunft nach Wortanfang<\/b><\/p>\n Doch natürlich bemühen wir uns, auch für dieses Problem eine Lösung zu finden. Diese sieht so aus, dass wir den Benutzer auffordern, ein oder mehrere Zeichen einzutippen, mit denen der gesuchte Ausdruck beginnt (s. Bild 7).<\/p>\n Bild 7: Nach Eingabe einiger Zeichen zeigt das Kombinationsfeld die Liste ab dem ersten möglichen Wert an.<\/span><\/b><\/p>\n Das ist eigentlich sogar das Standardverhalten eines Kombinationsfeldes, zumindest, wenn die Eigenschaft Automatisch ergänzen <\/b>auf den Wert Ja <\/b>eingestellt ist. So zeigt das Kombinationsfeld automatisch den richtigen Eintrag an, wenn der Benutzer etwa die Zeichenfolge 1234 <\/b>eingibt.<\/p>\n Das ändert allerdings nichts an der Tatsache, dass das Kombinationsfeld aktuell noch nicht alle Einträge der Datensatzherkunft anzeigt. Also müssen wir wohl per VBA nachhelfen und jeweils die Datensätze anzeigen, die der aktuell in das Kombinationsfeld eingetragenen Zeichenkette entsprechen.<\/p>\n Daten dynamisch laden<\/b><\/p>\n Wir wollen also nun einen Weg finden, die Daten möglichst effizient zu laden – und zwar alle Daten, die der Benutzer anfragt. Das heißt, dass wir auf die Eingabe eines ersten Zeichens durch den Benutzer reagieren und alle Datensätze laden, die mit diesem Zeichen beginnen. <\/p>\n Die passende Ereignisprozedur zum Abfangen der Eingaben des Benutzers heißt cboBeispielwerte_Change <\/b>und wird für die Ereignisprozedur Bei änderung <\/b>hinterlegt. Unser erster Versucht sieht wie in Listing 2 aus. Die Prozedur ermittelt den aktuellen Text des Kombinationsfeldes und speichert diesen in der Variablen strSuche<\/b>. Diese wird beim anschließenden Zusammensetzen der aktualisierten Datensatzherkunft als Vergleichswert für das Feld Beispielwert <\/b>herangezogen. Dabei ergänzen wir den Wert aus strSuche <\/b>noch um das Sternchen (*) als Platzhalter. Auf diese Weise liest das Kombinationsfeld alle Datensätze ein, die mit dem eingegebenen Buchstaben beginnen.<\/p>\n Listing 2: Aktualisieren der Datensatzherkunft bei Eingabe eines Zeichens<\/span><\/b><\/p>\n Schließlich sorgt die abschließende Anweisung mit der DropDown<\/b>-Methode noch dafür, dass das Kombinationsfeld aufgeklappt wird.<\/p>\n Der Wechsel in die Formularansicht und die Eingabe des ersten Zeichens liefern allerdings nicht das gewünschte Ergebnis: Die Autovervollständigung ergänzt den Inhalt des Kombinationsfeldes nämlich direkt um den Rest des ersten gefundenen Treffers (s. Bild 8). <\/p>\n Bild 8: Der Filter funktioniert – aber anders, als erwartet.<\/span><\/b><\/p>\n Schauen wir uns doch an, was hier geschieht – und zwar, indem wir der Prozedur die folgende Zeile hinzufügen:<\/p>\n Damit geben wir den verwendeten Suchbegriff aus. Und zu unserer überraschung führt die Eingabe des Buchstabens A <\/b>nicht zum Suchbegriff A<\/b>, sondern zum Suchbegriff a0000307-B136-4163-9030-6C79D9787003<\/b>. Das Kombinationsfeld löst also erst die Autovervollständigung aus und aktualisiert dann die Datensatzherkunft.<\/p>\n Was aber geschieht, wenn wir die Eigenschaft Automatisch vervollständigen <\/b>an dieser Stelle auf den Wert Nein <\/b>einstellen Dies liefert im ersten Schritt das gewünschte Ergebnis, das Kombinationsfeld wird nämlich nun mit den passenden Treffern gefüllt und zeigt diese auch an. Wenn wir dann allerdings etwa mit der Nach unten<\/b>-Taste nach unten scrollen, übernimmt das Kombinationsfeld das erste Element und löst wiederum das Ereignis Bei änderung <\/b>aus – wodurch wieder nur ein passender Eintrag angezeigt wird.<\/p>\n Ansatz mit nicht markiertem Bereich<\/b><\/p>\n Also müssen wir uns einen anderen Ansatz ausdenken, wobei wir wieder zu der Variante mit der automatischen Vervollständigung zurückkehren. Dabei nutzen wir die Tatsache, dass das Kombinationsfeld automatisch, noch vor dem Auslösen des Ereignisses Bei änderung<\/b>, den aktuellen Text im Kombinationsfeld aktualisiert. Dies geschieht so, dass die vom Benutzer eingegebenen Zeichen nicht markiert sind, der Rest hingegen wird markiert dargestellt.<\/p>\n Praktischerweise können wir die erste Position der Markierung per VBA ermitteln, und zwar über die Eigenschaft SelStart <\/b>des jeweiligen Steuerelements. Wir ändern die Prozedur cboBeispielwerte_Change <\/b>also, indem wir eingangs die Position des Beginns der Markierung ermitteln (s. Listing 3). Damit können wir nun die Zeichen einlesen, die sich vor dem markierten Bereich befinden und die folglich der Benutzer eingegeben hat. Dazu nutzen wir die Left<\/b>-Zeichenkettenfunktion, welche alle Zeichen bis zu der in intPosStart <\/b>gespeicherten Position zurückliefert.<\/p>\n Listing 3: Erweiterte Prozedur zum Filtern des Kombinationsfeldes<\/span><\/b><\/p>\n Mit dem nun in der Variablen strSuche <\/b>gespeicherten Vergleichswert findet die Prozedur die gewünschten Werte für die Datensatzherkunft des Kombinationsfeldes (s. Bild 9).<\/p>\n Bild 9: Korrekte Ermittlung der Datensatzherkunft des Kombinationsfeldes<\/span><\/b><\/p>\n Allerdings bleiben noch zwei Probleme: Erstens ist das Aktualisieren der Datensatzherkunft noch recht langsam, wenn man nur den ersten Buchstaben eingegeben hat, was ja noch recht viele Treffer liefert. Zweitens klappt das Auswählen eines der gefundenen Einträge noch immer nicht – allerdings schlägt es nun auf eine andere Art fehl als zuvor: Das Kombinationsfeld trägt den Eintrag, den man ausgewählt hat, nämlich gleich oben als Text des Kombinationsfeldes ein und markiert den vollständigen Text. Die Ereignisprozedur, die wir gerade erst geändert haben, damit sie die zu den vom Benutzer eingegebenen, nicht markierten Zeichen passenden Einträge liefert, arbeitet hier zwar richtig, aber nicht wie gewünscht: Durch die vollständige Markierung bleibt strSuche<\/b> leer und das Kombinationsfeld zeigt wieder die ersten 65.536 Datensätze an.<\/p>\n Auswahl optimieren<\/p>\n Optimal wäre es also, wenn die Prozedur cboBeispielwerte_Change <\/b>einfach nicht ausgelöst würde, wenn der Benutzer mit der Nach unten<\/b>-Taste zur Auswahl eines der angezeigten Einträge schreitet – oder wenn der Teil der Prozedur, der für die Aktualisierung der Datensatzherkunft verantwortlich ist, nicht ausgeführt würde.<\/p>\n Wie aber können wir erkennen, ob der Benutzer die Nach unten-Taste verwendet hat Leider gibt das Kombinationsfeld keine Eigenschaft her, welche den aktuell in der Auswahl markierten Eintrag ausgibt. Was sonst ändert sich also, was wir als Indikator dafür erfassen können, dass der Benutzer von der Eingabe der Startzeichen des gesuchten Eintrags zur Auswahl in der Liste übergegangen ist Ganz einfach: In diesem Moment wird nämlich der komplette ausgewählte Eintrag oben im Textteil des Kombinationsfelds angezeigt – s. Bild 10.<\/p>\n Bild 10: Nach der Auswahl eines Eintrags wird dieser im Textbereich des Kombinationsfeldes angezeigt und komplett markiert.<\/span><\/b><\/p>\n Wir brauchen in der Prozedur also nur zu prüfen, ob die Markierung gegebenenfalls bereits beim ersten Zeichen beginnt. Dazu fügen wir der Prozedur eine If…Then<\/b>-Bedingung hinzu, die nur dann die enthaltenen Anweisungen ausführt, wenn intPosStart<\/b> größer als 0 <\/b>ist. Anderenfalls geschieht nichts und der Benutzer kann in Ruhe den gewünschten Eintrag auswählen (s. Listing 4).<\/p>\n Listing 4: Diese Version aktualisiert die Datensatzherkunft nur, wenn der Benutzer gerade ein Zeichen eingegeben hat.<\/span><\/b><\/p>\n Performance verbessern<\/b><\/p>\n Fehlt nur noch eine Möglichkeit, die doch zahlreichen Einträge bei Eingabe des ersten Zeichens in das Kombinationsfeld zu reduzieren. Die Variante aus Listing 5 lädt zunächst 16 Elemente. Wenn der Benutzer dann einen Eintrag markiert, der sieben oder weniger Stellen von der aktuell geladenen Anzahl entfernt ist, lädt die Prozedur 16 Elemente nach. Leider springt die Markierung dabei etwas hin und her, sodass hier letztlich noch Potenzial für weitere Verbesserungen bleibt.<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_002.png\")
<\/p>\nPublic Sub <\/span>BeispieltabelleFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>l As Long<\/span>\r\n Dim <\/span>strBeispielwert As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n For l = 1 To 100000\r\n strBeispielwert = Mid<\/span>(CreateGUID, 2, 36)\r\n db.Execute \"INSERT INTO tblBeispieldaten(Beispielwert) VALUES(''\" _\r\n & strBeispielwert & \"'')\", dbFailOnError\r\n Next<\/span> l\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_003.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_004.png\")
<\/p>\n![\"Kombinationsfeld](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_005.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_006.png\")
<\/p>\nDebug.Print<\/span> Forms! frmKombinationsfeldMitVielenDaten! cboBeispielwerte.ListCount\r\n 65536 <\/pre>\nDebug.Print<\/span> Screen.ActiveControl.ListCount\r\n 65536 <\/pre>\n![\"Nach](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_007.png\")
<\/p>\nPrivate Sub <\/span>cboBeispielwerte_Change()\r\n Dim <\/span>strSuche As String<\/span>\r\n strSuche = Me!cboBeispielwerte.Text\r\n Me!cboBeispielwerte.RowSource = _\r\n \"SELECT * FROM tblBeispieldaten WHERE Beispielwert LIKE ''\" & strSuche _\r\n & \"*'' ORDER BY Beispielwert\"\r\n Me!cboBeispielwerte.Dropdown\r\nEnd Sub<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_008.png\")
<\/p>\nDebug.Print<\/span> strSuche<\/pre>\nPrivate Sub <\/span>cboBeispielwerte_Change()\r\n Dim <\/span>strSuche As String<\/span>\r\n Dim <\/span>intPosStart As Integer<\/span>\r\n intPosStart = Me!cboBeispielwerte.SelStart\r\n strSuche = Left<\/span>(Me!cboBeispielwerte.Text, intPosStart)\r\n Me!cboBeispielwerte.RowSource = _\r\n \"SELECT * FROM tblBeispieldaten WHERE Beispielwert LIKE ''\" & strSuche _\r\n & \"*'' ORDER BY Beispielwert\"\r\n Me!cboBeispielwerte.Dropdown\r\nEnd Sub<\/span><\/pre>\n![\"Korrekte](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_009.png\")
<\/p>\n![\"Nach](\"..\/fileadmin\/_temp_\/2014_06\/pic_959_010.png\")
<\/p>\nPrivate Sub <\/span>cboBeispielwerte_Change()\r\n Dim <\/span>strSuche As String<\/span>\r\n Dim <\/span>intPosStart As Integer<\/span>\r\n intPosStart = Me!cboBeispielwerte.SelStart\r\n If <\/span>intPosStart > 0 Then<\/span>\r\n strSuche = Left<\/span>(Me!cboBeispielwerte.Text, intPosStart)\r\n Me!cboBeispielwerte.RowSource = _\r\n \"SELECT * FROM tblBeispieldaten WHERE Beispielwert LIKE ''\" & strSuche _\r\n & \"*'' ORDER BY Beispielwert\"\r\n Me!cboBeispielwerte.Dropdown\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>lngGeladen As Long<\/span>\r\nDim <\/span>strSuche As String<\/span>\r\nConst cIntAnzahl As Integer<\/span> = 16\r\nPrivate Sub <\/span>cboBeispielwerte_Change()\r\n Dim <\/span>intPosStart As Integer<\/span>\r\n intPosStart = Me!cboBeispielwerte.SelStart\r\n If <\/span>intPosStart > 0 Then<\/span>\r\n lngGeladen = cIntAnzahl\r\n strSuche = Left<\/span>(Me!cboBeispielwerte.Text, intPosStart)\r\n Me!cboBeispielwerte.RowSource = \"SELECT TOP \" & lngGeladen _\r\n & \" * FROM tblBeispieldaten WHERE Beispielwert LIKE ''\" _\r\n & strSuche & \"*'' ORDER BY Beispielwert\"\r\n lngGeladen = Me!cboBeispielwerte.ListCount\r\n Me!cboBeispielwerte.Dropdown\r\n End If<\/span>\r\n If <\/span>Me!cboBeispielwerte.ListIndex > lngGeladen - 7 Then<\/span>\r\n lngGeladen = lngGeladen + cIntAnzahl\r\n Me!cboBeispielwerte.RowSource = \"SELECT TOP \" & lngGeladen _\r\n & \" * FROM tblBeispieldaten WHERE Beispielwert LIKE ''\" _\r\n & strSuche & \"*'' ORDER BY Beispielwert\"\r\n Me!cboBeispielwerte.Dropdown\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n