<\/p>\n
Erstellen Sie in Ihren Anwendungen mit VBA Filterausdrücke, um Formulare zu filtern oder Recordsets mit einer gefilterten Datenherkunft zu öffnen Sind Ihnen dabei schon Fehler passiert, weil Sie die Werte nicht richtig konvertiert haben Oder finden Sie den Code zum Filtern zu aufwendig und suchen eine Möglichkeit, die Erstellung des Filtertextes zu vereinfachen Im vorliegenden Beitrag werden Sie verfolgen, wie eine Code-Struktur entsteht, die alle notwendigen Konvertierungsregeln berücksichtigt und trotzdem in der Anwendung übersichtlich ist und Programmierfehler vermeidet.<\/b><\/p>\nProblemstellung<\/h2>\n
In Access-Anwendungen wird relativ oft mittels VBA ein Filterausdruck zusammengestellt. Typische Beispiele sind:<\/p>\n
Beim Zusammensetzen der SQL-Texte werden – wie Sie in vielen Beiträgen in Foren lesen können – regelmäßig Fehler gemacht. Es wird der Datentyp nicht SQL-konform in Text konvertiert, mögliche Null-Werte werden übersehen, statt dem Variableninhalt wird der Variablenname in den SQL-Ausdruck übernommen und so weiter. Damit Ihnen diese Fehler nicht passieren, beschreiben wir zuerst die Grundlagen für das Zusammenstellen von SQL-Anweisungen in VBA. Anschließend erstellen wir einen Code (in Form von Klassen), der die richtige Syntax für Sie erzeugt. Sie müssen den Klassen in Ihren Anwendungen nur noch Ihr Vorhaben mittels VBA-Anweisung mitteilen, um den gewünschten Filterausdruck zu erstellen.<\/p>\n
Bei der Konvertierung von Filterwerten in einen SQL-Text müssen Sie jeden Datentyp passend für das verwendete Datenbanksystem konvertieren. Die folgenden Absätze beschreiben dies für die relevanten Datentypen.<\/p>\n
Ein Text muss mit Hochkommata (“<\/b>) umschlossen werden. Je nach Datenbanksystem sind auch Anführungszeichen („) oder ähnliches möglich. Im weiteren Text werden wir zur Vereinfachung von Access\/Jet-SQL für DAO ausgehen.<\/p>\n
Beispiele:<\/p>\n
... WHERE Textfeld = ''Filtertext''\r\n... WHERE Textfeld LIKE ''Filtertext*''<\/pre>\nWenn im zu filternden Text ein Hochkomma (“<\/b>) enthalten ist (Beispiel: O“Neill<\/b>), muss das Zeichen verdoppelt werden, damit der SQL-Interpreter erkennen kann, dass der Text noch nicht zu Ende ist. Aus dem Ausdruck<\/p>\n
... WHERE Textfeld = ''O''Neill''<\/pre>\nwird dann der folgende Ausdruck (mit O““Neill<\/b>):<\/p>\n
... WHERE Textfeld = ''O''''Neill'' <\/pre>\nZahlen<\/h2>\n
Zahlen sind in englischer Schreibweise mit Punkt als Dezimaltrennzeichen zu verwenden.<\/p>\n
... WHERE Zahlfeld = 1.23<\/pre>\nDatum<\/h2>\n
Datumswerte sind im SQL-Text für Jet-SQL mit dem Raute-Zeichen (#<\/b>) zu umschließen. Die Reihenfolge für Tag, Monat und Jahr muss in amerikanischer Schreibweise (mm\/dd\/yyyy<\/b>) oder im ISO-Format (yyyy-mm-dd<\/b>) erfolgen. Die erforderlichen Datumsformate sehen je nach Datenbanksystem unterschiedlich aus. Beispiele für Jet-SQL:<\/p>\n
... WHERE Datumsfeld = #12\/24\/2015#\r\n... WHERE Datumsfeld = #2015-12-24#\r\n... WHERE Datumsfeld = #2015-12-24 16:30:00#<\/pre>\nT-SQL (SQL-Server):<\/p>\n
... WHERE Datumsfeld = ''20151224''\r\n... WHERE Datumsfeld = ''20151224 16:30:00''<\/pre>\nJa\/Nein (Boolean)<\/h2>\n
In Access-Datenbanken wird True <\/b>als -1 <\/b>in Zahlenschreibweise verwendet. Der SQL-Server (T-SQL) betrachtet 1 <\/b>als True <\/b>bei Bit-Datenfeldern. Im SQL-Text einer Access-Abfrage beziehungsweise DAO-Recordset und ähnlichen ist die Angabe von True <\/b>statt -1 <\/b>zu empfehlen.<\/p>\n
Dann gibt es auch bei Abfragen auf über ODBC verknüpfte SQL-Server-Tabellen keine Probleme.<\/p>\n
... WHERE JaNeinFeld = True<\/span><\/pre>\nStolperfallen<\/h2>\n
Beim Zusammensetzen eines SQL-Textes entstehen die meisten Fehler beim Einbinden von Werten aus Variablen oder Steuerelementen in den SQL-Text.<\/p>\n
\n
- Die Konvertierung der Variablenwerte in einen SQL-Ausdruck wird nicht beziehungsweise falsch durchgeführt.<\/li>\n
- Verdoppeln des Begrenzungszeichens vom Text (meist “) wird übersehen, falls das Zeichen im Text enthalten ist. <\/li>\n
- Wenn die Zusammenstellung des SQL-Textes über mehrere VBA-Zeilen erfolgt, werden notwendige Leerzeichen übersehen.<\/li>\n<\/ul>\n
Diese Stolperfallen können Sie problemlos vermeiden, wenn Sie die Vorgehensweise für das Zusammenstellen eines SQL-Textes verinnerlichen und die für Ihr Datenbanksystem gültige SQL-Syntax kennen.<\/p>\n
Vom statischen Text zum dynamisch aus Werten in Steuerelementen erstellten Text<\/h2>\n
Wenn Sie nicht sicher sind, wie ein SQL-Text mit Filterwerten aus Steuerelementen oder Variablen zusammengesetzt wird, versuchen Sie die Erstellung in umgekehrter Reihenfolge anzugehen.<\/p>\n
Nehmen Sie zum Ausprobieren der SQL-Anweisungen einen fixen Filterwert (welcher später etwa durch eine Benutzereingabe übergeben wird) an und erstellen im Access-Abfrageeditor eine SQL-Anweisung. Die Funktionsfähigkeit dieser SQL-Anweisung testen Sie nun. Wenn die Abfrage das erwartete Ergebnis liefert, wissen Sie, dass diese SQL-Anweisung passt.<\/p>\n
Beispiel:<\/p>\n
SELECT * FROM tabTest WHERE Textfeld LIKE ''abc*''<\/pre>\nStufe 1: Vollständiger SQL-Text in Variable<\/h2>\n
Nun kopieren Sie diese SQL-Anweisung und speichern sie in einer String<\/b>-Variable in einer Test-Prozedur, wie in Listing 1 gezeigt, ab.<\/p>\n
Private Sub <\/span>SqlText_VBA_Stufe1()\r\n Dim <\/span>SqlText As String<\/span>\r\n SqlText = \"SELECT * FROM tabTest WHERE Textfeld LIKE ''abc*''\"\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span><\/pre>\nListing 1: VBA-Ausbaustufe 1<\/span><\/b><\/p>\n
Zum öffnen eines Recordsets mit dem in VBA gespeicherten SQL-Text und zur Ausgabe der enthaltenen Datensätze in den Direktbereich verwenden wir die Hilfsprozedur aus Listing 2.<\/p>\n
Private Sub <\/span>SqlAnweisungAuswerten(ByVal SqlText As String<\/span>)\r\n Debug.Print<\/span> \"SQL: \"; SqlText\r\n With<\/span> CurrentDb.OpenRecordset(SlText)\r\n Do While<\/span> Not<\/span> .EOF\r\n Debug.Print<\/span> \"ID: \"; .Fields(\"idTest\"), _\r\n \"Textfeld: \"; .Fields(\"Textfeld\")\r\n .MoveNext<\/span>\r\n Loop<\/span>\r\n .Close\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 2: Hilfsprozedur zum Auswerten einer SQL-Anweisung<\/span><\/b><\/p>\n
Stufe 2: Filterausdruck als extra String verketten<\/h2>\n
Im nächsten Ausbauschritt (s. Listing 3) trennen wir den Filterausdruck von der restlichen SQL-Anweisung (SqlText_VBA_Stufe2a<\/b>). Desweiteren speichern wir den Filterausdruck in einer zusätzlichen Variablen ab und verketten diese Variable mit dem restlichen SQL-Ausdruck (SqlText_VBA_Stufe2b<\/b>). Zusätzlich zur Variable für den gesamten Filterausdruck können wir den Filterwert (im SQL-Format) in einer Stringvariable speichern (SqlText_VBA_Stufe2c<\/b>).<\/p>\n
Private Sub <\/span>SqlText_VBA_Stufe2a()\r\n Dim <\/span>SqlText As String<\/span>\r\n SqlText = \"SELECT * FROM tabTest WHERE \" & \"Textfeld LIKE ''abc*''\"\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>SqlText_VBA_Stufe2b()\r\n Dim <\/span>SqlText As String<\/span>\r\n Dim <\/span>SqlFilter As String<\/span>\r\n SqlFilter = \"Textfeld LIKE ''abc*''\"\r\n SqlText = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>SqlText_VBA_Stufe2c()\r\n Dim <\/span>SqlText As String<\/span>\r\n Dim <\/span>SqlFilter As String<\/span>\r\n Dim <\/span>WertImSqlFormat As String<\/span>\r\n WertImSqlFormat = \"''abc*''\"\r\n SqlFilter = \"Textfeld LIKE \" & FilterWertImSqlFormat\r\n SqlText = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span><\/pre>\nListing 3: VBA-Ausbaustufe 2<\/span><\/b><\/p>\n
Stufe 3: Filterwerte in passenden SQL-Text konvertieren<\/h2>\n
In den obigen Beispielen wurde der SQL-Text für den Filterwert im passenden SQL-Format in der Variable gespeichert.<\/p>\n
üblicherweise muss der Filterwert in SQL-Text konvertiert werden, weil die Werte zum Beispiel aus Steuerelementen in Formularen oder aus VBA-Variablen kommen, die nur den Wert und nicht dessen SQL-Ausdruck enthalten.<\/p>\n
Ablauf des Codes in Listing 4: Aus dem String abc* <\/b>soll der SQL-Ausdruck “abc*“ <\/b>entstehen. Dazu werden die Hochkommata (“<\/b>) mit dem Filterwert verkettet („““ & „abc*“ & „““<\/b>). Von den anfangs genannten Regeln wissen wir, dass die im Filterwert enthaltenen Hochkommata verdoppelt werden müssen. Das erledigt die Replace<\/b>-Funktion.<\/p>\n
Private Sub <\/span>SqlText_VBA_Stufe3()\r\n Dim <\/span>SqlText As String<\/span>\r\n Dim <\/span>SqlFilter As String<\/span>\r\n Dim <\/span>WertImSqlFormat As String<\/span>\r\n Dim <\/span>FilterWert As String<\/span>\r\n FilterWert = \"abc*\"\r\n WertImSqlFormat = \"''\" & Replace<\/span>(FilterWert, \"''\", \"''''\") & \"''\"\r\n SqlFilter = \"Textfeld LIKE \" & WertImSqlFormat\r\n SqlText = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span><\/pre>\nListing 4: VBA-Ausbaustufe 3<\/span><\/b><\/p>\n
Bei anderen Datentypen können Sie die gleiche Vorgehensweise anwenden.<\/p>\n
Sie müssen nur die Zeile WertimSqlFormat = … <\/b>entsprechend anpassen, damit der Filterwert in das passende SQL-Format konvertiert wird.<\/p>\n
Möglicher Umwandlungscode für Text:<\/p>\n
WertImSqlFormat = \"''\" & Replace<\/span>(FilterWert, \"''\", \"''''\") & \"''\"<\/pre>\nFür Zahlen:<\/p>\n
WertImSqlFormat = Str(FilterWert)<\/pre>\nDie Str<\/b>-Funktion nicht mit der CStr<\/b>-Funktion verwechseln!<\/p>\n
Für Datumsangaben:<\/p>\n
WertImSqlFormat = Format(FilterWert, \"\\#yyyy-mm-dd\\#\")<\/pre>\nFür Ja\/Nein-Felder (Boolean<\/b>):<\/p>\n
WertImSqlFormat = IIf(FilterWert = True, \"True\", \"False\")<\/pre>\nStufe 4: Filter kombinieren<\/h2>\n
Im nächsten Code-Beispiel (s. Listing 5) erstellen wir SQL-Filtertexte für verschiedene Datentypen und fügen sie zu einem kombinierten Filterausdruck zusammen.<\/p>\n
Private Sub <\/span>SqlText_VBA_Stufe4()\r\n Dim <\/span>SqlText As String<\/span> \r\n Dim <\/span>SqlFilter As String<\/span>\r\n Dim <\/span>SqlFilterAusdruck As String<\/span>\r\n Dim <\/span>WertImSqlFormat As String<\/span>\r\n Dim <\/span>TextWert As Variant<\/span>\r\n Dim <\/span>DoubleWert As Double<\/span>\r\n Dim <\/span>DatumsWert As Date<\/span>\r\n Dim <\/span>BooleanWert As Boolean<\/span>\r\n ''Text\r\n TextWert = \"abc*\"\r\n WertImSqlFormat = \"''\" & Replace<\/span>(TextWert, \"''\", \"''''\") & \"''\"\r\n SqlFilterAusdruck = \"Textfeld LIKE \" & WertImSqlFormat\r\n SqlFilter = SqlFilterAusdruck\r\n ''Zahlen\r\n DoubleWert = 1.23\r\n WertImSqlFormat = Trim<\/span>(Str(DoubleWert))\r\n SqlFilterAusdruck = \"DoubleZahlenfeld > \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n ''Datum\r\n DatumsWert = Date\r\n WertImSqlFormat = Format(DatumsWert, \"\\#yyyy-mm-dd\\#\")\r\n SqlFilterAusdruck = \"Datumsfeld <= \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n ''Ja\/Nein (Boolean)\r\n BooleanWert = True<\/span>\r\n WertImSqlFormat = IIf(BooleanWert = True, \"True\", \"False\")\r\n SqlFilterAusdruck = \"JaNeinFeld = \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n ''gesamten SQL-Text zusammenstellen\r\n SqlText = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span><\/pre>\nListing 5: VBA-Ausbaustufe 4<\/span><\/b><\/p>\n
Stufe 5: Filterwerte aus Formular-Steuerelementen<\/h2>\n
Häufig werden Formulare zum Filtern von Datenmengen verwendet. In diesen Formularen befinden sich Steuerelemente, in die der Anwender Werte eingeben kann. Wenn in einem Steuerelement ein Wert enthalten ist, sollen die Datensätze entsprechend gefiltert werden. Ist im Steuerelement kein Wert enthalten, soll dieser Filter ignoriert werden.<\/p>\n
Typisches Code-Gerüst im Formular-Modul mit den Filtersteuerelementen:<\/p>\n
With<\/span> Me.Steuerelement\r\n If Not<\/span> IsNull(.Value) then\r\n '' Filterausdruck erstellen\r\n End If<\/span>\r\nEnd With<\/span><\/pre>\nIm Code in Listing 6 werden die Werte aus den Formular-Steuerelementen auf vorhandene Filterwerte geprüft, aus den vorhandenen Einträgen Filterausdrücke erstellt und zu einem kombinierten Filterstring zusammengesetzt.<\/p>\n
Private Sub <\/span>SqlText_VBA_Stufe5()\r\n Dim <\/span>SqlText As String<\/span>\r\n Dim <\/span>SqlFilter As String<\/span>\r\n Dim <\/span>SqlFilterAusdruck As String<\/span>\r\n Dim <\/span>WertImSqlFormat As String<\/span>\r\n ''Text\r\n With<\/span> Me.txtTextFilter\r\n If <\/span>Len<\/span>(.Value) > 0 Then<\/span> '' Null und Leerstring ignorieren\r\n WertImSqlFormat = \"''\" & Replace<\/span>(.Value, \"''\", \"''''\") & \"''\"\r\n SqlFilterAusdruck = \"Textfeld LIKE \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n End If<\/span>\r\n End With<\/span>\r\n ''Zahlen\r\n With<\/span> Me.txtZahlenFilter\r\n If <\/span>Not<\/span> IsNull(.Value) Then<\/span>\r\n WertImSqlFormat = Trim<\/span>(Str(.Value))\r\n SqlFilterAusdruck = \"DoubleZahlenfeld > \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n End If<\/span>\r\n End With<\/span>\r\n ''Datum\r\n With<\/span> Me.txtDatumsFilter\r\n If <\/span>Not<\/span> IsNull(.Value) Then<\/span>\r\n WertImSqlFormat = Format(.Value, \"\\#yyyy-mm-dd\\#\")\r\n SqlFilterAusdruck = \"Datumsfeld <= \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n End If<\/span>\r\n End With<\/span>\r\n ''Filterausdruck aufbereiten\r\n If <\/span>Len<\/span>(SqlFilter) > 0 Then<\/span>\r\n '' ersten \" And \"-Ausdruck wegschneiden\r\n SqlFilter = Mid<\/span>(SqlFilter, Len<\/span>(\" And \") + 1)\r\n End If<\/span>\r\n ''gesamten SQL-Text zusammenstellen\r\n SqlText = \"SELECT * FROM tabTest\"\r\n If <\/span>Len<\/span>(SqlFilter) > 0 Then<\/span>\r\n SqlText = SqlText & \" WHERE \" & SqlFilter\r\n End If<\/span>\r\n Call<\/span> SqlAnweisungAuswerten(SqlText)\r\nEnd Sub<\/span><\/pre>\n<\/p>\n
Listing 6: VBA-Ausbaustufe 5<\/span><\/b><\/p>\n
Nach diesem Prinzip können Sie Ihre Filterbedingungen zusammenstellen. Einen Nachteil hat diese Vorgehensweise: Der Code wird bei mehreren Filter-Feldern schnell unübersichtlich.<\/p>\n
Ein Refactoring dieses Codes führt uns allerdings zu unserem Vorhaben, eine universell einsetzbare Code-Struktur zu gestalten, die statt dem Programmieren des Filtertextes ein Definieren der Filterbedingungen erlaubt und uns den fertigen SQL-Filtertext liefert.<\/p>\n
Zuvor sehen wir uns noch ein bereits in Access eingebautes Hilfsmittel zum Erzeugen eines Filterausdrucks an.<\/p>\n
Hilfsfunktion Access.BuildCriteria<\/h2>\n
Die Methode BuildCriteria <\/b>vom Access-Objekt erlaubt eine übergabe der Filterwerte als String. Dabei müssen keine SQL-relevanten Zeichen zum Eingrenzen eines Textes oder Datums ergänzt werden. BuildCriteria <\/b>erzeugt die Zeichen in Abhängigkeit vom FieldType<\/b>-Parameter selbst.<\/p>\n
Syntax: BuildCriteria(Field, FieldType, Expression)<\/b><\/p>\n
Beispiele finden Sie in Listing 7.<\/p>\n
Private Sub <\/span>BuildCriteriaBeispiele()\r\n Dim <\/span>SqlAnweisung As String<\/span>\r\n Dim <\/span>SqlFilter As String<\/span>\r\n ''Text\r\n SqlFilter = BuildCriteria(\"Textfeld\", dbText, \"LIKE abc*\")\r\n SqlAnweisung = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlAnweisung)\r\n ''Zahlen\r\n SqlFilter = BuildCriteria(\"DoubleZahlenfeld\", dbDouble, \"> 1,23\")\r\n SqlAnweisung = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlAnweisung)\r\n ''Datum\r\n SqlFilter = BuildCriteria(\"Datumsfeld\", dbDate, \"<=\" & Date)\r\n SqlAnweisung = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlAnweisung)\r\n ''Ja\/Nein (Boolean)\r\n SqlFilter = Access.BuildCriteria(\"JaNeinFeld\", dbBoolean, True<\/span>)\r\n SqlAnweisung = \"SELECT * FROM tabTest WHERE \" & SqlFilter\r\n Call<\/span> SqlAnweisungAuswerten(SqlAnweisung)\r\nEnd Sub<\/span><\/pre>\nListing 7: Einsatz von Access.BuildCriteria<\/span><\/b><\/p>\n
Ein Nachteil dieser Hilfsfunktion ist, dass die Funktion nur einen Filterausdruck für Jet\/DAO-SQL erzeugt. Falls Sie einen SQL-Text für den SQL-Server in T-SQL für eine Pass-Through-Abfrage benötigen, können Sie diese BuildCriteria<\/b>-Funktion nicht verwenden. Für unsere Klassenbibliothek können wir uns das Konzept dieser Funktion merken, um etwas ähnliches zu erstellen.<\/p>\n
Alternative zu dynamisch erzeugten SQL-Anweisungen<\/h2>\n
Wenn Sie auf das dynamische Erstellen von SQL-Anweisungen für Recordsets verzichten wollen, besteht die Möglichkeit, eine Parameterabfrage zu verwenden. Bei Parameterabfragen wird der Datentyp in der Parameter-Deklaration festgelegt und Sie müssen bei der übergabe nicht auf die SQL-konforme Formatierung achten (s. Listing 8).<\/p>\n
Private Sub <\/span>Alternative_ParameterAbfrage()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Set<\/span> db = CurrentDb\r\n ''1. Verwendung einer gespeicherten Abfrage\r\n Set<\/span> qdf = db.QueryDefs(\"ParameterAbfrageGrundlagenBeispiel\")\r\n qdf.Parameters(\"TextFilter\").Value = \"abc*\"\r\n qdf.Parameters(\"ZahlenFilter\").Value = 1.23\r\n qdf.Parameters(\"DatumsFilter\").Value = Date\r\n Call<\/span> QueryDefAuswerten(qdf)\r\n qdf.Close\r\n ''2. Dynamische Parameterabfrage erstellen\r\n Dim <\/span>SqlText As String<\/span>\r\n SqlText = \"PARAMETERS TextFilter Text(255), ZahlenFilter Double,\" _\r\n & \" DatumsFilter DateTime;\" _\r\n & \" SELECT * FROM tabTest WHERE Textfeld LIKE [TextFilter]\" _\r\n & \" AND DoubleZahlenfeld>[ZahlenFilter] AND Datumsfeld<=[DatumsFilter]\"\r\n Set<\/span> qdf = db.CreateQueryDef(\"\", SqlText)\r\n qdf.Parameters(\"TextFilter\").Value = \"abc*\"\r\n qdf.Parameters(\"ZahlenFilter\").Value = 1.23\r\n qdf.Parameters(\"DatumsFilter\").Value = Date\r\n Call<\/span> QueryDefAuswerten(qdf)\r\n qdf.Close\r\nEnd Sub<\/span><\/pre>\nListing 8: Parameterabfrage<\/span><\/b><\/p>\n
Bei diesen Varianten ist sowohl der SQL-Code als auch die Wertübergabe für die Filter in VBA relativ gut lesbar. Für das Eintragen von Filterwerten in die Filter-Eigenschaft von Formularen müssen Sie trotzdem den Filterausdruck als Text übergeben.<\/p>\n
Refactoring<\/h2>\n
Im folgenden Abschnitt werden wir ein Refactoring vom Code der Prozedur SqlText_VBA_Stufe5<\/b> durchführen und daraus Hilfsprozeduren und in weiterer Folge eine Klassenstruktur herausarbeiten (s. Listing 9).<\/p>\n
With<\/span> Me.txtTextFilter\r\n If <\/span>Len<\/span>(.Value) > 0 Then<\/span> '' Null und Leerstring ignorieren\r\n WertImSqlFormat = \"''\" & Replace<\/span>(.Value, \"''\", \"''''\") & \"''\"\r\n SqlFilterAusdruck = \"Textfeld LIKE \" & WertImSqlFormat\r\n SqlFilter = SqlFilter & \" And \" & SqlFilterAusdruck\r\n End If<\/span>\r\nEnd With<\/span><\/pre>\nListing 9: Auszug aus der Prozedur SqlText_VBA_Stufe5<\/span><\/b><\/p>\n
Die markierte Zeile zur Konvertierung der Filterwerte von einem bestimmten Datentyp in SQL-Text wird regelmäßig wiederholt und sollte daher in eine Prozedur ausgelagert werden. Wir wollen die Konvertierung für verschiedene SQL-Dialekte erstellen.<\/p>\n
Daher fügen wir die Prozedur in die Klasse SqlTools<\/b> ein, die verschiedene Hilfsmethoden zur Gestaltung von SQL-Text enthalten wird.<\/p>\n
Filterwerte in SQL-Text konvertieren<\/h2>\n
Beispiel:<\/p>\n
Filterwert = \"abc*\"\r\nWertImSqlFormat = SqlTools.TextToSqlText(Filterwert)\r\nDebug.Print<\/span> WertImSqlFormat '' --> ''abc*''\r\nFilterwert = \"O''Neill\"\r\nWertImSqlFormat = SqlTools.TextToSqlText(Filterwert)\r\nDebug.Print<\/span> WertImSqlFormat '' --> ''O''''Neill''<\/pre>\nIn Listing 10 sehen Sie die Umsetzung dieser Aufgabe mit der SqlTools<\/b>-Methode TextToSqlText<\/b>.<\/p>\n
Public Function <\/span>TextToSqlText(ByVal Value As Variant<\/span>, Optional<\/span> ByVal Delimiter As String<\/span> = SQL_DEFAULT_TEXTDELIMITER, _\r\n Optional<\/span> ByVal WithoutLeftRightDelim As Boolean<\/span> = False<\/span>) As String<\/span>\r\n Dim <\/span>Result As String<\/span>\r\n If <\/span>IsNull(Value) Then<\/span>\r\n TextToSqlText = ResultTextIfNull\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Result = Replace$(Value, Delimiter, Delimiter & Delimiter)\r\n