<\/p>\n
Wer Access-Frontends mit einem SQL Server-Backend entwickelt, wird früher oder später nicht immer zum SQL Server Management Studio wechseln wollen, um mal eben eine Abfrage auf die Daten der SQL Server-Datenbank abzusetzen. Viel schöner wäre es doch, wenn man dies direkt vom Access-Fenster aus erledigen könnte! Kein Problem: Da wir in den vorherigen Ausgaben ohnehin schon Add-Ins für den Einsatz mit dem SQL Server vorgestellt haben, machen wir hier gleich weiter.<\/b><\/p>\n
In den Beiträgen RDBMS-Tools: Verbindungen verwalten <\/b>(www.access-im-unternehmen.de\/976<\/b>), RDBMS-Tools: Tabellen verknüpfen <\/b>(www.access-im-unternehmen.de\/977<\/b>) und RDBMS-Tools als Add-In nutzen <\/b>(www.access-im-unternehmen.de\/978<\/b>) haben wir bereits zwei kleine Tools vorgestellt und als Add-In aufbereitet.<\/p>\n
Diese Add-In-Datei namens RDBMSTools.mda <\/b>bauen wir jetzt weiter aus, indem wir ein Formular hinzufügen, mit dem Sie direkt Abfragen an die Datenbank eines SQL Servers absetzen können.<\/p>\n
Dieses Formular sieht wie in Bild 1 aus und soll ebenfalls über einen Befehl des Add-In-Menüs verfügbar sein.<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_001.png\")
<\/p>\n
Bild 1: Formular zur direkten Eingabe von SQL-Anweisungen gegen ein SQL Server-Backend<\/span><\/b><\/p>\n Das Formular soll zunächst über das obere Kombinationsfeld die Auswahl einer Verbindung ermöglichen. Diese haben wir natürlich zuvor mit einem der anderen beiden Add-Ins hergestellt, nämlich mit dem aus dem Beitrag RDBMS-Tools: Verbindungen verwalten<\/b>.<\/p>\n Das Kombinationsfeld zeigt also, soweit bereits eingegeben, die vorhandenen Verbindungen an. Alternativ klicken Sie auf die Schaltfläche rechts vom Kombinationsfeld und öffnen so den Dialog aus Bild 2.<\/p>\n Bild 2: Verwalten der zu verwendenden Verbindungszeichenfolge<\/span><\/b><\/p>\n Nach dem Auswählen der Verbindungszeichenfolge können Sie dann gleich mit der Eingabe von SQL-Anweisungen loslegen. Diese tragen Sie einfach in das große Textfeld direkt unter der Verbindungsauswahl ein. Dabei können Sie dort eine oder mehrere SQL-Anweisungen unterbringen. <\/p>\n Der Clou ist: Wenn Sie mehrere Anweisungen unterbringen, werden diese auch nacheinander abgearbeitet. Manchmal möchten Sie aber vielleicht ein paar Anweisungen eingeben und diese nacheinander ausführen.<\/p>\n Dann können Sie die jeweils auszuführende Anweisung einfach markieren und diese dann durch Betätigen der Schaltfläche Ausführen <\/b>oder der Taste F5 <\/b>starten.<\/p>\n Damit Sie wissen, welche Anweisungen aktuell für die Ausführung vorgesehen sind, zeigt das Formular diese Zeilen unter dem Eingabefeld für die SQL-Anweisungen an. Wenn Sie also nur eine einzige Zeile wie in Bild 3 markieren, dann wird auch nur diese angezeigt – und durch F5 <\/b>oder Ausführen<\/b> auch ausgeführt.<\/p>\n Bild 3: Markieren der auszuführenden SQL-Anweisung<\/span><\/b><\/p>\n Fehlt noch das Unterformularsteuerelement im unteren Bereich des Formulars: Dieses zeigt die Ergebnisse der ausgeführten Anweisungen an.<\/p>\n Bei Datensatzänderungen wie dem Löschen, ändern oder Hinzufügen wird hier beispielsweise die Anzahl der betroffenen Datensätze ausgegeben. Wenn Sie eine SELECT<\/b>-Abfrage ausführen, liefert das Unterformular bis zu zehn Felder des Abfrageergebnisses.<\/p>\n Sie können also die folgenden Abfragetypen mit dem hier vorgestellten Formular ausführen:<\/p>\n Das Unterformular liefert sogar eine entsprechende Fehlermeldung, wenn Sie eine ungültige SQL-Abfrage absetzen (s. Bild 4).<\/p>\n Bild 4: Ausgabe von Fehlermeldungen<\/span><\/b><\/p>\n Und noch ein wichtiges Feature: Möglicherweise benötigen Sie die eine oder andere SQL-Anweisung im Laufe der Entwicklung der Anwendung mehrmals. Die eingegebenen Daten samt Bezeichnung, Verbindungszeichenfolge und SQL-Befehlen werden in einer Tabelle gespeichert, sodass Sie durch Blättern durch die Datensätze die verschiedenen SQL-Befehle ansteuern können.<\/p>\n Das Formular sieht in der Entwurfsansicht wie in Bild 5 aus. Da die eingegebenen SQL-Befehle gespeichert und bei Bedarf wieder aufrufbar sein sollen, binden wir das Formular an die Tabelle tblSQLBefehle <\/b>als Datenherkunft. Das Feld SQLBefehl <\/b>soll dabei als Memofeld ausgelegt sein, da eine SQL-Anweisung leicht einmal mehr als 255 Zeichen umfasst. VerbindungID <\/b>ist ein Fremdschlüsselfeld zur Tabelle tblVerbindungszeichenfolgen <\/b>und Bezeichnung <\/b>ein einfaches Textfeld.<\/p>\n Bild 5: Entwurf des Formulars frmSQLBefehle<\/span><\/b><\/p>\n Diese Tabelle finden Sie in der Entwurfsansicht in Bild 6. Die Felder der Tabelle werden – mit Ausnahme des Primärschlüsselfeldes – im oberen Teil des Formulars frmSQLBefehle <\/b>angezeigt. Das Feld VerbindungID<\/b> führen wir dabei als Kombinationsfeld aus, damit Sie damit leicht die Einträge der Tabelle tblVerbindungszeichenfolgen <\/b>auswählen können. Rechts neben dem Kombinationsfeld finden Sie eine Schaltfläche namens cmdVerbindungenBearbeiten<\/b>, mit der Sie das bereits im Beitrag RDBMS-Tools: Verbindungen verwalten <\/b>beschriebene Formular öffnen können.<\/p>\n Bild 6: Entwurf der Tabelle zum Speichern der SQL-Befehle<\/span><\/b><\/p>\n Dieses zeigt dann direkt die aktuell im Kombinationsfeld ausgewählte Verbindung an. Das Kombinationsfeld cboVerbindung <\/b>erhält also die folgende Abfrage als Datensatzherkunft:<\/p>\n Damit die Schaltfläche cmdVerbindungenBearbeiten<\/b> auf Knopfdruck das Formular frmVerbindungszeichenfolgen <\/b>öffnet, hinterlegen Sie die Ereignisprozedur aus Listing 1 für das Ereignis Beim Klicken<\/b>. Dieses öffnet das Formular frmVerbindungszeichenfolgen <\/b>und übergibt den Primärschlüsselwert der aktuell im Kombinationsfeld cboVerbindung <\/b>ausgewählten Verbindungszeichenfolge per öffnungsargument.<\/p>\n Listing 1: Formular zum Auswählen der Verbindungszeichenfolge öffnen<\/span><\/b><\/p>\n Dann speichert die Prozedur einen Verweis auf das Formular in einer Objektvariablen namens frmVerbindungszeichenfolgen<\/b>, die im Kopf des Klassenmoduls wie folgt deklariert wird:<\/p>\n Der Hintergrund ist, dass wir im Klassenmodul des aufrufenden Formulars frmSQLBefehle <\/b>eine Ereignisprozedur definieren wollen, die beim Schließen des Formulars frmVerbindungszeichenfolgen <\/b>ausgelöst wird. Dazu müssen wir die Objektvariable mit dem Schlüsselwort WithEvents <\/b>auszeichnen. Nun können wir per VBA eine Ereignisprozedur für die Ereigniseigenschaft Beim Entladen <\/b>angeben (OnUnload = [Event Procedure]<\/b>).<\/p>\n Damit brauchen wir nun nur noch die folgende Ereignisprozedur im Klassenmodul des Formulars frmSQLBefehle<\/b> zu hinterlegen:<\/p>\n Damit rufen wir nun das Formular frmVerbindungszeichenfolgen <\/b>auf und können im Formular frmSQLBefehle <\/b>auf das Beim Schließen<\/b>-Ereignis von frmVerbindungszeichenfolgen <\/b>reagieren.<\/p>\n Dort aktualisieren wir den Inhalt von cboVerbindung <\/b>(falls im Formular frmVerbindungszeichenfolgen <\/b>neue Verbindungszeichenfolgen hinzugefügt oder welche gelöscht wurden) und stellen das Kombinationsfeld cboVerbindung <\/b>auf die zuletzt im Formular frmVerbindungszeichenfolgen <\/b>gewählte Verbindungszeichenfolge ein.<\/p>\n Das Textfeld txtSQL <\/b>ist an das Feld SQLBefehl <\/b>der Tabelle tblSQLBefehle <\/b>gebunden. Damit Sie darin Zeilenumbrüche einfach mit der Eingabetaste herbeiführen können, ohne dass der Fokus auf das nächste Steuerelement verschoben wird, stellen wir die Eigenschaft Eingabetastenverhalten <\/b>auf Neue Zeile im Feld <\/b>ein.<\/p>\n Das Bezeichnungsfeld lblSQL <\/b>soll jeweils den SQL-Ausdruck aus dem Textfeld txtSQL <\/b>anzeigen, der beim Betätigen von F5 <\/b>beziehungsweise beim Anklicken der Schaltfläche cmdAusfuehren <\/b>ausgeführt würde.Das ist normalerweise der komplette SQL-Text, außer der Benutzer markiert nur einen Teil des enthaltenen Textes. Dann wird nur dieser Teil in lblSQL <\/b>abgebildet und auch ausgeführt.<\/p>\n Das Formular enthält außerdem eine Schaltfläche namens cmdAusfuehren<\/b>, auf deren Funktion wir weiter unten eingehen.<\/p>\n Außerdem enthält das Formular ein Unterformular-Steuerelement, dessen Eigenschaft Herkunftsobjekt <\/b>wir auf das Formular sfmSQLBefehle <\/b>einstellen.<\/p>\n Dieses Formular enthält zehn Textfelder mit den Namen txt01<\/b>, txt02 <\/b>und so weiter (s. Bild 7). Die zehn dazu gehörenden Bezeichnungsfelder heißen entsprechend lbl01<\/b>, lbl02 <\/b>und so weiter. Das Unterformular und die Textfelder sind standardmäßig nicht an eine Datenherkunft gebunden. Dies geschieht erst später, wenn ein Ergebnis einer Abfrage vorliegt oder ein Fehler beim Ausführen einer Abfrage auftritt.<\/p>\n <\/p>\n Bild 7: Entwurf des Unterformulars sfmSQLBefehle<\/span><\/b><\/p>\n Die Begrenzung auf zehn Textfelder haben wir nur für diese Beispieldatenbank vorgenommen. Sie sorgt dafür, dass das Ergebnis einer Ad-hoc-Abfrage nicht mehr als zehn Felder zurückliefert beziehungsweise anzeigt. Wenn Sie mehr benötigen, legen Sie einfach weitere Textfelder entsprechend der Namenskonvention der vorhandenen Felder an.<\/p>\n Es wird vorkommen, dass Sie Fehler in die SQL-Anweisungen einbauen. Diese wollen wir dann in einer dafür vorgesehenen Tabelle speichern und dann im Unterformular sfmSQLBefehle <\/b>anzeigen. Die Tabelle sieht im Entwurf wie in Bild 8 aus.<\/p>\n Bild 8: Entwurf der Tabelle tblFehler<\/span><\/b><\/p>\n In dem Moment, in dem Sie ein Zeichen in das Textfeld txtSQL <\/b>eingeben, soll das Formular bereits den Ausdruck im Bezeichnungsfeld lblSQL <\/b>anzeigen, der bei Betätigen von F5 <\/b>oder der Schaltfläche cmdAusfuehren <\/b>ausgeführt wird. Daher muss der Inhalt von lblSQL <\/b>immer auf dem aktuellen Stand gehalten werden. Dafür sorgt zunächst einmal die Ereignisprozedur Bei Maustaste auf<\/b>, die nach der Eingabe eines jeden Zeichens in das Textfeld txtSQL <\/b>ausgelöst wird, und eine weitere Prozedur namens SQLAusdruckErmitteln <\/b>aufruft:<\/p>\n Die Prozedur SQLAusdruckErmitteln<\/b> finden Sie in Listing 2. Sie prüft, ob das Textfeld txtSQL <\/b>eine Markierung enthält, das heißt, dass der Benutzer einen Bereich einer Zeile oder gar eine oder mehrere Zeilen markiert hat. Dies geschieht mit der Abfrage der Eigenschaft SelLength<\/b>, die dann einen Wert größer als 0 <\/b>aufweisen müsste. Ist dies der Fall, ermittelt die Prozedur den Inhalt der Markierung und trägt diesen in die Variable strSQL <\/b>ein, die wie folgt im Kopf des Klassenmoduls deklariert ist:<\/p>\n Listing 2: Ermitteln des aktuell markierten SQL-Ausdrucks im Textfeld txtSQL<\/span><\/b><\/p>\n Falls keine Markierung vorliegt, landet schlicht der komplette Inhalt von txtSQL <\/b>in der Variablen strSQL<\/b>.<\/p>\n Der Inhalt von strSQL <\/b>wird dann als Beschriftung des Bezeichnungsfeldes lblSQL <\/b>eingetragen.<\/p>\n Nun erfassen wir den aktuellen Ausdruck nach der Eingabe eines jeden Zeichens, also auch, wenn der Benutzer bei gedrückter Umschalttaste die Cursor-Tasten verwendet und so einen Bereich markiert. Wie aber registrieren wir es, wenn der Benutzer einen Bereich mit der Maus markiert Auch dafür gibt es natürlich eine geeignete Ereignisprozedur, nämlich Bei Maus nach oben<\/b>. Dafür hinterlegen wir die folgende Prozedur, die ebenfalls die Routine SQLAusdruckErmitteln <\/b>aufruft:<\/p>\n Die offensichtliche Möglichkeit, die SQL-Abfrage auszuführen, ist das Anklicken der Schaltfläche cmdAusfuehren<\/b>. Dies löst die Ereignisprozedur aus Listing 3 aus. Diese Prozedur prüft zunächst, ob die Variable strSQL<\/b>, die den aktuell auszuführenden SQL-Ausdruck speichert, nicht leer ist, und gibt gegebenenfalls eine entsprechende Meldung aus und bricht die Prozedur ab.<\/p>\n Listing 3: Ausführen einer SQL-Anweisung<\/span><\/b><\/p>\n Ist strSQL <\/b>nicht leer, wird eine neue temporäre Abfrage namens qryTemp <\/b>auf Basis der angegebenen SQL-Anweisung erstellt.<\/p>\n Da gegebenenfalls von vorherigen Anwendungen bereits eine gleichnamige Abfrage vorhanden ist, löscht die Prozedur diese unter Deaktivierung der Fehlerbehandlung. Anderenfalls würde ein Fehlen der zu löschenden Abfrage zu einem Fehler führen.<\/p>\n Die CreateQueryDef<\/b>-Methode legt die Abfrage dann neu an und referenziert sie mit der Objektvariablen qdf<\/b>. Die Connect<\/b>-Eigenschaft füllt die Prozedur dann mit der in der Tabelle tblVerbindungszeichenfolgen <\/b>gespeicherten Verbindungszeichenfolge für diese Abfrage.<\/p>\n Ein Aufruf der Funktion LeerzeichenEntfernen <\/b>sorgt dafür, dass unnötige Leerzeichen und Zeilenumbrüche aus der SQL-Abfrage entfernt werden. Diese Funktion erwartet die SQL-Abfrage als Parameter und liefert die bereinigte SQL-Anweisung zurück:<\/p>\n Nach diesem Schritt prüft cmdAusfuehren_Click<\/b>, um was für eine Art von Abfrage es sich handelt. Die vorliegende Version unterstützt SELECT<\/b>-, DELETE<\/b>-, INSERT<\/b>-, UPDATE<\/b>-, CREATE<\/b>-, DROP<\/b>– und ALTER<\/b>-Anweisungen. Beim Auffinden des SELECT<\/b>-Schlüsselwortes geschieht nichts weiter.<\/p>\n Bei den übrigen Anweisungen stellt die Prozedur ein, dass die Anweisung SELECT @@ROWCOUNT AS Anzahl… <\/b>an die SQL-Anweisung angehängt wird. Dies sorgt dafür, dass bei Aktionsabfragen die Anzahl der betroffenen Datensätze als Abfrageergebnis zurückgegeben wird. Wird keines dieser Schlüsselworte verwendet, wird die Prozedur mit einer entsprechenden Meldung beendet.<\/p>\n Die Prozedur stellt die Eigenschaft ReturnRecords <\/b>für die Abfrage auf True <\/b>ein und öffnet dann mit der OpenRecordset<\/b>-Methode ein neues Recordset auf Basis dieser Abfrage. Dieses referenziert sie dann mit der Objektvariablen rst<\/b>. Sollte nun ein Fehler auftreten, erfolgt die Protokollierung des Fehlers in der Tabelle tblFehler<\/b>.<\/p>\n Dazu leert die Prozedur diese Tabelle zunächst und trägt dann für jedes Element der Errors<\/b>-Auflistung des DAO<\/b>-Objekts einen neuen Datensatz in die Tabelle tblFehler <\/b>ein. Den Inhalt der Tabelle tblFehler <\/b>liest die Prozedur dann wiederum in das Recordset rst <\/b>ein. rst <\/b>enthält nun entweder das Ergebnis der Abfrage oder aber den aktuellen Inhalt der Tabelle tblFehler<\/b>. Mithilfe der Routine UnterdatenblattFuellen <\/b>erscheint der Inhalt von rst <\/b>dann als Datenherkunft des Unterformulars sfmSQLBefehle<\/b>.<\/p>\n Nachdem das Abfrageergebnis nun in Form eines Recordsets vorliegt, müssen wir es nur noch im Unterformular sfmSQLBefehle <\/b>anzeigen. Weiter oben haben Sie ja bereits gesehen, dass dieses Unterformular einen Vorrat von zehn ungebundenen Textfeldern samt Bezeichnungsfeldern enthält.<\/p>\n Die Aufgabe der Prozedur UnterdatenblattFuellen <\/b>aus Listing 4 ist es nun, die Bezeichnungsfelder mit den Feldnamen des Recordsets zu füllen, die Textfelder an die Felder des Abfrageergebnisses zu binden und die Spaltenbreiten zu optimieren, sodass alle enthaltenen Texte sichtbar sind. Außerdem sollen bei Abfragen, die weniger als zehn Felder liefern, die nicht verwendeten Textfelder ausgeblendet werden.<\/p>\n Listing 4: Anzeigen des Abfrageergebnisses im Unterformular sfmSQLBefehle<\/span><\/b><\/p>\n Die Prozedur weist dem im Unterformularsteuerelement sfmErgebnis <\/b>enthaltenen Unterformular (hier also sfm-SQL-Befehle<\/b>) das als Parameter übergebene Recordset zu.<\/p>\n Dann durchläuft es eine For…Next<\/b>-Schleife von 0 <\/b>bis zur Anzahl der Felder des Recordsets rst<\/b>. Die Schleife wird abgebrochen, sobald zehn Felder durchlaufen wurden (i=10<\/b>).<\/p>\n Für die ersten zehn Felder referenziert die Prozedur dynamisch jeweils das dem aktuellen Wert entsprechende Textfeld und stellt zwei Eigenschaften ein: ColumnHidden <\/b>enthält den Wert False<\/b>, was dieses Feld einblendet und ControlSource <\/b>wird mit dem Namen des aktuellen Feldes des Recordsets gefüllt. Dies bindet das Textfeld an das entsprechende Recordset-Feld.<\/p>\n Dann referenziert es das zu diesem Textfeld gehörende Bezeichnungsfeld und stellt mit dessen Eigenschaft Caption <\/b>die Spaltenüberschrift für dieses Feld ein.<\/p>\n Danach durchläuft die Prozedur die Felder des Recordsets in einer zweiten For…Next<\/b>-Schleife ein zweites Mal. Diesmal stellt es die Eigenschaft ColumnWidth <\/b>auf den Wert -2 <\/b>ein, was eine Optimierung der Spaltenbreite für die aktuell angezeigten Zeilen auslöst. Dies können wir leider nicht direkt im ersten Durchlauf der For…Next<\/b>-Schleife auslösen, da sonst ein Fehler auftritt.<\/p>\n Sollte das Abfrageergebnis weniger als zehn Felder enthalten, müssen wir die übrigen Felder noch ausblenden. Da die zuletzt durchlaufene For…Next<\/b>-Schleife in diesem Fall nur bis zum letzten Feld des Recordsets durchlaufen wurde, können wir den aktuellen Wert der Laufvariable i <\/b>als Startwert für eine weitere For…Next<\/b>-Schleife verwenden.<\/p>\n Diese nutzt diesmal die Laufvariable j <\/b>und läuft von i <\/b>bis 10<\/b>. Dabei stellt sie die Eigenschaft ColumnHidden <\/b>des entsprechenden Textfeldes jeweils auf den Wert True <\/b>ein und blendet die Spalten somit aus.<\/p>\n Damit erscheinen nun die Daten der angegebenen Abfrage (oder eine Fehlermeldung) im Unterformular sfmSQLBefehle<\/b>.<\/p>\n Fehlt noch die Möglichkeit, auf die Schnelle mit der Taste F5 <\/b>auszuführen. Dazu fragen wir in der Ereignisprozedur Bei Maustaste ab <\/b>einfach den KeyCode der gedrückten Taste ab. Beträgt dieser 116, was der Taste F5 entspricht, rufen wir auch in diesem Fall die soeben beschriebene Prozedur cmdAusfuehren_Click <\/b>auf:<\/p>\n Nun soll dieses Tool auch noch als Add-In verfügbar sein. Dazu sind noch ein paar kleine Handgriffe nötig. Als Erstes müssen Sie der Tabelle USysRegInfos<\/b>, die in der Beispieldatenbank des Beitrags RDBMS-Tools als Add-In nutzen <\/b>bereits enthalten ist, um ein weiteres Set von Datensätzen für das neue Add-In erweitern. Diese sehen wie in Bild 9 aus.<\/p>\n Bild 9: Erweiterung der Tabelle USysRegInfo<\/span><\/b><\/p>\n Außerdem fügen Sie noch die in der ersten Zeile der neuen Einträge in die Tabelle USysRegInfo <\/b>genannte VBA-Funktion zum Modul mdlGlobal <\/b>hinzu. Dieses sieht so aus:<\/p>\n![\"Verwalten](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_002.png\")
<\/p>\n![\"Markieren](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_003.png\")
<\/p>\n\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_004.png\")
<\/p>\nFormular erstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_005.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_006.png\")
<\/p>\nSELECT VerbindungszeichenfolgeID, Bezeichnung \r\nFROM tblVerbindungszeichenfolgen;<\/pre>\n
Private Sub <\/span>cmdVerbindungenBearbeiten_Click()\r\n DoCmd.OpenForm \"frmVerbindungszeichenfolgen\", OpenArgs:=Nz(Me!cboVerbindung, 0)\r\n Set<\/span> frmVerbindungszeichenfolgen = Forms!frmVerbindungszeichenfolgen\r\n With<\/span> frmVerbindungszeichenfolgen\r\n .Modal = True<\/span>\r\n .OnUnload = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents frmVerbindungszeichenfolgen As <\/span>Form<\/pre>\nPrivate Sub <\/span>frmVerbindungszeichenfolgen_Unload(Cancel _\r\n As Integer<\/span>)\r\n Me!cboVerbindung.Requery\r\n Me!cboVerbindung = _\r\n frmVerbindungszeichenfolgen!VerbindungszeichenfolgeID\r\nEnd Sub<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_007.png\")
<\/p>\nDie Fehlertabelle<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_008.png\")
<\/p>\nEingabe des SQL-Ausdrucks<\/h2>\n
Private Sub <\/span>txtSQL_KeyUp(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n SQLAusdruckErmitteln\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SQLAusdruckErmitteln()\r\n If <\/span>Me!txtSQL.SelLength > 0 Then<\/span>\r\n strSQL = Mid<\/span>(Me!txtSQL.Text, Me!txtSQL.SelStart + 1, Me!txtSQL.SelLength)\r\n Else<\/span>\r\n strSQL = Me!txtSQL.Text\r\n End If<\/span>\r\n Me!lblSQL.Caption = strSQL\r\nEnd Sub<\/span><\/pre>\nDim <\/span>strSQL As String<\/span><\/pre>\nMarkierten Ausdruck abfragen<\/h2>\n
Private Sub <\/span>txtSQL_MouseUp(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n SQLAusdruckErmitteln\r\nEnd Sub<\/span><\/pre>\nSQL-Abfrage ausführen<\/h2>\n
Private Sub <\/span>cmdAusfuehren_Click()\r\n Dim <\/span>db As <\/span>DAO.Database, qdf As <\/span>DAO.QueryDef, rst As <\/span>DAO.Recordset, i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Len<\/span>(strSQL) = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte markieren Sie den auszuführenden SQL-Befehl.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n db.QueryDefs.Delete \"qryTemp\"\r\n On Error GoTo<\/span> 0\r\n Set<\/span> qdf = db.CreateQueryDef(\"qryTemp\")\r\n With<\/span> qdf\r\n .Connect = DLookup(\"Verbindungszeichenfolge\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & Me!cboVerbindung)\r\n .SQL = LeerzeichenEntfernen(strSQL)\r\n Select Case Left<\/span>(.SQL, 6)\r\n Case <\/span>\"SELECT\"\r\n Case <\/span>\"DELETE\": .SQL = \"SET NOCOUNT ON;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS AnzahlGeloescht\"\r\n Case <\/span>\"INSERT\": .SQL = \"SET NOCOUNT ON;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS AnzahlEingefuegt\"\r\n Case <\/span>\"UPDATE\": .SQL = \"SET NOCOUNT ON;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS AnzahlAktualisiert\"\r\n Case <\/span>\"CREATE\": .SQL = \"SET NOCOUNT ON;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS AnzahlAktualisiert\"\r\n Case Else<\/span>\r\n If <\/span>Left<\/span>(.SQL, 5) = \"ALTER\" Then<\/span>\r\n .SQL = \"SET NOCOUNT ON ;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS Aktualisiert\"\r\n Else<\/span>If Left<\/span>(.SQL, 4) = \"DROP\" Then\r\n .SQL = \"SET NOCOUNT ON ;\" & vbCrLf<\/span> & .SQL & vbCrLf<\/span> & \"SELECT @@ROWCOUNT AS Aktualisiert\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Anweisung muss mit SELECT, DELETE, INSERT, UPDATE, CREATE, ALTER oder DROP beginnen.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\n .ReturnsRecords = True<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> rst = .OpenRecordset\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n On Error GoTo<\/span> 0\r\n db.Execute \"DELETE FROM tblFehler\", dbFailOnError\r\n For i = 0 To DAO.Errors.Count - 1\r\n db.Execute \"INSERT INTO tblFehler(FehlerID, Fehler) VALUES(\" & DAO.Errors(i).Number & \", ''\" _\r\n & Replace<\/span>(DAO.Errors(i).Description, \"''\", \"''''\") & \"'')\", dbFailOnError\r\n Debug.Print<\/span> DAO.Errors(i).Source\r\n Next<\/span> i\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblFehler\")\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End With<\/span>\r\n UnterdatenblattFuellen rst\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>LeerzeichenEntfernen(strSQL As String<\/span>) _\r\n As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>intLaengeVorher As Integer<\/span>\r\n strTemp = strSQL\r\n intLaengeVorher = Len<\/span>(strTemp) + 1\r\n Do While<\/span> Len<\/span>(strTemp) < intLaengeVorher\r\n intLaengeVorher = Len<\/span>(strTemp)\r\n Mid<\/span>(strTemp, 1, 1) = _\r\n Replace<\/span>(Mid<\/span>(strTemp, 1, 1), Chr(13), \" \")\r\n Mid<\/span>(strTemp, 1, 1) = _\r\n Replace<\/span>(Mid<\/span>(strTemp, 1, 1), Chr(10), \" \")\r\n strTemp = Trim<\/span>(strTemp)\r\n Loop<\/span>\r\n LeerzeichenEntfernen = strTemp\r\nEnd Function<\/span><\/pre>\nErgebnis im Unterformular anzeigen<\/h2>\n
Private Sub <\/span>UnterdatenblattFuellen(rst As <\/span>DAO.Recordset)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Set<\/span> Me!sfmErgebnis.Form.Recordset = rst\r\n For i = 0 To rst.Fields.Count - 1\r\n If <\/span>i = 10 Then<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n With<\/span> Me!sfmErgebnis.Form.Controls(\"txt\" & Format(i + 1, \"00\"))\r\n .ColumnHidden = False<\/span>\r\n .ControlSource = rst.Fields(i).Name\r\n End With<\/span>\r\n With<\/span> Me!sfmErgebnis.Form.Controls(\"lbl\" & Format(i + 1, \"00\"))\r\n .Caption = rst.Fields(i).Name\r\n End With<\/span>\r\n Next<\/span> i\r\n ''ColumnWidth muss später eingestellt werden, da sonst nicht zuverlässig\r\n For i = 0 To rst.Fields.Count - 1\r\n If <\/span>i = 10 Then<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n With<\/span> Me!sfmErgebnis.Form.Controls(\"txt\" & Format(i + 1, \"00\"))\r\n .ColumnWidth = -2\r\n End With<\/span>\r\n Next<\/span> i\r\n For j = i To 9\r\n With<\/span> Me!sfmErgebnis.Form.Controls(\"txt\" & Format(j + 1, \"00\"))\r\n .ColumnHidden = True<\/span>\r\n End With<\/span>\r\n Next<\/span> j\r\nEnd Sub<\/span><\/pre>\nAbfrage mit F5 ausführen<\/h2>\n
Private Sub <\/span>Form_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>116\r\n KeyCode = 0\r\n Call<\/span> cmdAusfuehren_Click\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nFormular in das Add-In einbinden<\/h2>\n
![\"Erweiterung](\"..\/fileadmin\/_temp_\/2015_04\/pic_989_009.png\")
<\/p>\nPublic Function <\/span>AutostartSQLBefehleAusfuehren()\r\n TabellenErstellen\r\n DoCmd.OpenForm \"frmSQLBefehle\"\r\nEnd Function<\/span><\/pre>\n