<\/p>\n
Mit dem Einsatz von Klassen können Sie Ihren Programmcode übersichtlich gestalten. Wenn Sie konkrete Aufgaben mittels wiederverwendbarer Klassen umsetzen, erhalten Sie zusätzlich eine Code-Sammlung, die die Code-Qualität erhöht, weil Sie Korrekturen im Code nur noch an einer Stelle umsetzen müssen. Die in diesem Beitrag beschriebenen Klassen sind wiederverwendbare Klassen für die Erstellung eines Filterausdrucks, die Sie ohne änderung in Ihre Anwendung importieren und nutzen können.<\/b><\/p>\nZiel<\/h2>\n
Das Erstellen von SQL-Filterausdrücken soll standardisiert und ohne hohen Programmieraufwand für unterschiedliche SQL-Dialekte anwendbar werden.<\/p>\n
SQL-Text zum Filtern von Formulardaten oder als Bestandteil von SQL-Anweisungen für Recordsets wird regelmäßig benötigt. Beim Zusammenstellen der SQL-Anweisungen muss auf die passende Konvertierung in Text geachtet werden. Die Konvertierung sowie das Zusammenfügen mehrerer Filter-Kriterien können zu schlecht lesbarem Code führen. Eine Sammlung von Hilfsprozeduren und Klassen soll diese Aufgaben vereinfachen.<\/p>\n
Die Lösung stellt die folgenden Anforderungen:<\/p>\n
Der Lösungsansatz beinhaltet die folgenden Elemente:<\/p>\n
Die Klasse SqlTools <\/b>stellt Methoden zum Erstellen eines SQL-Ausdrucks bereit. Die Methoden TextToSqlText<\/b>, NumberToSqlText<\/b>, DateToSqlText <\/b>und BooleanToSqlText <\/b>konvertieren Werte mit einem bestimmten Datentyp in einen SQL-konformen Text.<\/p>\n
Damit diese Konvertierungsfunktion Text für verschiedene SQL-Dialekte erzeugen können, müssen Sie die gewünschten Formate als Parameter an die Konvertier-Funktionen weitergeben oder Sie stellen die Formate mit den Eigenschaften SqlDateFormat<\/b>, SqlBooleanTrueString <\/b>und SqlWildCardString <\/b>für die Klassen-Instanz ein. Die Methode ConvertToSqlText <\/b>bildet einen zentralen Einstiegspunkt dieser Konvertierungsfunktionen. In Listing 1 sehen Sie Auszüge aus der Beispiele-Datei SqlTools_Beispiele.mdb<\/b>.<\/p>\n Listing 1: Einsatz der Konvertierungsfunktionen<\/span><\/b><\/p>\n Zum Erstellen eines Filterausdrucks übergeben Sie den Datenfeldnamen, den Datentyp, den gewünschten Vergleichsausdruck und den Wert an die Methode BuildCriteria<\/b>. Innerhalb der Methode wird der Wert über die Konvertierungsfunktion für den jeweiligen Datentyp in SQL-Text umgeformt. Aus den Enum<\/b>-Werten vom RelationalOperator<\/b>-Parameter wird der Vergleichsausdruck erstellt.<\/p>\n Diese Texte werden mit dem Feldnamen zu einem Filterausdruck zusammengefügt und als Funktionsergebnis zurückgegeben. Die Beispiele in Listing 2 zeigen übliche Varianten für Vergleichsausdrücke.<\/p>\n Listing 2: BuildCriteria-Beispiele<\/span><\/b><\/p>\n Für Between<\/b>-Filterbedingungen gibt es spezielle Features in der SqlTools<\/b>-Klasse. Wenn Sie beispielsweise einen Datumsfilter erzeugen wollen und in den zu filternden Werten auch die Uhrzeit enthalten ist, können Sie SQL_Add_WildCardSuffix <\/b>verwenden, um den ganzen Tag des Ende-Datums anzugeben. Der Between<\/b>-Ausdruck wird zu einem Feld >= Startdatum And Feld < (EndDatum+1)<\/b>-Ausdruck umgeschrieben.<\/p>\n übergeben Sie Null<\/b> an einen der Wert-Parameter, wird der Between<\/b>-Ausdruck wieder umgeformt, da Null <\/b>standardmäßig als Filterwert nicht berücksichtigt werden soll. Beispiele zu diesen Features sehen Sie in Listing 3.<\/p>\n <\/p>\n Listing 3: BuildCriteria: Between-Features<\/span><\/b><\/p>\n Wie Ihnen bereits bei der Between<\/b>-Bedingung aufgefallen ist, kann man an die BuildCriteria<\/b>-Methode mehr als einen Filterwert für eine Filterbedingung übergeben. Für einen Between<\/b>-Ausdruck werden immer zwei Werte benötigt. Für einen In<\/b>-Filterausdruck können Sie ein Array als übergabewert verwenden.<\/p>\n Listing 4 zeigt neben der In<\/b>-Variante noch eine weitere Variante, mit der Sie mehrere Filterwerte für ein Datenfeld in einer BuildCriteria<\/b>-Zeile verwenden können. Wenn Sie ein Array mit Werten übergeben und als RelationalOperator <\/b>nicht SQL_In <\/b>verwenden, wird für jeden Array-Wert ein Filterausdruck erzeugt und diese Filterausdrücke werden mit Or <\/b>verbunden.<\/p>\n Listing 4: BuildCriteria: Array-übergabe<\/span><\/b><\/p>\n Die bisher erwähnten Methoden und Eigenschaften sind für den Aufgabenbereich der Klasse ausreichend. In der Klasse sind noch zwei weitere Methoden enthalten, die die Verwendung der Klasse vereinfachen. Mit Clone können Sie eine vorhandene Instanz einschließlich der Formateinstellungen kopieren. NewInstance ermöglicht die Erstellung einer neuen Instanz mit der Möglichkeit, die SQL-Formate als Parameter einzustellen. Die letzten zwei Methoden sind nützlich, da SqlTools selbst-instanziierend gestaltet ist. Sie können den Klassennamen direkt in VBA einsetzen und auf eine Factory-Methode verzichten.<\/p>\n Das ist vorteilhaft, wenn Sie hauptsächlich einen bestimmten SQL-Dialekt verwenden und nur selten SQL-Text für einen anderen Dialekt benötigen. Sie müssen dafür nur einmalig beim Anwendungsstart die SQL-Formate übergeben oder im Code der SqlTools-Klasse die Konstanten im Klassenkopf für die Standardwerte entsprechend einstellen.<\/p>\n In vielen Fällen werden mehr als ein Filterkriterium benötigt. Für diese Aufgabe – das Zusammenführen von mehreren Filterbedingungen – ist die Klasse FilterStringBuilder <\/b>zuständig. Zum Erstellen eines kombinierten Filterausdrucks erzeugen Sie eine neue Instanz der FilterStringBuilder<\/b>-Klasse. Falls die Instanz nicht die Standard-Instanz der SqlTools <\/b>verwenden soll, übergeben Sie an die Eigenschaft SqlTool <\/b>eine passende Referenz von einer SqlTools<\/b>-Instanz oder Sie stellen über die Methode ConfigSqlFormat <\/b>die benötigten SQL-Formate ein. Für die Verwendung in einer Prozedur können Sie einen With<\/b>-Ausdruck zum Erzeugen einer Instanz verwenden. In Listing 5 sehen Sie eine Grundstruktur für einen Code, der mittels FilterStringBuilder<\/b> einen Filterausdruck erzeugt.<\/p>\n Listing 5: FilterStringBuilder verwenden<\/span><\/b><\/p>\n Die im Filterausdruck benötigten Kriterien fügen Sie mittels Add<\/b>-Methode an. Den Text für den SQL-Filterausdruck lesen Sie über die Methode ToString <\/b>aus.<\/p>\n In dieser Methode können Sie optional den Verkettungsausdruck einstellen, damit die einzelnen Filterbedingungen mit And <\/b>oder Or <\/b>verkettet werden. Verwenden Sie die Methode AddCriteria <\/b>zum Anfügen eines fertigen SQL-Textes als Filterausdruck. Die Parameter der Add<\/b>-Methode sind identisch mit den Parametern der BuildCriteria<\/b>-Methode aus der SqlTools<\/b>-Klasse. Die Parameterwerte werden innerhalb der Add<\/b>-Methode ohne Zwischenbearbeitung direkt an die BuildCriteria<\/b>-Methode der eingestellten SqlTools<\/b>-Instanz übergeben.<\/p>\n Ein Vorteil bei der Verwendung der FilterStringBuilder<\/b>-Klasse ist, dass Filterwerte, die in der Ausschlussliste enthalten sind, nicht in den Filterstring übernommen werden. Die Ausschlussliste können Sie über den Parameter IgnoreValue <\/b>der Add<\/b>-Methode je Filterbedingung einstellen. Als Standardwert ist Null <\/b>eingestellt, da in der üblichen Verwendung bei Filtersteuerelementen in Formularen Null <\/b>als Inhalt von leeren Steuerelementen nicht als Filterwert dienen soll, sondern der Filter auf das dazugehörige Feld nicht angewendet werden soll. Der Code in Listing 6 zeigt den Einsatz des Parameters IgnoreValue<\/b>.<\/p>\n Listing 6: FilterStringBuilder: Einsatz von IgnoreValue<\/span><\/b><\/p>\n Wie Sie im Ergebnis von Debug.Print <\/b>sehen, wird die Filterbedingung für das Feld A <\/b>erzeugt. Wenn Sie bei Textwerten neben Null <\/b>auch Leerstrings ignorieren wollen, können Sie ein Array mit Null <\/b>und vbNullString <\/b>übergeben. Dies wurde beim Definieren der Filterbedingung für das Feld B <\/b>verwendet, daher ist der Filterausdruck für B <\/b>nicht im Filtertext enthalten.<\/p>\n Beim Filterausdruck für das Feld C <\/b>sehen Sie, dass von den mittels Array übergebenen Filterwerten die Werte aus dem IgnoreValue<\/b>-Array nicht vorkommen. Wenn Sie Null<\/b>-Filterwerte zulassen wollen, können Sie, wie im Filterausdruck für D <\/b>gezeigt, den Standardwert mit einem Wert überschreiben, die nie zum ausgewählten Datentyp passen wird. Beim Textdatentyp verwenden Sie beispielsweise eine Zahl und bei allen anderen Datentypen verwenden Sie einen Buchstaben. Damit werden alle übergebenen Filterwerte im Filterausdruck berücksichtigt und aus einem Null-Filterwert wird ein Filterausdruck mit Is Null<\/b>.<\/p>\n üblicherweise werden Sie die FilterStringBuilder<\/b>-Klasse nicht, wie bisher in den Beispielen gezeigt, mit konstanten Filterwerten verwenden, sondern die Werte aus Variablen oder Formularsteuerelementen einsetzen. Da Sie mittels Add<\/b>-Methode nur die Filterbedingung definieren, müssen Sie im Code nicht darauf achten, welcher Wert in der Variablen oder im Steuerelement enthalten ist. Die korrekte Konvertierung in SQL-Text oder das Auslassen der Bedingung im Filterausdruck, weil der Filterwert ignoriert werden soll, nimmt Ihnen der Code in der Klasse ab.<\/p>\n Das letzte Beispiel im Beitrag Filterbedingungen einfach zusammenstellen <\/b>(www.access-im-unternehmen.de\/47<\/b>) zeigt einen üblichen Einsatz in einem Formular zu Datenfilterung. Das Formular mit dem vollständigen Code ist in der Beispielanwendung Suedsturm-FilterForm.mdb <\/b>enthalten. In Listing 7sehen Sie einen Auszug aus diesem Code. Dieser Code ist nach der Struktur aus Listing 5 aufgebaut. Anstelle von konstanten Filterwerten werden die Werte aus Steuerelementen verwendet.<\/p>\n Listing 7: CreateFilterString aus einem Suchformular<\/span><\/b><\/p>\n Die Filter-Klassen sind in der Quellcode-Verwaltung von access-codelib.net<\/b> gespeichert. Zum Einfügen in Ihre Anwendung können Sie den ACLib-FilterForm-Wizard <\/b>verwenden. Dieses Access-Add-In wird regelmäßig aktualisiert, sobald Fehler in den Filter-Klassen behoben oder Features ergänzt werden. Im Beitrag Der ACLib-FilterForm-Wizard <\/b>(www.access-im-unternehmen.de\/1020<\/b>) wird die Verwendung des Add-Ins beschrieben. Wenn Sie den aktuellsten Code der Klassen verwenden wollen, können Sie die Klassen direkt aus der Quellcodeverwaltung einsetzen.<\/p>\n Dafür übertragen Sie den aktuellen Code mit TortoiseSVN aus der Quellcodeverwaltung in Ihr Dateisystem und nutzen den ACLib-Import-Wizard zum Einfügen bzw. Aktualisieren der Code-Module.<\/p>\n Die gezeigten Filterklassen sind nicht als Beispiel-Code gedacht, den Sie anpassen müssen, um eine funktionierende Klasse zu erhalten. Diese Klassen stellen vielmehr eine Code-Sammlung dar, die Sie ohne Veränderung nutzen können. Natürlich dürfen Sie individuelle Verbesserungen in die Klassen einbauen, dann profitieren Sie aber möglicherweise später nicht mehr von den Verbesserungen anderer Entwickler.<\/p>\n Wenn Sie beispielsweise die SqlTools<\/b>-Klasse ändern wollen, ändern Sie nicht diese Klasse, sondern erstellen Sie eine neue Klasse, die die Schnittstelle von SqlTools <\/b>unterstützt. Anschließend können Sie Ihre neue Klasse an die FilterStringBuilder<\/b>-Klasse übergeben, ohne diese ändern zu müssen. Für allgemeine Verbesserungsvorschläge dienen das Forum und der Bugtracker in http:\/\/access-codelib.net<\/b>.<\/p>\n Wenn Sie einen Fehler in den Klassen finden, schreiben Sie diesen bitte in den Bugtracker unter http:\/\/bug.access-codelib.net\/<\/b>, damit der Fehler im Code-Archiv behoben wird. Sie dürfen natürlich den Fehler selbst beheben und den korrigierten Code in den Entwurfszeig der Quellcodeverwaltung stellen. Dafür benötigen Sie allerdings Schreibrechte für das Subversion-Repository, welches Sie nach Anmeldung im Forum beantragen können.<\/p>\n Die Funktionsweise der Klassen wird mit Unit-Tests sichergestellt. Die Unit-Tests beschreiben das gewünschte Verhalten der Klassen. Bevor eine Klasse in den trunk-Zweig (freigegebener, geprüfter Code) der Quellcodeverwaltung kopiert wird, müssen alle Tests erfolgreich durchlaufen werden.<\/p>\n Die Filter-Klassen dienen als Werkzeug für die Filterstring-Erstellung. Für Konvertierung in SQL-Text dient die SqlTools<\/b>-Klasse. Die FilterStringBuilder<\/b>-Klasse erzeugt aus einzelnen Filterbedingungen einen zusammengefassten Filterausdruck. Zum Filtern in Formularen über Steuerelemente übernimmt die, in diesem Beitrag nicht gezeigte, FilterControlManager<\/b>-Klasse die Steuerung. In der Suedsturm<\/b>-Beispielanwendung ist ein Formular mit Filterstring<\/b>-Erzeugung durch diese Klasse enthalten.<\/p>\n Die FilterControlManager<\/b>-Klasse nutzt die FilterStringBuilder<\/b>– und die SqlTools<\/b>-Klasse, um aus Filterwertänderungen in den Steuerelementen den Filterstring zu aktualisieren. Auf eine ähnliche Art könnten Sie eine Klasse erstellen, die nicht nur den Filterstring erzeugt, sondern direkt in das Filterformular eingreift und den Filter über eine passende Filtermethode anwendet. <\/p>\n Enthaltene Beispieldateien:<\/p>\n FilterStringBuilder-Beispiele.mdb<\/p>\n SqlTools-Beispiele.mdb<\/p>\nPrivate Sub <\/span>DatentypToSqlText()\r\n [...]\r\n FilterWert = DateSerial(2015, 12, 24)\r\n SqlText = SqlTools.DateToSqlText(FilterWert, \"\\#yyyy-mm-dd\\#\")\r\n Debug.Print<\/span> \"Aus \"; FilterWert; \" wird \"; SqlText\r\n '' --> Aus 24.12.2015 wird #2015-12-24#\r\n [...]\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>ConvertToSqlText_JetDaoDialekt()\r\n [...]\r\n ''SQL-Formate einstellen\r\n With<\/span> SqlTools\r\n .SqlDateFormat = \"\\#yyyy-mm-dd\\#\"\r\n .SqlBooleanTrueString = \"True\"\r\n End With<\/span>\r\n [...]\r\n FilterWert = DateSerial(2015, 12, 24)\r\n SqlText = SqlTools.ConvertToSqlText(FilterWert, SQL_Date)\r\n Debug.Print<\/span> \"Aus \"; FilterWert; \" wird \"; SqlText\r\n [...]\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BuildCriteria_EqualGreaterThan()\r\n [...]\r\n FilterWert = \"O''Neill\"\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, SQL_Equal + SQL_GreaterThan, FilterWert)\r\n Debug.Print<\/span> \"SQL_Text:\", SqlText\r\n '' --> Textfeld >= ''O''''Neill''\r\n [...]\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>BuildCriteria_Like()\r\n [...]\r\n FilterWert = \"abc\"\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, SQL_Like, FilterWert)\r\n Debug.Print<\/span> \"SQL_Text:\", SqlText\r\n '' --> Textfeld Like ''abc''\r\n FilterWert = \"a\"\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, SQL_Like + SQL_Add_WildCardSuffix, FilterWert)\r\n Debug.Print<\/span> \"SQL_Text:\", SqlText\r\n '' --> Textfeld Like ''a*''\r\n FilterWert = \"c\"\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, SQL_Like + SQL_Add_WildCardPrefix, FilterWert)\r\n Debug.Print<\/span> \"SQL_Text:\", SqlText\r\n '' --> Textfeld Like ''*c''\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BuildCriteria_Between_Features()\r\n [...]\r\n ''Datum + SQL_Add_WildCardSuffix:\r\n ErsterWert = DateSerial(2015, 12, 1)\r\n ZweiterWert = DateSerial(2015, 12, 31)\r\n SqlText = SqlTools.BuildCriteria(\"Datumsfeld\", SQL_Date, _\r\n SQL_Between + SQL_Add_WildCardSuffix, ErsterWert, ZweiterWert)\r\n Debug.Print<\/span> \"SQL_Date + SQL_Add_WildCardSuffix: zwischen \"; _\r\n ErsterWert; \"und \"; ZweiterWert; \"ergibt:\"; vbNewLine; SqlText\r\n '' --> Datumsfeld >= #2015-12-01# And Datumsfeld < #2016-01-01#\r\n ''Nullwerte:\r\n ErsterWert = 1\r\n ZweiterWert = Null\r\n SqlText = SqlTools.BuildCriteria(\"Zahlenfeld\", SQL_Numeric, _\r\n SQL_Between, ErsterWert, ZweiterWert)\r\n Debug.Print<\/span> \"ZweiterWert = Null: \"; SqlText\r\n '' --> Zahlenfeld >= 1\r\n ErsterWert = Null\r\n ZweiterWert = 5\r\n SqlText = SqlTools.BuildCriteria(\"Zahlenfeld\", SQL_Numeric, _\r\n SQL_Between, ErsterWert, ZweiterWert)\r\n Debug.Print<\/span> \"ErsterWert = Null: \"; SqlText\r\n '' --> Zahlenfeld <= 5\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BuildCriteria_ArrayUebergabe()\r\n [...]\r\n '' In(...):\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, _\r\n SQL_In, Array(\"a\", \"c\", \"l\"))\r\n Debug.Print<\/span> \"SQL_Text, In(...):\", SqlText\r\n '' --> Textfeld In (''a'',''c'',''l'')\r\n SqlText = SqlTools.BuildCriteria(\"Zahlenfeld\", SQL_Numeric, _\r\n SQL_In, Array(1, 3, 5))\r\n Debug.Print<\/span> \"SQL_Numeric, In(...):\", SqlText\r\n '' --> Zahlenfeld In (1,3,5)\r\n '' Mehrere Filter mit Or kombiniert\r\n SqlText = SqlTools.BuildCriteria(\"Textfeld\", SQL_Text, _\r\n SQL_Like + SQL_Add_WildCardSuffix, Array(\"a\", \"c\", \"l\"))\r\n '' --> Textfeld Like ''a*'' Or Textfeld Like ''c*'' Or Textfeld Like ''l*''\r\nEnd Sub<\/span><\/pre>\nKlasse FilterStringBuilder<\/h2>\n
Private Sub <\/span>FilterStringBuilder_Grundstruktur()\r\n Dim <\/span>FilterString As String<\/span>\r\n With<\/span> New<\/span> FilterStringBuilder\r\n ''SQL-Formate einstellen\r\n .ConfigSqlFormat \"\\#yyyy-mm-dd\\#\", \"True\", \"*\"\r\n ''oder neue SqlTools-Instanz erzeugen:\r\n ''Set<\/span> .SqlTool = SqlTools.Clone(\"\\#yyyy-mm-dd\\#\", \"True\", \"*\")\r\n ''oder vorhandene SqlTools-Instanz verwenden:\r\n ''Set<\/span> .SqlTool = DaoSqlTools \r\n ''Filterbedingungen anfügen:\r\n .Add \"Datumsfeld\", SQL_Date, SQL_LessThan, DateSerial(2015, 12, 24)\r\n .Add \"Zahlenfeld\", SQL_Numeric, SQL_Equal + SQL_GreaterThan, 1.23\r\n '' ...\r\n ''Filterausdruck ausgeben:\r\n FilterString = .ToString(SQL_And)\r\n End With<\/span>\r\n Debug.Print<\/span> FilterString\r\n '' --> (Datumsfeld < #2015-12-24#) And (Zahlenfeld >= 1.23)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>FilterStringBuilder_IgnoreValue()\r\n Dim <\/span>FilterString As String<\/span>\r\n With<\/span> New<\/span> FilterStringBuilder\r\n .ConfigSqlFormat \"\\#yyyy-mm-dd\\#\", \"True\", \"*\"\r\n ''Filterbedingungen:\r\n .Add \"A\", SQL_Text, SQL_Equal, vbNullString\r\n .Add \"B\", SQL_Text, SQL_Equal, vbNullString, , _\r\n Array(Null, vbNullString)\r\n .Add \"C\", SQL_Numeric, SQL_In, Array(1, 3, 5, 7, 11, 13, 17), , _\r\n Array(1, 3, 5)\r\n .Add \"D\", SQL_Text, SQL_Equal, Null, , 0\r\n FilterString = .ToString(SQL_And)\r\n End With<\/span>\r\n Debug.Print<\/span> FilterString\r\n '' --> (A = '''') And (C In (7,11,13,17)) And (D Is Null)\r\nEnd Sub<\/span><\/pre>\nEinsatz in der Praxis<\/h2>\n
Private Function <\/span>CreateFilterString() As String<\/span>\r\n ''Diese Prozedur erzeugt den Filterausdruck \r\n ''aus den Filter-Steuerelementen\r\n With<\/span> New<\/span> FilterStringBuilder\r\n Set<\/span> .SqlTool = DaoSqlTools\r\n .Add \"KundenCode\", SQL_Text, SQL_Like, Me.fctlKundenCode.Value\r\n .Add \"Kunde_Firma\", SQL_Text, SQL_Like, Me.fctlKundeFirma.Value\r\n [...]\r\n CreateFilterString = .ToString(SQL_And)\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\nKopieren der Klassen in eine Access-Anwendung<\/h2>\n
Quellen:<\/h2>\n
\n
Weiterentwicklung der Klassen<\/h2>\n
Code-Qualität<\/h2>\n
Zusammenfassung<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n