<\/p>\n
Sie kennen das sicher vom Drucken-Dialog, wo Sie einzelne Zahlen oder Zahlenbereiche angeben können, um die betroffenen Seiten zu drucken – also beispielsweise 1-2, 3-5 und so weiter. Eine solche Möglichkeit wollen wir auch für das Filtern von Datensätzen in der Datenblattansicht schaffen. Der Benutzer soll also eine oder mehrere Seitenzahlen oder Bereiche von Seiten in ein Textfeld eingeben können, nach denen dann gefiltert wird.<\/b><\/p>\n
Vorbereitung<\/b><\/p>\n
Wir benötigen ein Hauptformular, welches das Textfeld für die Eingabe der gewünschten Filterausdrücke enthält sowie ein Unterformular, das die gefilterten Datensätze anzeigt. Das Unterformular soll die Tabelle tblArtikel <\/b>als Datensatzquelle verwenden, und zwar als Abfrage formuliert, welche die Artikel aufsteigend nach dem Wert des Feldes ArtikelID <\/b>sortiert. Das Unterformular namens sfmArtikelNachBereich <\/b>enthält alle Felder der zugrundeliegenden Abfrage. Außerdem stellen wir seine Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein.<\/p>\n
Das Formular sfmArtikelNachBereich <\/b>fügen wir dann dem Hauptformular als Unterformular hinzu. Außerdem legen wir im Hauptformular ein Textfeld namens txtBereiche <\/b>an. Neben diesem Textfeld legen wir zwei Schaltflächen an – eine zum Anwenden des Filters und eine zum Zurücksetzen. Für das Hauptformular stellen wir außerdem die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n
Die beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>des Unterformular-Steuerelements erhalten den Wert Beide<\/b>, das Bezeichnungsfeld des Unterformular-Steuerelements löschen wir. Das Hauptformular sieht dann inklusive Steuerelementen und Unterformular wie in Bild 1 aus.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_01\/pic_1219_001.png\")
<\/p>\n
Bild 1: Entwurf des Formulars zum Filtern nach Zahlenbereichen<\/span><\/b><\/p>\n Anforderungen<\/b><\/p>\n Welche Filtermöglichkeiten wollen wir schaffen Hier sind die einzelnen Möglichkeiten:<\/p>\n Diese Möglichkeiten sollen auch noch kombiniert werden können, und zwar jeweils getrennt durch das Komma-Zeichen.<\/p>\n Und was auch noch nicht geklärt ist: Worauf genau sollen sich die Zahlen beziehen Dazu gibt es zwei Möglichkeiten:<\/p>\n Da wir vorher nie wissen, wie die Wünsche des Benutzers aussehen, fügen wir dazu noch eine Optionsgruppe mit den beiden Möglichkeiten hinzu.<\/p>\n So kann der Benutzer auch nach der Sortierung etwa nach dem Artikelnamen die Datensätze nach dem Index filtern lassen. Dazu fügen wir noch die Optionsgruppe ogrFilter <\/b>wie in Bild 2 zum Hauptformular hinzu.<\/p>\n Bild 2: Optionsgruppe zum Einstellen des Kriteriums zum Filtern<\/span><\/b><\/p>\n Einzelne Filterausdrücke extrahieren<\/b><\/p>\n Wir beginnen einfach und wollen zunächst alle Filterausdrücke aus dem Textfeld txtBereiche<\/b> extrahieren. Das sind also alle Teile der im Textfeld enthaltenen Zeichenkette, die durch ein Komma voneinander getrennt werden.<\/p>\n Um diese schnell zu erhalten, nutzen wir die Split<\/b>-Funktion, um aus der Zeichenkette ein String<\/b>-Array mit den einzelnen Elementen zu bilden.<\/p>\n Dieses durchlaufen wir dann in einer For…Next<\/b>-Schleife über alle Elemente. Die Indexwerte dieser Elemente ermitteln wir dabei mit den Funktionen LBound <\/b>(unterer Indexwert) und UBound <\/b>(oberer Indexwert):<\/p>\n Wenn der Benutzer nun 1,3,5 <\/b>eingibt, erhalten wir diese Ausgabe:<\/p>\n Damit lässt sich schon einmal arbeiten. Wenn wir Bereiche eingeben, erhalten wir auch die gewünschten Informationen, zum Beispiel bei -2, 4, 7-9, 75-<\/b>. Das liefert:<\/p>\n Unzulässige Zeichen erkennen<\/b><\/p>\n Bevor wir überhaupt in die Analyse der einzelnen, durch Kommata getrennten Elemente einsteigen, wollen wir direkt prüfen, ob der Ausdruck unzulässige Zeichen enthält. Dazu nutzen wir die folgende Funktion, der wir zwei Parameter übergeben:<\/p>\n Der Aufruf dieser Funktion sieht beispielsweise wie folgt aus:<\/p>\n Als Ergebnis soll eine Zeichenkette ohne nicht zulässige Zeichen zurückgeliefert werden.<\/p>\n In diesem Fall ist das führende x <\/b>ein nicht zulässiges Zeichen, also sollte der Aufruf dieses Ergebnis liefern:<\/p>\n Die Funktion sieht wie folgt aus:<\/p>\n Die Funktion erwartet die nicht zulässigen Zeichen in einer Form, wie Sie mit einem Like<\/b>-Vergleich genutzt werden kann, also in eckigen Klammern. Außerdem können Bereiche von Zeichen wie etwa die Zahlen von 0 <\/b>bis 9 <\/b>vereinfacht durch 0-9 <\/b>angegeben werden.<\/p>\n Die Funktion durchläuft alle Zeichen der zu untersuchenden Zeichenkette in einer For…Next<\/b>-Schleife, wobei jeweils ein Zeichen mit dem Like<\/b>-Operator mit den Vergleichszeichen vergleichen wird. Ist das Zeichen in den mit dem zweiten Parameter übergebenen Zeichen enthalten, wird dieses an die Zeichenkette der Variablen strTemp <\/b>angehängt. Diese wird nach dem Durchlaufen aller Zeichen an die aufrufende Instanz zurückgegeben.<\/p>\n Der Sinn dieser Funktion ist in unserem Fall, unerwünschte und gegebenenfalls versehentlich eingegebene Zeichen zu extrahieren. Diese Funktion bauen wir daher direkt in die Ereignisprozedur cmdFiltern_Click <\/b>ein:<\/p>\n Bereiche analysieren<\/b><\/p>\n Diese Bereiche analysieren wir nun. Dabei gibt es die folgenden Fälle: <\/p>\n Diese vier Fälle müssen wir zunächst erkennen. Dazu verwenden wir eine neue Funktion, die wir in der For…Next<\/b>-Schleife für jedes durch Komma getrennte Element einmal aufrufen:<\/p>\n Die Funktion sieht zunächst wie folgt aus:<\/p>\n Die Funktion ersetzt zunächst alle Leerzeichen durch leere Zeichenketten. Dann ermittelt sie in der Variablen intPos <\/b>die Position des Minuszeichens (–<\/b>). Im Falle von 0 <\/b>ist kein Minuszeichen vorhanden, was wir aktuell einfach im Direktbereich vermerken. Lautet der Wert von intPos <\/b>hingegen 1<\/b>, befindet sich das Minuszeichen an der ersten Stelle, was auf einen Ausdruck wie -3 <\/b>hindeutet. In allen anderen Fällen ist eine weitere Untersuchung nötig, die wir im Else<\/b>-Zweig der Select Case<\/b>-Bedingung prüfen. Hier prüfen wir, ob intPos <\/b>gleich der Anzahl der Zeichen der übergebenen Zeichenkette entspricht, was bedeuten würde, dass sich das Minus-Zeichen an der letzten Stelle befindet. In allen anderen Fällen befindet sich das Minuszeichen nicht an erster und nicht an letzter Stelle, der Ausdruck sollte also wie 1-3 lauten.<\/p>\n <\/p>\n Vergleichsausdrücke ermitteln<\/b><\/p>\n Nun reichern wir die obige Prozedur um die resultierenden Vergleichsausdrücke an. Dabei betrachten wir zunächst nur den Fall, dass wir das ID<\/b>-Feld als Vergleichsfeld nutzen wollen und nicht den Index der angezeigten Elemente – der ist nämlich noch etwas komplizierter zu handhaben.<\/p>\n Die neue Version der Prozedur finden Sie in Listing 1. Die Prozedur erwartet nun mit dem ersten Parameter auch noch den Namen des Feldes, das als Vergleichsfeld verwendet werden soll. Im Vergleichswert entfernen wir die Leerzeichen und ermitteln dann die Position eines gegebenenfalls enthaltenen Minuszeichens.<\/p>\n Listing 1: Ermittlung der Vergleichsausdrücke<\/span><\/b><\/p>\n Im ersten Case<\/b>-Zweig der Select Case<\/b>-Bedingung tragen wir für die Variable strVergleichsausdruck <\/b>den Namen des Vergleichsfeldes, ein Gleichheitszeichen und den Vergleichswert ein, und zwar in der Form Der Case<\/b>-Zweig, der davon ausgeht, dass das Minuszeichen gleich das erste Zeichen ist, fügt den Namen des Vergleichsfelds mit dem Vergleichsoperator <= <\/b>und dem Teil aus strVergleichswert <\/b>zusammen, der nach dem Minuszeichen folgt, also in der Form Im If<\/b>-Teil der If…Then<\/b>-Bedingung des Else<\/b>-Zweigs der Select Case<\/b>-Bedingung, der davon ausgeht, dass sich das Minuszeichen am Ende von strVergleichswert <\/b>befindet, fügen wir in strVergleichsausdruck <\/b>den Wert aus strVergleichsfeld<\/b>, den Vergleichsoperator >= <\/b>und den Inhalt aus strVergleichswert <\/b>bis zum Minuszeichen zusammen. Der Ausdruck lautet dann Schließlich folgt noch der Else<\/b>-Teil der If…Then<\/b>-Bedingung aus dem Else<\/b>-Teil der Select Case<\/b>-Bedingung. Dieser nimmt an, dass das Minuszeichen sich zwischen zwei Zahlenwerten befindet. Hier soll der Vergleichsausdruck später ( Der in strVergleichsausdruck <\/b>enthaltene Vergleichsausdruck wird dann als Funktionsergebnis an die aufrufende Routine zurückgegeben.<\/p>\n In der For…Next<\/b>-Schleife der aufrufenden Prozedur, die nun wie in Listing 2 aussieht, stellen wir nun in der Variablen strFilterkriterium <\/b>die einzelnen Kriterienausdrücke zusammen. Dabei stellen wir jedem Ausdruck zunächst den OR<\/b>-Operator voran.<\/p>\n Listing 2: Setzen des Filters<\/span><\/b><\/p>\n Für unseren weiter oben vorgestellten Ausdruck -2, 4, 7-9, 75- <\/b>enhält strFilterkriterium <\/b>beim ersten Aufruf also folgenden Ausdruck:<\/p>\n In den folgenden Durchläufen wird der Ausdruck dann zu folgendem Ausdruck ergänzt:<\/p>\n Die folgende If…Then<\/b>-Bedingung prüft dann, ob strFilterkriterium <\/b>eine Zeichenkette mit einer Länge größer 0 <\/b>enthält. Ist das der Fall, schneidet die Prozedur zunächst das führende OR <\/b>ab, sodass dieser Ausdruck übrigbleibt:<\/p>\n Diesen Ausdruck weisen wir dann der Eigenschaft Filter <\/b>des Formulars im Unterformular-Steuerelement zu und aktivieren den Filter, indem wir die Eigenschaft FilterOn <\/b>auf True <\/b>einstellen.<\/p>\n Wenn strFilterkriterium <\/b>hingegen eine leere Zeichenkette enthält, führt die Prozedur den Else<\/b>-Teil der If…Then<\/b>-Bedingung aus, welcher die Eigenschaft Filter <\/b>auf eine leere Zeichenkette einstellt und somit den Filter zurücksetzt.<\/p>\n Das Ergebnis sieht nun wie in Bild 3 aus und entspricht genau den Erwartungen.<\/p>\n Bild 3: Erster Test der Filterfunktion<\/span><\/b><\/p>\n Filtern nach Index<\/b><\/p>\n Das Filtern nach dem Index ist noch ein wenig komplizierter, da wir für jedes angezeigte Element über den Index erst den Primärschlüsselwert ermitteln und dann nach diesem filtern müssen.<\/p>\n Als Erstes erweitern wir die Ereignisprozedur, die durch das Anklicken der Schaltfläche cmdFiltern <\/b>ausgelöst wird. Innerhalb der For…Next<\/b>-Schleife, die alle Elemente des Arrays strVergleichswerte <\/b>durchläuft, fügen wir nun noch eine If…Then<\/b>-Bedingung hinzu, die prüft, ob die Optionsgruppe ogrFilter <\/b>den Wert 1 <\/b>(ID<\/b>) oder 2 <\/b>(Index<\/b>) aufweist.<\/p>\n Im Fall des Wertes 1 <\/b>behalten wir den bisherigen Aufruf der Funktion FilterkriteriumErmitteln <\/b>bei, den wir auch weiter oben bereits beschrieben haben. <\/p>\n Anderenfalls rufen wir eine neue Funktion namens FilterkriteriumErmittelnIndex <\/b>auf, der wir das Recordset des Unterformulars als ersten Parameter übergeben. Als zweiten und dritten Parameter übergeben wir die gleichen Werte, die wir auch bisher schon übergeben haben – also den Namen des Primärschlüsselfeldes und den aktuellen Wert des Arrays strVergleichswerte<\/b> (siehe Listing 3).<\/p>\n Listing 3: Erweiterte Version der Prozedur, die beim Filtern ausgelöst wird<\/span><\/b><\/p>\n Die Funktion FilterkriteriumErmittelnIndex <\/b>finden Sie in Listing 4. Sie entfernt wieder die Leerzeichen aus dem übergebenen Vergleichswert, der genauso aufgebaut sein kann wie die Vergleichswerte, die wir für das Filtern nach dem Primärschlüsselwerten (ID<\/b>) weiter oben verwendet haben – also beispielsweise -2, 4, 7-9, 75-<\/b>. Der Unterschied ist nun, dass wir die Werte und Bereiche nicht auf den Primärschlüsselwert anwenden, sondern auf den Index der Einträge im Datenblatt. Ein weiterer Vorteil ist, dass die Funktion die aktuelle Sortierung berücksichtigt. Wenn Sie also beispielsweise vorher nach dem Artikelnamen sortieren statt nach dem Primärschlüsselwert, verwendet die Funktion den aktuellen Index mit Sortierung nach dem Artikelnamen.<\/p>\n\n
\n
![\"Optionsgruppe](\"..\/fileadmin\/_temp_\/2020_01\/pic_1219_002.png\")
<\/p>\nPrivate Sub <\/span>cmdFiltern_Click()\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>strBereiche As String<\/span>\r\n Dim <\/span>strVergleichswerte() As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n strBereiche = Nz(Me!txtBereiche, \"\")\r\n strVergleichswerte = Split<\/span>(strBereiche, \",\")\r\n For i = LBound<\/span>(strVergleichswerte) To UBound<\/span>(strVergleichswerte)\r\n Debug.Print<\/span> strVergleichswerte(i)\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n1\r\n3\r\n5<\/pre>\n
-2\r\n4\r\n7-9\r\n75-<\/pre>\n
\n
NurZulaessigeZeichen(\"x-2, 4, 7-9, 75-\", \"[0-9,-]\")<\/pre>\n
-2, 4, 7-9, 75-<\/pre>\n
Public Function <\/span>NurZulaessigeZeichen(strText As String<\/span>, strZeichen As String<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n For i = 1 To Len<\/span>(strText)\r\n If <\/span>Mid<\/span>(strText, i, 1) Like strZeichen Then<\/span>\r\n strTemp = strTemp & Mid<\/span>(strText, i, 1)\r\n End If<\/span>\r\n Next<\/span> i\r\n NurZulaessigeZeichen = strTemp\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>cmdFiltern_Click()\r\n ...\r\n strBereiche = Nz(Me!txtBereiche, \"\")\r\n strBereiche = NurZulaessigeZeichen(strBereiche, \"[,-0-9]\")\r\n ...\r\nEnd Sub<\/span><\/pre>\n\n
For i = LBound<\/span>(strVergleichswerte) To UBound<\/span>(strVergleichswerte)\r\n Debug.Print<\/span> strVergleichswerte(i)\r\n FilterkriteriumErmitteln strVergleichswerte(i)\r\nNext<\/span> i<\/pre>\nPrivate Function <\/span>FilterkriteriumErmitteln(ByVal strVergleichswert As String<\/span>)\r\n Dim <\/span>intPos As Integer<\/span>\r\n strVergleichswert = Replace<\/span>(strVergleichswert, \" \", \"\")\r\n intPos = InStr<\/span>(1, strVergleichswert, \"-\")\r\n Select Case intPos\r\n Case <\/span>0\r\n Debug.Print<\/span> \"kein Minus\"\r\n Case <\/span>1\r\n Debug.Print<\/span> \"Minus an erster Stelle\"\r\n Case Else<\/span>\r\n If <\/span>intPos = Len<\/span>(strVergleichswert) Then<\/span>\r\n Debug.Print<\/span> \"Minus an letzter Stelle\"\r\n Else<\/span>\r\n Debug.Print<\/span> \"Minus dazwischen\"\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>FilterkriteriumErmitteln(strVergleichsfeld As String<\/span>, ByVal strVergleichswert As String<\/span>)\r\n Dim <\/span>intPos As String<\/span>\r\n Dim <\/span>strVergleichsausdruck As String<\/span>\r\n strVergleichswert = Replace<\/span>(strVergleichswert, \" \", \"\")\r\n intPos = InStr<\/span>(1, strVergleichswert, \"-\")\r\n Select Case intPos\r\n Case <\/span>0\r\n strVergleichsausdruck = strVergleichsfeld & \" = \" & strVergleichswert\r\n Case <\/span>1\r\n strVergleichsausdruck = strVergleichsfeld & \" <= \" & Mid<\/span>(strVergleichswert, intPos + 1)\r\n Case Else<\/span>\r\n If <\/span>intPos = Len<\/span>(strVergleichswert) Then<\/span>\r\n strVergleichsausdruck = strVergleichsfeld & \" >= \" & Mid<\/span>(strVergleichswert, 1, intPos - 1)\r\n Else<\/span>\r\n strVergleichsausdruck = \"(\" & strVergleichsfeld & \" >= \" & Mid<\/span>(strVergleichswert, 1, intPos - 1) _\r\n & \" AND \" & strVergleichsfeld & \" <= \" & Mid<\/span>(strVergleichswert, intPos + 1) & \")\"\r\n End If<\/span>\r\n End Select<\/span>\r\n FilterkriteriumErmitteln = strVergleichsausdruck\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>cmdFiltern_Click()\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>strBereiche As String<\/span>\r\n Dim <\/span>strVergleichswerte() As String<\/span>\r\n Dim <\/span>strFilterkriterium As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n strBereiche = Nz(Me!txtBereiche, \"\")\r\n strBereiche = NurZulaessigeZeichen(strBereiche, \"[0-9,-]\")\r\n strVergleichswerte = Split<\/span>(strBereiche, \",\")\r\n For i = LBound<\/span>(strVergleichswerte) To UBound<\/span>(strVergleichswerte)\r\n strFilterkriterium = strFilterkriterium & \" OR \" & FilterkriteriumErmitteln(\"ArtikelID\", strVergleichswerte(i))\r\n Next<\/span> i\r\n If <\/span>Len<\/span>(strFilterkriterium) > 0 Then<\/span>\r\n strFilterkriterium = Mid<\/span>(strFilterkriterium, 5)\r\n With<\/span> Me!sfmArtikelNachBereich.Form\r\n .Filter = strFilterkriterium\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\n Else<\/span>\r\n Me!sfmArtikelNachBereich.Form.Filter = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n OR ArtikelID <= 2<\/pre>\n
OR ArtikelID <= 2 OR ArtikelID = 4 OR (ArtikelID >= 7 AND ArtikelID <= 9) OR ArtikelID >= 75<\/pre>\n
ArtikelID <= 2 OR ArtikelID = 4 OR (ArtikelID >= 7 AND ArtikelID <= 9) OR ArtikelID >= 75<\/pre>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2020_01\/pic_1219_003.png\")
<\/p>\nPrivate Sub <\/span>cmdFiltern_Click()\r\n ...\r\n For i = LBound<\/span>(strVergleichswerte) To UBound<\/span>(strVergleichswerte)\r\n If <\/span>Me!ogrFilter = 1 Then<\/span>\r\n strFilterkriterium = strFilterkriterium & \" OR \" & FilterkriteriumErmitteln(\"ArtikelID\", _\r\n strVergleichswerte(i))\r\n Else<\/span>\r\n strFilterkriterium = strFilterkriterium & \" OR \" & FilterkriteriumErmittelnIndex( _\r\n Me!sfmArtikelNachBereich.Form.Recordset, \"ArtikelID\", strVergleichswerte(i))\r\n End If<\/span>\r\n Next<\/span> i\r\n ...\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>FilterkriteriumErmittelnIndex(rst As <\/span>DAO.Recordset, strVergleichsfeld As String<\/span>, _\r\n ByVal strVergleichswert As String<\/span>)\r\n Dim <\/span>intPos As Integer<\/span>\r\n Dim <\/span>strVergleichsausdruck As String<\/span>\r\n Dim <\/span>l As Long<\/span>\r\n Dim <\/span>strIN As String<\/span>\r\n Dim <\/span>lngMax As Long<\/span>\r\n strVergleichswert =