<\/p>\n
Es gibt viele Möglichkeiten, eine Suche über die Datensätze einer Tabelle zu programmieren. Wir wollen in diesem Beitrag eine sehr flexible Variante vorstellen. Damit können Sie sowohl einfach Suchbegriffe eingeben, mit denen dann alle für die Suche angegebenen Felder durchsucht werden. Andererseits soll die Suche auch das gezielte Ermitteln von Datensätzen ermöglichen, deren Felder bestimmte Werte enthalten. Um die Angabe der Feldnamen zu vereinfachen, haben wir der Suche auch noch eine Funktion zur Autovervollständigung hinzugefügt.<\/b><\/p>\n
Vorweg ist zu erwähnen, dass wir hier keine Suchfunktion mit nicht überschaubaren Möglichkeiten produzieren möchten. Vielmehr soll sie sich an der Praxis orientieren – in diesem Fall an meiner Praxis. Mein Bedarf an einer Suchfunktion, speziell an der hier vorgestellten, resultiert aus einer wachsenden Kundendatenbank.<\/p>\n
Früher verwendete ich eine Suchfunktion, die bestimmte Felder nach dem angegebenen Suchbegriff durchforstete. Wenn ich also die ersten Buchstaben des Nachnamens eines Kunden eingegeben habe, sollte das Formular nach den Kunden mit diesem Nachnamen gefiltert werden.<\/p>\n
Da ich aber nicht nur das Feld Nachname<\/b>, sondern auch noch andere Felder nach dem eingegebenen Suchbegriff durchsuchte, erschienen plötzlich Such-treffer, bei denen etwa der Straßenname mit den gleichen Buchstaben begann wie der Nachname.<\/p>\n
Bei einer überschaubaren Anzahl von Kundendatensätzen ist da kein Problem: Man blättert halt schnell durch die gefilterten Datensätze und landet so schnell bei dem gesuchten Kunden. Mit einer kleinen Anzahl Kunden klappte das recht gut. Mit wachsender Anzahl funktionierte es allerdings immer schlechter, da auch die Anzahl der Suchtreffer wuchs.<\/p>\n
Da ich keine Lust hatte, schon wieder eine neue Suchfunktion zu programmieren, machte ich aus der Not eine Tugend und suchte fortan nach Elementen in den Kundendaten, die eine kleinere Treffermenge versprachen.<\/p>\n
Wenn ein Kunde also etwa den Nachnamen Meier <\/b>trägt, habe ich erst gar nicht mehr nach dem Nachnamen gesucht, sondern den Vornamen als Suchbegriff eingegeben. Dumm nur, wenn der gesuchte Kunde etwa Michael Meier <\/b>heißt – so waren auf jeden Fall eine Menge Treffer zu erwarten.<\/p>\n
Auch interessant waren Kunden mit einem Nachnamen, der auch als Vorname verwendet wird – auch hier fallen eine Reihe Treffer mehr an als man eigentlich durchblättern möchte.<\/p>\n
Also musste eine neue Suchfunktion her: Eine, die zwar immer noch die flexible Suche über alle festgelegten Suchfelder erlaubte, aber die auch die konkrete Angabe der zu durchsuchenden Felder erlaubte (s. Bild 1). Wenn man also etwa einfach den Nachnamen Meier <\/b>eingibt, sollten alle festgelegten Felder nach dieser Zeichenkette durchsucht werden.<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_001.png\")
<\/p>\n
Bild 1: Beispiel für die Suche in einem Formular in der Formularansicht<\/span><\/b><\/p>\n Um nur solche Datensätze zu finden, die den Wert Meier<\/b> nur im Feld Nachname <\/b>enthalten, soll der Benutzer diesen Ausdruck angeben können:<\/p>\n Wenn die Suche zu viele Treffer liefert, kann der Benutzer das Ergebnis weiter einschränken – etwa durch zusätzliche Angabe des Vornamens:<\/p>\n „Und“ oder „Oder“<\/b><\/p>\n Die große Frage, die sich nun stellt, ist folgende: Benötigen wir eine Und-Verknüpfung für alle Vergleichskriterien oder eine Oder-Verknüpfung – oder gar beide Und sollte man gegebenenfalls sogar Klammern zum Einstellen der Priorität der Verknüpfungen hinzufügen können Normalerweise sollte eine Und-Verknüpfung ausreichen. Wenn man zusätzlich zum gesuchten Nachnamen noch den Vornamen eingibt, soll das Suchergebnis auch nur die Datensätze enthalten, bei denen beide Suchkriterien zutreffen. Dies gilt zumindest dann, wenn man nach genau einem Kundendatensatz sucht. Aber auch hier gibt es Ausnahmen: Es kann ja zum Beispiel sein, dass Sie nicht wissen, ob der Nachname des Kunden nun in der Lieferadresse (etwa im Feld Nachname_Liefer<\/b>) oder in der Rechnungsadresse (zum Beispiel Nachname_Rechnung<\/b>) gespeichert ist. Dann wäre es natürlich sinnvoll, wenn die Suchfunktion die beiden Suchausdrücke per Or <\/b>verknüpfen würde. Also enthält die Lösung die Möglichkeit, And <\/b>und Or <\/b>als Verknüpfungsoperatoren zu verwenden.<\/p>\n In allen Feldern suchen<\/b><\/p>\n Und die Suchfunktion soll noch ein weiteres interessantes Feature liefern – nämlich die Suche über alle möglichen Felder. Dies soll immer dann geschehen, wenn der Benutzer einen Suchbegriff ohne Angabe des zu durchsuchenden Feldes angibt.<\/p>\n Die Eingabe des Ausdrucks Chai <\/b>ohne vorheriges Artikelname: <\/b>soll also alle Felder nach diesem Ausdruck durchsuchen.<\/p>\n Automatische Ergänzung<\/b><\/p>\n Eine der wichtigsten Funktionen der Suche ist die automatische Ergänzung bei der Eingabe der zu durchsuchenden Felder. Wenn die Datenherkunft also etwa ein Feld namens Artikelname <\/b>enthält und der Benutzer gibt die Buchstaben Art <\/b>ein, dann soll das Suchtextfeld automatisch die fehlenden Buchstaben (hier ikelname<\/b>) anzeigen und gegebenenfalls nach Betätigen der Tab<\/b>-Taste oder nach Eingabe des Doppelpunkts (:<\/b>) hinzufügen (s. Bild 2).<\/p>\n Bild 2: Automatische Ergänzung von Suchfeldern<\/span><\/b><\/p>\n Einschränkung<\/b><\/p>\n In der aktuellen Version funktioniert die Suche nach Textpassagen in Feldern des Datentyps Text <\/b>oder Memo <\/b>problemlos. Auch die Suche nach Zahlen oder Datumsangaben gelingt, allerdings nur für den Gleich-Operator. Größer\/Kleiner und ähnliche Operatoren sind hier noch nicht umgesetzt.<\/p>\n Einsatz der Lösung<\/b><\/p>\n Ein Beispiel für den Einsatz der Lösung liefert das Formular frmFormularansicht<\/b>. Hier haben wir ein Formular, das die Datensätze der Tabelle tblArtikel<\/b> in der Formularansicht anzeigt, mit einem Suchfeld versehen. Im Beispiel soll die Suche alle Artikel liefern, deren Feld Artikelname <\/b>den Wert Chai <\/b>enthält – was genau einen Treffer bringt (siehe unten in der Abbildung: Datensatz 1 von 1<\/b>).<\/p>\n Welche Schritte sind zum Anwenden der Lösung nötig In Kurzfassung sind es die folgenden:<\/p>\n Textfeld für die Suche hinzufügen<\/b><\/p>\n Im ersten Schritt fügen Sie dem Formular an der gewünschten Stelle ein Textfeld hinzu, das Sie zur Eingabe des Suchbegriffs nutzen möchten – beispielsweise im oberen Bereich des Formulars. Im ersten Beispiel des Formulars frmFormularansicht<\/b>, das die Daten der Tabelle tblArtikel <\/b>anzeigt, nennen wir dieses Steuerelement txtSucheNach <\/b>(s. Bild 3).<\/p>\n Bild 3: Hinzufügen eines Suchfeldes zum Formular<\/span><\/b><\/p>\n Abfrage mit den zu durchsuchenden Feldern erstellen<\/b><\/p>\n Neben der Datenherkunft für das Formular benötigen wir noch eine Abfrage, welche die zu durchsuchenden Felder enthält. Warum aber sollte man nicht einfach die gleiche Abfrage verwenden, die auch als Datenherkunft für das zu durchsuchende Formular dient Aus einem ganz einfachen Grund: Im Beispiel des Formulars frmFormular-ansicht <\/b>etwa werden nur Daten der Tabelle tblArtikel <\/b>angezeigt. Nun könnte man annehmen, dass dies auch für die Ermittlung der zu durchsuchenden Felder gilt. Das ist manchmal der Fall, aber nicht hier: Die Datenherkunft des Formulars liefert nämlich mit den beiden Feldern LieferantID <\/b>und KategorieID <\/b>zwei Nachschlagefelder, die ja nur die Werte der Primärschlüsselfelder der verknüpften Einträge aus den Tabellen tblLieferanten <\/b>und tblKategorien<\/b> enthalten. Wenn wir nun als Suchbegriff etwa für die Kategorie den Wert Getränke <\/b>eingeben, finden wir in der Datenherkunft des Formulars natürlich keinen passenden Datensatz, weil das Feld KategorieID <\/b>dort nur Zahlenwerte wie 1<\/b>, 2<\/b>, 3 <\/b>et cetera enthält.<\/p>\n Wenn wir aber nach den eigentlichen Werten hinter den als Nachschlagefeld definierten Feldern suchen möchten, müssen wir die verknüpften Tabellen noch zur Datenherkunft für die Suchfunktion hinzufügen. Dies sieht dann wie in Bild 4 aus: Hier haben wir einer neuen Abfrage namens qryArtikelsuche <\/b>nicht nur die Tabelle tblArtikel<\/b>, sondern auch noch die beiden verknüpften Tabellen tblKategorien <\/b>und tblLieferanten <\/b>hinzugefügt. Nachdem alle benötigten Tabellen in der Abfrage enthalten sind, ist es wichtig, nur die Felder zum Entwurfsraster hinzuzufügen, die auch für die Suche herangezogen werden sollen – plus dem Primärschlüsselfeld der eigentlich zu durchsuchenden Tabelle, also ArtikelID<\/b>.<\/p>\n <\/p>\n Bild 4: Abfrage mit den zu durchsuchenden Feldern<\/span><\/b><\/p>\n In diesem Fall fügen wir also zunächst die Felder ArtikelID <\/b>und Artikelname <\/b>hinzu. Dann folgt in der Tabelle tblArtikel <\/b>das Feld LieferantID<\/b>, welches wir aber nicht zur Datenherkunft hinzufügen – wir wollen ja nicht nach den Primärschlüsselwerten der Tabelle tblLieferanten <\/b>suchen.<\/p>\n Stattdessen ziehen Sie das Feld Firma <\/b>aus der Tabelle tblLieferanten <\/b>in das Entwurfsraster. Auch das nächste Feld namens KategorieID <\/b>benötigen wir nicht, sondern das Feld Kategoriename <\/b>der verknüpften Tabelle tblKategorien<\/b>. Die übrigen Felder der Tabelle tblArtikel <\/b>können wir dann wieder direkt in das Entwurfsraster der Abfrage ziehen.<\/p>\n Hier fehlt nur noch eine kleine Optimierung: Im Formular wird etwa das Feld KategorieID <\/b>mit der Bezeichnung Kategorie <\/b>angezeigt. Der Name des Feldes in der Abfrage, die für die Suche verwendet werden soll, lautet hingegen Kategoriename<\/b>. ähnlich sieht es für das Feld Lieferant <\/b>aus, das in der verknüpften Tabelle Firma <\/b>heißt. In beiden Fällen versehen wir die Felder der Suchabfrage mit einem entsprechenden Alias: Kategoriename <\/b>wird durch Kategorie:Kategoriename <\/b>ersetzt, Firma <\/b>durch Lieferant:Firma<\/b> (s. Bild 5).<\/p>\n Bild 5: Optimierung: Anpassen der Felder der verknüpften Tabellen an den Feldnamen der Haupttabelle<\/span><\/b><\/p>\n Diese Abfrage taucht nirgends im Formular auf. Sie wird lediglich für zwei Zwecke benötigt: Erstens als Lieferant für die Feldnamen, die im Suchtextfeld bei der Eingabe der Anfangsbuchstaben automatisch ergänzt werden sollen, zweitens als Abfrage, welche zur Ermittlung der gesuchten Datensätze dient.<\/p>\n Beim Laden: Suche initialisieren<\/b><\/p>\n Die Suchfunktion steckt komplett in einem einzigen Klassenmodul. Dieses müssen Sie im Klassenmodul des Formulars instanzieren und ihm einige Informationen übergeben, die es für die Implementierung der Suchfunktion für das Formular benötigt.<\/p>\n Dazu sind zwei Schritte nötig. Der erste ist die Deklaration einer Objektvariablen namens objFlexSearch <\/b>im Kopf des Klassenmoduls des Formulars:<\/p>\n Der zweite ist das Hinzufügen einer Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Für dieses hinterlegen Sie den folgenden Code:<\/p>\n Die Eigenschaften der Klasse clsFlexSearch<\/b> werden im VBA-Fenster per IntelliSense bereitgestellt und können so leicht gefüllt werden (s. Bild 6).<\/p>\n Bild 6: Die Eigenschaften der Klasse clsFlexSearch werden per IntelliSense bereitgestellt.<\/span><\/b><\/p>\n Die Eigenschaften haben die folgende Bedeutung:<\/p>\n Beim Entladen: Suchfunktion beenden<\/b><\/p>\n Beim Entwickeln der Suchfunktion gab es öfters Probleme, wenn das Formular oder die Anwendung geschlossen wurde, wenn die Objektvariable nicht durch Setzen des Wertes Nothing <\/b>geleert wurde – Access stürzte dann einfach ab.<\/p>\n Dies war natürlich besonders ärgerlich, wenn so nicht gespeicherte änderungen im Code verloren gingen. Also habe ich noch eine Ereignisprozedur hinzugefügt, die durch das Ereignis Beim Entladen <\/b>des Formulars ausgelöst wird und die folgende Anweisung ausführt:<\/p>\n Ereignisprozedur für die Suche<\/b><\/p>\n Mit den bisher angelegten Ereignisprozeduren stellen wir immerhin schon einmal sicher, dass das Such-Textfeld die Eingabe interpretiert und gegebenenfalls automatisch Vorschläge zur Vervollständigung der zu durchsuchenden Felder anbietet. Eines fehlt allerdings noch: Wenn der Benutzer nun auf die Eingabetaste klickt, um die Suche durchzuführen, geschieht noch nichts. Das liegt daran, dass wir die Suche möglichst flexibel gestalten wollten – auch, was das Objekt angeht, das die zu durchsuchenden Daten anzeigt. Hier können Sie nämlich beispielsweise ein Formular in der Formularansicht, ein Unterformular in der Datenblattansicht, ein Endlosformular oder auch ein Formular mit einem Listenfeld verwenden.<\/p>\n Um diese Objekte gezielt zu filtern, bietet die Klasse clsFlexSearch <\/b>ein Ereignis namens Suchen <\/b>an. Dieses wird von der Klasse ausgelöst, wenn der Benutzer im Such-Textfeld die Eingabetaste betätigt. Das Ereignis bietet mit strWhere <\/b>einen Parameter an, der die ermittelte Bedingung liefert.<\/p>\n Um die Suchen<\/b>-Ereignisprozedur zu implementieren, wählen Sie im linken Kombinationsfeld des Codefensters den Eintrag objFlexSearch <\/b>aus. Das rechte Kombinationsfeld nimmt dann automatisch den Wert Suchen <\/b>an und der VBA-Editor erstellt die folgende Ereignisprozedur:<\/p>\n Nun müssen Sie dieser Prozedur nur noch zwei Anweisungen hinzufügen, was das Ergebnis aus Listing 1 liefert.<\/p>\n Listing 1: Anwenden der ermittelten Where-Bedingung<\/span><\/b><\/p>\n Die Prozedur weist der Eigenschaft Filter des Formulars also den mit strWhere <\/b>übergebenen Ausdruck zu und aktiviert den Filter durch Einstellen der Eigenschaft FilterOn <\/b>des Formulars auf den Wert True<\/b>.<\/p>\n Fertig – damit haben Sie bereits das erste Formular mit der Suchfunktion ausgestattet.<\/p>\n Bevor wir einen Blick auf die Funktion der Klasse werfen, schauen wir uns noch zwei weitere Implementierungen an.<\/p>\n Durchsuchen eines Unterformulars<\/b><\/p>\n Den Inhalt eines Formulars in der Formularansicht zu filtern, ist natürlich nur sinnvoll, wenn Sie direkt den gesuchten Datensatz finden.<\/p>\n Sollte die Suche jedoch mehr als einen Datensatz liefern, muss der Benutzer gegebenenfalls erst noch alle Suchergebnisse durchblättern, um den gewünschten Eintrag zu finden. Also schauen wir uns an, wie wir die Suchergebnisse in einem Unterformular in der Datenblattansicht anzeigen können.<\/p>\n Dazu legen Sie ein Formular namens frmUnterformular <\/b>an und fügen diesem das Textfeld zur Eingabe der Suchergebnisse hinzu. Außerdem erstellen Sie ein Unterformular namens sfmKunden<\/b>, das alle Felder der Tabelle tblKunden <\/b>anzeigt. Die fertige Konstellation sieht wie in Bild 7 aus.<\/p>\n Bild 7: Durchsuchen eines Unterformulars in der Datenblattansicht<\/span><\/b><\/p>\n Damit das Suchfeld nur die gewünschten Felder der Datenherkunft als Kriterienfelder anzeigt, legen Sie eine Anfrage namens qryKundensuche <\/b>an. Diese enthält alle Felder der Tabelle tblKunden<\/b>.<\/p>\n Die Konfiguration der Klasse clsFlexSearch <\/b>nehmen wir wiederum in der Ereignisprozedur Form_Load <\/b>auf:<\/p>\n Fehlt noch das Ausführen der Suche: Diese löst die Ereignisprozedur aus Listing 2 aus. In diesem Fall stellt die Prozedur nicht die Eigenschaft Filter <\/b>des Formulars selbst ein, sondern die des Unterformulars. Gleiches gilt für die Eigenschaft FilterOn<\/b>.<\/p>\n Listing 2: Anwenden der ermittelten Where-Bedingung für ein Unterformular<\/span><\/b><\/p>\n Durchsuchen eines Listenfeldes<\/b><\/p>\n Schließlich schauen wir uns noch an, wie Sie ein Listenfeld mit der hier vorgestellten Suchfunktion filtern können.<\/p>\n Dazu fügen Sie dem Formular neben dem Such-Textfeld das zu durchsuchende Listenfeld hinzu und versehen es mit der entsprechenden Datensatzherkunft, hier die Abfrage qryLstArtikel<\/b>. Das resultierende Formular frmListenfeld<\/b> sieht nun wie in Bild 8 aus.<\/p>\n Bild 8: Durchsuchen eines Listenfeldes nach den Artikeln einer bestimmten Kategorie<\/span><\/b><\/p>\n Es ist an dieser Stelle wichtig, dass Sie die Datensatzherkunft für das Listenfeld als gespeicherte Abfrage unter dem Namen qryLstArtikel <\/b>anlegen und nicht nur den entsprechenden SQL-Ausdruck als Wert der Eigenschaft Datensatzherkunft <\/b>hinterlegen.<\/p>\n Der Grund ist die fehlende Filter<\/b>-Eigenschaft beim Listenfeld. Wenn der Benutzer den Suchausdruck eingegeben hat und die Eingabetaste betätigt, löst dies wieder das Ereignis Suchen <\/b>des Objekts objFlexSearch <\/b>aus.<\/p>\n Wir können dem mit strWhere <\/b>gelieferten Ausdruck daher nicht wie bei den Formularen oder Unterformularen direkt einer Filter<\/b>-Eigenschaft zuweisen, sondern müssen die Eigenschaft RowSource <\/b>verwenden.<\/p>\n Diese erwartet aber nicht nur eine Where-Klausel, sondern eine komplette SQL-Abfrage. Also setzen wir diese aus dem Ausdruck SELECT * FROM qryLstArtikel WHERE <\/b>und dem Inhalt des Parameters strWhere<\/b> zusammen (s. Listing 3). Dies geschieht allerdings nur, wenn strWhere <\/b>auch einen Ausdruck enthält, was wir mit der Bedingung Len(strWhere) > 0 <\/b>prüfen. Anderenfalls weist die Prozedur der Eigenschaft RowSource <\/b>einfach die Abfrage qryLstArtikel <\/b>zu.<\/p>\n Listing 3: Anwenden der ermittelten Where-Bedingung für ein Listenfeld<\/span><\/b><\/p>\n Listenfeldsuche plus Detailansicht<\/b><\/p>\n Wenn Sie nun noch die Details zu dem aktuell im Listenfeld markierten Datensatz anzeigen möchten, können Sie eine Kombination der beiden Beispielformulare frmFormularansicht <\/b>und frmListenfeld <\/b>programmieren.<\/p>\n Dabei würde das Anklicken eines Eintrags im Listenfeld lstArtikel <\/b>dazu führen, dass der aktuell ausgewählte Eintrag in den gebundenen Steuerelementen des Formulars angezeigt wird.<\/p>\n Das Ergebnis sieht dann wie in Bild 9 aus.<\/p>\n Bild 9: Vollständige Suche mit Listenfeld für Ergebnisse und Anzeige eines einzelnen Eintrags<\/span><\/b><\/p>\n Der Code des Klassenmoduls des Formulars muss an drei Stellen erweitert werden. Als Erstes soll die Datenherkunft des Formulars gleich nach dem öffnen nach dem aktuell im Listenfeld markierten Eintrag gefiltert werden.<\/p>\n Dazu muss natürlich erst mal ein Listenfeldeintrag markiert werden. Beides erledigen wir mit drei zusätzlichen Anweisungen in der Ereignisprozedur Form_Load <\/b>aus Listing 4.<\/p>\n Listing 4: Erweiterung von Form_Load um die Anzeige des ersten Datensatzes im Listenfeld<\/span><\/b><\/p>\n Danach müssen wir dafür sorgen, dass das Hauptformular nach der Auswahl eines neuen Eintrags im Listenfeld den jeweiligen Datensatz anzeigt. Dies erledigen wir mit einer neuen Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Listenfeldes ausgelöst wird und die wie in Listing 5 aussieht.<\/p>\n Listing 5: Aktualisieren der Details nach Auswahl eines Eintrags im Listenfeld<\/span><\/b><\/p>\n Schließlich soll auch nach dem Ausführen der Suche der erste Eintrag im Listenfeld markiert und das Formular nach dem entsprechenden Datensatz gefiltert werden. Dies erledigen einige zusätzliche Anweisungen in der Ereignisprozedur objFlexSearch_Suchen<\/b> wie in Listing 6.<\/p>\nNachname:Meier<\/pre>\n
Vorname:Michael Nachname:Meier<\/pre>\n
![\"Automatische](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_004.png\")
<\/p>\n\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_002.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_003.png\")
<\/p>\n![\"Optimierung:](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_005.png\")
<\/p>\nDim <\/span>WithEvents objFlexSearch As <\/span>clsFlexSearch<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFlexSearch = New<\/span> clsFlexSearch\r\n With<\/span> objFlexSearch\r\n .Suchabfrage = \"qryArtikelsuche\"\r\n .PKFeld = \"ArtikelID\"\r\n .PKFeldEinschliessen = False<\/span>\r\n Set<\/span> .Suchfeld = Me!txtSucheNach\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_006.png\")
<\/p>\n\n
Private Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n Set<\/span> objFlexSearch = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objFlexSearch_Suchen( _\r\n strWhere As String<\/span>)\r\n ...\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objFlexSearch_Suchen(strWhere As String<\/span>)\r\n Me.Filter = strWhere\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Durchsuchen](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_007.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFlexSearch = _\r\n New<\/span> clsFlexSearch\r\n With<\/span> objFlexSearch\r\n .Suchabfrage = \"qryKundensuche\"\r\n .PKFeld = \"KundeID\"\r\n .PKFeldEinschliessen = False<\/span>\r\n Set<\/span> .Suchfeld = Me!txtSuche\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objFlexSearch_Suchen(strWhere As String<\/span>)\r\n With<\/span> Me!sfmKunden.Form\r\n .Filter = strWhere\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Durchsuchen](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_008.png\")
<\/p>\nPrivate Sub <\/span>objFlexSearch_Suchen(strWhere As String<\/span>)\r\n If <\/span>Len<\/span>(strWhere) > 0 Then<\/span>\r\n Me!lstArtikel.RowSource = \"SELECT * FROM qryLstArtikel WHERE \" & strWhere\r\n Else<\/span>\r\n Me!lstArtikel.RowSource = \"qryLstArtikel\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Vollständige](\"..\/fileadmin\/_temp_\/2014_06\/pic_965_009.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFlexSearch = New<\/span> clsFlexSearch\r\n With<\/span> objFlexSearch\r\n .Suchabfrage = \"qryArtikelsuche\"\r\n ...\r\n End With<\/span>\r\n Me!lstArtikel = Me!lstArtikel.ItemData(0)\r\n Me.Filter = \"ArtikelID = \" & Me!lstArtikel\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstArtikel_AfterUpdate()\r\n Me.Filter = \"ArtikelID = \" & Me!lstArtikel\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objFlexSearch_Suchen(strWhere As String<\/span>)\r\n If <\/span>Len<\/span>(strWhere) > 0 Then<\/span>\r\n Me!lstArtikel.RowSource = \"SELECT * FROM qryLstArtikel WHERE \" & strWhere\r\n Else<\/span>\r\n Me!lstArtikel.RowSource = \"qryLstArtikel\"\r\n End If<\/span>\r\n Me!lstArtikel = Me!lstArtikel.ItemData(0)\r\n Me.Filter = \"ArtikelID = \" & Me!lstArtikel\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n