Zur Hauptseite ... Zum Onlinearchiv ... Zum Abonnement ... Zum Newsletter ... Zu den Tools ... Zum Impressum ... Zum Login ...

Gedrucktes Heft

Diesen Beitrag finden Sie in Ausgabe 4/2015.

Unser Angebot für Sie!

Lesen Sie diesen Beitrag und 500 andere sofort im Onlinearchiv, und erhalten Sie alle zwei Monate brandheißes Access-Know-how auf 72 gedruckten Seiten! Plus attraktive Präsente, zum Beispiel das bald erscheinende Buch 'Access 2010 - Das Grundlagenbuch für Entwickler'!

Diesen Beitrag twittern

T-SQL per Formular

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.

In den Beiträgen RDBMS-Tools: Verbindungen verwalten (www.access-im-unternehmen.de/976), RDBMS-Tools: Tabellen verknüpfen (www.access-im-unternehmen.de/977) und RDBMS-Tools als Add-In nutzen (www.access-im-unternehmen.de/978) haben wir bereits zwei kleine Tools vorgestellt und als Add-In aufbereitet.

Diese Add-In-Datei namens RDBMSTools.mda 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.

Dieses Formular sieht wie in Bild 1 aus und soll ebenfalls über einen Befehl des Add-In-Menüs verfügbar sein.

Formular zur direkten Eingabe von SQL-Anweisungen gegen ein SQL Server-Backend

Bild 1: Formular zur direkten Eingabe von SQL-Anweisungen gegen ein SQL Server-Backend

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.

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.

Verwalten der zu verwendenden Verbindungszeichenfolge

Bild 2: Verwalten der zu verwendenden Verbindungszeichenfolge

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.

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.

Dann können Sie die jeweils auszuführende Anweisung einfach markieren und diese dann durch Betätigen der Schaltfläche Ausführen oder der Taste F5 starten.

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 oder Ausführen auch ausgeführt.

Markieren der auszuführenden SQL-Anweisung

Bild 3: Markieren der auszuführenden SQL-Anweisung

Fehlt noch das Unterformularsteuerelement im unteren Bereich des Formulars: Dieses zeigt die Ergebnisse der ausgeführten Anweisungen an.

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-Abfrage ausführen, liefert das Unterformular bis zu zehn Felder des Abfrageergebnisses.

Sie können also die folgenden Abfragetypen mit dem hier vorgestellten Formular ausführen:

  • Auswahlabfragen (SELECT)
  • Aktualisierungsabfragen (INSERT INTO, SELECT INTO, UPDATE, DELETE)
  • Datendefinitionsabfragen (CREATE TABLE et cetera)

Das Unterformular liefert sogar eine entsprechende Fehlermeldung, wenn Sie eine ungültige SQL-Abfrage absetzen (s. Bild 4).

Ausgabe von Fehlermeldungen

Bild 4: Ausgabe von Fehlermeldungen

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.

Formular erstellen

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 als Datenherkunft. Das Feld SQLBefehl soll dabei als Memofeld ausgelegt sein, da eine SQL-Anweisung leicht einmal mehr als 255 Zeichen umfasst. VerbindungID ist ein Fremdschlüsselfeld zur Tabelle tblVerbindungszeichenfolgen und Bezeichnung ein einfaches Textfeld.

Entwurf des Formulars frmSQLBefehle

Bild 5: Entwurf des Formulars frmSQLBefehle

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 angezeigt. Das Feld VerbindungID führen wir dabei als Kombinationsfeld aus, damit Sie damit leicht die Einträge der Tabelle tblVerbindungszeichenfolgen auswählen können. Rechts neben dem Kombinationsfeld finden Sie eine Schaltfläche namens cmdVerbindungenBearbeiten, mit der Sie das bereits im Beitrag RDBMS-Tools: Verbindungen verwalten beschriebene Formular öffnen können.

Entwurf der Tabelle zum Speichern der SQL-Befehle

Bild 6: Entwurf der Tabelle zum Speichern der SQL-Befehle

Dieses zeigt dann direkt die aktuell im Kombinationsfeld ausgewählte Verbindung an. Das Kombinationsfeld cboVerbindung erhält also die folgende Abfrage als Datensatzherkunft:

SELECT VerbindungszeichenfolgeID, Bezeichnung 
FROM tblVerbindungszeichenfolgen;

Damit die Schaltfläche cmdVerbindungenBearbeiten auf Knopfdruck das Formular frmVerbindungszeichenfolgen öffnet, hinterlegen Sie die Ereignisprozedur aus Listing 1 für das Ereignis Beim Klicken. Dieses öffnet das Formular frmVerbindungszeichenfolgen und übergibt den Primärschlüsselwert der aktuell im Kombinationsfeld cboVerbindung ausgewählten Verbindungszeichenfolge per Öffnungsargument.

Private Sub cmdVerbindungenBearbeiten_Click()
     DoCmd.OpenForm "frmVerbindungszeichenfolgen", OpenArgs:=Nz(Me!cboVerbindung, 0)
     Set frmVerbindungszeichenfolgen = Forms!frmVerbindungszeichenfolgen
     With frmVerbindungszeichenfolgen
         .Modal = True
         .OnUnload = "[Event Procedure]"
     End With
End Sub

Listing 1: Formular zum Auswählen der Verbindungszeichenfolge öffnen

Dann speichert die Prozedur einen Verweis auf das Formular in einer Objektvariablen namens frmVerbindungszeichenfolgen, die im Kopf des Klassenmoduls wie folgt deklariert wird:

Dim WithEvents frmVerbindungszeichenfolgen As Form

Der Hintergrund ist, dass wir im Klassenmodul des aufrufenden Formulars frmSQLBefehle eine Ereignisprozedur definieren wollen, die beim Schließen des Formulars frmVerbindungszeichenfolgen ausgelöst wird. Dazu müssen wir die Objektvariable mit dem Schlüsselwort WithEvents auszeichnen. Nun können wir per VBA eine Ereignisprozedur für die Ereigniseigenschaft Beim Entladen angeben (OnUnload = [Event Procedure]).

Damit brauchen wir nun nur noch die folgende Ereignisprozedur im Klassenmodul des Formulars frmSQLBefehle zu hinterlegen:

Private Sub frmVerbindungszeichenfolgen_Unload(Cancel _
         As Integer)
     Me!cboVerbindung.Requery
     Me!cboVerbindung = _
         frmVerbindungszeichenfolgen!VerbindungszeichenfolgeID
End Sub

Damit rufen wir nun das Formular frmVerbindungszeichenfolgen auf und können im Formular frmSQLBefehle auf das Beim Schließen-Ereignis von frmVerbindungszeichenfolgen reagieren.

Dort aktualisieren wir den Inhalt von cboVerbindung (falls im Formular frmVerbindungszeichenfolgen neue Verbindungszeichenfolgen hinzugefügt oder welche gelöscht wurden) und stellen das Kombinationsfeld cboVerbindung auf die zuletzt im Formular frmVerbindungszeichenfolgen gewählte Verbindungszeichenfolge ein.

Das Textfeld txtSQL ist an das Feld SQLBefehl der Tabelle tblSQLBefehle 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 auf Neue Zeile im Feld ein.

Das Bezeichnungsfeld lblSQL soll jeweils den SQL-Ausdruck aus dem Textfeld txtSQL anzeigen, der beim Betätigen von F5 beziehungsweise beim Anklicken der Schaltfläche cmdAusfuehren 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 abgebildet und auch ausgeführt.

Das Formular enthält außerdem eine Schaltfläche namens cmdAusfuehren, auf deren Funktion wir weiter unten eingehen.

Außerdem enthält das Formular ein Unterformular-Steuerelement, dessen Eigenschaft Herkunftsobjekt wir auf das Formular sfmSQLBefehle einstellen.

Dieses Formular enthält zehn Textfelder mit den Namen txt01, txt02 und so weiter (s. Bild 7). Die zehn dazu gehörenden Bezeichnungsfelder heißen entsprechend lbl01, lbl02 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.

Entwurf des Unterformulars sfmSQLBefehle

Bild 7: Entwurf des Unterformulars sfmSQLBefehle

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.

Die Fehlertabelle

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 anzeigen. Die Tabelle sieht im Entwurf wie in Bild 8 aus.

Entwurf der Tabelle tblFehler

Bild 8: Entwurf der Tabelle tblFehler

Eingabe des SQL-Ausdrucks

In dem Moment, in dem Sie ein Zeichen in das Textfeld txtSQL eingeben, soll das Formular bereits den Ausdruck im Bezeichnungsfeld lblSQL anzeigen, der bei Betätigen von F5 oder der Schaltfläche cmdAusfuehren ausgeführt wird. Daher muss der Inhalt von lblSQL immer auf dem aktuellen Stand gehalten werden. Dafür sorgt zunächst einmal die Ereignisprozedur Bei Maustaste auf, die nach der Eingabe eines jeden Zeichens in das Textfeld txtSQL ausgelöst wird, und eine weitere Prozedur namens SQLAusdruckErmitteln aufruft:

Private Sub txtSQL_KeyUp(KeyCode As Integer, _
         Shift As Integer)
     SQLAusdruckErmitteln
End Sub

Die Prozedur SQLAusdruckErmitteln finden Sie in Listing 2. Sie prüft, ob das Textfeld txtSQL 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, die dann einen Wert größer als 0 aufweisen müsste. Ist dies der Fall, ermittelt die Prozedur den Inhalt der Markierung und trägt diesen in die Variable strSQL ein, die wie folgt im Kopf des Klassenmoduls deklariert ist:

Private Sub SQLAusdruckErmitteln()
     If Me!txtSQL.SelLength > 0 Then
         strSQL = Mid(Me!txtSQL.Text, Me!txtSQL.SelStart + 1, Me!txtSQL.SelLength)
     Else
         strSQL = Me!txtSQL.Text
     End If
     Me!lblSQL.Caption = strSQL
End Sub

Listing 2: Ermitteln des aktuell markierten SQL-Ausdrucks im Textfeld txtSQL

Dim strSQL As String

Falls keine Markierung vorliegt, landet schlicht der komplette Inhalt von txtSQL in der Variablen strSQL.

Der Inhalt von strSQL wird dann als Beschriftung des Bezeichnungsfeldes lblSQL eingetragen.

Markierten Ausdruck abfragen

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. Dafür hinterlegen wir die folgende Prozedur, die ebenfalls die Routine SQLAusdruckErmitteln aufruft:

Private Sub txtSQL_MouseUp(Button As Integer, _
         Shift As Integer, X As Single, Y As Single)
     SQLAusdruckErmitteln
End Sub

SQL-Abfrage ausführen

Die offensichtliche Möglichkeit, die SQL-Abfrage auszuführen, ist das Anklicken der Schaltfläche cmdAusfuehren. Dies löst die Ereignisprozedur aus Listing 3 aus. Diese Prozedur prüft zunächst, ob die Variable strSQL, die den aktuell auszuführenden SQL-Ausdruck speichert, nicht leer ist, und gibt gegebenenfalls eine entsprechende Meldung aus und bricht die Prozedur ab.

Private Sub cmdAusfuehren_Click()
     Dim db As DAO.Database, qdf As DAO.QueryDef, rst As DAO.Recordset, i As Integer
     Set db = CurrentDb
     If Len(strSQL) = 0 Then
         MsgBox "Bitte markieren Sie den auszuführenden SQL-Befehl."
         Exit Sub
     End If
     On Error Resume Next
     db.QueryDefs.Delete "qryTemp"
     On Error GoTo 0
     Set qdf = db.CreateQueryDef("qryTemp")
     With qdf
         .Connect = DLookup("Verbindungszeichenfolge", "tblVerbindungszeichenfolgen", "VerbindungszeichenfolgeID = " _
             & Me!cboVerbindung)
         .SQL = LeerzeichenEntfernen(strSQL)
         Select Case Left(.SQL, 6)
             Case "SELECT"
             Case "DELETE": .SQL = "SET NOCOUNT ON;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS AnzahlGeloescht"
             Case "INSERT": .SQL = "SET NOCOUNT ON;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS AnzahlEingefuegt"
             Case "UPDATE": .SQL = "SET NOCOUNT ON;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS AnzahlAktualisiert"
             Case "CREATE": .SQL = "SET NOCOUNT ON;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS AnzahlAktualisiert"
             Case Else
                 If Left(.SQL, 5) = "ALTER" Then
                     .SQL = "SET NOCOUNT ON ;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS Aktualisiert"
                 ElseIf Left(.SQL, 4) = "DROP" Then
                     .SQL = "SET NOCOUNT ON ;" & vbCrLf & .SQL & vbCrLf & "SELECT @@ROWCOUNT AS Aktualisiert"
                 Else
                     MsgBox "Die Anweisung muss mit SELECT, DELETE, INSERT, UPDATE, CREATE, ALTER oder DROP beginnen."
                     Exit Sub
                 End If
         End Select
         .ReturnsRecords = True
         On Error Resume Next
         Set rst = .OpenRecordset
         If Not Err.Number = 0 Then
             On Error GoTo 0
             db.Execute "DELETE FROM tblFehler", dbFailOnError
             For i = 0 To DAO.Errors.Count - 1
                 db.Execute "INSERT INTO tblFehler(FehlerID, Fehler) VALUES(" & DAO.Errors(i).Number & ", '" _
                     & Replace(DAO.Errors(i).Description, "'", "''") & "')", dbFailOnError
                 Debug.Print DAO.Errors(i).Source
             Next i
             Set rst = db.OpenRecordset("SELECT * FROM tblFehler")
         End If
         On Error GoTo 0
     End With
     UnterdatenblattFuellen rst
End Sub

Listing 3: Ausführen einer SQL-Anweisung

Ist strSQL nicht leer, wird eine neue temporäre Abfrage namens qryTemp auf Basis der angegebenen SQL-Anweisung erstellt.

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.

Die CreateQueryDef-Methode legt die Abfrage dann neu an und referenziert sie mit der Objektvariablen qdf. Die Connect-Eigenschaft füllt die Prozedur dann mit der in der Tabelle tblVerbindungszeichenfolgen gespeicherten Verbindungszeichenfolge für diese Abfrage.

Ein Aufruf der Funktion LeerzeichenEntfernen 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:

Private Function LeerzeichenEntfernen(strSQL As String) _
         As String
     Dim strTemp As String
     Dim intLaengeVorher As Integer
     strTemp = strSQL
     intLaengeVorher = Len(strTemp) + 1
     Do While Len(strTemp) < intLaengeVorher
         intLaengeVorher = Len(strTemp)
         Mid(strTemp, 1, 1) = _
             Replace(Mid(strTemp, 1, 1), Chr(13), " ")
         Mid(strTemp, 1, 1) = _
             Replace(Mid(strTemp, 1, 1), Chr(10), " ")
         strTemp = Trim(strTemp)
     Loop
     LeerzeichenEntfernen = strTemp
End Function

Nach diesem Schritt prüft cmdAusfuehren_Click, um was für eine Art von Abfrage es sich handelt. Die vorliegende Version unterstützt SELECT-, DELETE-, INSERT-, UPDATE-, CREATE-, DROP- und ALTER-Anweisungen. Beim Auffinden des SELECT-Schlüsselwortes geschieht nichts weiter.

Bei den übrigen Anweisungen stellt die Prozedur ein, dass die Anweisung SELECT @@ROWCOUNT AS Anzahl... 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.

Die Prozedur stellt die Eigenschaft ReturnRecords für die Abfrage auf True ein und öffnet dann mit der OpenRecordset-Methode ein neues Recordset auf Basis dieser Abfrage. Dieses referenziert sie dann mit der Objektvariablen rst. Sollte nun ein Fehler auftreten, erfolgt die Protokollierung des Fehlers in der Tabelle tblFehler.

Dazu leert die Prozedur diese Tabelle zunächst und trägt dann für jedes Element der Errors-Auflistung des DAO-Objekts einen neuen Datensatz in die Tabelle tblFehler ein. Den Inhalt der Tabelle tblFehler liest die Prozedur dann wiederum in das Recordset rst ein. rst enthält nun entweder das Ergebnis der Abfrage oder aber den aktuellen Inhalt der Tabelle tblFehler. Mithilfe der Routine UnterdatenblattFuellen erscheint der Inhalt von rst dann als Datenherkunft des Unterformulars sfmSQLBefehle.

Ergebnis im Unterformular anzeigen

Nachdem das Abfrageergebnis nun in Form eines Recordsets vorliegt, müssen wir es nur noch im Unterformular sfmSQLBefehle anzeigen. Weiter oben haben Sie ja bereits gesehen, dass dieses Unterformular einen Vorrat von zehn ungebundenen Textfeldern samt Bezeichnungsfeldern enthält.

Die Aufgabe der Prozedur UnterdatenblattFuellen 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.

Private Sub UnterdatenblattFuellen(rst As DAO.Recordset)
     Dim i As Integer
     Dim j As Integer
     Set Me!sfmErgebnis.Form.Recordset = rst
     For i = 0 To rst.Fields.Count - 1
         If i = 10 Then
             Exit For
         End If
         With Me!sfmErgebnis.Form.Controls("txt" & Format(i + 1, "00"))
             .ColumnHidden = False
             .ControlSource = rst.Fields(i).Name
         End With
         With Me!sfmErgebnis.Form.Controls("lbl" & Format(i + 1, "00"))
             .Caption = rst.Fields(i).Name
         End With
     Next i
     'ColumnWidth muss später eingestellt werden, da sonst nicht zuverlässig
     For i = 0 To rst.Fields.Count - 1
         If i = 10 Then
             Exit For
         End If
         With Me!sfmErgebnis.Form.Controls("txt" & Format(i + 1, "00"))
             .ColumnWidth = -2
         End With
     Next i
     For j = i To 9
         With Me!sfmErgebnis.Form.Controls("txt" & Format(j + 1, "00"))
             .ColumnHidden = True
         End With
     Next j
End Sub

Listing 4: Anzeigen des Abfrageergebnisses im Unterformular sfmSQLBefehle

Die Prozedur weist dem im Unterformularsteuerelement sfmErgebnis enthaltenen Unterformular (hier also sfm­SQL­Befehle) das als Parameter übergebene Recordset zu.

Dann durchläuft es eine For...Next-Schleife von 0 bis zur Anzahl der Felder des Recordsets rst. Die Schleife wird abgebrochen, sobald zehn Felder durchlaufen wurden (i=10).

Für die ersten zehn Felder referenziert die Prozedur dynamisch jeweils das dem aktuellen Wert entsprechende Textfeld und stellt zwei Eigenschaften ein: ColumnHidden enthält den Wert False, was dieses Feld einblendet und ControlSource wird mit dem Namen des aktuellen Feldes des Recordsets gefüllt. Dies bindet das Textfeld an das entsprechende Recordset-Feld.

Dann referenziert es das zu diesem Textfeld gehörende Bezeichnungsfeld und stellt mit dessen Eigenschaft Caption die Spaltenüberschrift für dieses Feld ein.

Danach durchläuft die Prozedur die Felder des Recordsets in einer zweiten For...Next-Schleife ein zweites Mal. Diesmal stellt es die Eigenschaft ColumnWidth auf den Wert -2 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-Schleife auslösen, da sonst ein Fehler auftritt.

Sollte das Abfrageergebnis weniger als zehn Felder enthalten, müssen wir die übrigen Felder noch ausblenden. Da die zuletzt durchlaufene For...Next-Schleife in diesem Fall nur bis zum letzten Feld des Recordsets durchlaufen wurde, können wir den aktuellen Wert der Laufvariable i als Startwert für eine weitere For...Next-Schleife verwenden.

Diese nutzt diesmal die Laufvariable j und läuft von i bis 10. Dabei stellt sie die Eigenschaft ColumnHidden des entsprechenden Textfeldes jeweils auf den Wert True ein und blendet die Spalten somit aus.

Damit erscheinen nun die Daten der angegebenen Abfrage (oder eine Fehlermeldung) im Unterformular sfmSQLBefehle.

Abfrage mit F5 ausführen

Fehlt noch die Möglichkeit, auf die Schnelle mit der Taste F5 auszuführen. Dazu fragen wir in der Ereignisprozedur Bei Maustaste ab 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 auf:

Private Sub Form_KeyDown(KeyCode As Integer, _
         Shift As Integer)
     Select Case KeyCode
         Case 116
             KeyCode = 0
             Call cmdAusfuehren_Click
     End Select
End Sub

Formular in das Add-In einbinden

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, die in der Beispieldatenbank des Beitrags RDBMS-Tools als Add-In nutzen bereits enthalten ist, um ein weiteres Set von Datensätzen für das neue Add-In erweitern. Diese sehen wie in Bild 9 aus.

Erweiterung der Tabelle USysRegInfo

Bild 9: Erweiterung der Tabelle USysRegInfo

Außerdem fügen Sie noch die in der ersten Zeile der neuen Einträge in die Tabelle USysRegInfo genannte VBA-Funktion zum Modul mdlGlobal hinzu. Dieses sieht so aus:

Public Function AutostartSQLBefehleAusfuehren()
     TabellenErstellen
     DoCmd.OpenForm "frmSQLBefehle"
End Function

Diese Funktion wird aufgerufen, wenn der Benutzer später auf den entsprechenden Eintrag im Add-In-Menü klickt.

Damit dies geschieht, müssen Sie das Add-In noch neu installieren (beziehungsweise überhaupt installieren, falls noch nicht geschehen). Dazu öffnen Sie mit Datenbanktools|Add-Ins|Add-Ins|Add-In-Manager den Add-In-Manager und fügen das Add-In hinzu. Dadurch erscheint anschließend ein neuer Eintrag im Ribbon unter Datenbanktools|Add-Ins|Add-Ins (s. Bild 10). Klicken Sie auf diesen, öffnet sich das oben beschriebene Formular frmSQLBefehle.

Neuer Eintrag in der Add-In-Liste

Bild 10: Neuer Eintrag in der Add-In-Liste

Besonderheiten bei den gespeicherten Daten

Das Add-In legt zum Speichern der Daten die Tabellen tblVerbindungszeichenfolgen, tblTreiber, tblFehler und tblSQLBefehle in der jeweiligen Zieldatenbank an. Dort müssen Sie die Verbindungszeichenfolgen et cetera, die Sie bei der Verwendung der jeweiligen Datenbank nutzen wollen, anlegen.

Zusammenfassung und Ausblick

Mit diesem Tool haben wir die Sammlung der Add-Ins für den Zugriff auf den SQL Server nochmals erweitert, sodass Sie nun drei Tools zur Verfügung haben.

Bei dem vorliegenden Add-In könnte man noch eine globale Speicherung aller Verbindungszeichen vorsehen, sodass der Benutzer aus allen bislang verwendeten Verbindungen diejenigen zur Zieldatenbank hinzufügen kann, die er dort benötigt.

Kompletten Artikel lesen?

Einfach für den Newsletter anmelden, dann lesen Sie schon in einer Minute den kompletten Artikel und erhalten die Beispieldatenbanken.

E-Mail:

Download

Download

Die .zip-Datei enthält folgende Dateien:

RDBMSTools.mda

Beispieldateien downloaden

© 2003-2015 André Minhorst Alle Rechte vorbehalten.