<\/p>\n
Geschieht Ihnen das auch regelmäßig Sie wollen mal eben per Abfrage ein paar Daten filtern, sortieren oder zusammenführen, aber die Abfrage nach dieser Anwendung gleich wieder löschen. Dummerweise vergessen Sie Letzteres und irgendwann ist das Datenbankfenster voller gespeicherter Abfragen. Oder Sie benötigen gleichzeitig die Ergebnisse verschiedener Abfragen, finden die vielen geöffneten Fenster im Access-Hauptfenster aber unübersichtlich. Für beides liefert unser Abfrageverwalter die Lösung: Sie können damit mal eben eine Abfrage erstellen, ohne dass diese dauerhaft im Navigationsbereich verbleibt. Oder Sie zeigen die Ergebnisse mehrerer Abfragen übersichtlich im Registersteuerelement eines einzigen Formulars an.<\/b><\/p>\n
Damit Sie gleich eine Vorstellung davon bekommen, wie diese Lösung aussehen soll, schauen wir uns das Formular aus Bild 1 an. Hier finden Sie eine ganze Reihe Elemente, zuoberst ein Listenfeld. Dieses zeigt alle mit dem Formular erstellten und gespeicherten Abfragen an. Darunter folgen die Steuerelemente für die Verwaltung der Abfragen:<\/p>\n
![\"Benutzeroberfläche](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_001.png\")
<\/p>\n
Bild 1: Benutzeroberfläche des Abfrageverwalters<\/span><\/b><\/p>\n Nun werden Sie sich zu Recht fragen: Wenn die Abfragen schon nicht im Navigationsbereich der Datenbank auftauchen, wo werden diese dann gespeichert Ganz einfach: Wie legen für jede hier hinzugefügte Abfrage einen neuen Datensatz in einer speziell für diesen Zweck vorbereiteten Tabelle an.<\/p>\n Diese Tabelle heißt tblAbfragen <\/b>und sieht in der Entwurfsansicht wie in Bild 2 aus. Das Feld Abfragebezeichnung <\/b>soll die Bezeichnung aufnehmen und ist als eindeutiger Index ausgelegt. Auf diese Weise verhindern wir, dass die Tabelle mehrere Abfragen mit der gleichen Bezeichnung aufnimmt. Das Feld AbfrageSQL <\/b>enthält später den SQL-Ausdruck, den Sie mithilfe der Entwurfsansicht für Abfragen zusammengestelt haben. Das Feld Abfrageeigenschaften <\/b>nimmt die wichtigsten Eigenschaften der Abfrage auf, die Sie üblicherweise über das Eigenschaftsfenster der Abfrage eingeben – wie etwa in Bild 3 die Beschreibung der Abfrage.<\/p>\n Bild 2: Entwurf der Tabelle zum Speichern der Abfragen<\/span><\/b><\/p>\n Bild 3: Einstellen von Eigenschaften für die Abfrage<\/span><\/b><\/p>\n Die meisten der hier angegebenen Eigenschaften landen indes ohnehin in Form entsprechender Schlüsselwörter im SQL-Text der Abfrage – zum Beispiel die Eigenschaft Spitzenwerte <\/b>als TOP<\/b>.<\/p>\n Das Feld Uebersichtsposition <\/b>enthält einen Wert, der Folgendes angibt: Wenn das Feld leer ist, soll diese Abfrage nicht in der übersicht der Abfrageergebnisse im Registersteuerelement erscheinen. Nur wenn dieses Feld einen Zahlenwert enthält, soll dies geschehen. In diesem Fall werden die Abfragen in aufsteigender Reihenfolge entsprechend dem Wert des Feldes dort angezeigt.<\/p>\n Damit können wir uns nun an das Formular zur Verwaltung der Abfragen begeben.<\/p>\n Das Formular sieht in der Entwurfsansicht wie in Bild 4 aus. Es enthält ein Listenfeld zur Anzeige der in der Tabelle tblAbfragen <\/b>gespeicherten Abfragen, einige Schaltflächen sowie ein Registersteuerelement mit zehn Registerseiten.<\/p>\n Bild 4: Entwurf des Formulars frmAbfragen<\/span><\/b><\/p>\n Das Listenfeld heißt lstAbfragen <\/b>und verwendet die Abfrage aus Bild 5 als Datensatzherkunft. Diese liefert das Primärschlüsselfeld AbfrageID <\/b>und die Bezeichnung der Abfrage aus dem Feld Abfragebezeichnung<\/b>, nach der die Ergebnisse dieser Abfrage auch sortiert werden. Die Eigenschaft Spaltenanzahl <\/b>des Listenfeldes erhält den Wert 2<\/b>, die Eigenschaft Spaltenbreiten <\/b>den Wert 0cm<\/b>.<\/p>\n Bild 5: Abfrage, die als Datensatzherkunft des Listenfeldes lstAbfragen dient<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche cmdNeu <\/b>soll eine neue Abfrage in der Entwurfsansicht öffnen und dem Benutzer die Möglichkeit geben, die gewünschten Tabellen und Felder in den Entwurf zu ziehen. Dieser Teil ist einfach und wird durch die folgende Prozedur realisiert:<\/p>\n Die Prozedur definiert in strAktuelleAbfrage <\/b>den temporären Namen der zu erstellenden Abfrage. Die Variable strAktuelleAbfrage <\/b>ist modulweit deklariert:<\/p>\n Die Prozedur löscht dann eine eventuell noch vorhandene temporäre Abfrage mit dem Namen qryTemp_New <\/b>und legt diese mit der Methode CreateQueryDef <\/b>neu an. Danach öffnet die OpenQuery<\/b>-Methode des DoCmd<\/b>-Objekts diese Abfrage in der Entwurfsansicht.<\/p>\n Die auf diese Weise geöffnete Abfrage zeigt gar nicht erst das Tabelle anzeigen<\/b>-Fenster an, sodass Sie die als Datenquelle zu verwendenden Tabellen oder Abfragen direkt aus dem Navigationsbereich in den Abfrageentwurf ziehen können (s. Bild 6).<\/p>\n Bild 6: Anlegen einer neuen Abfrage in der Entwurfsansicht<\/span><\/b><\/p>\n Mit dem entsprechenden Kontextmenü-Eintrag können Sie dieses Fenster aber auch nachträglich noch anzeigen.<\/p>\n Was aber geschieht, wenn die Abfrage fertiggestellt ist – wie bekommt das Formular mit, dass es soweit ist und wie wird dann die Abfrage in der Tabelle tblAbfragen <\/b>gespeichert Dazu nutzen wir das Ereignis Bei Aktivierung <\/b>des Formulars frmAbfragen<\/b>. Dieses wird beispielsweise ausgelöst, wenn der Benutzer über die Schaltfläche cmdNeu <\/b>eine neue Abfrage erstellt hat und diese dann schließt. Das Formular wird dann wieder aktiviert und führt die genannte Ereignisprozedur aus.<\/p>\n Deren Code finden Sie in Listing 1. Die Prozedur prüft zunächst, ob die Variable strAktuelleAbfrage <\/b>einen Wert enthält. Dies ist beispielsweise der Fall, wenn Sie kurz zuvor die Schaltfläche cmdNeu <\/b>betätigt haben. Ist dies der Fall, prüft die Prozedur auch noch, ob die Abfrage aktuell noch geöffnet ist. Dazu nutzt sie die Hilfsfunktion IstAbfrageGeoeffnet<\/b>:<\/p>\n Listing 1: Diese Prozedur prüft, ob der Benutzer neue Abfragen angelegt hat, und speichert gegebenenfalls die Daten.<\/span><\/b><\/p>\n Ist die Abfrage noch geöffnet, erscheint eine Meldung, die den Benutzer darüber informiert, dass die Abfrage gespeichert und geschlossen werden muss. Die Prozedur wird dann beendet.<\/p>\n Ist die Abfrage nicht mehr geöffnet, referenziert die Prozedur das QueryDef<\/b>-Objekt zu dieser Abfrage mit der Variablen qdf <\/b>und vergleicht das Datum der Erstellung mit dem änderungsdatum. Sind die Daten gleich, hat der Benutzer seit der Erstellung keine änderungen vorgenommen und die Abfrage braucht nicht gespeichert zu werden.<\/p>\n Anderenfalls liest die Prozedur den SQL-Code der Abfrage in die Variable strAbfrageSQL <\/b>ein und die Eigenschaften in die Variable strAbfrageEigenschaften <\/b>– dazu später mehr. Sie liest dann den Primärschlüsselwert einer eventuell bereits in der Tabelle tblAbfragen <\/b>gespeicherten Abfrage in die Variable lngAbfrageID <\/b>ein.<\/p>\n Nur wenn noch keine Abfrage gleichen Namens vorhanden ist, fragt die Prozedur den Benutzer, ob dieser die erstellte Abfrage sichern möchte. Dann fragt die folgende InputBox<\/b>-Funktion den Namen ab, unter dem die Abfrage gespeichert werden soll. Die folgende Do While<\/b>-Schleife wird so lange durchlaufen, bis der Benutzer eine Bezeichnung eingegeben hat, die noch nicht in der Tabelle vorhanden ist. Dies kann natürlich schon nach der bereits erfolgten Eingabe in die InputBox <\/b>der Fall sein. Falls nicht, erscheint eine weitere InputBox<\/b> und fragt erneut die zu verwendende Bezeichnung ab.<\/p>\n Die Schleife wird erst verlassen, wenn eine noch nicht verwendete Bezeichnung eingegeben wurde – oder gar keine. Dies kann der Benutzer durch eine entsprechende Eingabe erreichen oder aber durch das Anklicken der Abbrechen<\/b>-Schaltfläche der InputBox<\/b>.<\/p>\n Diesen Fall prüft die erste If…Then<\/b>-Bedingung nach der Do While<\/b>-Schleife und beendet die Prozedur im Falle einer leeren Abfragebezeichnung.<\/p>\n Erst wenn eine gültige Abfragebezeichnung vorliegt, kann es weitergehen. Dann stellt die Prozedur in strSQL <\/b>eine INSERT INTO<\/b>-Aktionsabfrage zusammen, welche die ermittelten Daten in einen neuen Datensatz der Tabelle tblAbfragen <\/b>schreibt, führt diese aus und aktualisiert den Inhalt des Listenfeldes, das nun den neuen Datensatz anzeigen sollte.<\/p>\n <\/p>\n Nun folgt noch der Fall, dass die Abfrage bereits gespeichert wurde. Dies geschieht, um etwas vorzugreifen, beispielsweise dann, wenn der Benutzer eine bereits gespeicherte Abfrage im Entwurf öffnet und diese ändert.<\/p>\n In diesem Fall fragt die Prozedur per MsgBox<\/b>, ob die geänderte Abfrage gespeichert werden soll. Dies erledigt dann eine entsprechende UPDATE<\/b>-Anweisung.<\/p>\n Schließlich stellt die Prozedur den Wert von strAktuelleAbfrage <\/b>auf eine leere Zeichenkette ein, damit die Prozedur Form_Activate <\/b>beim nächsten Aktivieren des Formulars ohne zwischenzeitliches Erstellen oder öffnen einer der gespeicherten Abfragen weiß, dass nichts zu tun ist.<\/p>\n Vorhin wurde auch die Funktion Abfrageeigenschaften <\/b>erwähnt, welche die Eigenschaften einer Abfrage ermitteln soll. Diese finden Sie in Listing 2. Die Funktion erwartet lediglich einen Verweis auf das QueryDef<\/b>-Objekt dieser Abfrage und liefert eine Zeichenkette zurück, welche die Eigenschaften und ihre Werte etwa wie folgt enthält, also als Name-Wert-Paare, die durch das Pipe-Zeichen (|<\/b>) voneinander getrennt sind:<\/p>\n Listing 2: Einlesen der Eigenschaften einer Abfrage und ihrer Werte in eine Zeichenkette<\/span><\/b><\/p>\n Die Funktion durchläuft alle Property<\/b>-Elemente der Properties<\/b>-Auflistung und schließt einige Elemente aus, die entweder nicht eingelesen werden können oder keinen Nutzen haben. Dabei stellt sie in der Variablen strEigenschaften <\/b>eine Zeichenkette wie oben dargestellt zusammen. Diese wird anschließend noch um das zuletzt hinzugefügte Pipe-Zeichen gekürzt und als Funktionswert an die aufrufende Prozedur zurückgegeben. Damit ist der Vorgang zum Speichern der Definition einer Abfrage in der Tabelle tblAbfragen <\/b>abgeschlossen.<\/p>\n Die zweite Schaltfläche des Formulars heißt cmdEntwurf <\/b>und soll die aktuell im Listenfeld markierte Abfrage in der Entwurfsansicht anzeigen. Dies geschieht primär durch die folgende Ereignisprozedur, die allerdings zwei weitere Routinen aufruft:<\/p>\n Die erste heißt AbfrageErstellen <\/b>und soll basierend auf den in der Tabelle tblAbfragen <\/b>gespeicherten Daten ein neues QueryDef<\/b>-Objekt erstellen (s. Listing 3). Dabei soll der Name der erstellten Abfrage als Funktionswert zurückgeliefert werden. Den Namen der frisch erstellten Abfrage übergibt die Prozedur dann an die Routine AbfrageOeffnen<\/b>, welche die Abfrage in der Entwurfsansicht öffnen soll. Dazu erhält diese Routine außerdem als zweiten Parameter den Wert acViewDesign<\/b>.<\/p>\n Listing 3: Erstellen einer Abfrage aus dem in der Tabelle tblAbfragen gespeicherten Daten<\/span><\/b><\/p>\n Die Funktion AbfrageErstellen <\/b>erwartet lediglich den Wert des Primärschlüsselfeldes des Datensatzes, aus dessen Daten die Abfrage erstellt werden soll. Sie prüft dann, ob gegebenenfalls der Wert 0 <\/b>übergeben wurde (falls kein Listenfeldeintrag markiert ist) und bricht die Funktion gegebenenfalls ab. Ansonsten erstellt sie ein Recordset-Objekt auf Basis des entsprechenden Datensatzes der Tabelle tblAbfragen <\/b>und stellt einen Namen für diese Abfrage zusammen, der aus der Zeichenfolge qryTemp_ <\/b>und der Bezeichnung der Abfrage aus dem Listenfeld besteht. Sie löscht mit der Delete<\/b>-Methode eine eventuell bereits vorhandene Abfrage gleichen Namens und erzeugt diese mit der CreateQueryDef<\/b>-Methode neu. Dabei übergibt sie als ersten Parameter den neuen Abfragenamen und als zweiten Parameter den SQL-Ausdruck.<\/p>\n Anschließend folgt das Parsen und Zuweisen der Abfrageeigenschaften. Dazu speichert die Funktion zunächst die komplette Zeichenkette mit den Eigenschaften in der Array-Variablen strEigenschaften<\/b>. Dabei landen alle durch das Pipe-Zeichen voneinander getrennten Elemente in je einem Array-Element. Diese durchläuft die Funktion anschließend in einer For…Next<\/b>-Schleife.<\/p>\n Sie schreibt den Teil des jeweiligen Elements vor dem Gleichheitszeichen in die Variable varWert <\/b>und ersetzt dort die Zeichenketten Wahr <\/b>und Falsch <\/b>durch die Werte -1 <\/b>und 0<\/b>. Wahr <\/b>und Falsch <\/b>können nämlich als Werte von Boolean<\/b>-Eigenschaften verwendet werden. Danach weist die Funktion der jeweiligen Eigenschaft, dessen Namen sie aus dem Teil des aktuellen Array-Elements vor dem Gleichheitszeichen ermittelt, den zuvor ermittelten Wert zu. Sollte ein Fehler auftreten, weil die Eigenschaft noch nicht definiert wurde, legt die Funktion diesen mit der CreateProperty<\/b>-Methode des QueryDef<\/b>-Objekts an, weist dieser den entsprechenden Wert zu und hängt das Property<\/b>-Objekt mit der Append<\/b>-Methode an die Properties<\/b>-Auflistung der Abfrage an. Der Name der neu erstellen Abfrage landet dann schließlich in der Variablen AbfrageErstellen <\/b>und wird somit an die aufrufende Routine zurückgegeben.<\/p>\n Die Prozedur AbfrageOeffnen <\/b>übernimmt das eigentliche Anzeigen der Abfrage mit dem im Parameter strAbfrage <\/b>übergebenen Namen. Der Parameter intView <\/b>erhält in diesem Fall den Wert acViewNormal<\/b>, da die Abfrage in der Datenblattansicht geöffnet werden soll:<\/p>\n Diese Aufgabe übernimmt die Schaltfläche cmdAnzeigen<\/b>, welche beim Anklicken die folgende Prozedur aufruft:<\/p>\n Der Unterschied zum Anzeigen einer Abfrage in der Datenblattansicht ist, dass die Prozedur der Routine Abfrage-Oeffnen <\/b>mit dem Parameter intView <\/b>die Kon-stante acViewNormal <\/b>übergibt. Die Abfrage wird zuvor auf die gleiche Weise durch die Funktion AbfrageErstellen <\/b>erzeugt.<\/p>\n Damit Sie schnell mal eine Abfrage aus dem Listenfeld löschen können, haben wir die Schaltfläche cmdLoeschen <\/b>hinzufügt. Diese löst die Prozedur aus Listing 4 aus. Die Prozedur speichert zunächst den Wert des Feldes Uebersichtsposition <\/b>des Abfrage-Datensatzes aus der Tabelle tblAbfragen <\/b>in der Variablen intUebersichtsposition<\/b>.<\/p>\n\n
Speicherort der Abfragen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_002.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_003.png\")
<\/p>\nDas Formular frmAbfragen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_004.png\")
<\/p>\nListenfeld zur Anzeige der Abfragen<\/h2>\n
![\"Abfrage,](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_005.png\")
<\/p>\nNeue Abfrage anlegen<\/h2>\n
Private Sub <\/span>cmdNeu_Click()\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 strAktuelleAbfrage = \"qryTemp_New\"\r\n On Error Resume Next<\/span>\r\n db.QueryDefs.Delete strAktuelleAbfrage\r\n On Error GoTo<\/span> 0\r\n Set<\/span> qdf = db.CreateQueryDef(strAktuelleAbfrage)\r\n DoCmd.OpenQuery strAktuelleAbfrage, acViewDesign\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>strAktuelleAbfrage As String<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2015_04\/pic_988_006.png\")
<\/p>\nPrivate Sub <\/span>Form_Activate()\r\n Dim <\/span>db As <\/span>DAO.Database, qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>strAbfrageSQL As String<\/span>, strAbfragebezeichnung As String<\/span>, strAbfrageeigenschaften As String<\/span>\r\n Dim <\/span>lngAbfrageID As Long<\/span>, strSQL As String<\/span>\r\n If <\/span>Len<\/span>(strAktuelleAbfrage) > 0 Then<\/span>\r\n If <\/span>IstAbfrageGeoeffnet(strAktuelleAbfrage) Then<\/span>\r\n MsgBox<\/span> \"Bitte speichern und schließen Sie die temporäre Abfrage ''\" & strAktuelleAbfrage & \"''\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(strAktuelleAbfrage)\r\n If <\/span>CDec(qdf.DateCreated) = CDec(qdf.LastUpdated) Then<\/span>\r\n Exit Sub<\/span>\r\n Else<\/span>\r\n strAbfrageSQL = qdf.SQL\r\n strAbfrageeigenschaften = Abfrageeigenschaften(qdf)\r\n lngAbfrageID = Nz(DLookup(\"AbfrageID\", \"tblAbfragen\", \"''qryTemp_'' & Abfragebezeichnung = ''\" _\r\n & qdf.Name & \"''\"), 0)\r\n If <\/span>lngAbfrageID = 0 Then<\/span>\r\n If <\/span>MsgBox<\/span>(\"Soeben erstellte Abfrage sichern\", vbYesNo) = vbYes Then<\/span>\r\n strAbfragebezeichnung = Mid<\/span>(qdf.Name, 9)\r\n strAbfragebezeichnung = InputBox(\"Bezeichnung der Abfrage: \", \"Abfrage speichern\", _\r\n strAbfragebezeichnung)\r\n Do While<\/span> Not<\/span> IsNull(DLookup(\"AbfrageID\", \"tblAbfragen\", \"Abfragebezeichnung = ''\" _\r\n & strAbfragebezeichnung & \"''\"))\r\n strAbfragebezeichnung = InputBox(\"Unter diesem Namen ist bereits eine Abfrage vorhanden. \" _\r\n & \"Geben Sie eine neue Bezeichnung ein: \", \"Abfrage speichern\", strAbfragebezeichnung)\r\n Loop<\/span>\r\n If <\/span>Len<\/span>(strAbfragebezeichnung) = 0 Then<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strAbfragebezeichnung) > 0 Then<\/span>\r\n strSQL = \"INSERT INTO tblAbfragen(Abfragebezeichnung, AbfrageSQL, Abfrageeigenschaften) \" _\r\n & \"VALUES(''\" & strAbfragebezeichnung & \"'', ''\" & strAbfrageSQL & \"'', ''\" _\r\n & Replace<\/span>(Replace<\/span>(strAbfrageeigenschaften, \"\"\"\", \"''\"), \"''\", \"''''\") & \"'')\"\r\n db.Execute strSQL, dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\n Me!lstAbfragen.Requery\r\n Else<\/span>\r\n If <\/span>MsgBox<\/span>(\"Soeben geänderte Abfrage speichern\", vbYesNo) = vbYes Then<\/span>\r\n strSQL = \"UPDATE tblAbfragen SET AbfrageSQL = ''\" & strAbfrageSQL & \"'', Abfrageeigenschaften = ''\" _\r\n & strAbfrageeigenschaften & \"'' WHERE AbfrageID = \" & lngAbfrageID\r\n db.Execute strSQL, dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strAktuelleAbfrage = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>IstAbfrageGeoeffnet(strAbfrage As <\/span>_\r\n String) As Boolean<\/span>\r\n IstAbfrageGeoeffnet = _\r\n SysCmd(acSysCmdGetObjectState, acQuery, strAbfrage)\r\nEnd Function<\/span><\/pre>\nEigenschaften der Abfrage speichern<\/h2>\n
Private Function <\/span>Abfrageeigenschaften(qdf As <\/span>DAO.QueryDef) As String<\/span>\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>strEigenschaften As String<\/span>\r\n For Each prp In qdf.Properties\r\n Select Case prp.Name\r\n Case <\/span>\"StillExecuting\", \"CacheSize\", \"Prepare\", \"DOL\", \"NameMap\", \"DateCreated\", \"LastUpdated\", \"Type\", _\r\n \"Updatable\", \"RecordsAffected\", \"RecordLocks\", \"RecordsetType\", \"Name\"\r\n Case Else<\/span>\r\n On Error Resume Next<\/span>\r\n strEigenschaften = strEigenschaften & prp.Name & \"=\" & prp.Value & \"|\"\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Debug.Print<\/span> prp.Name, prp.Value\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End Select<\/span>\r\n Next<\/span> prp\r\n If <\/span>Len<\/span>(strEigenschaften) > 0 Then<\/span>\r\n strEigenschaften = Left<\/span>(strEigenschaften, Len<\/span>(strEigenschaften) - 1)\r\n End If<\/span>\r\n Abfrageeigenschaften = strEigenschaften\r\nEnd Function<\/span><\/pre>\nSQL=SELECT ...|Connect=|ReturnsRecords=Wahr|ODBCTimeout=60|MaxRecords=0|\r\nOrderByOn=Falsch|Orientation=0|DefaultView=2|GUID=|FilterOnLoad=Falsch|\r\nOrderByOnLoad=Wahr|TotalsRow=Falsch|FilterOn=Wahr|Description=Beispielbeschreibung|...<\/pre>\n
Entwurf einer Abfrage öffnen<\/h2>\n
Private Sub <\/span>cmdEntwurf_Click()\r\n Dim <\/span>strAbfrage As String<\/span>\r\n strAbfrage = AbfrageErstellen(Nz(Me!lstAbfragen, 0))\r\n If <\/span>Not<\/span> Len<\/span>(strAbfrage) = 0 Then<\/span>\r\n AbfrageOeffnen strAbfrage, acViewDesign\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>AbfrageErstellen(lngAbfrageID As Long<\/span>) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strEigenschaften() As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>varWert As Variant<\/span>\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>lngError As Long<\/span>\r\n If <\/span>lngAbfrageID = 0 Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblAbfragen WHERE AbfrageID = \" & lngAbfrageID, dbOpenDynaset)\r\n strAktuelleAbfrage = \"qryTemp_\" & rst!Abfragebezeichnung\r\n On Error Resume Next<\/span>\r\n db.QueryDefs.Delete strAktuelleAbfrage\r\n On Error GoTo<\/span> 0\r\n Set<\/span> qdf = db.CreateQueryDef(strAktuelleAbfrage, rst!AbfrageSQL)\r\n strEigenschaften = Split<\/span>(rst!Abfrageeigenschaften, \"|\")\r\n For i = LBound<\/span>(strEigenschaften) To UBound<\/span>(strEigenschaften)\r\n varWert = Split<\/span>(strEigenschaften(i), \"=\")(1)\r\n varWert = Replace<\/span>(varWert, \"Wahr\", -1)\r\n varWert = Replace<\/span>(varWert, \"Falsch\", 0)\r\n On Error Resume Next<\/span>\r\n qdf.Properties(Split<\/span>(strEigenschaften(i), \"=\")(0)) = varWert\r\n lngError = Err.Number\r\n On Error GoTo<\/span> 0\r\n If <\/span>lngError = 3270 Then<\/span>\r\n Set<\/span> prp = qdf.CreateProperty(Split<\/span>(strEigenschaften(i))(0))\r\n Select Case strEigenschaften(i)\r\n Case Else<\/span>\r\n prp.Type = dbText\r\n End Select<\/span>\r\n prp.Value = varWert\r\n qdf.Properties.Append prp\r\n End If<\/span>\r\n Next<\/span> i\r\n AbfrageErstellen = strAktuelleAbfrage\r\nEnd Function<\/span><\/pre>\nAbfrage aus den gespeicherten Daten erstellen<\/h2>\n
öffnen der Abfrage<\/h2>\n
Private Sub <\/span>AbfrageOeffnen(strAbfrage As String<\/span>, _\r\n intView As <\/span>AcView)\r\n DoCmd.OpenQuery strAbfrage, intView\r\nEnd Sub<\/span><\/pre>\nAbfrage in der Datenblattansicht öffnen<\/h2>\n
Private Sub <\/span>cmdAnzeigen_Click()\r\n Dim <\/span>strAbfrage As String<\/span>\r\n strAbfrage = AbfrageErstellen(Nz(Me!lstAbfragen, 0))\r\n If <\/span>Not<\/span> Len<\/span>(strAbfrage) = 0 Then<\/span>\r\n AbfrageOeffnen strAbfrage, acViewNormal\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nLöschen einer Abfrage<\/h2>\n
Private Sub <\/span>cmdLoeschen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>intUebersichtsposition As Integer<\/span>\r\n intUebersichtsposition = Nz(DLookup(\"Uebersichtsposition\", \"tblAbfragen\", \"AbfrageID = \" & Me!lstAbfragen), 0)\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblAbfragen WHERE AbfrageID = \" & Nz(Me!lstAbfragen, 0)\r\n If <\/span>