{"id":55001483,"date":"2024-02-01T00:00:00","date_gmt":"2024-02-02T20:00:06","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1483"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Abfragen_direkt_in_der_SQLAnsicht_erstellen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Abfragen_direkt_in_der_SQLAnsicht_erstellen\/","title":{"rendered":"Abfragen direkt in der SQL-Ansicht erstellen"},"content":{"rendered":"

\"\"<\/p>\n

Microsoft hat neuerdings einen Befehl zum direkten Anzeigen von Abfragen in der SQL-Ansicht. Damit können wir eine Abfrage direkt in der SQL-Ansicht öffnen statt den Umweg über den Abfrageentwurf zu wählen. Leider hat Microsoft keine entsprechende Funktion für das Erstellen von Abfragen hinzugefügt – also eine Schaltfläche im Ribbon, mit der wir eine neue SQL-Abfrage direkt in der SQL-Ansicht öffnen können. Das ist allerdings gar nicht schlimm, denn wir rüsten diese Funktion einfach selbst nach. Zunächst schauen wir uns an, welche Befehle dazu notwendig sind, danach erstellen wir ein COM-Add-In, das die Funktion in der Benutzeroberfläche verankert – gleich neben den Schaltflächen für den Abfrageassistenten und das Anlegen von neuen Abfragen über die Entwurfsansicht.<\/b><\/p>\n

In dem Beitrag, der die neuen Befehle zum direkten Anzeigen vorhandener Abfragen in der SQL-Ansicht vorstellt, gehen wir bereits kurz auf die notwendigen Anweisungen ein, die zum Erstellen einer neuen Abfrage und ihrer Anzeige in der SQL-Ansicht nötig sind – siehe Abfragen in der SQL-Ansicht öffnen <\/b>(www.access-im-unternehmen.de\/1482<\/b>).<\/p>\n

Dort stellen wir die folgende Prozedur vor:<\/p>\n

Public Sub <\/span>NewQueryInSQLView()\r\n     RunCommand acCmdNewObjectDesignQuery\r\n     RunCommand acCmdSQLView\r\nEnd Sub<\/span><\/pre>\n
Diese ruft die RunCommand<\/b>-Anweisung mit zwei verschiedenen Parametern auf, die wir auch über die Benutzeroberfläche aufrufen können.<\/p>\n
Der erste namens acCmdNewObjectDesignQuery <\/b>öffnet zunächst eine neue Abfrage in der Entwurfsansicht.<\/p>\n
Der zweite nutzt den Parameter acCmdSQLView<\/b>, um die so erstellte Abfrage in der SQL-Ansicht anzuzeigen. Platzieren wir Access-Fenster und VBA-Editor nebeneinander und rufen die Prozedur auf, sehen wir ein kurzes Flackern und erhalten anschließend eine weitgehend leere SQL-Ansicht der neuen Abfrage (siehe Bild 1).<\/p>\n
\"Neue,<\/p>\n
Bild 1: Neue, leere Abfrage per Code in der SQL-Ansicht<\/span><\/b><\/p>\n
Das kurze Flackern resultiert daraus, dass zuerst die Entwurfsansicht eingeblendet wird, zu der standardmäßig auch noch der Bereich Tabellen hinzufügen <\/b>eingeblendet wird (in älteren Access-Versionen erscheint ein Fenster mit dem Titel Tabelle auswählen<\/b>). Dieser verschwindet beim Wechsel zur SQL-Ansicht allerdings direkt wieder.<\/p>\n
In älteren Versionen (zum Beispiel Access 2010) wird das Fenster Tabelle auswählen <\/b>als modaler Dialog eingeblendet, den man erst schließen muss, bevor die Abfrage von der Entwurfsansicht in die SQL-Ansicht wechselt (siehe Bild 2).<\/p>\n
\"Dieses<\/p>\n
Bild 2: Dieses Fenster erscheint in älteren Access-Versionen<\/span><\/b><\/p>\n
In diesem Fall können wir nicht viel ausrichten – beim Anzeigen eines modalen Dialogs wird der aufrufende Code unterbrochen und folgende Anweisungen, mit denen wir den Dialog ausblenden könnten, würden nicht ausgeführt werden.<\/p>\n
Benutzer älterer Access-Versionen müssen also diese Meldung noch schließen, bevor dann die SQL-Ansicht eingeblendet wird. Immerhin wird die Anweisung zum Wechseln zur SQL-Ansicht dann noch ausgeführt.<\/p>\n
Funktion per COM-Add-In zum Ribbon hinzufügen<\/h2>\n
Wenn wir diese aus zwei Anweisungen bestehende Funktion über das Ribbon aufrufen wollen, haben wir verschiedene Möglichkeiten. Die nachhaltigste ist die Erstellen eines COM-Add-Ins. Dieses wird einmal installiert und die Funktion ist dauerhaft in der Benutzeroberfläche verankert – egal, welche Datenbank Sie damit öffnen.<\/p>\n
Das könnte beispielsweise wie in Bild 3 aussehen. Es schien uns logisch, dass die betroffene Schaltfläche in den Bereich Erstellen|Abfragen <\/b>integriert werden sollte. Ein Mausklick auf diese Abfrage ruft die beiden oben vorgestellten Anweisungen auf und öffnet so eine neue Abfrage in der SQL-Ansicht.<\/p>\n
\"Neue<\/p>\n
Bild 3: Neue Schaltfläche zum Anlegen einer Abfrage in der SQL-Ansicht<\/span><\/b><\/p>\n
Ein solches COM-Add-In ist schnell erstellt. Wir nutzen dazu das schon oft referenzierte twinBASIC von Wayne Philips, das in der Version für das Erstellen von 32-Bit-Programmen kostenlos ist – erst die 64-Bit-Version ist kostenpflichtig (in DLLs, die mit der kostenlosen Version erstellt wurden, werden Hinweise auf twinBASIC eingeblendet). Die jeweils aktuelle Version kann hier heruntergeladen werden:<\/p>\n
https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
Nach dem Erstellen eines neuen Projekts auf Basis der Vorlage Sample 5. MyCOMAddin <\/b>(siehe Bild 4) beginnen wir mit dem Speichern des Projekts unter dem von uns gewählten Pfad und Dateinamen, zum Beispiel amvSQLView.twinproj<\/b>. Merken Sie sich diesen Pfad, wir benötigen ihn später noch. Danach fahren wir mit dem Anpassen der Projekteinstellungen fort.<\/p>\n
\"Neues<\/p>\n
Bild 4: Neues Projekt auf Basis einer Vorlage<\/span><\/b><\/p>\n
Projekteinstellungen anpassen<\/h2>\n
Diese finden wir, wenn wir auf der linken Seite auf Settings <\/b>klicken. Wir stellen nun den Projektnamen, die Projektbeschreibung und den Anwendungstitel auf den gewünschten Wert ein, beispielsweise amvSQLView<\/b>. Das sieht dann für den Projekttitel wie in Bild 5 aus.<\/p>\n
\"Projekteinstellungen<\/p>\n
Bild 5: Projekteinstellungen anpassen<\/span><\/b><\/p>\n
Danach fügen wir noch einen Verweis auf die Access-Bibliothek hinzu. Dazu scrollen wir unter Settings<\/b> weiter nach unten bis zum Bereich Library References<\/b>.<\/p>\n
Hier wechseln wir zur Registerseite Available COM References <\/b>und suchen nach Access. Die nun erscheinende Bibliothek fügen wir durch Setzen eines Hakens hinzu (siehe Bild 6).<\/p>\n
\"Hinzufügen<\/p>\n
Bild 6: Hinzufügen eines Access-Verweises<\/span><\/b><\/p>\n
Registrierung der DLL programmieren<\/h2>\n
Damit kommen wir zu einem wichtigen Aspekt für ein COM-Add-In, das als DLL erstellt wird, nämlich die Registrierung. Damit Access beim Starten merkt, dass die Funktionen unseres COM-Add-Ins geladen werden sollen, müssen wir dies an bestimmten Stellen in der Registry vermerken.<\/p>\n
Die Funktionen des Moduls aus Listing 1 erledigen genau dies. Im oberen Teil finden wir einige Konstanten mit wichtigen Informationen, die während der Installation benötigt werden. Die Funktion DLLRegisterServer <\/b>schreibt die Einträge, die von Access beim Start abgefragt werden sollen und zum Laden des COM-Add-Ins führen, in einen bestimmten Bereich der Registry.<\/p>\n
Module DllRegistration\r\n     Const AddinProjectName As String<\/span> = VBA.Compilation.CurrentProjectName\r\n     Const AddinClassName As String<\/span> = \"amvSQLView\"\r\n     Const AddinQualifiedClassName As String<\/span> = AddinProjectName & \".\" & AddinClassName\r\n     Const RootRegistryFolder As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\\" & AddinQualifiedClassName & \"\\\"\r\n     Public <\/span>Function DllRegisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegWrite RootRegistryFolder & \"FriendlyName\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder & \"Description\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n         Return True<\/span>\r\n     RegError:\r\n         MsgBox<\/span> \"DllRegisterServer -- An error occured trying to write to the system registry:\" & vbCrLf<\/span> & _\r\n                 Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n         Return False<\/span>\r\n     End Function\r\n     Public <\/span>Function DllUnregisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegDelete RootRegistryFolder & \"FriendlyName\"\r\n         wscript.RegDelete RootRegistryFolder & \"Description\"\r\n         wscript.RegDelete RootRegistryFolder & \"LoadBehavior\"\r\n         wscript.RegDelete RootRegistryFolder\r\n         Return True<\/span>\r\n     RegError:\r\n         MsgBox<\/span> \"DllUnregisterServer -- An error occured trying to delete from the system registry:\" & vbCrLf<\/span> & _\r\n                 Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n         Return False<\/span>\r\n     End Function\r\nEnd Module<\/pre>\n
Listing 1: Modul für die Registrierung und die Deregistrierung des COM-Add-Ins<\/span><\/b><\/p>\n
Die Funktion DllUnregisterServer <\/b>entfernt diese Einträge wieder, falls gewünscht. Den Code des Moduls DLLRegistration<\/b> des soeben erstellen Projekts können Sie durch den Code aus dem abgedruckten Listing ersetzen.<\/p>\n
Wann werden diese Funktionen aufgerufen?<\/p>\n