{"id":55001071,"date":"2017-02-01T00:00:00","date_gmt":"2020-05-14T13:41:00","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1071"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Lookupkombinationsfelder_nach_Texten_filtern","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Lookupkombinationsfelder_nach_Texten_filtern\/","title":{"rendered":"Lookupkombinationsfelder nach Texten filtern"},"content":{"rendered":"

\"\"<\/p>\n

Bild 1: Aufbau des Beispielformulars<\/span><\/b><\/p>\n

Wenn Sie die Datensätze eines Unterformulars in der Datenblattansicht filtern wollen, gelingt die Eingabe in Text-, Zahlen- und Datumsfelder recht einfach. Wenn Sie jedoch ein Suchfeld für die Werte eines Lookup-Kombinationsfeldes programmieren wollen, stoßen Sie schnell an die Grenzen. Sie können die Feldinhalte nämlich nicht einfach mit den in den Feldern angezeigten Werten vergleichen, denn diese stammen ja aus den Lookup-Tabellen, mit denen solche Steuerelemente gefüllt werden. Dieser Beitrag zeigt, wie auch das Filtern nach den Werten in Kombinationsfeldern zum Kinderspiel wird.<\/b><\/p>\n

Als Erstes zeigen wir Ihnen, wie es nicht gelingt und was somit das Problem beim Filtern nach den Inhalten von Lookup-Kombinationsfeldern ist. In unserem Beispielformular haben wir ein Textfeld zur Eingabe des Suchbegriffs, eine Suchen-Schaltfläche namens cmdSuchen <\/b>sowie ein Unterformular namens sfmArtikel_Lookupfilter <\/b>angelegt (s. Bild 1).<\/p>\n

\"Aufbau<\/p>\n

Bild 1: Aufbau des Beispielformulars<\/span><\/b><\/p>\n

In einem ersten, naiven Ansatz wollen wir die Suche wie für ein normales Feld des Datentyps String durchführen. Die dazugehörige Prozedur sieht dann wie in Listing 1 aus.<\/p>\n

Private Sub <\/span>cmdSuchen_Click()\r\n     Dim <\/span>strLieferant As String<\/span>\r\n     strLieferant = Me!txtLieferant\r\n     Me!sfmArtikel_Lookupfilter.Form.Filter = \"LieferantID LIKE ''\" & strLieferant & \"''\"\r\n     Me!sfmArtikel_Lookupfilter.Form.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Erster Ansatz zum Filtern der angezeigten Werte im Kombinationsfeld<\/span><\/b><\/p>\n
Das Ergebnis sieht wie in Bild 2 aus: Es liefert keinerlei Datensätze, obwohl das Kombinationsfeld doch einige Werte anzeigt, die mit dem Suchbegriff E* <\/b>beginnen. Eine Analyse des resultierenden Filterausdrucks lässt eine Vorahnung aufkommen. Das Feld LieferantID <\/b>enthält doch nur Zahlenwerte<\/p>\n
\"Erster,<\/p>\n
Bild 2: Erster, erfolgloser Anlauf<\/span><\/b><\/p>\n
LieferantID LIKE ''E*''<\/pre>\n
Es ist also klar: Auch, wenn das Kombinationsfeld die Hersteller anzeigt, sind dies nicht die Werte des an das Steuerelement gebundenen Feldes LieferantID<\/b>. Lieferant-ID <\/b>gibt lediglich an, mit welchem Datensatz der Tabelle tblLieferanten <\/b>der aktuelle Datensatz der Tabelle tblArtikel <\/b>verknüpft ist. Das Feld enthält also, wenn wie in diesem Fall referenzielle Integrität definiert ist, mit Sicherheit nur Zahlenwerte.<\/p>\n
Sie könnten nun den Wert 1 <\/b>als Suchbegriff in das Textfeld txtFirma <\/b>eingeben. Das Ergebnis wäre für den Benutzer eher noch verwirrender als das vorherige: Es erscheinen nämlich alle Datensätze mit dem Lieferanten Exotic Liquids<\/b>.<\/p>\n
Dieser hat wiederum, wie Sie vielleicht erahnen, den Wert 1 <\/b>im Feld LieferantID<\/b> der Tabelle tblLieferanten<\/b>, also zeigt das Unterformular nach dem Filtern alle Datensätze der Tabelle tblArtikel <\/b>an, die diesem Lieferanten zugeordnet sind.<\/p>\n
Noch verwirrender wird es, wenn Sie beispielsweise den Wert 1* <\/b>eingeben. Dann erscheint das Ergebnis aus Bild 3.<\/p>\n
\"Alle<\/p>\n
Bild 3: Alle Artikel, die zu einem Lieferanten gehören, der mit einer LieferantID wie 1* beginnt<\/span><\/b><\/p>\n
Der Benutzer würde dies nun gar nicht mehr einordnen können, aber wir wissen: Das sind alle Artikel, deren Feld Lieferant-ID <\/b>einen Wert enthält, der mit 1 <\/b>beginnt.<\/p>\n
Filtern nach dem angezeigten Wert<\/h2>\n
Damit wenden wir uns dem eigentlichen Ziel dieses Beitrags zu: Wir wollen ja nicht nach den Fremdschlüsselwerten filtern, sondern nach dem Wert, der im Kombinationsfeld angezeigt wird. Hier gibt es verschiedene Ansätze, die wir uns nun ansehen.<\/p>\n
Im Grunde ist es ganz einfach: Wir müssen lediglich die Abfrage in der Ereignisprozedur der Schaltfläche cmdSuchen<\/b> anpassen, um das Ergebnis aus Bild 4 zu erhalten! Die entsprechende Zeile sieht dann wie folgt aus:<\/p>\n
\"Diese<\/p>\n
Bild 4: Diese Artikel wollen wir sehen.<\/span><\/b><\/p>\n
Me!sfmArtikel_Lookupfilter.Form.Filter = _\r\n    & \"LieferantID IN (SELECT LieferantID FROM tblLieferanten WHERE Firma LIKE ''\" & strLieferant & \"'')\"<\/pre>\n
Der nackte SQL-Ausdruck etwa nach Eingabe des Suchausdrucks E* <\/b>sieht wie folgt aus:<\/p>\n
LieferantID IN (\r\n     SELECT LieferantID \r\n     FROM tblLieferanten \r\n     WHERE Firma LIKE ''E*''\r\n)<\/pre>\n
Was bedeutet das nun Wir verwenden hier immer noch das Feld LieferantID <\/b>als Vergleichsfeld. Allerdings unterscheidet sich der Rest gravierend von der vorherigen Version.<\/p>\n
Der erste Unterschied ist, dass wir nicht den Operator LIKE <\/b>(oder auch das Gleichheitszeichen) verwenden, sondern den IN<\/b>-Operator.<\/p>\n
Dieser erwartet eine Menge von einem oder mehreren Vergleichswerten, die immer in Klammern angegeben werden müssen. Die Vergleichswerte können als kommaseparierte Liste angegeben werden, also etwa so: <\/p>\n
IN (1, 2, 3)<\/pre>\n
In diesem Fall ist die Menge der Vergleichswerte jedoch dynamisch und von den Werten der Tabelle tblLieferanten <\/b>abhängig, daher nutzen wir in Klammern eine SELECT<\/b>-Abfrage:<\/p>\n
SELECT LieferantID FROM tblLieferanten WHERE Firma LIKE ''E*''<\/pre>\n
Die Abfrage liefert alle Werte des Feldes LieferantID <\/b>der Tabelle tblLieferanten<\/b>, deren Feld Firma <\/b>mit dem Buchstaben E <\/b>beginnt (LIKE E*<\/b>) – hier steckt also nun ein weiterer Vergleichsoperator, der diesmal festlegt, mit welchem Suchbegriff die im Kombinationsfeld angezeigten Werte verglichen werden sollen.<\/p>\n
<\/p>\n
Dies ist die einfachste Lösung, um ein Lookup-Kombinationsfeld nach den angezeigten Werten zu filtern.<\/p>\n
Variante mit erweiterter Datenherkunft<\/h2>\n
Die zweite Variante setzt ein wenig Vorarbeit voraus, dafür ist die Gestaltung des Filter-Kriteriums wesentlich einfacher. Wir verwenden hier im Formular frmArtikel_Look-upfilter_II <\/b>die Abfrage aus Bild 5 als Datenherkunft des Unterformulars.<\/p>\n
\"Erweiterte<\/p>\n
Bild 5: Erweiterte Datenherkunft des Formulars<\/span><\/b><\/p>\n
Der Unterschied zum Einsatz der reinen Tabelle tblArtikel <\/b>ist, dass wir die Tabelle tblLieferanten <\/b>noch hinzugefügt und aus dieser Tabelle das Feld Firma <\/b>in das Entwurfsraster gezogen haben.<\/p>\n
Im Entwurf des Unterformulars müssen wir allerdings keine änderungen vornehmen, denn wir wollen die Firma <\/b>aus der Tabelle tblLieferanten <\/b>ja nicht direkt in einem Textfeld, sondern nach wie vor als Kombinationsfeld anzeigen.<\/p>\n
Hinweis: Der Name des Unterformular-Steuerelements im Formular frmArtikel_Lookupfilter_II <\/b>lautet nach wie vor sfmArtikel_Lookupfilter<\/b>, aber es zeigt das neue Unterformular frmArtikel_Lookupfilter_II <\/b>an.<\/p>\n
Die Ereignisprozedur, die durch die Schaltfläche cmdSuchen <\/b>ausgelöst wird, sieht nun so aus:<\/p>\n
Private Sub <\/span>cmdSuchen_Click()\r\n     Dim <\/span>strLieferant As String<\/span>\r\n     strLieferant = Me!txtLieferant\r\n     Me!sfmArtikel_Lookupfilter.Form.Filter =  \"Firma LIKE ''\" & strLieferant & \"''\"\r\n     Me!sfmArtikel_Lookupfilter.Form.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Der Filterausdruck sieht nun nur noch so aus:<\/p>\n
\"Firma LIKE ''\" & strLieferant & \"''\"<\/pre>\n
Dies ist nun so einfach, weil das Feld Firma <\/b>ja nun zur Datenherkunft des Unterformulars gehört.<\/p>\n
Flexible Suche<\/h2>\n
Nun wollen wir den Code noch so anpassen, dass wir den Filterausdruck nicht mehr manuell erstellen müssen, sondern nur noch das Kombinationsfeld und den Vergleichswert angeben müssen.<\/p>\n
Dazu verwenden wir eine Hilfsfunktion, und zwar die aus Listing 2.<\/p>\n
Private Function <\/span>LookupSearchstring(cbo As <\/span>ComboBox, strValue As String<\/span>) As String<\/span>\r\n     Dim <\/span>strBoundColumn As String<\/span>\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>fldBound As <\/span>DAO.Field\r\n     Dim <\/span>strSQL As String<\/span>\r\n     Dim <\/span>strBoundTable As String<\/span>\r\n     Dim <\/span>strForeignKey As String<\/span>\r\n     Dim <\/span>strFieldCriteria As String<\/span>\r\n     Dim <\/span>strColumnWidths() As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     Dim <\/span>dblColumnwidth As Double<\/span>\r\n     Set<\/span> rst = cbo.Recordset\r\n     Set<\/span> fldBound = rst.Fields(cbo.BoundColumn - 1)\r\n     strBoundTable = fldBound.SourceTable\r\n     strBoundColumn = fldBound.SourceField\r\n     strForeignKey = cbo.ControlSource\r\n     strColumnWidths = Split<\/span>(cbo.ColumnWidths, \";\")\r\n     For i = 0 To cbo.ColumnCount - 1\r\n         dblColumnwidth = 1\r\n         On Error Resume Next<\/span>\r\n         dblColumnwidth = Split<\/span>(cbo.ColumnWidths, \";\")(i)\r\n         On Error GoTo<\/span> 0\r\n         If <\/span>dblColumnwidth > 0 Then<\/span>\r\n             Exit For<\/span>\r\n         End If<\/span>\r\n     Next<\/span> i\r\n     strFieldCriteria = rst.Fields(i).Name\r\n     strSQL = strForeignKey & \" IN (SELECT \" & strBoundColumn & \" FROM \" & strBoundTable & \" WHERE \" _\r\n         & strFieldCriteria & \" LIKE ''\" & strValue & \"'')\"\r\n     LookupSearchstring = strSQL\r\nEnd Function<\/span><\/pre>\n
Listing 2: Flexibles Suchen von Zeichenketten in der Datensatzherkunft von Kombinationsfeldern<\/span><\/b><\/p>\n
Um die Suche auszuprobieren, legen wir eine zweite Schaltfläche namens cmdSucheFlexibel <\/b>an, für die wir die folgende Ereignisprozedur hinterlegen:<\/p>\n
Private Sub <\/span>cmdSucheFlexibel_Click()\r\n     Dim <\/span>strLieferant As String<\/span>\r\n     Dim <\/span>strSearchstring As String<\/span>\r\n     strLieferant = Me!txtLieferant\r\n     strSearchstring = LookupSearchstring(Me! sfmArtikel_Lookupfilter.Form!LieferantID, strLieferant)\r\n     Me!sfmArtikel_Lookupfilter.Form.Filter = strSearchstring\r\n     Me!sfmArtikel_Lookupfilter.Form.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Die Funktion LookupSearchstring <\/b>soll uns also den Filterausdruck liefern, den wir dann nur noch der Eigenschaft Filter <\/b>des Unterformulars zuweisen müssen.<\/p>\n
Dazu übergeben wir der Funktion zwei Parameter: einen Verweis auf das betroffene Kombinationsfeld und den Suchbegriff.<\/p>\n
Das Ziel der Funktion ist es, die Datenherkunft des Kombinationsfeldes zu analysieren und daraus folgende Eigenschaften zu ermitteln:<\/p>\n