<\/p>\n
Abfragen lassen sich auf unterschiedlichste Weise mit den Vergleichswerten für ihre Kriterien bestücken – beispielsweise, indem man einfach den gewünschten SQL-Ausdruck per VBA zusammensetzt. Es gelingt jedoch unter Einsatz von Abfrageparametern: Sie fügen in eckige Klammern eingefasste Bezeichnungen in den Abfrageentwurf ein und füllen diese dann entweder per eingebauter Inputbox oder per VBA. Dieser Beitrag stellt alle wichtigen Techniken rund um den Einsatz von Parameterabfragen vor.<\/b><\/p>\n
Warum Parameterabfragen<\/b><\/p>\n
In vielen Fällen benötigen Sie keine Parameterabfragen, weil die Abfrage entweder bereits die notwendigen Kriterien enthält oder diese nachträglich per Filter appliziert werden. Dies kann beispielsweise der Fall sein, wenn Sie einem Formular eine komplette Tabelle als Datenherkunft zuweisen, dann aber etwa mit der OpenForm<\/b>-Methode des DoCmd<\/b>-Objekts einen entsprechenden Filterausdruck übergeben. Dieser wird dann beim öffnen des Formulars angewendet.<\/p>\n
In manchen Fällen kommen Sie damit aber nicht weiter: Wenn Sie etwa eine Aktualisierungsabfrage erstellen, die ein oder mehrere Kriterien enthält, können Sie die Vergleichswerte nur auf zwei Arten anwenden: Entweder, indem Sie den SQL-Ausdruck der Abfrage in eine VBA-Variable laden und dieser die entsprechenden Kriterien hinzufügen oder eben mit Abfrageparametern.<\/p>\n
Bestimmte Anwendungsfälle erfordern es auch, dass man mehrere aufeinander aufbauende Abfragen nutzt. Das kann etwa sein, wenn Sie zunächst die Daten einer Abfrage mit OUTER JOIN<\/b>-Verknüpfung ermitteln und das Ergebnis dann in einer weiteren Abfrage mit den Daten aus weiteren Tabellen verknüpfen. In diesem Fall kommen Sie kaum um den Einsatz von Abfrageparametern herum. Sie könnten zwar noch den Abfragetext der Ausgangsabfrage per VBA anpassen und erst dann die andere Abfrage darauf zugreifen lassen, aber das wäre doch etwas umständlich.<\/p>\n
Darüber hinaus haben Parameterabfragen den Vorteil, dass Access für diese nach der ersten Ausführung einen Ausführungsplan erstellt. Das bedeutet, dass ein Plan aufgestellt, mit dem das Ergebnis optimal ermittelt wird. Wenn Sie die gleiche Abfrage anschließend nochmals aufrufen, kann diese auf den bereits ermittelten Ausführungsplan zurückgreifen. Wenn Sie eine Abfrage bei jedem Aufruf erneut per VBA zusammenstellen, muss auch der Ausführungsplan mit jedem Aufruf erneut erstellt werden.<\/p>\n
Parameterabfrage erstellen<\/b><\/p>\n
Eine Parameterabfrage unterscheidet sich nicht wesentlich von einer herkömmlichen Abfrage. Der Unterschied ist, dass beispielsweise ein Kriteriumsausdruck nicht direkt beim Erstellen mit dem Vergleichswert für diese Abfrage ausgestattet wird, sondern stattdessen einen in eckigen Klammern eingefassten Parameter aufnimmt.<\/p>\n
Dies sieht beispielsweise so wie in Bild 1 aus. Wenn Sie die Abfrage nun ausführen, zeigt diese alle Datensätze der Tabelle tblArtikel <\/b>an, deren Feld KategorieID <\/b>den Wert 1 <\/b>enthält. Dies wollen wir nun flexibler gestalten: Der Benutzer soll diesen Wert beim Aufruf der Abfrage selbst eingeben können. Dazu ersetzen Sie den Wert 1 <\/b>einfach durch den Ausdruck [VergleichskategorieID]<\/b>.<\/p>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_001.png\")
<\/p>\n
Bild 1: Abfrage mit festem Vergleichswert<\/span><\/b><\/p>\n Wenn Sie die Abfrage dann ausführen, zeigt Access einen Dialog zur Eingabe des Vergleichswertes an (s. Bild 2). Dieser erhält als Titel den Text Parameterwert eingeben <\/b>und als Meldungstext den in eckigen Klammern angegebenen Ausdruck. Hier ist zu beachten, dass der Text in eckigen Klammern, also der Name des Parameters, nicht den Namen eines der Felder der Tabellen der Datenherkunft enthalten darf. In diesem Fall wird der Parameter mit dem jeweiligen Wert der Datenherkunft gefüllt. <\/p>\n Bild 2: Abfrage mit Parameter als Vergleichswert<\/span><\/b><\/p>\n Bei der Benennung der Parameter gibt es sonst kaum Einschränkungen – Sie dürfen allerdings keinen Punkt und kein Ausrufezeichen verwenden. Dies führt direkt zu einer entsprechenden Meldung (s. Bild 3).<\/p>\n Bild 3: Abfrageparameter mit ungültigem Zeichen<\/span><\/b><\/p>\n Wenn Sie den Parameter tatsächlich über den dafür vorgesehenen Dialog vom Benutzer abfragen möchten, können Sie allerdings auch komplette Sätze unterbringen – nur ohne Punkt. Aber das ist kein Problem – Sie können einen solchen Satz ja auch mit einem Doppelpunkt abschließen:<\/p>\n Zeichenketten und Parameter<\/b><\/p>\n Wenn Sie eine Zeichenkette mit einem Parameter vergleichen wollen, gehen Sie genauso vor wie mit einem Zahlenwert wie im obigen Beispiel. Allerdings möchten Sie den Parameter ja vielleicht als Teil des Vergleichsausdrucks einsetzen.<\/p>\n Auch das ist kein Problem: Sie müssen den Abfrageparameter lediglich per Und-Zeichen mit den übrigen Elementen verbinden. Wenn der Benutzer etwa Kundendatensätze anhand der Postleitzahl eingrenzen soll, können Sie ihm folgendes Kriterium anbieten:<\/p>\n Dieses fragt wie in Bild 4 eine Zeichenkette ab und hängt an diese noch das Sternchen (*) als Platzhalter an. Die Abfrage liefert dann alle Datensätze der Tabelle tblKunden<\/b>, deren Feld PLZ <\/b>mit dem als Parameter übergebenen Wert übereinstimmt.<\/p>\n Bild 4: Abfrageparameter als Teil des Vergleichswertes<\/span><\/b><\/p>\n Datentypen für Parameter festlegen<\/b><\/p>\n Aktuell kann der Benutzer für die Parameter alle denkbaren Werte eingeben. So landet dann auch schon mal eine Zeichenkette in einem Parameter, der eigentlich ein Datumsfeld betrifft. Dies führt natürlich zu einer entsprechenden Fehlermeldung, die – wie in vielen Fällen – für Otto Normalverbraucher wenig Aussagekraft besitzt. Wenn Sie sicherstellen wollen, dass der Benutzer einen Wert als Parameter übergibt, der einem bestimmten Datentyp entspricht, müssen Sie den Parameter in einem separaten Dialog deklarieren. Diesen Dialog rufen Sie auf, indem Sie das Kontextmenü des Abfrageentwurfs anzeigen und dort den Eintrag Parameter <\/b>auswählen (s. Bild 5).<\/p>\n Bild 5: Anzeigen des Dialogs zum Deklarieren von Parametern<\/span><\/b><\/p>\n In diesem Fall wollen wir dafür sorgen, dass der Benutzer für die beiden Parameter Startdatum <\/b>und Enddatum <\/b>nur Datumswerte eintragen darf. Der Dialog, den Sie mit dem Kontextmenüeintrag Parameter anzeigen, enthält leider noch nicht automatisch die bereits im Kriterium angegebenen Abfrageparameter. Sie müssen diese also manuell dort eintragen und dann den Datentyp festlegen. Dabei stellen wir fest, dass die Datentypen nicht exakt mit denen im Tabellenentwurf übereinstimmen. Die Zahlendatentypen etwa werden hier direkt mit der entsprechenden Feldgröße angegeben, also Byte<\/b>, Long <\/b>et cetera (s. Bild 6). Wir tragen hier die beiden Parameter Startdatum <\/b>und Enddatum <\/b>ein und legen als Felddatentyp jeweils Datum\/Uhrzeit <\/b>fest.<\/p>\n Bild 6: Der Dialog zum Anzeigen von Parametern<\/span><\/b><\/p>\n Wenn der Benutzer dann einen falschen Wert einträgt, erscheint die Meldung Sie haben einen Wert eingegeben, der für dieses Feld nicht gültig ist <\/b>– also die gleiche Meldung, die auch bei der Eingabe falscher Daten in Tabellenfelder erscheint.<\/p>\n Davon abgesehen arbeiten Abfrageparameter, die auch als solche deklariert wurden, genau wie nicht deklarierte Abfrageparameter.<\/p>\n Nun wird es Zeit, einen Blick auf den SQL-Code für eine Abfrage mit deklarierten Parametern zu werfen. Die Parameter werden hier in einer eigenen Zeile vor Beginn der eigentlichen SQL-Anweisung mit dem Schlüsselwort PARAMETERS <\/b>unter Angabe des entsprechenden Datentyps deklariert:<\/p>\n Sollten die Namen der im Kriterium untergebrachten Parameter nicht mit denen im Parameter<\/b>-Dialog übereinstimmen, fragt Access alle verschiedenen Versionen ab.<\/p>\n Wenn Sie also einen Parameter namens Datum eingeben: <\/b>im Abfrageentwurf unterbringen und im Parameter<\/b>-Dialog einen Parameter namens Datumeingabe: <\/b>definieren, erscheinen Abfragedialoge für beide Varianten. Allerdings wirkt sich nur derjenige, der auch im Kriterium eingesetzt wird, auf das Abfrageergebnis aus.<\/p>\n Parameter-abfragen per VBA<\/b><\/p>\n Für einen Schnellschuss kann man den Benutzer mal mit den von Access erzeugten Dialogen zum Abfragen von Parametern konfrontieren, aber in der Regel sollte man die Werte per Formular abfragen. Dort kann man diese gegebenenfalls vorbelegen, eine eigene Fehlerbehandlung für den Fall der Eingabe ungültiger Werte unterbringen et cetera. Also schauen wir uns an, wie man unter VBA mit Parameterabfragen umgeht.<\/p>\n Wenn Sie die Abfrage etwa als Recordset öffnen und durchlaufen möchten und annehmen, dass Access wie beim manuellen öffnen den Dialog zum Eingeben der Parameter anzeigt, probieren Sie einmal die Prozedur aus Listing 1 aus.<\/p>\n Listing 1: Dieser Zugriff auf die Parameterabfrage löst einen Fehler aus.<\/span><\/b><\/p>\n Das Ergebnis ist die Fehlermeldung aus Bild 7. Access zeigt also keine Eingabedialoge an, wenn Sie eine Parameterabfrage als Recordset öffnen. Wie also bringen Sie die Parameterwerte in der Abfrage unter<\/p>\n Bild 7: Fehlermeldung beim Versuch, eine Abfrage mit Parametern per OpenRecordset zu öffnen<\/span><\/b><\/p>\n VBA und QueryDef<\/b><\/p>\n Dazu benötigen Sie zwei weitere DAO-Objekte, nämlich das QueryDef<\/b>-Objekt, mit dem Sie auf Abfragen zugreifen und ihre Eigenschaften verändern können, sowie das Parameter<\/b>-Objekt, das den Zugriff auf die Parameter einer Abfrage erlaubt. Für das Beispiel der Abfrage qryBestellungenNachDatum <\/b>benötigen wir eigentlich sogar zwei Parameter-Objekte, die wir als prmStart <\/b>und prmEnde <\/b>deklarieren. Theoretisch würde zwar eine Variable reichen (prm<\/b>), aber wir wollen für eine bessere übersicht für jeden Parameter eine eigene Variable einsetzen. Der Einsatz von Parametern in VBA sieht wie in Listing 2 aus.<\/p>\n Listing 2: Parameterabfrage mit per VBA zugewiesenen Parametern<\/span><\/b><\/p>\n Neben den beiden Parameter<\/b>-Variablen deklarieren wir dort eine QueryDef<\/b>-Variable namens qdf<\/b> sowie ein Database<\/b>-Objekt und ein Recordset<\/b>-Objekt. Das Database<\/b>-Objekt db <\/b>füllen wir mit einem Verweis auf die aktuelle Datenbank. Dann referenzieren wir die Abfrage qryBestellungenNachDatum<\/b> mit dem QueryDef<\/b>-Objekt qdf<\/b>, das wir über den Namen der Abfrage aus der QueryDefs<\/b>-Auflistung des Database<\/b>-Objekts beziehen.<\/p>\n <\/p>\n Und natürlich müssen wir noch die beiden Parameter<\/b>-Variablen füllen. Dies erledigen wir über die Parameters<\/b>-Auflistung, deren Elemente wir beispielsweise direkt über den Namen ansprechen können – also Startdatum <\/b>und Enddatum<\/b>.<\/p>\n Das Parameter<\/b>-Objekt bietet eine Eigenschaft namens Value<\/b>, mit der wir den Parameterwert übergeben können. Schließlich erstellen wir ein Recordset<\/b>-Objekt auf Basis des mit den entsprechenden Parametern versehenen QueryDef<\/b>-Objekts qdf <\/b>und durchlaufen zum Test dessen Datensätze.<\/p>\n Parameter aufnehmen<\/b><\/p>\n Im nächsten Beispiel bieten wir dem Benutzer eine Möglichkeit, um die beiden Parameter einzugeben und gleich die gesuchten Datensätze anzuzeigen. Dazu erstellen Sie ein Hauptformular namens frmBestellungen<\/b>, das die beiden Textfelder txtStartdatum <\/b>und txtEnddatum <\/b>enthält, sowie eine Schaltfläche namens cmdAnzeigen<\/b> (s. Bild 8). Das Unterformular enthält zunächst die Daten der Tabelle tblBestellungen<\/b>. Beim Laden belegt das Formular die beiden Textfelder vor:<\/p>\n Bild 8: Eingabe der Parameter per Textfeld<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche cmdAnzeigen <\/b>sorgt schließlich für das Einlesen eines Recordsets auf Basis der Abfrage qryBestellungenNachDatum <\/b>und der beiden angegebenen Datumsangaben (s. Listing 3).<\/p>\n Listing 3: Füllen des Unterformulars per Recordset aus einer benutzerdefinierten Funktion<\/span><\/b><\/p>\n Die Funktion BestellungenNachDatum <\/b>erwartet schließlich die beiden Datums-angaben als Parameter (s. Listing 4). Sie arbeitet prinzipiell wie die Prozedur Parameterabfrage aus dem vorherigen Beispiel, gibt das Recordset<\/b>-Objekt jedoch als Funktionswert zurück. Dieses wird dann direkt der Recordset<\/b>-Eigenschaft des Unterformulars zugewiesen. Achtung: Dies führte in der Beispieldatenbank zu nicht reproduzierbaren Abstürzen, wenn man das Recordset mehrfach nacheinander aktualisiert hat.<\/p>\n Listing 4: Zusammenstellung des Recordsets mit den angegebenen Kriterien<\/span><\/b><\/p>\n Parameter auslesen<\/b><\/p>\n Die Auflistung Parameters <\/b>des QueryDefs<\/b>-Objekts haben Sie ja bereits genutzt, um über den Namen auf die Parameter<\/b>-Objekte zuzugreifen. Sie können den Namen, den Datentyp und den Wert eines Parameter<\/b>-Elements auch per VBA auslesen. Die Prozedur aus Listing 5 erledigt dies in einer Schleife über alle Elemente der Parameters<\/b>-Auflistung. Die einzelnen Eigenschaften Name<\/b>, Type <\/b>und Value <\/b>landen dann im Direktbereich des VBA-Editors.<\/p>\n Listing 5: Parameter einer Abfrage auslesen<\/span><\/b><\/p>\n Per Index auf die Parameter zugreifen<\/b><\/p>\n Sie können nicht nur über den Namen, sondern auch über den Indexwert auf ein Element der Parameters<\/b>-Auflistung zugreifen.<\/p>\n Wie dies gelingt, zeigt die Prozedur aus Listing 6. Die Parameters<\/b>-Auflistung liefert mit einer Eigenschaft namens Count <\/b>die Anzahl der Parameter der Abfrage. Wenn Sie in einer Schleife von 0 <\/b>bis zur Anzahl der Elemente minus eins alle Elemente der Parameters<\/b>-Auflistung anhand des numerischen Index durchlaufen, erhalten Sie das gleiche Ergebnis wie beim Durchlaufen über eine For Each<\/b>-Schleife. Allerdings benötigen Sie eine Zeile mehr, weil die Zuweisung an die Variable prm<\/b> ja nicht direkt in der Schleife erfolgt.<\/p>\n Listing 6: Parameter einer Abfrage mit numerischem Index durchlaufen<\/span><\/b><\/p>\n Flexibel Recordset aus Abfrage generieren<\/b><\/p>\n Damit Sie in Zukunft auf einfache Weise Recordsets auf Basis von Parameterabfragen erstellen können, haben wir die Funktion RecordsetAusParameterabfrage <\/b>erstellt (s. Listing 7). Diese erwartet die folgenden Parameter:<\/p>\n Listing 7: Flexible Funktion zum Erstellen von Recordsets auf Basis von Parameterabfragen<\/span><\/b><\/p>\n Der Rückgabewert der Funktion ist ein Recordset<\/b>-Objekt mit den ermittelten Datensätzen.<\/p>\n Wie schon angedeutet, können Sie die Parameter auf zwei Arten übergeben. Wenn Sie genau wissen, in welcher Reihenfolge die Parameter der Parameterabfrage vorliegen, können Sie einfach die Werte als Parameter-Array übergeben. Anderenfalls übergeben Sie jeweils durch Komma getrennte Paare aus Parametername und -wert. Zur Verdeutlichung finden Sie in Listing 8 zunächst ein Beispiel für den Aufruf der Funktion nur mit den Parameterwerten – wir verwenden wieder die Abfrage qryBestellungenNachDatum<\/b>.<\/p>\n Listing 8: Beispielaufruf der Funktion RecordsetAusParameterabfrage<\/span><\/b><\/p>\n Die Prozedur deklariert ein Database<\/b>– und ein Recordset<\/b>-Objekt und ruft dann die Funktion RecordsetAusParameterabfrage <\/b>auf. Wissend, dass die Parameter in der Reihenfolge Startdatum<\/b>, Enddatum <\/b>vorliegen, werden die Parameterwerte in dieser Reihenfolge übergeben. Die Funktion liefert dann ein Recordset <\/b>zurück, das direkt weiterverwendet werden kann – beispielsweise zum Durchlaufen der einzelnen Datensätze.<\/p>\n Wenn Sie die Reihenfolge der Parameter nicht kennen, könnte der Aufruf auch so aussehen:<\/p>\n In diesem Fall übergeben Sie für den Parameter bolBenannteParameter <\/b>den Wert True <\/b>und hängen dann immer abwechselnd den Namen des Parameters und den Wert des Parameters an.<\/p>\n Die Funktion deklariert ein QueryDef<\/b>– und ein Parameter<\/b>-Objekt sowie Integer<\/b>-Variablen zur Aufnahme der Anzahl der Parameter und als Laufvariable.<\/p>\n Dann füllt sie zunächst die QueryDef<\/b>-Variable qdf <\/b>mit einem Verweis auf die mit strAbfrage <\/b>übergebene Abfrage. Durch Subtrahieren der unteren von der oberen Array-Grenze und anschließendes Addieren von 1 <\/b>ermittelt die Funktion die Anzahl der Parameter und speichert diese in der Variablen intAnzahlParameter<\/b>.<\/p>\n Da LBound <\/b>bei einem leeren Array den Wert -1 <\/b>liefert und UBound <\/b>den Wert 0<\/b>, liefert dieser Ausdruck sogar die richtige Anzahl, wenn das Parameter-Array leer ist – nämlich 0<\/b>.<\/p>\n Nun unterscheidet die Funktion die Fälle, ob der Parameter bolBenannteParameter <\/b>den Wert True <\/b>oder False <\/b>hat. Lautet der Wert True<\/b>, wird der erste Teil der If…Then<\/b>-Bedingung ausgeführt. Hier prüft die Prozedur mit dem ![\"Abfrage](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_002.png\")
<\/p>\n![\"Abfrageparameter](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_003.png\")
<\/p>\n[Geben Sie die KategorieID ein:]<\/pre>\n
Wie [Geben Sie die PLZ ein:] & \"*\"<\/pre>\n
![\"Abfrageparameter](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_004.png\")
<\/p>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_005.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_006.png\")
<\/p>\nPARAMETERS Startdatum DateTime, Enddatum DateTime;\r\nSELECT BestellungID, KundeID, PersonalID, Bestelldatum\r\nFROM tblBestellungen\r\nWHERE Bestelldatum Between [Startdatum] And [Enddatum];<\/pre>\n
Public Sub <\/span>ParameterabfrageMitFehler()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"qryBestellungenNachDatum\")\r\n Do While<\/span> Not<\/span> rst.EOF\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_007.png\")
<\/p>\nPublic Sub <\/span>Parameterabfrage()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>prmStart As <\/span>DAO.Parameter\r\n Dim <\/span>prmEnde As <\/span>DAO.Parameter\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryBestellungenNachDatum\")\r\n Set<\/span> prmStart = qdf.Parameters(\"Startdatum\")\r\n prmStart.Value = \"1.1.2012\"\r\n Set<\/span> prmEnde = qdf.Parameters(\"Enddatum\")\r\n prmEnde.Value = \"31.1.2012\"\r\n Set<\/span> rst = qdf.OpenRecordset\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!BestellungID\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Eingabe](\"..\/fileadmin\/_temp_\/2013_06\/pic_910_008.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Me!txtEnddatum = Date\r\n Me!txtStartdatum = DateAdd(\"yyyy\", -1, Date)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdAnzeigen_Click()\r\n Set<\/span> Me!sfmBestellungen.Form.Recordset = _\r\n BestellungenNachDatum(Me!txtStartdatum, Me!txtEnddatum)\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>BestellungenNachDatum(datStart As Date<\/span>, datEnde As Date<\/span>) _\r\n As <\/span>DAO.Recordset\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>prmStart As <\/span>DAO.Parameter\r\n Dim <\/span>prmEnde As <\/span>DAO.Parameter\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryBestellungenNachDatum\")\r\n Set<\/span> prmStart = qdf.Parameters(\"Startdatum\")\r\n prmStart.Value = datStart\r\n Set<\/span> prmEnde = qdf.Parameters(\"Enddatum\")\r\n prmEnde.Value = datEnde\r\n Set<\/span> BestellungenNachDatum = qdf.OpenRecordset\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>ParameterAuslesen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>prm As <\/span>DAO.Parameter\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryBestellungenNachDatum\")\r\n For Each prm In qdf.Parameters\r\n Debug.Print<\/span> prm.Name, prm.Type, prm.Value\r\n Next<\/span> prm\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>ParameterPerIndex()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>prm As <\/span>DAO.Parameter\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryBestellungenNachDatum\")\r\n For i = 0 To qdf.Parameters.Count - 1\r\n Set<\/span> prm = qdf.Parameters(i)\r\n Debug.Print<\/span> prm.Name, prm.Type, prm.Value\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>RecordsetAusParameterabfrage(db As <\/span>DAO.Database, strAbfrage As String<\/span>, bolBenannteParameter As Boolean<\/span>, _\r\n ParamArray varParameter() As Variant<\/span>) As <\/span>DAO.Recordset\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>prm As <\/span>DAO.Parameter\r\n Dim <\/span>intAnzahlParameter As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> qdf = db.QueryDefs(strAbfrage)\r\n intAnzahlParameter = UBound<\/span>(varParameter) - LBound<\/span>(varParameter) + 1\r\n If <\/span>bolBenannteParameter = True<\/span> Then<\/span>\r\n If <\/span>intAnzahlParameter Mod<\/span> 2 = 0 Then<\/span>\r\n For i = LBound<\/span>(varParameter) To UBound<\/span>(varParameter)\r\n Set<\/span> prm = qdf.Parameters(varParameter(i))\r\n i = i + 1\r\n prm.Value = varParameter(i)\r\n Next<\/span> i\r\n Else<\/span>\r\n MsgBox<\/span> \"Ungerade Anzahl von Parameter, Name\/Wert-Paare können nicht gebildet werden.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>intAnzahlParameter = qdf.Parameters.Count Then<\/span>\r\n For i = LBound<\/span>(varParameter) To UBound<\/span>(varParameter)\r\n Set<\/span> prm = qdf.Parameters(i)\r\n prm.Value = varParameter(i)\r\n Next<\/span> i\r\n Else<\/span>\r\n MsgBox<\/span> \"Anzahl der Abfrageparameter und der übergebenen Parameter muss gleich sein.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Set<\/span> RecordsetAusParameterabfrage = qdf.OpenRecordset\r\nEnd Function<\/span><\/pre>\n\n
Public Sub <\/span>Test_RecordsetAusParameterabfrage()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = RecordsetAusParameterabfrage(db, \"qryBestellungenNachDatum\", False, \"1.1.2012\", \"4.1.2012\")\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!BestellungID, rst!Bestelldatum\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nRecordsetAusParameterabfrage(db, \"qryBestellungenNachDatum\", True, \"Startdatum\", \"1.1.2012\", \"Enddatum\", \"4.1.2012\")<\/pre>\n