<\/p>\n
Access liefert zwar eine hilfreiche Suchfunktion, mit der Sie die in der Datenblattansicht angezeigte Daten sortieren oder filtern können, aber wirklich übersichtlich und intuitiv ist diese nicht. Also legen wir selbst Hand an und bauen uns ein eigenes Suchformular, dass die verschiedenen Steuerelementtypen der Datenblattansicht berücksichtig und dieses gleich entsprechend der definierten Suche filtert.<\/b><\/p>\n
Als Beispiel für unsere Lösung dient die Artikel-Tabelle der Südsturm-Datenbank – unsere optimierte Nordwind-Datenbank aus dem Beitrag Südsturm, die bessere Beispieldatenbank <\/b>(www.access-im-unternehmen.de\/411<\/b>). Diese Tabelle enthält die drei möglichen Steuerelementtypen, die üblicherweise in der Datenblattansicht von Formularen dargestellt werden, nämlich Textfelder, Kombinationsfelder und Kontrollkästchen.<\/p>\n
Die Konfiguration für die Anzeige von Daten in der Datenblattansicht sieht üblicherweise so aus, dass es ein Hauptformular gibt, dass einige Steuerelemente wie beispielsweise eine Suchen-Schaltfläche und ein Unterformular mit den eigentlichen Daten enthält. Dies ist allein der Tatsache geschuldet, dass Formulare in der Datenblattansicht keinen Kopf- oder Fußbereich anzeigen, in dem man weitere Steuerelemente unterbringen könnte. Das in diesem Beitrag demonstrierte Beispiel sieht wie in Bild 1 aus.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_03\/Suchformulare-web-images\/pic001.png\")
<\/p>\n
Bild 1: Beispiel für das Durchsuchen eines Datenblatts mit einem zusätzlichen Suchformular<\/span><\/b><\/p>\n Unser Suchformular soll folgende Voraussetzungen erfüllen:<\/p>\n Anzeige der Daten in der Datenblattansicht<\/b><\/p>\n Das Formular frmArtikel <\/b>enthält die Schaltfläche cmdSuchen <\/b>und das Unterformularsteuerelement sfm<\/b>. Die Eigenschaften Datenherkunft <\/b>und Standardansicht <\/b>des Unterformular sfmArtikel <\/b>stellen Sie auf tblArtikel <\/b>und Datenblatt <\/b>ein.<\/p>\n Außerdem ziehen Sie alle gewünschten Felder ( in der Beispieldatenbank alle) in den Detailbereich des Formularentwurfs.<\/p>\n Einbinden des Unterformulars in das Hauptformular<\/p>\n Wenn Sie dem Hauptformular bereits ein Unterformularsteuerelement hinzugefügt haben, brauchen Sie nur noch dessen Eigenschaft Herkunftsobjekt <\/b>auf sfmArtikel <\/b>einzustellen. Im Entwurf sieht der aktuelle Stand nun wie in Bild 2 aus.<\/p>\n Bild 2: Entwurf von Haupt- und Unterformular für die zu durchsuchenden Daten<\/span><\/b><\/p>\n Wenn Sie der Schaltfläche cmdSuchen <\/b>nun noch die folgende Ereignisprozedur unterjubeln, ist dieser Teil der Lösung bereits erledigt:<\/p>\n Erstellen des Suchformulars<\/b><\/p>\n Das Suchformular heißt frmSuche <\/b>und besitzt keine Datenherkunft und somit nur ungebundene Steuerelemente. Die drei Schaltflächen heißen cmdSuchen<\/b>, cmdLeeren <\/b>und cmdAbbrechen<\/b>. Die Schaltfläche cmdAbbrechen <\/b>hat die einfachste Aufgabe, die mit folgender Ereignisprozedur erledigt wird:<\/p>\n Für zusätzlichen Komfort stellen Sie die Eigenschaft Abbrechen <\/b>dieser Schaltfläche auf den Wert Ja <\/b>ein. Dies löst obige Prozedur aus, wenn der Benutzer auf Escape tippt. Außerdem sorgen Sie mit Popup <\/b>gleich Ja <\/b>dafür, dass das Formular immer im Vordergrund bleibt.<\/p>\n Kein Suchformular ohne aufrufendes Formular<\/b><\/p>\n Der Rest ist weniger trivial, aber nach einmaliger Programmierung vielfältig einsetzbar. Wir beschäftigen uns zunächst damit, dass das Formular beim Schließen des aufrufenden Formulars automatisch mit geschlossen werden soll. Hier gibt es zwei Möglichkeiten:<\/p>\n Wir verwenden die zweite Variante, wozu wir zunächst eine Objektvariable namens frmParent <\/b>deklarieren:<\/p>\n Durch die Deklaration mit dem Schlüsselwort WithEvents<\/b> können wir uns überhaupt erst in die Ereigniskette dieses Formulars einklinken. frmParant werden wir gleich mit einem Verweis auf das aufrufende Formular füllen. Wir brauchen noch einen weiteren Objektverweis, und zwar für den Zugriff auf das zu durchsuchende Unterformular in der Datenblattansicht. Dieses referenzieren wir mit dieser Objektvariablen:<\/p>\n Beide Objektvariablen füllen wir gleich beim Öffnen des Suchformulars frmSuche<\/b>. Dazu verwenden wir die Prozedur, die durch das Ereignis Beim Öffnen <\/b>ausgelöst wird:<\/p>\n Die Prozedur ermittelt zunächst einen Verweis auf das aktive Steuerelement. Die Eigenschaft Screen.ActiveControl <\/b>sollte hier tunlichst einen Verweis auf die Schaltfläche cmdSuchen <\/b>zurückliefern. Über die Parent<\/b>-Eigenschaft dieses Steuerelements erhalten wir einen Verweis auf das Formular, das dieses enthält. Das funktioniert auch, wenn das Formular mit der Schaltfläche cmdSuchen<\/b> selbst als Unterformular in einem weiteren Unterformular untergebracht ist. Nur wenn die Schaltfläche und das Unterformular mit der Datenblattansicht nicht das gleiche übergeordnete Formular besitzen, müssen Sie diesen Code entsprechend umbauen.<\/p>\n <\/p>\n Die folgende Zuweisung des Wertes [Event Procedure] <\/b>an die Eigenschaft OnUnload <\/b>bewirkt nichts anderes, als wenn Sie von Hand den Wert [Ereignisprozedur] <\/b>in das entsprechende Eigenschaftsfeld eintragen würden – allerdings muss sich die passende Ereignisprozedur im gleichen Klassenmodul wie die Deklaration der Objektvariablen befinden (also in dem des Suchformulars). Dort legen Sie auch die benötigte Ereignisprozedur an, die schlicht das Suchformular schließt:<\/p>\n Besonderheiten beim Anlegen der Felder zur Eingabe der Kriterien<\/b><\/p>\n Bevor wir uns um den Code kümmern, der die eingegebenen Kriterien auswertet, legen wir erstmal die zur Eingabe benötigten Steuerelemente an. Es gibt vier Möglichkeiten (dies ist erweiterbar, aber wir wollen nicht den Rahmen dieses Beitrags sprengen):<\/p>\n Es gibt ein paar kleine Regeln für das Anlegen dieser Felder: Text- und Kombinationsfelder, die Suchkriterien für Textfelder aufnehmen, sollen das Präfix txt <\/b>besitzen (also die ersten beiden Einträge der obigen Liste). Kombinationsfelder für die Auswahl von Werten aus Kombinationsfeldern sollen das Präfix cbo <\/b>erhalten (für Combobox<\/b>). Und solche, die sich auf Ja\/Nein<\/b>-Felder beziehen, beginnen mit chk <\/b>(für Checkbox<\/b>). Der Teil des Steuerelementnamens hinter dem Präfix muss genau mit dem Feldnamen übereinstimmen. Im Falle der Artikel-Tabelle sieht dies so aus:<\/p>\n Insgesamt werden die Steuerelemente zur Eingabe der Suchkriterien im Entwurf des Formulars wie in Bild 3 angeordnet.<\/p>\n Bild 3: Formular zur Eingabe von Suchkriterien in der Entwurfsansicht<\/span><\/b><\/p>\n Die Kombinationsfelder müssen Sie schließlich noch mit einer Datensatzherkunft versehen. Am einfachsten ist dies bei den Kombinationsfeldern, die zum Auswählen der Werte aus verknüpften Tabellen dienen: Sie brauchen dort lediglich die Datensatzherkunft des entsprechenden Feldes der zu filternden Tabelle einzutragen. Beim Feld Lieferant <\/b>ist dies beispielsweise der folgende Ausdruck:<\/p>\n Stellen Sie außerdem die Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf die Werte 2 <\/b>und 0cm <\/b>ein, damit nur der eigentliche Wert angezeigt wird und der Inhalt des Primärschlüsselfeldes verborgen bleibt. Die Datensatzherkunft eines Nachschlagefeldes finden Sie übrigens in den Eigenschaften des jeweiligen Feldes im Tabellenentwurf, und dort auf der Registerseite Nachschlagen <\/b>(siehe Bild 4).<\/p>\n Bild 4: Hier finden Sie die Datensatzherkunft eines Nachschlagefeldes.<\/span><\/b><\/p>\n Bei einem Feld, dessen Inhalte Sie ebenfalls als Kombinationsfeld anbieten möchten, das aber eigentlich nur ein Textfeld ist, können Sie die Datensatzherkunft ganz leicht selbst ableiten: Sie benötigen eigentlich nur den Feld- und den Tabellennamen und betten beides dann in einen SQL-Ausdruck wie diesen hier ein:<\/p>\n Wichtig sind dabei das Schlüsselwort DISTINCT<\/b>, das dafür sorgt, dass jeder Eintrag nur einmal angezeigt wird, und die Sortierung nach dem Feldinhalt – auf diese Weise findet der Benutzer die Einträge gleich in alphabetischer Reihenfolge. Beachten Sie außerdem, dass Sie Spaltenanzahl <\/b>auf 1 <\/b>einstellen und Spaltenbreiten <\/b>leeren – die Datensatzherkunft enthält schließlich nur ein Feld.<\/p>\n Beim Ja\/Nein<\/b>-Feld verwenden Sie grundsätzlich den folgenden Ausdruck als Datensatzherkunft:<\/p>\n Wie Sie sehen, handelt es sich nicht um einen SQL-Ausdruck, sondern um eine Wertliste. Dementsprechend stellen Sie die Eigenschaft Herkunftsart <\/b>auf Wertliste <\/b>ein. Spaltenanzahl <\/b>und Spaltenbreite <\/b>setzen Sie auf 2 <\/b>und 0cm<\/b>, damit nur die Werte Ja <\/b>und Nein <\/b>angezeigt werden. Die Werte der ersten Spalte werden anschließend beim Zusammensetzen des Filterausdrucks berücksichtigt.<\/p>\n Auswerten von Suchkriterien<\/b><\/p>\n Die Auswertung erfolgt unabhängig der speziellen Implementation des Formulars. Sie könnten auch eine ganz andere Tabelle in dem Unterformular in der Datenblattansicht hinterlegen und das Suchformular mit entsprechenden Steuerelementen zur Eingabe der Suchkriterien ausstatten – wichtig ist allein, dass die Steuerelemente den oben angegebenen Konventionen entsprechen. Generell wird die Suche über einen Mausklick auf die Schaltfläche cmdSuchen <\/b>gestartet. Damit der Benutzer nach Eingabe der Suchbegriffe nicht erst zur Maus greifen muss, um diese Schaltfläche anzuklicken, stellen Sie ihre Eigenschaft Standard <\/b>auf Ja <\/b>ein – das Betätigen der Eingabetaste führt dann zum Auslösen der Ereignisprozedur dieser Schaltfläche. Die Ereignisprozedur sieht wie folgt aus und erledigt nur einen Teil der Arbeit:<\/p>\n Sie überlässt das Zusammenstellen des Filterkriteriums nämlich einer weiteren Funktion namens SuchfilterErstellen<\/b>, die wir uns weiter unten anschauen. Diese liefert einen Ausdruck zurück, der beispielsweise so aussieht:<\/p>\n Diesen braucht die Prozedur dann nur noch an die Filter<\/b>-Eigenschaft des Unterformulars zu übergeben und die Eigenschaft FilterOn <\/b>auf True <\/b>einzustellen – schon zeigt das Unterformular nur noch die passenden Datensätze an. Es kann natürlich auch sein, dass der Benutzer auf die Suchen<\/b>-Schaltfläche klickt, obwohl er noch gar keine Suchkriterien eingegeben hat – in diesem Fall wird Filter <\/b>mit einer leeren Zeichenkette gefüllt und FilterOn <\/b>auf False <\/b>einstellt. Das entscheidende Kriterium hierfür ist, dass der Suchausdruck in strSuchfilter <\/b>eine leere Zeichenkette enthält.<\/p>\n Suchstring zusammensetzen<\/b><\/p>\n Kommen wir zur Funktion SuchfilterErstellen<\/b>, die in Listing 1 abgebildet ist. Diese Funktion liest die Inhalte sämtlicher Steuerelemente des Suchformulars ein und fügt aus denjenigen, für die die der Benutzer einen Wert eingegeben hat, eine SQL-Where-Bedingung zusammen. Dabei durchläuft die Funktion in einer For Each<\/b>-Schleife alle Steuerelemente des Formulars (Me.Controls<\/b>), wobei der Verweis auf das aktuelle Steuerelement jeweils in der Variablen ctl <\/b>gespeichert wird. Eine Select Case<\/b>-Bedingung sondiert zunächst, ob es sich bei dem Steuerelement um ein Textfeld oder ein Kombinationsfeld handelt; alle übrigen Steuerelementtypen bleiben unberücksichtigt.<\/p>\n Listing 1: Diese Routine erstellt aus den Suchkriterien eine SQL-Where-Bedingung.<\/p>\n Text- und Kombinationsfelder erfahren eine unterschiedliche Behandlung, und bei Kombinationsfeldern gibt es wiederum unterschiedliche Vorgehensweisen. Bei einem Textfeld ist klar, dass das zugrunde liegende Feld mit der im Textfeld angegebenen Zeichenkette verglichen werden soll, bei Kombinationsfeldern kann es sich um eines handeln, das nur die verschiedenen Werte eines Textfelds anbietet, um ein Nachschlagefeld oder um die Auswahl der potenziellen Werte eines Ja\/Nein<\/b>-Feldes.<\/p>\n Beim Textfeld prüft die Funktion, ob diese überhaupt Text enthält. Falls ja, fügt es ein neues Kriterium zusammen, dass aus dem Feldnamen (der ja aus dem hinteren Teil des Steuerelementnamens abgeleitet wird), dem Vergleichsoperator LIKE <\/b>und einer in Hochkommata eingefassten Zeichenkette besteht. Da auch der Inhalt des Textfeldes Hochkommata enthalten kann, werden diese verdoppelt. Aus einem Eintrag wie Josef“s <\/b>wird dann Josef““s<\/b>. So interpretiert die Jet Engine das Hochkomma nicht fälschlicherweise als Ende des Vergleichswertes.<\/p>\n Der so zusammengesetzte Vergleichsausdruck wird an die bisher in strFilter <\/b>enthaltenen Ausdrucke angehängt und mit dem Schlüsselwort AND<\/b> so verknüpft, das nur solche Datensätze angezeigt werden, die alle Bedingungen erfüllen.<\/p>\n Die Auswertung von Kombinationsfeldern ist etwas schwieriger. Hier untersucht die Funktion in einer weiteren Select Case<\/b>-Anweisung die ersten drei Buchstaben des Steuerelementnamens, also das Präfix:<\/p>\n Nach dem Durchlaufen aller Steuerelemente des Suchformulars prüft die Funktion, ob in strFilter <\/b>überhaupt Vergleichsausdrücke zusammengekommen sind.<\/p>\n Falls ja, schneidet sie die ersten fünf Zeichen ab: Immerhin wurden alle Vergleichsausdrücke mit führendem AND <\/b>zusammengestellt, damit man nicht jedes Mal prüfen muss, ob bereits ein Ausdruck enthalten ist. Mit diesem Ausdruck wird schließlich das Unterformular gefiltert.<\/p>\n Suchkriterien leeren und alle anzeigen<\/b><\/p>\n Ein Klick auf die Schaltfläche Leeren soll schließlich alle Suchfelder zurücksetzen und dementsprechend wieder alle Datensätze im Unterformular anzeigen. Dafür sorgt die folgende Ereignisprozedur:<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die Lösung können Sie für alle Formulare einsetzen, die im Unterformular Daten einer Tabelle oder Abfrage in der Datenblatt- oder Endlosansicht anzeigen. Neben den bereits genannten Regeln brauchen Sie nur dafür zu sorgen, dass das Unterformularsteuerelement sfm <\/b>heißt.<\/p>\n Im Suchformular legen Sie dann die Steuerelemente an, mit denen Sie die Datensätze des Unterformulars filtern. Diese benennen Sie entsprechend den erwähnten Konventionen (txt<\/b>, cbo <\/b>oder chk <\/b>als Präfix plus angehängtem Feldnamen).<\/p>\n Noch schöner wäre es natürlich, wenn man solche Formulare per Add-In anlegen könnte. In einem weiteren Beitrag namens Suchformulare per Assistent <\/b>(www.access-im-unternehmen.de\/****<\/b>) stellen wir ein solches Add-In vor.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Suchformular.mdb<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_03\/Suchformulare-web-images\/pic002.png\")
<\/p>\nPrivate Sub cmdSuche_Click()\r\n DoCmd.OpenForm "frmSuche"\r\nEnd Sub<\/pre>\n
Private Sub cmdAbbrechen_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
\n
Private WithEvents frmParent As Form<\/pre>\n
Private frmDatasheet As Form<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Dim ctl As Control\r\n Set ctl = Screen.ActiveControl\r\n Set frmParent = ctl.Parent\r\n frmParent.OnUnload = "[Event Procedure]"\r\n Set frmDatasheet = frmParent!sfm.Form\r\nEnd Sub<\/pre>\n
Private Sub frmParent_Unload(Cancel As Integer)\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
\n
\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_03\/Suchformulare-web-images\/pic003.png\")
<\/p>\nSELECT LieferantID, Firma FROM tblLieferanten;<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_03\/Suchformulare-web-images\/pic004.png\")
<\/p>\nSELECT DISTINCT Liefereinheit FROM tblArtikel ORDER BY Liefereinheit;<\/pre>\n
-1;"Ja";0;"Nein"<\/pre>\n
Private Sub cmdSuchen_Click()\r\n Dim strSuchfilter As String\r\n strSuchfilter = SuchfilterErstellen\r\n If Len(strSuchfilter) > 0 Then\r\n frmDatasheet.Filter = strSuchfilter\r\n frmDatasheet.FilterOn = True\r\n Else\r\n frmDatasheet.Filter = ""\r\n frmDatasheet.FilterOn = False\r\n End If\r\nEnd Sub<\/pre>\n
Artikelname LIKE ''Ch*''<\/pre>\n
Private Function SuchfilterErstellen() As String\r\n Dim strFilter As String\r\n Dim strFieldname As String\r\n Dim ctl As Control\r\n For Each ctl In Me.Controls\r\n Select Case ctl.ControlType\r\n Case acTextBox, acComboBox\r\n strFieldname = Mid(ctl.Name, 4)\r\n If ctl.ControlType = acTextBox Then\r\n If Len(ctl.Value) > 0 Then\r\n strFilter = strFilter & " AND " & strFieldname & " LIKE ''" _\r\n & Replace(ctl.Value, "''", "''''") & "''"\r\n End If\r\n Else\r\n If Not IsNull(ctl.Value) Then\r\n Select Case Left(ctl.Name, 3)\r\n Case "cbo"\r\n strFilter = strFilter & " AND " & strFieldname & " = " & ctl.Value\r\n Case "txt"\r\n strFilter = strFilter & " AND " & strFieldname & " = ''" _\r\n & Replace(ctl.Value, "''", "''''") & "''"\r\n Case "chk"\r\n strFilter = strFilter & " AND " & strFieldname & " = " & ctl.Value\r\n End Select\r\n End If\r\n End If\r\n End Select\r\n Next ctl\r\n If Len(strFilter) > 0 Then\r\n SuchfilterErstellen = Mid(strFilter, 5)\r\n End If\r\nEnd Function<\/pre>\n
\n
Private Sub cmdFilterLeeren_Click()\r\n Dim ctl As Control\r\n For Each ctl In Me.Controls\r\n Select Case ctl.ControlType\r\n Case acTextBox, acComboBox\r\n ctl.Value = Null\r\n End Select\r\n Next ctl\r\n frmDatasheet.Filter = ""\r\n frmDatasheet.FilterOn = False\r\nEnd Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n