Im ersten Teil dieser Beitragsreihe („Detailformular und Datenblatt mit ADODB-Recordset“, www.access-im-unternehmen.de\/1601) haben wir gezeigt, wie man ein Formular per VBA-Code an ein ADODB-Recordset bindet. Dabei sind wir auf ein grundlegendes Problem gestoßen: Die eingebauten Sortier- und Filterfunktionen von Access – sowohl im Ribbon als auch im Dropdown-Menü des Datenblatt-Spaltenkopfes – funktionieren bei ADODB-gebundenen Formularen nicht. In diesem Beitrag zeigen wir, wie wir diese Funktionen mit eigenen Mitteln vollständig nachbauen.<\/b><\/p>\n
Das Problem: Warum funktioniert die eingebaute Filterung nicht?<\/h2>\n
Wenn Access ein Formular filtert oder sortiert, greift es intern auf die Datensatzquelle<\/b> des Formulars zu – also auf die Tabelle oder Abfrage, die in der gleichnamigen Eigenschaft eingetragen ist.<\/p>\n
Bei einem ADODB-gebundenen Formular ist diese Eigenschaft leer, denn wir haben die Datensatzquelle bewusst nicht eingetragen und das Recordset stattdessen per VBA gesetzt.<\/p>\n
Access findet also keine SQL-Datensatzquelle und quittiert den Versuch zu filtern mit der Fehlermeldung Geben Sie einen gültigen Wert ein<\/b> oder Der Datenprovider konnte nicht initialisiert werden<\/b>.<\/p>\n
Die Lösung ist konsequent: Wir übernehmen die Kontrolle über Filterung und Sortierung vollständig selbst. Anstatt Access die SQL-Abfrage manipulieren zu lassen, bauen wir den SQL-String in unserem VBA-Code zusammen und laden das Recordset neu.<\/p>\n
Das hat den zusätzlichen Vorteil, dass die Lösung ohne Änderung auch beim Wechsel auf einen SQL Server funktioniert.<\/p>\n
Im Datenblatt gibt es zwei Möglichkeiten, wie der Benutzer sortieren und filtern kann.<\/p>\n
Erstens über das Ribbon<\/b> – die Gruppe Sortieren und Filtern<\/b> im Tab Start<\/b> (siehe Bild 1).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_03\/pic_1602_001.png\")
<\/p>\n
Bild 1: Die Anreden werden nicht mehr angezeigt.<\/span><\/b><\/p>\n Zweitens über das Dropdown-Menü im Spaltenkopf<\/b> des Datenblatts, das erscheint wenn man mit der Maus über den Spaltenkopf fährt und auf den kleinen Pfeil klickt (siehe Bild 2).<\/p>\n Bild 2: Weitere Filtermöglichkeiten in der Datenblattansicht<\/span><\/b><\/p>\n Für das Ribbon verwenden wir eine angepasste Ribbon-Definition in der Tabelle USysRibbons<\/b>, mit der wir die eingebaute Gruppe ausblenden und durch eine eigene ersetzen. Dort haben wir volle Kontrolle über jeden Button und jeden Callback. Das Dropdown-Menü im Spaltenkopf hingegen ist ein eingebauter Access-Mechanismus, den wir nicht direkt ersetzen können. Wir können ihn aber über das Ereignis Bei Filter anwenden<\/b> (Form_ApplyFilter<\/b>) abfangen. Access ruft dieses Ereignis auf, bevor es versucht, den Filter anzuwenden – und gibt uns damit die Möglichkeit, die Aktion selbst zu übernehmen.<\/p>\n Eine Information vorneweg: Die Filter unter Textfilter<\/b>, also zum Beispiel Gleich…<\/b>, konnten wir nicht technisch sauber abfangen, daher sind diese in Zusammenhang mit Recordsets in Formularen nicht wie gewohnt nutzbar.<\/p>\n Die Grundidee unserer Lösung ist einfach: Wir halten den aktuellen SQL-String des Formulars in öffentlichen Variablen im Modul mdlADODB<\/b> vor. So haben sowohl das Formularmodul als auch die Ribbon-Callbacks jederzeit Zugriff auf den aktuellen Stand:<\/p>\n strBaseSQL<\/b> enthält den Basis-SQL-String ohne WHERE und ORDER BY<\/b> – also zum Beispiel „SELECT * FROM tblKunden“<\/b>.<\/p>\n Dieser wird einmalig in Form_Open<\/b> gesetzt und ändert sich nie. strLastSQL<\/b> enthält den zuletzt ausgeführten SQL-String inklusive aller aktiven Filter und Sortierungen. strPendingSQL<\/b> ist ein Zwischenspeicher, den wir im Timer-Trick benötigen – dazu gleich mehr.<\/p>\n Um WHERE<\/b>– und ORDER BY<\/b>-Teile aus einem SQL-String zu extrahieren, haben wir zwei Hilfsfunktionen in mdlADODB<\/b> angelegt.<\/p>\n Diese werden per VBA sowohl von den Ribbon-Callbacks als auch vom Formularmodul aus verwendet (siehe Listing 1).<\/p>\n Listing 1: Hilfsfunktionen zum Extrahieren von WHERE- und ORDER BY-Teilen<\/span><\/b><\/p>\n GetWhereTeil<\/b> gibt den Inhalt der WHERE<\/b>-Klausel zurück – also den Teil nach dem Schlüsselwort WHERE<\/b> und vor einem eventuellen ORDER BY<\/b>. GetOrderByTeil<\/b> gibt entsprechend den Teil nach ORDER BY<\/b> zurück. Beide Funktionen geben einen leeren String zurück, wenn der jeweilige Teil nicht vorhanden ist.<\/p>\n Für die Sortierung über das Ribbon überschreiben wir die eingebauten Ribbon-Commands SortUp<\/b> und SortDown<\/b> mit eigenen Callbacks. In der Ribbon-XML-Definition der Tabelle USysRibbons<\/b> blenden wir zunächst die eingebaute Gruppe GroupSortAndFilter<\/b> aus und fügen eine eigene Gruppe ein (siehe Listing 2).<\/p>\n Listing 2: Ribbon-XML für die eigene Gruppe Sortieren und Filtern<\/span><\/b><\/p>\n Das Ergebnis sehen wir in Bild 3.<\/p>\n Bild 3: Neuer Sortieren und Filtern-Bereich im Ribbon<\/span><\/b><\/p>\n Die Callbacks SortUp<\/b> und SortDown<\/b> überschreiben wir mit dem commands<\/b>-Element der Ribbon-XML, das wir vor der ribbon<\/b>-Sektion einfügen:<\/p>\n Der Callback OnAction_Toggle<\/b> im Modul mdlRibbons<\/b> wird aufgerufen, wenn der Benutzer auf Aufsteigend<\/b> oder Absteigend<\/b> klickt. Er setzt CancelDefault = True<\/b> um die eingebaute Aktion zu unterdrücken und ruft dann SortierungAnwenden<\/b> auf (siehe Listing 3).<\/p>\n Listing 3: Callback OnAction_Toggle für Aufsteigend und Absteigend<\/span><\/b><\/p>\n Screen.ActiveControl.Name<\/b> liefert den Namen des Feldes, in dessen Spalte der Benutzer geklickt hat. Dieser wird zusammen mit der Sortierrichtung an SortierungAnwenden<\/b> übergeben.<\/p>\n SortierungAnwenden<\/b> in mdlADODB<\/b> ist die zentrale Funktion für alle Sortieroperationen. Sie baut aus dem bestehenden SQL-String einen neuen mit der gewünschten Sortierung zusammen und lädt das Recordset neu. Dabei bleibt ein eventuell aktiver Filter erhalten (siehe Listing 4).<\/p>\n Listing 4: Die Prozedur SortierungAnwenden<\/span><\/b><\/p>\n Achtung: Bei Nachschlagefeldern wird hier nach dem Wert der gebundenen Spalte sortiert, nicht nach dem angezeigten Wert. Sie ruft SQLMitSortierung<\/b> auf, die den neuen SQL-String zusammenstellt. Diese Hilfsfunktion extrahiert den WHERE<\/b>-Teil aus dem bisherigen SQL und hängt die neue Sortierung an (siehe Listing 5).<\/p>\n Listing 5: Die Funktion SQLMitSortierung<\/span><\/b><\/p>\n Wichtig: Wir verwenden immer nur die zuletzt gewählte Sortierung – eine neue Sortierung ersetzt die vorherige komplett.<\/p>\n Eine Mehrfachsortierung über mehrere Felder ist über das Ribbon nicht sinnvoll abbildbar, da der Benutzer keine Rückmeldung erhält, welche Felder gerade sortiert sind. Nach dem Setzen des neuen Recordsets rufen wir objRibbon_Main.Invalidate<\/b> auf. Das zwingt Access, alle Ribbon-Callbacks neu auszuwerten – insbesondere getEnabled<\/b> für die Schaltfläche Filter ein\/aus<\/b>, die nur aktiv sein soll wenn ein Filter vorhanden ist.<\/p>\n Die Schaltfläche Sortierung entfernen<\/b> ruft den Callback OnAction_SortRemove<\/b> auf. Dieser prüft, ob überhaupt eine Sortierung aktiv ist und baut dann einen neuen SQL-String ohne ORDER BY<\/b> zusammen – einen eventuell aktiven Filter behält er dabei (siehe Listing 6).<\/p>\n Listing 6: Callback OnAction_SortRemove<\/span><\/b><\/p>\n Für die Filterung nutzen wir das eingebaute Ribbon-Menü SortSelectionMenu<\/b> (Auswahl). Dieses zeigt automatisch nur die für den aktuellen Feldtyp passenden Filteroptionen an – bei Textfeldern etwa Enthält<\/b> und Beginnt mit<\/b>, bei Datumsfeldern Vor<\/b> und Nach<\/b>„. Die einzelnen Commands dieses Menüs überschreiben wir ebenfalls über das commands<\/b>-Element mit unserem Callback OnAction<\/b>.<\/p>\n Der Callback OnAction<\/b> erledigt drei Aufgaben: Er ermittelt das aktive Steuerelement und seinen Wert, quotet den Wert abhängig vom Feldtyp korrekt für SQL und baut den Filterausdruck zusammen.<\/p>\n Je nachdem, ob ein Feld Text, eine Zahl oder ein Datum enthält, muss der Wert im SQL-Filterausdruck unterschiedlich formatiert werden. Bei Textwerten müssen einfache Anführungszeichen gesetzt werden, bei Datumswerten Rauten. Zahlen benötigen kein Trennzeichen. Den Feldtyp lesen wir über frm.Recordset.Fields(strFeld).Type<\/b> aus dem ADODB-Recordset aus:<\/p>\n Die ADODB-Typkonstanten für Zahlen umfassen unter anderem adInteger<\/b> (3), adSmallInt<\/b> (2) und weitere ganzzahlige Typen. Für Datum sind es adDate<\/b> (7) sowie datumsähnliche Typen. Alle anderen Typen werden als Text behandelt.<\/p>\n Bei Datumswerten ist zu beachten, dass Access den Wert im deutschen Format liefert – also zum Beispiel 23.01.1971<\/b>. SQL erwartet das Datum jedoch im US-Format mm\/dd\/yyyy<\/b>. Wir wandeln den Wert daher zunächst mit CDate<\/b> in einen echten Datumswert um und formatieren ihn dann mit Format<\/b> im richtigen Format.<\/p>\n Bei Textwerten ersetzen wir außerdem einfache Anführungszeichen im Wert selbst durch zwei einfache Anführungszeichen – das ist die SQL-Standard-Escape-Sequenz für Hochkommas in Zeichenketten. Ohne diese Maßnahme würde zum Beispiel der Name O’Brien<\/b> zu einem SQL-Fehler führen.<\/p>\n Abhängig vom gewählten Ribbon-Command bauen wir unterschiedliche SQL-Filterausdrücke zusammen. Die folgende Übersicht zeigt alle unterstützten Commands:<\/p>\n Ein Hinweis zu den Commands FilterSmallerThanSelection<\/b> und FilterLargerThanSelection<\/b>: Access benennt diese intern als „Kleiner oder gleich“ und „Größer oder gleich“ – wir verwenden daher <=<\/b> beziehungsweise >=<\/b> als Operatoren.<\/p>\n Der Command FilterBetween<\/b> (Zwischen) ist ein Sonderfall, weil Access keinen Feldwert liefert – der Benutzer muss zwei Grenzwerte selbst eingeben. Wir fragen diese per InputBox<\/b> ab (siehe Listing 7).<\/p>\n Listing 7: Sonderfall FilterBetween mit InputBox-Abfrage<\/span><\/b><\/p>\n Nachdem der Filterausdruck zusammengebaut wurde, wenden wir ihn an.<\/p>\n Dabei ist es wichtig, eine eventuell aktive Sortierung zu erhalten – ein neuer Filter soll die Sortierung nicht löschen:<\/p>\n CancelDefault = True<\/b> verhindert, dass Access nach unserem Callback noch seinen eigenen – nicht funktionierenden – Filtermechanismus aufruft.<\/p>\n Die Schaltfläche Filter ein\/aus<\/b> ruft OnAction_FilterRemove<\/b> auf. Sie hebt den aktiven Filter auf und behält dabei die Sortierung. Die Schaltfläche ist über getEnabled<\/b> nur dann aktiv, wenn tatsächlich ein Filter vorhanden ist – also wenn strLastSQL<\/b> einen WHERE<\/b>-Teil enthält (siehe Listing 8).<\/p>\n Listing 8: Filter aufheben und getEnabled-Callback<\/span><\/b><\/p>\n Das Dropdown-Menü im Spaltenkopf des Datenblatts bietet ebenfalls Sortier- und Filteroptionen an. Da wir dieses Menü nicht ersetzen können, fangen wir seine Aktionen über das Ereignis Form_ApplyFilter<\/b> ab.<\/p>\n Access ruft dieses Ereignis auf, bevor es die Sortierung oder Filterung intern anwendet – und gibt uns damit die Möglichkeit, die Aktion selbst zu übernehmen.<\/p>\n Das Ereignis liefert zwei Parameter: ApplyType<\/b> gibt an, welche Art von Aktion ausgelöst wurde, und Cancel<\/b> ermöglicht es, die Standardaktion zu unterdrücken.<\/p>\n In der Praxis hat sich gezeigt, dass Access ApplyType = 1<\/b> für das Setzen einer Sortierung oder eines Filters verwendet und ApplyType = 0<\/b> zum Aufheben.<\/p>\n Eine Besonderheit: Access übergibt bei ApplyType = 1<\/b> die gewünschte Sortierung über Me.OrderBy<\/b> und den gewünschten Filter über Me.Filter<\/b>. Nach Abschluss des Ereignisses setzt Access diese Eigenschaften aber wieder zurück – wir müssen sie also innerhalb des Ereignisses auswerten.<\/p>\n Ein weiteres Verhalten: Access ruft bei manchen Aktionen Form_ApplyFilter<\/b> zweimal auf – einmal mit ApplyType = 1<\/b> und direkt danach mit ApplyType = 0<\/b>.<\/p>\n Da wir im zweiten Aufruf (ApplyType = 0<\/b>) nur dann etwas tun, wenn strPendingSQL<\/b> leer ist, wird der zweite Aufruf automatisch ignoriert wenn bereits ein SQL zusammengebaut wurde.<\/p>\n Da das direkte Setzen des Recordsets innerhalb von Form_ApplyFilter<\/b> zu Abstürzen führen kann, verwenden wir einen Timer-Trick: Wir speichern den neuen SQL-String in strPendingSQL<\/b> und setzen das Timer-Intervall auf 1 Millisekunde.<\/p>\n Access führt den Timer-Callback erst aus, nachdem Form_ApplyFilter<\/b> vollständig abgeschlossen ist – also wenn der Call-Stack wieder leer ist (siehe Listing 9).<\/p>\n![\"Weitere](\"..\/fileadmin\/_temp_\/2026_03\/pic_1602_002.png\")
<\/p>\nDen SQL-Zustand im Modul halten<\/h2>\n
'SQL-Zustand des aktiven Formulars\r\nPublic <\/span>strBaseSQL As String<\/span>\r\nPublic <\/span>strLastSQL As String<\/span>\r\nPublic <\/span>strPendingSQL As String<\/span><\/pre>\nHilfsfunktionen für SQL-String-Manipulation<\/h2>\n
Public Function <\/span>GetWhereTeil(strSQL As String<\/span>) As String<\/span>\r\n Dim <\/span>strBisOrderBy As String<\/span>\r\n If <\/span>InStr<\/span>(strSQL, \" WHERE \") > 0 Then<\/span>\r\n strBisOrderBy = strSQL\r\n If <\/span>InStr<\/span>(strBisOrderBy, \" ORDER BY \") > 0 Then<\/span>\r\n strBisOrderBy = Left<\/span>(strBisOrderBy, InStr<\/span>(strBisOrderBy, \" ORDER BY \") - 1)\r\n End If<\/span>\r\n GetWhereTeil = Mid<\/span>(strBisOrderBy, InStr<\/span>(strBisOrderBy, \" WHERE \") + 7)\r\n End If<\/span>\r\nEnd Function<\/span>\r\nPublic Function <\/span>GetOrderByTeil(strSQL As String<\/span>) As String<\/span>\r\n If <\/span>InStr<\/span>(strSQL, \" ORDER BY \") > 0 Then<\/span>\r\n GetOrderByTeil = Mid<\/span>(strSQL, InStr<\/span>(strSQL, \" ORDER BY \") + 10)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nSortierung über das Ribbon<\/h2>\n
<group idMso=\"GroupSortAndFilter\" visible=\"false\"\/>\r\n<group id=\"grpSortierenFiltern\" label=\"Sortieren und Filtern\"\r\n insertAfterMso=\"GroupClipboard\">\r\n <toggleButton idMso=\"FiltersMenu\" size=\"large\"\/>\r\n <separator id=\"sep0\"\/>\r\n <toggleButton idMso=\"SortUp\" size=\"normal\"\/>\r\n <toggleButton idMso=\"SortDown\" size=\"normal\"\/>\r\n <button id=\"btnSortierungAufheben\" label=\"Sortierung entfernen\"\r\n imageMso=\"SortRemoveAllSorts\" size=\"normal\"\r\n onAction=\"OnAction_SortRemove\"\/>\r\n <separator id=\"sep1\"\/>\r\n <menu idMso=\"SortSelectionMenu\" size=\"large\"\/>\r\n <separator id=\"sep2\"\/>\r\n <button id=\"btnFilterAufheben\" label=\"Filter ein\/aus\"\r\n imageMso=\"FilterToggleFilter\" size=\"large\"\r\n onAction=\"OnAction_FilterRemove\"\r\n getEnabled=\"getEnabled\"\/>\r\n<\/group><\/pre>\n
![\"Neuer](\"..\/fileadmin\/_temp_\/2026_03\/pic_1602_003.png\")
<\/p>\n<commands>\r\n <command idMso=\"SortUp\" onAction=\"OnAction_Toggle\"\/>\r\n <command idMso=\"SortDown\" onAction=\"OnAction_Toggle\"\/>\r\n ... weitere Filter-Commands ...\r\n<\/commands><\/pre>\n
Sub <\/span>OnAction_Toggle(control As <\/span>IRibbonControl, ByRef pressed As Boolean<\/span>, ByRef CancelDefault)\r\n Dim <\/span>strRichtung As String<\/span>\r\n CancelDefault = True<\/span>\r\n Select Case control.Id\r\n Case <\/span>\"SortUp\"\r\n strRichtung = \"ASC\"\r\n Case <\/span>\"SortDown\"\r\n strRichtung = \"DESC\"\r\n End Select<\/span>\r\n SortierungAnwenden Screen.ActiveForm, Screen.ActiveControl.Name, strRichtung\r\nEnd Sub<\/span><\/pre>\nDie Funktion SortierungAnwenden<\/h2>\n
Public Sub <\/span>SortierungAnwenden(frm As <\/span>Form, strFeld As String<\/span>, strRichtung As String<\/span>)\r\n On Error Resume Next<\/span>\r\n strFeld = frm.Controls(strFeld).ControlSource\r\n On Error GoTo<\/span> 0\r\n strLastSQL = SQLMitSortierung(IIf(Len<\/span>(strLastSQL) > 0, strLastSQL, strBaseSQL), strFeld, strRichtung)\r\n Set<\/span> frm.Recordset = GetRecordset(strLastSQL)\r\n If <\/span>Not<\/span> objRibbon_Main Is Nothing Then<\/span>\r\n objRibbon_Main.Invalidate\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>SQLMitSortierung(strSQLQuelle As String<\/span>, strFeld As String<\/span>, strRichtung As String<\/span>) As String<\/span>\r\n Dim <\/span>strWhere As String<\/span>\r\n strWhere = GetWhereTeil(strSQLQuelle)\r\n SQLMitSortierung = strBaseSQL\r\n If <\/span>Len<\/span>(strWhere) > 0 Then<\/span>\r\n SQLMitSortierung = SQLMitSortierung & \" WHERE \" & strWhere\r\n End If<\/span>\r\n SQLMitSortierung = SQLMitSortierung & \" ORDER BY \" & strFeld & \" \" & strRichtung\r\nEnd Function<\/span><\/pre>\nSortierung aufheben<\/h2>\n
Sub <\/span>OnAction_SortRemove(control As <\/span>IRibbonControl)\r\n If <\/span>Len<\/span>(GetOrderByTeil(strLastSQL)) = 0 Then<\/span> Exit Sub<\/span>\r\n strLastSQL = strBaseSQL & IIf(Len<\/span>(GetWhereTeil(strLastSQL)) > 0, \" WHERE \" & GetWhereTeil(strLastSQL), \"\")\r\n Set<\/span> Screen.ActiveForm.Recordset = GetRecordset(strLastSQL)\r\n If <\/span>Not<\/span> objRibbon_Main Is Nothing Then<\/span>\r\n objRibbon_Main.Invalidate\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nFilterung über das Auswahl-Menü im Ribbon<\/h2>\n
Werte korrekt für SQL quoten<\/h2>\n
'Wert je nach Feldtyp quoten\r\nSelect Case lngTyp\r\n Case <\/span>3, 2, 16, 17, 18, 19, 20, 21 'Zahlentypen\r\n strWert = CStr(varWert)\r\n Case <\/span>7, 133, 134, 135 'Datumstypen\r\n strWert = \"#\" & Format(CDate(varWert), _\r\n \"mm\\\/dd\\\/yyyy\") & \"#\"\r\n Case Else<\/span> 'Text\r\n strWert = \"'\" & Replace<\/span>(CStr(varWert), _\r\n \"'\", \"''\") & \"'\"\r\nEnd Select<\/span><\/pre>\nDie Filterausdrücke im Überblick<\/h2>\n
Select Case control.Id\r\n Case <\/span>\"FilterEqualsSelection\"\r\n strFilter = strFeld & \" = \" & strWert\r\n Case <\/span>\"FilterNotEqualsSelection\"\r\n strFilter = strFeld & \" <> \" & strWert\r\n Case <\/span>\"FilterContainsSelection\"\r\n strFilter = strFeld & \" LIKE '%\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"%'\"\r\n Case <\/span>\"FilterDoesNotContainSelection\"\r\n strFilter = strFeld & \" NOT LIKE '%\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"%'\"\r\n Case <\/span>\"FilterBeginsWithSelection\"\r\n strFilter = strFeld & \" LIKE '\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"%'\"\r\n Case <\/span>\"FilterDoesNotBeginsWithSelection\"\r\n strFilter = strFeld & \" NOT LIKE '\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"%'\"\r\n Case <\/span>\"FilterEndsWithSelection\"\r\n strFilter = strFeld & \" LIKE '%\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"'\"\r\n Case <\/span>\"FilterDoesNotEndWithSelection\"\r\n strFilter = strFeld & \" NOT LIKE '%\" & _\r\n Replace<\/span>(CStr(varWert), \"'\", \"''\") & \"'\"\r\n Case <\/span>\"FilterSmallerThanSelection\"\r\n strFilter = strFeld & \" <= \" & strWert\r\n Case <\/span>\"FilterLargerThanSelection\"\r\n strFilter = strFeld & \" >= \" & strWert\r\n Case <\/span>\"FilterBeforeSelection\"\r\n strFilter = strFeld & \" < \" & strWert\r\n Case <\/span>\"FilterAfterSelection\"\r\n strFilter = strFeld & \" > \" & strWert\r\n Case <\/span>\"FilterIsSelected\"\r\n strFilter = strFeld & \" IS NOT NULL\"\r\n Case <\/span>\"FilterIsNotSelected\"\r\n strFilter = strFeld & \" IS NULL\"\r\nEnd Select<\/span><\/pre>\nSonderfall: Zwischen-Filter<\/h2>\n
Case <\/span>\"FilterBetween\"\r\n Dim <\/span>strVon As String<\/span>\r\n Dim <\/span>strBis As String<\/span>\r\n strVon = InputBox(\"Von:\", control.Id)\r\n If <\/span>strVon = \"\" Then<\/span> Exit Sub<\/span>\r\n strBis = InputBox(\"Bis:\", control.Id)\r\n If <\/span>strBis = \"\" Then<\/span> Exit Sub<\/span>\r\n Select Case lngTyp\r\n Case <\/span>3, 2, 16, 17, 18, 19, 20, 21\r\n strFilter = strFeld & \" >= \" & strVon & \" AND \" & strFeld & \" <= \" & strBis\r\n Case <\/span>7, 133, 134, 135\r\n strFilter = strFeld & \" >= #\" & Format(CDate(strVon), \"mm\\\/dd\\\/yyyy\") & \"# AND \" & strFeld & \" <= #\" & _\r\n Format(CDate(strBis), \"mm\\\/dd\\\/yyyy\") & \"#\"\r\n Case Else<\/span>\r\n strFilter = strFeld & \" >= '\" & Replace<\/span>(strVon, \"'\", \"''\") & \"' AND \" & strFeld & \" <= '\" & _\r\n Replace<\/span>(strBis, \"'\", \"''\") & \"'\"\r\n End Select<\/span><\/pre>\nFilter anwenden und bestehende Sortierung erhalten<\/h2>\n
If <\/span>Len<\/span>(strFilter) > 0 Then<\/span>\r\n CancelDefault = True<\/span>\r\n Dim <\/span>strOrderBy As String<\/span>\r\n strOrderBy = GetOrderByTeil(strLastSQL)\r\n strLastSQL = strBaseSQL & \" WHERE \" & strFilter\r\n If <\/span>Len<\/span>(strOrderBy) > 0 Then<\/span>\r\n strLastSQL = strLastSQL & \" ORDER BY \" & strOrderBy\r\n End If<\/span>\r\n Set<\/span> frm.Recordset = GetRecordset(strLastSQL)\r\nEnd If<\/span>\r\nIf <\/span>Not<\/span> objRibbon_Main Is Nothing Then<\/span>\r\n objRibbon_Main.Invalidate\r\nEnd If<\/span><\/pre>\nFilter aufheben<\/h2>\n
Sub <\/span>OnAction_FilterRemove(control As <\/span>IRibbonControl)\r\n If <\/span>Len<\/span>(GetWhereTeil(strLastSQL)) = 0 Then<\/span> \r\n Exit Sub<\/span>\r\n End If<\/span>\r\n strLastSQL = strBaseSQL & IIf(Len<\/span>(GetOrderByTeil(strLastSQL)) > 0, \" ORDER BY \" & GetOrderByTeil(strLastSQL), \"\")\r\n Set<\/span> Screen.ActiveForm.Recordset = GetRecordset(strLastSQL)\r\n If <\/span>Not<\/span> objRibbon_Main Is Nothing Then<\/span>\r\n objRibbon_Main.Invalidate\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nSub <\/span>getEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\n Select Case control.Id\r\n Case <\/span>\"btnFilterAufheben\"\r\n enabled = Len<\/span>(GetWhereTeil(strLastSQL)) > 0\r\n Case Else<\/span>\r\n enabled = True<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nSortierung und Filterung über den Datenblatt-Spaltenkopf<\/h2>\n
Private Sub <\/span>Form_ApplyFilter(Cancel As Integer<\/span>, ApplyType