<\/p>\n
Christoph Spielmann, Düsseldorf<\/b><\/p>\n
Wenn Sie schon einmal mit dem Microsoft SQL-Server gearbeitet haben, werden Sie sicherlich den Query-Analyzer schätzen gelernt haben. Mit diesem Tool können Sie schnell und einfach eine SQL-Abfrage ausführen und das Ergebnis begutachten. Dieser Artikel stellt Ihnen einen Query-Analyzer zum Einsatz unter Access vor.<\/b><\/p>\n
Man mag es kaum glauben, aber auch der Microsoft SQL Server hat einmal in der Version 1.0 das Licht der Welt erblickt. 1989 hatte Microsoft die erste Version für das Betriebssystem OS\/2 herausgebracht, das damals noch unter der Federführung von Microsoft in Zusammenarbeit mit IBM entwickelt wurde. Die Basis des SQL-Servers stammte hierbei vom Sybase SQL-Server 4.0, einem Datenbank-Server für Unix und VMS. Das Typische für diese Datenbank-Server war zu jener Zeit, dass jegliche Kommunikation zwischen Benutzer und Server nur via SQL erfolgen konnte. Dies betraf zum Beispiel das Anlegen von Tabellen, das Hinzufügen von Benutzern, die Vergabe von Zugriffsrechten und natürlich auch das Abfragen von Daten. Die Eingabe von SQL-Anweisungen erfolgt hierbei über den Query-Analyzer (siehe Bild 1) beziehungsweise das DOS-Gegenstück „iSQL“. Erst später stellte Microsoft mit dem Enterprise-Manager eine Benutzeroberfläche zur Verfügung, die dem Benutzer Aufgaben wie beispielsweise die Anlage von Tabellen auch ohne komplizierte SQL-Anweisungen ermöglichte.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Der Query-Analyzer des Microsoft SQL-Servers<\/span><\/b><\/p>\n Trotz Enterprise-Managers wird der Query-Analyzer noch von vielen Benutzern eingesetzt, da zum Beispiel die Eingabe von DELETE FROM Kunden zum Löschen von Datensätzen für viele der schnellste Weg ist.<\/p>\n Auch zum Test und zur Fehlerbehebung von SQL-Anweisungen ist der Query-Analyzer gut geeignet.<\/p>\n Die hier vorgestellte Lösung des Query-Analyzers bietet die wichtigsten Funktionen nun auch unter Access. Hierzu zählen die Eingabe und Ausführung von SQL-Statements sowie das Speichern und Laden von Abfragen.<\/p>\n <\/b><\/p>\n Bild 2: Erforderliche Verweise zum Einsatz des Query-Analyzers<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 3: Der Access-Query-Analyzer in der Ergebnistabellenansicht …<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 4: … und in der Ergebnisansicht<\/span><\/b><\/p>\n Der Query-Analyzer für Access besteht aus einem einzelnen Formular, das Sie problemlos in Ihre Datenbank importieren können. Von dort aus können Sie den Query-Analyzer dann aus dem Datenbankfenster heraus öffnen und einsetzen.<\/p>\n Voraussetzung ist lediglich, dass Sie Ihrem Projekt Verweise auf die Objekte ADO und ADOX hinzufügen (siehe Bild 2).<\/p>\n Ein Einsatz des Query-Analyzers als Add-In ist leider nicht möglich, wie später noch erläutert wird.<\/p>\n Eingabe- und Ergebnisbereich<\/b><\/p>\n Das Formular des Query-Analyzers ist zweigeteilt. Im oberen Bereich befindet sich der Eingabebereich für SQL-Anweisungen. <\/p>\n Der untere Ergebnisbereich zeigt das Ergebnis an. Sollte es sich bei der Anweisung um eine SELECT-Anweisung handeln, wird das Ergebnis automatisch als Tabelle angezeigt.<\/p>\n Bei allen anderen Anweisungen – die keine Datensätze zurückliefern – erscheint eine entsprechende Meldung.<\/p>\n Daten und Meldungen sind im unteren Bereich durch ein Register-Steuerelement umschaltbar (s. Abb. 3 und Abb. 4).<\/p>\n Bei SELECT-Abfragen wird automatisch die Ergebnistabelle gefüllt. Als Meldung wird die Anzahl der zurückgelieferten Datensätze ausgegeben.<\/p>\n Bei allen anderen Abfrage-Typen (zum Beispiel DELETE, UPDATE oder INSERT INTO) wird das Register Daten automatisch ausgeblendet und lediglich das Meldungsfenster angezeigt.<\/p>\n Hier wird dann die Anzahl der von der Anweisung betroffenen Datensätze ausgegeben.<\/p>\n Bei DELETE-Anweisungen ist dies zum Beispiel die Anzahl der gelöschten Datensätze. <\/p>\n Sollte die angegebene Anweisung einen Fehler enthalten, wird dieser ebenfalls als Meldung ausgegeben (siehe Bild 5).<\/p>\n <\/b><\/p>\n Bild 5: Die Anzeige einer Fehlermeldung<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 6: Auswahl einer gespeicherten Abfrage<\/span><\/b><\/p>\n Ausführen undprüfen von Anweisungen<\/b><\/p>\n Im Kopf des Query-Analyzers befindet sich eine Symbolleiste. Mit Hilfe des Pfeil-Symbols führen Sie die aktuelle Abfrage aus. Alternativ können Sie die SQL-Anweisung auch nach dem Vorbild des SQL-Servers mit der Taste F5 starten.<\/p>\n Eine besondere Bedeutung hat das Prüf-Symbol direkt links daneben. Hiermit können Sie eine Abfrage prüfen, ohne dass hierbei die Daten verändert werden. Dies ist insbesondere bei komplexen Löschabfragen hilfreich.<\/p>\n öffnen undspeichern vonAbfragen<\/b><\/p>\n Eine weitere wichtige Funktion ist das Speichern und öffnen einer Abfrage.<\/p>\n Zu diesem Zweck stehen im Kopfbereich zwei entsprechende Symbole zur Verfügung.<\/p>\n Im Gegensatz zum Query-Analyzer des SQL-Servers werden die Abfragen jedoch nicht in Text-Dateien, sondern innerhalb der Datenbank als normale Access-Abfragen gespeichert.<\/p>\n Auch beim Laden einer Abfrage greifen Sie auf alle Access-Abfragen zu.<\/p>\n Beim Laden einer Abfrage ändert sich der Eingabebereich des Query-Analyzers in eine Auswahlliste (siehe Bild 6).<\/p>\n Hier können Sie eine Abfrage durch einen Doppelklick auswählen, deren SQL-Anweisung dann im Eingabebereich angezeigt wird.<\/p>\n Quellcode 1 (Start)<\/b><\/p>\n <\/p>\n Quellcode 1 (Fortsetzung)<\/b><\/p>\n Auf der CD zu dieser Ausgabe finden Sie zwei Versionen des Query-Analyzers, eine für Access XP und eine für Access 2000. Der Unterschied besteht darin, dass in der Access-XP-Version die Anzahl der Spalten mit Hilfe der Recordset-Eigenschaft des Listenfeldes ermittelt werden kann. Dies ist bei Access 2000 leider nicht möglich, weswegen die Spaltenanzahl immer auf 255 gesetzt wird. Weiterhin ist die Erkennung von Fehlern in der SQL-Anweisung bei der XP-Variante zuverlässiger. Die 2000er-Variante geht dagegen schon dann von einem Fehler in der Anweisung aus, wenn keine Datensätze zurückgeliefert werden (was ja nicht unbedingt einem Fehler in der Anweisung gleichkommt). In der Praxis hat dies jedoch kaum negative Auswirkungen. Aufgrund des besseren Funktionsumfangs wird im Folgenden die Version für Access XP beschrieben. <\/p>\n Damit der Query-Analyzer problemlos in andere Datenbanken importiert werden kann, befindet sich die gesamte Logik innerhalb des Formulars frmQueryAnalyzer beziehungsweise dem dazugehörigen Formularmodul.<\/p>\n Dies ist auch der Grund dafür, warum beim öffnen einer gespeicherten Abfrage nicht ein Auswahlfenster erscheint, sondern der obere Eingabebereich des Formulars durch eine Auswahlliste ersetzt wird. Abbildung 7 zeigt den Aufbau des Formulars in der Entwurfsansicht.<\/p>\n <\/b><\/p>\n Bild 7: Der Query-Analyzer in der Entwurfsansicht<\/span><\/b><\/p>\n Ausführen einer Abfrage<\/b><\/p>\n Das Ausführen einer Abfrage erledigt die Prozedur ExecuteSQL (s. Quellcode 1).<\/p>\n Die Prozedur prüft zunächst, ob überhaupt eine SQL-Anweisung eingegeben wurde. Wenn dies nicht der Fall ist, gibt sie eine Fehlermeldung aus.<\/p>\n Anschließend wird ein eventuell vorhandener Meldungstext gelöscht und mittels ReturnsData-Funktion geprüft, ob es sich bei der SQL-Anweisung um eine Auswahl-Abfrage (SELECT) oder eine Aktionsabfrage (DELETE, INSERT INTO, UPDATE …) handelt.<\/p>\n Den Aufbau dieser Funktion lernen Sie später noch kennen.<\/p>\n Im Falle einer Auswahlabfrage muss das Ergebnis abgefragt und angezeigt werden. Zu diesem Zweck befindet sich im Ergebnisbereich ein Listenfeld namens lstData. Diesem wird mittels RowSource-Eigenschaft die SQL-Anweisung zugewiesen und das Ergebnis mittels Requery-Methode abgefragt und angezeigt.<\/p>\n Schließlich wird noch die Anzahl der Felder ermittelt und diese der ColumnCount-Eigenschaft zugewiesen. Diese Anweisung ist in eine Fehlerbehandlung mittels On Error Resume Next gekapselt. Das hat den folgenden Grund: Wenn die SQL-Anweisung fehlerhaft ist, tritt beim Aufruf der Requery-Methode kein Fehler auf. Dies ist jedoch beim Zugriff auf die Recordset-Eigenschaft der Fall. Hier muss der Fehler also abgefangen werden. Zusätzlich wird die Variable SQLError auf True gesetzt, um den nachfolgenden Anweisungen mitzuteilen, dass die SQL-Anweisung einen Fehler enthält.<\/p>\n Zur Vervollständigung sei noch erwähnt, dass die Aktualisierung der Liste nur dann erfolgt, wenn die SQL-Anweisung nicht geprüft, also wirklich ausgeführt werden soll.<\/p>\n Der Einsatz des Listenfeldes ist der Grund dafür, warum die Datenbank nicht als Add-In eingesetzt werden kann. Die RowSource-Eigenschaft des Listenfeldes kann nicht aus einem Add-In heraus auf die Daten der Benutzerdatenbank zurückgreifen. Die einzige Lösung wäre, das Abfrageergebnis in einer dynamisch erzeugten Access-Tabelle zwischenzuspeichern, was jedoch insbesondere bei großen Datenmengen zu deutlichen Performanceeinbußen führen würde. <\/p>\n Quellcode 2<\/b><\/p>\n Quellcode 3<\/b><\/p>\n Quellcode 4<\/b><\/p>\n Quellcode 5<\/b><\/p>\n Quellcode 6<\/b><\/p>\n Wenn in der SQL-Anweisung ein Fehler vorhanden ist, wird die Abfrage nochmals ausgeführt, diesmal jedoch unter Zuhilfenahme eines ADO-Recordset-Objekts.<\/p>\n Bei der Ausführung der Open-Methode tritt hier der erwartete Laufzeitfehler auf, dessen Meldung schließlich als Text ausgegeben wird.<\/p>\n Das ADO-Recordset kommt auch dann zur Ausführung, wenn die SQL-Anweisung lediglich geprüft werden sollte. Wenn die Prüfung erfolgreich verläuft, erscheint eine Erfolgsmeldung, andernfalls eine Fehlermeldung.<\/p>\n Je nachdem wird auch das Register Daten oder Meldung eingeblendet, damit der Benutzer das Ergebnis der SQL-Anweisung direkt begutachten kann.<\/p>\n Im unteren Teil der ExecuteSQL-Prozedur befindet sich der Block zur Ausführung von Aktionsabfragen. Wesentlich ist hierbei die Ausführung der Execute-Methode des Objekts CurrentProject.Connection.<\/p>\n Als Parameter werden der SQL-Befehl sowie die leere Variable RecordsAffected übergeben.<\/p>\n Letztere füllt Access nach erfolgreicher Ausführung mit der Anzahl der betroffenen Datensätze.<\/p>\n Diese Information ist zum Beispiel bei Lösch- oder Aktualisierungsabfragen interessant. Sollte ein Fehler auftreten, erfolgt wieder die Ausgabe des Fehlertextes.<\/p>\n Besondere Wichtigkeit liegt bei der Handhabung der Prüf-Funktion: Da Aktionsabfragen die Daten verändern, muss mit Hilfe einer Transaktion gearbeitet werden.<\/p>\n Diese wird mit CurrentProject.Connection.BeginTrans gestartet und am Ende der Prüfung mit CurrentProject.Connection.Rollback wieder rückgängig gemacht.<\/p>\n Transaktionen sind unter Access leider nicht sehr sicher. Anders als beim SQL-Server kann Access Transaktionen, die nicht durch Rollback oder CommitTrans beendet wurden, nicht mehr zurückfahren. Dies wäre zum Beispiel bei einem Absturz von Access oder einem Stromausfall der Fall. Die Prüf-Funktion ist also mit gewisser Vorsicht zu verwenden. <\/p>\n Quellcode 7<\/b><\/p>\n Einsatz von Hilfsfunktionen<\/b><\/p>\n Wie bereits zu Beginn erwähnt, werden von der Prozedur ExecuteSQL einige Hilfsprozeduren verwendet.<\/p>\n Eine hiervon ist als Eigenschaft ausgelegt. Sie trägt den Namen SQL und ermittelt den vom Benutzer eingegebenen SQL-Text (Quellcode 2).<\/p>\n Die Besonderheit ist hierbei, dass mit Hilfe der FullTrim-Eigenschaft alle führenden Leerzeichen und Leerzeilen abgeschnitten werden. Die Funktion hat den in Quellcode 3 beschriebenen Aufbau.<\/p>\n Mit einer Schleife werden hier alle Sonderzeichen mit einem ASCII-Code kleiner als 32 durch Leerzeichen ersetzt.<\/p>\n Abschließend wird noch die Trim-Funktion von Access aufgerufen, um führende und nachfolgende Leerzeichen abzuschneiden.<\/p>\n Die Hilfsfunktion ReturnsData haben Sie bereits kennen gelernt. Sie prüft, ob es sich bei der Abfrage um eine Auswahl oder eine Aktionsabfrage handelt. Zu diesem Zweck prüft die Funktion, ob die SQL-Anweisung mit dem Text SELECT beginnt. Hierbei greift sie auf die SQL-Eigenschaft zu, die bereits führende Leerzeichen und -zeilen entfernt hat (s. Quellcode 4).<\/p>\n Quellcode 8<\/b><\/p>\n Quellcode 9<\/b><\/p>\n Der Start der ExecuteSQL-Funktion erfolgt sowohl von der Schaltfläche der Symbolleiste aus, als auch durch Drücken der Taste F5.<\/p>\n Hierfür sind die folgenden beiden Ereignisprozeduren aus Quellcode 5 und 6 verantwortlich. Letztere ist mit dem KeyDown-Ereignis des Textfeldes verbunden. Sie prüft, ob es sich bei dem KeyCode um die Nummer 116 handelt, die der F5-Taste entspricht.<\/p>\n Laden von SQL-Anweisungen<\/b><\/p>\n Das Laden von SQL-Anweisungen erledigt die Ereignisprozedur btnOpen_Click (s. Quellcode 7).<\/p>\n Die Prozedur erzeugt eine Liste aller Abfragen, indem sie mittels ADOX die Namen aller Auswahl-Abfragen (View) und Aktionsabfragen (Procedures) zu einer mit Semikolons getrennten Zeichenkette zusammen stellt und diese der Auswahlliste lstQueryList als Werteliste zuweist. Bei Aktionsabfragen werden hierbei die von Access angelegten temporären Abfragen ignoriert. Diese sind an einer führenden Tilde im Namen zu erkennen.<\/p>\n Nach Füllen der Liste wird das Formular in den Abfrageauswahlmodus umgeschaltet. Dies bedeutet, dass der Eingabebereich ausgeblendet und die Auswahlliste zusammen mit den beiden Schaltflächen OK und Abbrechen eingeblendet wird. Diese Aufgabe erledigt die Prozedur SetQuerySelectMode (s. Quellcode 8).<\/p>\n Sofern der Benutzer eine Abfrage ausgewählt und auf OK geklickt hat, wird die Prozedur aus Quellcode 9 ausgeführt. Diese greift mittels ADOX auf die Abfrage zu und liest die SQL-Anweisung aus. Da die Prozedur anhand des Namens nicht unterscheiden kann, ob es sich um eine Auswahlabfrage (View) oder eine Aktionsabfrage (Procedure) handelt, versucht sie zunächst den Zugriff per View und im Fehlerfall einen Zugriff per Procedure. Die Anweisung wird schließlich mit der Command.CommandText-Eigenschaft ausgelesen und in das Eingabefeld eingetragen. Abschließend erfolgt durch Aufruf der SetQuerySelectMode-Prozedur wieder eine Umschaltung vom Abfrageauswahlmodus in den Eingabemodus.<\/p>\n Quellcode 10<\/b><\/p>\n Speichern von SQL-Anweisungen<\/b><\/p>\n Das Speichern von SQL-Anweisungen funktioniert ebenfalls mit ADOX:<\/p>\n Nach der Prüfung, ob eine SQL-Anweisung vorhanden ist, wird der Benutzer zur Eingabe eines Abfragenamens aufgefordert. Danach erfolgt die Anlage der View beziehungsweise Procedure (s. Quellcode 10).<\/p>\n Unter Umständen ist die neue Abfrage nicht direkt im Datenbankfenster sichtbar.<\/p>\n Schalten Sie in diesem Fall einfach in ein anderes Register um und danach in das Abfragen-Register zurück.<\/p>\n Aus Sicherheitsgründen überschreibt der Query-Analyzer generell keine Abfragen. Sollten Sie also eine Abfrage öffnen, modifizieren und dann wieder unter dem gleichen Namen speichern, tritt ein Fehler auf. Löschen Sie in diesem Fall die Abfrage vorher aus dem Datenbankfenster von Access. <\/p>\n Der Query-Analyzer dürfte bereits im jetzigen Zustand für Access-Anwender mit SQL-Know-how eine deutliche Arbeitserleichterung bedeuten.<\/p>\n Trotzdem besteht natürlich Potenzial für weitere Entwicklungen. Denkbar wären zum Beispiel die folgenden Funktionen:<\/p>\n Falls Sie weitere Anregungen und Ideen haben, senden Sie diese einfach per Mail an vorschlaege@access-im-unternehmen.de.<\/p>\n Enthaltene Beispieldateien:<\/p>\n acc0503ml01_XP.mdb<\/p>\n![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic002.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic004.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic005.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic006.png\")
<\/p>\nPrivate Sub ExecuteSQL(CheckOnly As Boolean)\r\n Dim SQLError As Boolean\r\n If SQL = \"\" Then\r\n MsgBox \"Bitte geben Sie eine SQL-Anweisung ein!\", vbInformation\r\n Exit Sub\r\n End If\r\n Me.txtMessage.Value = \"\"\r\n If ReturnsData() Then\r\n If CheckOnly = False Then\r\n Me.lstData.RowSource = SQL\r\n Me.lstData.Requery\r\n On Error Resume Next\r\n Me.lstData.ColumnCount = Me.lstData.Recordset.Fields.Count\r\n If Err = 0 Then\r\n SQLError = False\r\n Else\r\n SQLError = True\r\n End If\r\n On Error GoTo 0\r\n End If\r\n If SQLError = True Or CheckOnly = True Then\r\n Dim tempData As New Recordset\r\n With tempData\r\n .ActiveConnection = CurrentProject.Connection\r\n .Source = SQL\r\n .CursorType = adOpenStatic\r\n .LockType = adLockReadOnly\r\n .CursorLocation = adUseClient\r\n On Error Resume Next\r\n .Open\r\n If Err <> 0 Then\r\n Me.txtMessage.Value = Err.Description\r\n Me.tabMessage.SetFocus\r\n Me.tabData.Visible = False\r\n Else\r\n If CheckOnly Then\r\n Me.txtMessage.Value = \"Die SQL-Anweisung wurde erfolgreich \" _ & \"geprüft\"\r\n Me.tabMessage.SetFocus\r\n Me.tabData.Visible = False<\/pre>\n
Else\r\n Me.tabData.Visible = True\r\n Me.tabData.SetFocus\r\n End If\r\n End If\r\n End With\r\n Else\r\n Me.tabData.Visible = True\r\n Me.tabData.SetFocus\r\n Me.txtMessage.Value = CStr(Me.lstData.ListCount - 1) _ & \" Datensätze abgefragt\"\r\n End If\r\n Else\r\n Me.tabMessage.SetFocus\r\n Me.tabData.Visible = False\r\n Dim RecordsAffected As Long\r\n If CheckOnly Then CurrentProject.Connection.BeginTrans\r\n On Error Resume Next\r\n CurrentProject.Connection.Execute SQL, RecordsAffected\r\n If Err <> 0 Then\r\n Me.txtMessage.Value = Err.Description\r\n Else\r\n If CheckOnly Then\r\n Me.txtMessage.Value = \"Die SQL-Anweisung wurde erfolgreich geprüft\"\r\n Else\r\n Me.txtMessage.Value = CStr(RecordsAffected) & \" Datensätze betroffen\"\r\n End If\r\n End If\r\n If CheckOnly Then CurrentProject.Connection.RollbackTrans\r\n End If\r\n Me.txtSQL.SetFocus\r\n Me.txtSQL.SelLength = 0\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{FE2AB2C6-0CBB-439A-ABC3-198D8DD43089}\/pic007.png\")
<\/p>\nHinweis<\/h3>\n
Private Property Get SQL() As String\r\n Dim SQLText As String\r\n Me.txtSQL.SetFocus\r\n SQL = FullTrim(Me.txtSQL.Text)\r\nEnd Property<\/pre>\n
Private Function FullTrim(ByVal Text As String) _ As String\r\n Dim i As Integer\r\n For i = 1 To Len(Text)\r\n If Asc(Mid(Text, i, 1)) < 32 Then\r\n Mid(Text, i, 1) = \" \"\r\n End If\r\n Next i\r\n FullTrim = Trim(Text)\r\nEnd Function<\/pre>\n
Private Function ReturnsData() As Boolean\r\n If Left(SQL, 6) = \"SELECT\" Then\r\n ReturnsData = True\r\n Else\r\n ReturnsData = False\r\n End If\r\nEnd Function<\/pre>\n
Private Sub btnExecuteSQL_Click()\r\n ExecuteSQL False\r\nEnd Sub<\/pre>\n
Private Sub txtSQL_KeyDown(KeyCode As _ Integer, Shift As Integer)\r\n If KeyCode = 116 Then\r\n ExecuteSQL False\r\n End If\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
Private Sub btnOpen_Click()\r\n Dim QueryList As String\r\n Dim MyCatalog As New ADOX.Catalog\r\n Dim i As Integer\r\n MyCatalog.ActiveConnection = CurrentProject.Connection\r\n For i = 0 To MyCatalog.Views.Count - 1\r\n QueryList = QueryList + MyCatalog.Views(i).Name + \";\"\r\n Next i\r\n For i = 0 To MyCatalog.Procedures.Count - 1\r\n If Left(MyCatalog.Procedures(i).Name, 1) <> \"~\" Then\r\n QueryList = QueryList + MyCatalog.Procedures(i).Name + \";\"\r\n End If\r\n Next i\r\n If Len(QueryList) > 0 Then\r\n QueryList = Left(QueryList, Len(QueryList) - 1)\r\n End If\r\n With Me.lstQueryList\r\n .RowSource = QueryList\r\n End With\r\n SetQuerySelectMode True\r\nEnd Sub<\/pre>\n
Public Sub SetQuerySelectMode(Activate As Boolean)\r\n If Activate Then\r\n Me.lstQueryList.Visible = True\r\n Me.lstQueryList.SetFocus\r\n Me.txtSQL.Visible = False\r\n Me.btnSelectQueryCancel.Visible = True\r\n Me.btnSelectQueryOK.Visible = True\r\n Else\r\n Me.txtSQL.Visible = True\r\n Me.txtSQL.SetFocus\r\n Me.lstQueryList.Visible = False\r\n Me.btnSelectQueryCancel.Visible = False\r\n Me.btnSelectQueryOK.Visible = False\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub btnSelectQueryOK_Click()\r\n If Me.lstQueryList.ItemsSelected.Count = 0 Then\r\n MsgBox \"Bitte Abfrage markieren.\", vbInformation\r\n Else\r\n Dim SQLName As String\r\n Dim MyCatalog As New ADOX.Catalog\r\n Dim MyView As ADOX.View\r\n Dim MyProc As ADOX.Procedure\r\n MyCatalog.ActiveConnection = _ CurrentProject.Connection\r\n SQLName = Me.lstQueryList.Value\r\n On Error Resume Next\r\n Set MyView = MyCatalog.Views(SQLName)\r\n Me.txtSQL.Value = MyView.Command.CommandText\r\n If Err <> 0 Then\r\n Set MyProc = MyCatalog.Procedures(SQLName)\r\n Me.txtSQL.Value = MyProc.Command.CommandText\r\n End If\r\n SetQuerySelectMode False\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub btnSave_Click()\r\n If SQL = \"\" Then\r\n MsgBox \"SQL-Anweisung eingeben!\", vbInformation\r\n Exit Sub\r\n End If\r\n Dim QueryName As String\r\n Dim MyCommand As New ADODB.Command\r\n QueryName = InputBox(\"Abfragename\")\r\n If Len(QueryName) > 0 Then\r\n On Error GoTo ErrHandler\r\n Dim MyCatalog As New ADOX.Catalog\r\n MyCatalog.ActiveConnection = _ CurrentProject.Connection\r\n If ReturnsData Then\r\n MyCommand.CommandText = SQL\r\n MyCatalog.Views.Append QueryName, MyCommand\r\n Else\r\n MyCommand.CommandText = SQL\r\n MyCatalog.Procedures.Append QueryName, _ MyCommand\r\n End If\r\n End If\r\n Exit Sub\r\nErrHandler:\r\n MsgBox Err.Description, vbCritical\r\n Exit Sub\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
Downloads zu diesem Beitrag<\/h3>\n