In Unterformularen in der Datenblattansicht lassen sich Daten prima filtern oder sortieren. Mit der DoCmd-Methode TransferSpreadsheet lassen sich Daten einer Tabelle oder Abfrage einfach in eine Excel-Datei exportieren. Aber wie bekommen wir beides unter einen Hut? Wir möchten also in einem Unterformular die Daten filtern und sortieren können und diese in dieser Ansicht in eine Excel-Datei exportieren können. Dazu brauchen wir ein wenig VBA und Kenntnisse der Eigenschaften eines Formulars. In diesem Beitrag zeigen wir, wie wir die Daten der Datenherkunft des Unterformulars wie im Unterformular angegeben filtern und sortieren und so in eine Excel-Datei schreiben.<\/b><\/p>\n
Beispieldatenbank<\/h2>\n
Wir verwenden ein einfaches Beispiel, in dem eine Tabelle namens tblBeispiele <\/b>mit den beiden Feldern ID <\/b>und Beispieltext <\/b>die Daten liefert (siehe Bild 1).<\/p>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2024_03\/pic_1496_002.png\")
<\/p>\n
Bild 1: Beispieltabelle mit einfachen Texten<\/span><\/b><\/p>\n Dazu legen wir zwei Formulare an. Das Unterformular sfmExportExcel <\/b>verwendet die Tabelle tblBeispiele <\/b>als Datensatzquelle und zeigt die beiden Felder ID <\/b>und Beispieltext <\/b>im Detailbereich an. Seine Eigenschaft Standardansicht <\/b>stellen wir auf Datenblatt <\/b>ein.<\/p>\n Dieses Unterformular fügen wir in das Hauptformular frmExportExcel <\/b>ein. Außerdem legen wir im Hauptformular eine Schaltfläche namens cmdExport <\/b>an.<\/p>\n Diese soll den Export der aktuell im Unterformular angezeigten Datensätze in eine Excel-Datei starten (siehe Bild 2).<\/p>\n Bild 2: Haupt- und Unterformular mit den Beispieldaten<\/span><\/b><\/p>\n Unsere Lösung basiert darauf, dass wir für ein Unterformular, das der Benutzer gefiltert und\/oder sortiert hat, den Filterausdruck als auch den Sortierausdruck aus entsprechenden Eigenschaften des Unterformulars auslesen können. Wir wissen auch, welche Datensatzquelle das Unterformular verwendet. Damit können wir folgendes tun:<\/p>\n Die grobe, auf unser konkretes Beispiel ausgelegte Prozedur für diesen Zweck finden wir in Listing 1. Die Prozedur legt in der Variablen strExcel <\/b>den Pfad der Zieldatei fest, die im aktuellen Verzeichnis unter dem Namen Beispiele.xlsx <\/b>gespeichert werden soll.<\/p>\n Listing 1: Exportieren der aktuellen Daten des Unterformulars in eine Excel-Tabelle<\/span><\/b><\/p>\n Gegebenenfalls ist diese Datei bereits vorhanden. Für diesen Fall führen die Kill<\/b>-Anweisung mit dem Pfad aus strExcel <\/b>aus – dies bei deaktivierter Fehlerbehandlung, damit keine Fehlermeldung erscheint, wenn die Datei nicht vorhanden sein sollte und die Kill<\/b>-Anweisung ins Leere läuft.<\/p>\n Dann referenziert die Prozedur das aktuelle Datenbankobjekt und legt in strQuery <\/b>den Namen für die temporär zu erzeugende Abfrage fest, hier qryTemp<\/b>.<\/p>\n Die grundlegende SQL-Anweisung legen wir als SELECT<\/b>-Anweisung über alle Felder der Tabelle tblBeispiele <\/b>fest. Dann prüft die Prozedur anhand der Eigenschaft FilterOn <\/b>des Unterformulars, ob der Filter aktiviert ist. In diesem Fall trägt sie den aktuellen Filter in die Variable strFilter <\/b>ein. Das Gleiche erledigen wir auch für die Sortierung, indem wir den Wert von OrderByOn <\/b>prüfen und gegebenenfalls den Inhalt der Eigenschaft OrderBy <\/b>in die Variable strOrderBy <\/b>eintragen.<\/p>\n Hat strFilter <\/b>einen Wert, hängen wir an die SELECT<\/b>-Anweisung in strSQL <\/b>eine entsprechende WHERE<\/b>-Klausel an. Gleiches erledigen wir für die ORDER BY<\/b>-Klausel, wenn strOrderBy <\/b>keine leere Zeichenkette enthält.<\/p>\n Schließlich erstellen wir mit der CreateQueryDef<\/b>-Methode des Database<\/b>-Objekts eine neue Abfrage mit dem Namen aus strQuery <\/b>und der SQL-Anweisung aus strSQL<\/b>.<\/p>\n Damit können wir nun den eigentlichen Export starten. Dazu nutzen wir die Methode TransferSpreadsheet <\/b>der DoCmd<\/b>-Klasse. Diese nutzt für die beiden ersten Parameter die Werte acExport <\/b>und acSpreadsheetTypeExcel12Xml<\/b>, damit ein Export in eine .xlsx<\/b>-Datei angestoßen wird. Der dritte Parameter enthält den Namen der Datenquelle, in diesem Fall der mit strQuery <\/b>angegebenen Abfrage. Mit dem vierten Parameter geben wir die zu erstellende Datei an und mit dem fünften die Information, dass Spaltenüberschriften mit exportiert werden sollen. Schließlich löschen wir die Abfrage aus strQuery <\/b>wieder.<\/p>\n Anschließend führen wir eine absteigende Sortierung nach dem Feld ID <\/b>und eine Filterung nach dem Feld Beispieltext <\/b>aus, der nur noch Werte liefert, die ein A <\/b>enthalten. Dann öffnen wir die erstellte Excel-Datei und finden genau die Daten vor, wie wir sie im Unterformular definiert haben (siehe Bild 3).<\/p>\n Bild 3: Der Export mit Filter und Sortierung<\/span><\/b><\/p>\n Damit haben wir eine recht spezifische Implementierung geschaffen. Diese werden wir nun ein wenig flexibler gestalten, sodass sich diese leicht auf andere Formulare übertragen lässt. Warum aber sollten wir das überhaupt tun?<\/p>\n Dazu fügen wir zunächst ein Textfeld namens txtExportdatei <\/b>hinzu sowie eine Schaltfläche namens cmdDateiauswahl<\/b>. Diese statten wir für das Ereignis Beim Klicken <\/b>mit der folgenden Prozedur aus:<\/p>\n Diese öffnet einen Dialog, mit dem wir die zu erstellende Datei festlegen können. Die gewählte Datei landet im Textfeld txtExportdatei<\/b>.<\/p>\n Für maximale Flexibilität haben wir eine Funktion geschrieben, die Sie von einer Schaltfläche aus aufrufen können. Die Beispielschaltfläche cmdExportFlexibel <\/b>nutzt dazu den folgenden Aufruf:<\/p>\n Die Funktion ExportFlexibel <\/b>aus Listing 2 verwendet diese Daten. Alles weitere ist tatsächlich flexibel – Sie können diese Funktion für alle weiteren Formulare mit Unterformular so nutzen.<\/p>\n Listing 2: Exportieren der aktuellen Daten des Unterformulars in eine Excel-Tabelle, flexible Variante<\/span><\/b><\/p>\n Auch diese Prozedur löscht zunächst eine eventuell bereits vorhandene Zieldatei. Wir verwenden weiterhin den Namen qryTemp <\/b>für die temporäre Datei.<\/p>\n Der nächste Schritt unterscheidet sich bereits deutlich von der ersten Variante. Hier verwenden wir nämlich nicht einfach die Abfrage SELECT * FROM tblBeispiele <\/b>als Datensatzherkunft für die zu erstellende Abfrage als Quelle für den Export, sondern untersuchen die Datensatzquelle des Unterformulars explizit.<\/p>\n Dazu prüfen wir, ob die ersten sechs Buchstaben der Datensatzquelle dem Ausdruck SELECT <\/b>entsprechen. In diesem Fall enthält die Datensatzquelle gegebenenfalls selbst eine WHERE<\/b>– oder ORDER BY<\/b>-Klausel. Hier weisen wir den Inhalt von sfm.RecordSource <\/b>direkt der Variablen strSQL <\/b>zu:<\/p>\n Anderenfalls erstellen wir eine SELECT<\/b>-Anweisung auf Basis der angegebenen Tabelle oder Abfrage:<\/p>\n Dann tragen wir, sofern der Filter und die Sortierung aktiviert sind, die entsprechenden Ausdrücke aus den Eigenschaften Filter <\/b>und OrderBy <\/b>in die Variablen strFilter <\/b>und strOrderBy <\/b>ein.<\/p>\n Nun folgt eine größere Operation, nämlich die Untersuchung des Inhalts von strSQL <\/b>auf eventuell bereits vorhandene WHERE<\/b>– oder ORDER BY<\/b>-Klauseln und das Einfügen der entsprechenden Klauseln aus dem Unterformular in diese Ausdrücke. Diesen Teil haben wir in die Funktion AddWhereAndOrderByToSQL <\/b>ausgegliedert, der wir drei Informationen übergeben:<\/p>\n Das Ergebnis dieser Funktion, die wir weiter unten beschreiben, landet wieder in der Variablen strSQL<\/b>. Daraus erstellen wir wieder das QueryDef<\/b>-Objekt, das wir als Datenquelle für den Aufruf von DoCmd.TransferSpreadsheet <\/b>nutzen. Danach löschen wir wie zuvor noch die für temporäre Zwecke erstellte Abfrage.<\/p>\n Warum brauchen wir eine eigene Funktion, um die für das Unterformular angegebenen Filter und Sortierungen hinzuzufügen, statt diese einfach anzuhängen?<\/p>\n Der Grund ist, dass wir als Datensatzquelle des Unterformulars durchaus einen Ausdruck wie den folgenden vorfinden können:<\/p>\n Hier können wir die weiteren Filter und Sortierungen nicht einfach anhängen, sondern wir müssen diese gegebenenfalls einbauen und müssen auch noch darauf achten, dass Schlüsselwörter wie WHERE <\/b>und ORDER <\/b>BY nicht doppelt verwendet werden.<\/p>\n Also nutzen wir die Funktion AddWhereAndOrderToSQL <\/b>aus Listing 3, um diese Aufgabe zu erledigen. Diese nimmt die oben erwähnten Parameter entgegen und schreibt den Wert von strSQL <\/b>zunächst in die Variable strTemp<\/b>.<\/p>\n Listing 3: Funktion zum Zusammenstellen der Abfrage mit Filtern und Sortierungen<\/span><\/b><\/p>\n Dann prüft sie, ob mit dem Parameter strFilter <\/b>ein Wert übergeben wurde. Falls ja, untersucht die Funktion, ob die aktuelle Version der Abfrage bereits das Schlüsselwort WHERE <\/b>enthält. Ist das nicht der Fall, untersucht sie weiter, ob die Abfrage eine ORDER BY<\/b>-Klausel enthält. Ist auch das nicht gegeben, können wir der Abfrage einfach das Schlüsselwort WHERE<\/b> gefolgt vom Inhalt aus strFilter <\/b>übergeben.<\/p>\n Falls noch keine WHERE<\/b>-Klausel enthalten ist, aber eine ORDER BY<\/b>-Klausel, dann müssen wir schon gezielter arbeiten: Die WHERE<\/b>-Klausel mit dem Inhalt von strFilter <\/b>müssen wir dann nämlich vor der ORDER BY<\/b>-Klausel einfügen. Dazu ersetzen wir ORDER BY <\/b>einfach mit der Replace<\/b>-Funktion durch WHERE <\/b>plus strFilter <\/b>plus ORDER BY<\/b>.<\/p>\n Für den Fall, dass bereits eine WHERE<\/b>-Bedingung in der Abfrage aus strTemp <\/b>enthalten ist, untersuchen wir auch wieder, ob auch eine ORDER BY<\/b>-Klausel vorliegt. Ist das nicht der Fall, können wir die Bedingung aus strFilter <\/b>ähnlich wie im ersten Fall hinten anhängen – diesmal allerdings nicht mit dem führenden Schlüsselwort WHERE<\/b>, sondern mit AND<\/b>. Das WHERE<\/b>-Schlüsselwort ist ja bereits vorhanden und es darf auch nur einmal verwendet werden.<\/p>\n Auch hier kann es wieder sein, dass eine ORDER BY<\/b>-Klausel vorhanden ist. In diesem Fall ersetzen wir diese wieder, diesmal durch AND <\/b>plus strFilter <\/b>plus ORDER BY<\/b>.<\/p>\n Danach hängen wir noch eine eventuell vorhandene Sortierung aus strOrderBy <\/b>an. In diesem Fall prüfen wir, ob bereits eine ORDER BY<\/b>-Klausel vorliegt. Ist das nicht der Fall, hängen wir einfach das Schlüsselwort ORDER BY <\/b>gefolgt vom Inhalt von strOrderBy <\/b>an. Anderenfalls ist ORDER BY <\/b>bereits vorhanden – dann hängen wir die weitere Sortierung einfach durch ein Komma getrennt daran an.<\/p>\n Das Ergebnis aus strTemp <\/b>geben wir schließlich als Funktionswert der Funktion AddWhereAndOrderByToSQL <\/b>an die aufrufende Routine zurück.<\/p>\n Es gibt noch eine wünschenswerte Erweiterung dieses Tools: Vielleicht möchte der Benutzer, dass auch nur die Felder, die im Unterformular angezeigt werden, im Ergebnis ausgegeben werden.<\/p>\n Hier wird es etwas komplizierter, denn wir müssten diese Spalten durchlaufen, eine Liste daraus bilden und diese im einfachsten Fall für das Sternchen in SELECT * FROM … <\/b>einfügen – oder eben für die Feldliste, die sich zwischen SELECT <\/b>und FROM<\/b>-Schlüsselwort befindet.<\/p>\n Hierfür setzen wir voraus, dass die Daten des Unterformulars aus einer einzigen Tabelle oder Abfrage stammen. <\/p>\n Dazu haben wir zunächst die einfache Personen-Tabelle noch um einige Spalten erweitert. Außerdem haben wir eine Kopie der Formulare frmExportExcel <\/b>und sfmExportExcel <\/b>unter den Namen frmExportExcelNurAngezeigteFelder <\/b>und sfmExportExcelNurAngezeigteFelder <\/b>erstellt. Letztere zeigt die Daten der Tabelle tblPersonen <\/b>an.<\/p>\n Dem Hauptformular fügen wir noch ein Kontrollkästchen namens chkNurAngezeigteFelder <\/b>hinzu (siehe Bild 4), dessen Standardwert wir auf Falsch eingestellt haben.<\/p>\n Bild 4: Erweitertes Formular<\/span><\/b><\/p>\n In der Prozedur, die durch die Schaltfläche cmdExportFlexibel <\/b>ausgelöst wird, passen wir den Aufruf der Prozedur ExportFlexibel <\/b>wie folgt an:<\/p>\n Diesen dritten Parameter müssen wir in der aufgerufenen Prozedur ExportFlexibel<\/b> verarbeiten. Damit auch der Aufruf vom Formular frmExportExcel <\/b>noch funktioniert, wo wir diesen Parameter nicht verwenden, legen wir diesen Parameter als optionalen Parameter an.<\/p>\n Die Anpassungen in der Prozedur ExportFlexibel <\/b>sind überschaubar. Das liegt daran, dass wir die Logik zum Ermitteln der angezeigten Felder im Formular und ihre Integration in den Abfrageausdruck für den Export in eine eigene Funktion ausgliedern. Die neue Version der Prozedur ExportFlexibel <\/b>sieht somit wie folgt aus – wir fügen nur den Parameter und den Aufruf einer weiteren Funktion namens ReplaceFieldsByVisibleFields <\/b>ein:<\/p>\n Diese Funktion erwartet zwei Parameter – den aktuellen SQL-Ausdruck mit strSQL <\/b>und einen Verweis auf das Unterformular mit sfm<\/b>. strSQL <\/b>enthält im aktuellen Zustand einen von zwei Werten:<\/p>\n Wenn eine SELECT<\/b>-Anweisung als Datensatzquelle für das Unterformular angegeben wurde, enthält strSQL <\/b>genau diese Abfrage. Wenn hingegen der Name einer Tabelle oder Abfrage angegeben wurde, enthält strSQL <\/b>eine SQL-Anweisung, die aus SELECT * FROM <\/b>und dem Namen der Tabelle oder Abfrage besteht.<\/p>\n In beiden Fällen gibt ExportFlexibel <\/b>im aktuellen Zustand alle Felder der so zusammengestellten SQL-Anweisung in die Excel-Tabelle aus – auch wenn wir nur einige dieser Felder im Unterformular anzeigen. Und auch hier gibt es noch eine Differenzierung: Wir können von Anfang an nur bestimmte Felder der Datensatzquelle in den Detailbereich des Unterformulars ziehen. Und dann kann der Benutzer auch noch einzelne Felder aus dem Datenblatt ausblenden (siehe Bild 5).<\/p>\n Bild 5: Felder ausblenden im Formular<\/span><\/b><\/p>\n Wir wollen am Ende nur die tatsächlich sichtbaren Felder in die Excel-Tabelle exportieren, sofern der Benutzer das Kontrollkästchen mit dem Text Nur angezeigte Felder <\/b>markiert hat.<\/p>\n Also nutzen wir die oben erwähnte Funktion ReplaceFieldsByVisibleFields<\/b>, um im SQL-Ausdruck strSQL <\/b>das Sternchen (*) oder die Feldliste durch die Liste der tatsächlich angezeigten Felder zu ersetzen.<\/p>\n Diese Funktion finden wir in Listing 4. Die Funktion kümmert sich nicht nur darum, nur die sichtbaren Felder zusammenzustellen und in die SQL-Abfrage zu integrieren, sondern sie untersucht auch noch die Reihenfolge, in welcher die Felder angezeigt werden. Wie das gelingt, schauen wir uns nun im Detail an.<\/p>\n![\"Haupt-](\"..\/fileadmin\/_temp_\/2024_03\/pic_1496_001.png\")
<\/p>\nVorgehensweise für das Ermitteln von Filter und Sortierung und den Export<\/h2>\n
\n
Aktuellen Filter ermitteln<\/h2>\n
Private Sub <\/span>cmdExport_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>QueryDef\r\n Dim <\/span>strQuery As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>strExcel As String<\/span>\r\n Dim <\/span>strOrderBy As String<\/span>\r\n strExcel = CurrentProject.Path & \"\\Beispiele.xlsx\"\r\n On Error Resume Next<\/span>\r\n Kill strExcel\r\n On Error GoTo<\/span> 0\r\n Set<\/span> db = CurrentDb\r\n strQuery = \"qryTemp\"\r\n strSQL = \"SELECT * FROM tblBeispiele\"\r\n If <\/span>Me!sfmExportExcel.Form.FilterOn = True<\/span> Then<\/span>\r\n strFilter = Me!sfmExportExcel.Form.Filter\r\n End If<\/span>\r\n If <\/span>Me!sfmExportExcel.Form.OrderByOn = True<\/span> Then<\/span>\r\n strOrderBy = Me!sfmExportExcel.Form.OrderBy#\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strFilter) = 0 Then<\/span>\r\n strSQL = strSQL & \" WHERE \" & strFilter\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strOrderBy) = 0 Then<\/span>\r\n strSQL = strSQL & \" ORDER BY \" & strOrderBy\r\n End If<\/span>\r\n Set<\/span> qdf = db.CreateQueryDef(strQuery, strSQL)\r\n DoCmd.TransferSpreadsheet acExport, acSpreadsheetTypeExcel12Xml, strQuery, strExcel, True<\/span>\r\n db.QueryDefs.Delete strQuery\r\nEnd Sub<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2024_03\/pic_1496_003.png\")
<\/p>\nVariable Gestaltung der Prozedur für den Export nach Excel<\/h2>\n
\n
Auswahl der Zieldatei<\/h2>\n
Private Sub <\/span>cmdDateiauswahl_Click()\r\n Dim <\/span>objFiledialog As <\/span>Office.FileDialog\r\n Set<\/span> objFiledialog = _\r\n Application.FileDialog(msoFileDialogSaveAs)\r\n With<\/span> objFiledialog\r\n .Title = \"Zieldatei festlegen\"\r\n .InitialFileName = _\r\n CurrentProject.Path & \"\\Export.xlsx\"\r\n If <\/span>.Show = True<\/span> Then<\/span>\r\n Me!txtExportdatei = .SelectedItems.Item(1)\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nFunktion zum Exportieren der Excel-Datei<\/h2>\n
Private Sub <\/span>cmdExportFlexibel_Click()\r\n ExportFlexibel Me!txtExportdatei, Me!sfmExportExcel.Form\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>ExportFlexibel(strExcelpath As String<\/span>, sfm As <\/span>Form)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>QueryDef\r\n Dim <\/span>strQuery As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>strOrderBy As String<\/span>\r\n Dim <\/span>strRecordsource As String<\/span>\r\n On Error Resume Next<\/span>\r\n Kill strExcelpath\r\n On Error GoTo<\/span> 0\r\n Set<\/span> db = CurrentDb\r\n strQuery = \"qryTemp\"\r\n If <\/span>Left<\/span>(sfm.RecordSource, 6) = \"SELECT\" Then<\/span>\r\n strSQL = sfm.RecordSource\r\n Else<\/span>\r\n strSQL = \"SELECT * FROM \" & sfm.RecordSource\r\n End If<\/span>\r\n If <\/span>sfm.FilterOn = True<\/span> Then<\/span>\r\n strFilter = sfm.Filter\r\n End If<\/span>\r\n If <\/span>sfm.OrderByOn = True<\/span> Then<\/span>\r\n strOrderBy = sfm.OrderBy\r\n End If<\/span>\r\n strSQL = AddWhereAndOrderByToSQL(strSQL, strFilter, strOrderBy)\r\n Set<\/span> qdf = db.CreateQueryDef(strQuery, strSQL)\r\n DoCmd.TransferSpreadsheet acExport, acSpreadsheetTypeExcel12Xml, strQuery, strExcelpath, True<\/span>\r\n db.QueryDefs.Delete strQuery\r\nEnd Sub<\/span><\/pre>\n If <\/span>Left<\/span>(sfm.RecordSource, 6) = \"SELECT\" Then<\/span>\r\n strSQL = sfm.RecordSource<\/pre>\n Else<\/span>\r\n strSQL = \"SELECT * FROM \" & sfm.RecordSource\r\n End If<\/span><\/pre>\nSQL-Ausdruck zusammenstellen<\/h2>\n
\n
Anreichern eines SQL-Ausdrucks um weitere WHERE- und ORDER BY-Ausdrücke<\/h2>\n
SELECT * FROM tblBeispiele WHERE Beispiel LIKE ''A*'' ORDER BY Beispiel DESC<\/pre>\n
Public Function <\/span>AddWhereAndOrderByToSQL(strSQL As String<\/span>, Optional<\/span> strFilter As String<\/span>, _\r\n Optional<\/span> strOrderBy As String<\/span>) As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n strTemp = strSQL\r\n If <\/span>Not<\/span> Len<\/span>(strFilter) = 0 Then<\/span>\r\n If <\/span>InStr<\/span>(1, strTemp, \"WHERE\") = 0 Then<\/span>\r\n If <\/span>InStr<\/span>(1, strTemp, \"ORDER BY\") = 0 Then<\/span>\r\n strTemp = strTemp & \" WHERE \" & strFilter\r\n Else<\/span>\r\n strTemp = Replace<\/span>(strTemp, \" ORDER BY \", \" WHERE \" & strFilter & \" ORDER BY \")\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>InStr<\/span>(1, strTemp, \"ORDER BY\") = 0 Then<\/span>\r\n strTemp = strTemp & \" AND \" & strFilter\r\n Else<\/span>\r\n strTemp = Replace<\/span>(strTemp, \" ORDER BY \", \" AND \" & strFilter & \" ORDER BY \")\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strOrderBy) = 0 Then<\/span>\r\n If <\/span>InStr<\/span>(1, strTemp, \" ORDER BY \") = 0 Then<\/span>\r\n strTemp = strTemp & \" ORDER BY \" & strOrderBy\r\n Else<\/span>\r\n strTemp = strTemp & \", \" & strOrderBy\r\n End If<\/span>\r\n End If<\/span>\r\n AddWhereAndOrderByToSQL = strTemp\r\nEnd Function<\/span><\/pre>\nNur die angezeigten Felder berücksichtigen<\/h2>\n
![\"Erweitertes](\"..\/fileadmin\/_temp_\/2024_03\/pic_1496_004.png\")
<\/p>\nPrivate Sub <\/span>cmdExportFlexibel_Click()\r\n Dim <\/span>strPath As String<\/span>\r\n strPath = Nz(Me!txtExportdatei, \"\")\r\n If <\/span>Not<\/span> Len<\/span>(strPath) = 0 Then<\/span>\r\n ExportFlexibel Me!txtExportdatei, _\r\n Me!sfmExportExcel.Form, _\r\n Me!chkNurAngezeigteFelder\r\n Else<\/span>\r\n MsgBox<\/span> \"Wähle zuerst eine Zieldatei aus.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>ExportFlexibel(strExcelpath As String<\/span>, _\r\n sfm As <\/span>Form, _\r\n Optional<\/span> bolNurAngezeigteFelder As Boolean<\/span>)\r\n ...\r\n strSQL = AddWhereAndOrderByToSQL(strSQL, strFilter, _\r\n strOrderBy)\r\n If <\/span>bolNurAngezeigteFelder = True<\/span> Then<\/span>\r\n strSQL = ReplaceFieldsByVisibleFields(strSQL, sfm)\r\n End If<\/span>\r\n Set<\/span> qdf = db.CreateQueryDef(strQuery, strSQL)\r\n ...\r\nEnd Sub<\/span><\/pre>\n![\"Felder](\"..\/fileadmin\/_temp_\/2024_03\/pic_1496_005.png\")
<\/p>\nPublic Function <\/span>ReplaceFieldsByVisibleFields(strSQL As String<\/span>, sfm As <\/span>Form) As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>strControlSource As String<\/span>\r\n