<\/p>\n
Code für den Datenzugriff brauchen Sie immer wieder. Mal möchten Sie eine SQL-Aktionsabfrage auf Basis einer Tabelle erzeugen, in die Sie eine Reihe zuvor gefüllter Variablen integrieren, mal greifen Sie vielleicht per DAO oder ADO auf die Felder einer solchen Tabelle zu. Wir stellen Ihnen die notwendigen Techniken vor, damit Sie dies nicht mehr von Hand erledigen müssen.<\/b><\/p>\n
DAO- und SQL-Ausdrücke erzeugen<\/b><\/p>\n
Wer Code für den Datenzugriff erstellen muss, der mehr als ein paar Felder umfasst, sieht sich einer Fleißaufgabe gegenüber, die oft Flüchtigkeitsfehler hervorbringt. Variablendeklaration, Werte zuweisen oder per Parameter entgegennehmen, Zuweisung der Variablen oder Werte zu den Feldern erfordern einiges an Schreibarbeit. Komplizierter wird es noch, wenn Sie SQL-Anweisungen wie UPDATE <\/b>oder INSERT INTO <\/b>erzeugen und mit den Feldern kompletter Tabellen füllen müssen.<\/p>\n
Dem Autor dieses Beitrags kribbelt es schon lange in den Fingern, ein Tool zu programmieren, mit dem sich solche Aufgaben per Mausklick erledigen lassen. Dieser Beitrag beschreibt, was dabei herausgekommen ist.<\/p>\n
Hauptelement der Lösung ist das Formular aus Bild 1. Es erlaubt zunächst das Auswählen der Zieltabelle. Dann legen Sie fest, welche Felder dieser Tabelle vom Einfügen beziehungsweise Óndern der Daten betroffen sind und welche Felder als Kriterien beim Auswählen eines zu ändernden Datensatzes verwendet werden.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2011_06\/DatenzugriffscodeErzeugen-web-images\/pic001.png\")
<\/p>\n
Bild 1: Das Formular frmDatenzugriffscode<\/span><\/b><\/p>\n Schließlich legen Sie diverse weitere Optionen fest, die wir in den folgenden Abschnitten zusammen mit der Programmierung dieses Formulars vorstellen.<\/p>\n Das Resultat ist eine fertige Prozedur, die genau auf die ausgewählten Parameter zugeschnitten ist. Sie können diese Prozedur kopieren und in die Module Ihrer eigenen Datenbank einfügen.<\/p>\n Um die Lösung im aktuellen Zustand einzusetzen, kopieren Sie einfach das Formular frmDatenzugriffscode <\/b>in die Zielanwendung und öffnen es – schon können Sie Datenzugriffscode erzeugen.<\/p>\n Gegebenenfalls benötigen Sie noch die Funktion IsoDatum <\/b>aus dem Modul mdlTools <\/b>– fügen Sie diese einfach zu einem bestehenden Modul mit Hilfsroutinen hinzu oder importieren Sie das Modul komplett in Ihre Anwendung.<\/p>\n Formular zum Festlegen der Parameter<\/b><\/p>\n Die Funktionen zum Erstellen der gewünschten Code-Schnipsel sollen über ein Formular gesteuert werden. Dieses Formular heißt frmDatenzugriffscode <\/b>und verfügt für die Auswahl der betroffenen Tabelle und der zu berücksichtigenden Felder ein Kombinationsfeld namens cboTabelle<\/b>, ein Listenfeld namens lstFelder<\/b> und einige weitere Steuerelemente (s. Bild 1).<\/p>\n Für das Listenfeld stellen Sie die Eigenschaft Herkunftstyp <\/b>auf Feldliste <\/b>ein. Es zeigt dann alle Felder der Tabelle an, die Sie für die Eigenschaft Datensatzherkunft <\/b>angeben.<\/p>\n Diese wählen Sie mit dem Kombinationsfeld cboTabelle<\/b> aus. Das Kombinationsfeld bezieht seine Werte aus der Systemtabelle MSysObjects<\/b>:<\/p>\n Stellen Sie für das Listenfeld außerdem die Eigenschaft Mehrfachauswahl <\/b>auf Einfach <\/b>ein. Der Benutzer kann so eines oder mehrere Felder durch simples Anklicken der gewünschten Felder auswählen.<\/p>\n Da sicher gelegentlich alle Felder in den Datenzugriffscode eingebunden werden sollen, fügen Sie außerdem eine Schaltfläche namens cmdAlleMarkieren <\/b>hinzu.<\/p>\n Damit diese alle Einträge des Listenfeldes lstFelder <\/b>auswählt, hinterlegen Sie für die Ereigniseigenschaft Beim Klicken <\/b>die folgende Prozedur:<\/p>\n Neben diesem Listenfeld befindet sich ein weiteres Listenfeld namens lstKriterien<\/b>, mit dem Sie festlegen können, welche Kriterien beim Óndern bestehender Datensätze berücksichtigt werden sollen.<\/p>\n Beide Listenfelder werden beim Auswählen einer Tabelle aktualisiert:<\/p>\n Die Optionsgruppe ogrKriterien <\/b>erlaubt das Festlegen eines Verknüpfungsoperators für mehrere Kriterien. Sie können diese entweder mit AND <\/b>oder mit OR <\/b>verknüpfen, aber nicht gemischt – dies müssen Sie gegebenenfalls manuell durchführen.<\/p>\n Die Optionsgruppe ogrVariablen <\/b>fragt ab, ob die zu verwendenden Variablen als Parameter der zu erstellenden Routine übergeben werden sollen oder ob diese innerhalb der Routine deklariert werden sollen. Mit der Optionsgruppe ogrZugriffsart <\/b>legen Sie fest, ob ein bestehender Datensatz bearbeitet oder ein neuer Datensatz angelegt werden soll.<\/p>\n Schließlich bestimmt die Optionsgruppe ogrZugriffstechnik<\/b>, ob beim Aktualisieren beziehungsweise Hinzufügen des Datensatzes DAO verwendet werden soll oder eine per Execute ausgeführte Aktionsabfrage.<\/p>\n In einem weiteren Rahmen finden Sie noch drei Optionen:<\/p>\n Zusammenstellen der Prozedur auf Basis der gewählten Parameter<\/b><\/p>\n In den folgenden Abschnitten erfahren Sie, wie das Tool den gewünschten Code zusammenstellt. <\/p>\n Den Startschuss geben Sie mit einem Klick auf die Schaltfläche cmdCodeErstellen<\/b>. Dies löst die folgende Prozedur aus:<\/p>\n Die Prozedur stellt sicher, dass der Benutzer eine Tabelle ausgewählt und mindestens ein Feld aus dem Listenfeld lstFelder <\/b>markiert hat.<\/p>\n Ist dies gewährleistet, wird das Textfeld txtZugriffscode <\/b>durch die Funktion CreateCode <\/b>mit der gewünschten Prozedur gefüllt.<\/p>\n Code erstellen<\/b><\/p>\n Der Prozess findet hauptsächlich in der Funktion CreateCode <\/b>statt, die eine Variable namens strCode <\/b>nach und nach mit den Zeilen der zu erstellenden Routine füllt:<\/p>\n Wir starten mit der Kopfzeile der Prozedur. Bereits diese kann nicht einfach erstellt werden, denn gegebenenfalls sollen ja die Variablen, auf deren Basis der Datenzugriff erfolgt, als Parameter übergeben werden. Die Zeile zum Erstellen der ersten Zeile ruft daher gleich zwei weitere Funktionen auf:<\/p>\n Die erste Funktion namens GetCodename<\/b> setzt den Namen der Prozedur zusammen (s. Listing 1<\/a><\/span>). Der Name besteht aus einem Präfix, das entweder Add_ <\/b>oder Update_ <\/b>lautet – je nachdem, ob der Datensatz hinzugefügt oder geändert werden soll. Das Präfix wird durch eine Choose<\/b>-Funktion auf Basis des Wertes der Optionsgruppe ogrZugriffsart <\/b>ermittelt. Dann folgt der Name der Tabelle und schließlich ein Suffix, das die Art des Datenzugriffs repräsentiert – entweder _DAO <\/b>oder _SQL <\/b>(je nach Wert der Optionsgruppe ogrZugriffstechnik<\/b>). Für das Hinzufügen eines Datensatzes per DAO zur Tabelle tblArtikel <\/b>entsteht so ein Routinenname wie Add_tblArtikel_DAO<\/b>.<\/p>\n Listing 1: Prozedurname erstellen<\/p>\n Variablen als Parameter übergeben<\/b><\/p>\n Wenn der Benutzer den Wert 1 <\/b>für die Optionsgruppe ogrVariablen <\/b>ausgewählt hat, sollen alle Variablen in der Parameterliste im Prozedurkopf erscheinen – sowohl die für die neuen Daten als auch für die eventuell zu verwendenden Kriterien. Diese Liste erzeugt die Funktion GetParameters <\/b>(s. Listing 2<\/a><\/span>). Sie prüft zunächst den Wert der Optionsgruppe ogrVariablen<\/b>. Danach durchläuft sie alle markierten Elemente der beiden Listenfelder lstFelder <\/b>und lstKriterien<\/b>. Für jeden Eintrag fügt sie der Variablen str <\/b>einen Ausdruck nach dem Schema [Präfix]Feldname As [Datentyp] <\/b>hinzu. Das Präfix wird dabei über eine weitere Funktion namens GetPraefix <\/b>ermittelt (s. Listing 3<\/a><\/span>). Diese Funktion erwartet einen Verweis auf das dem Eintrag entsprechende Field<\/b>-Objekt der Tabellendefinition. Abhängig vom Wert der Type<\/b>-Eigenschaft dieses Field<\/b>-Objekts liefert sie ein passendes Präfix wie etwa str <\/b>oder lng <\/b>zurück.<\/p>\n Listing 2: Parameterliste zusammenstellen<\/p>\n Listing 3: Präfix für ein Feld ermitteln<\/p>\n Listing 5: Deklarationszeilen zusammenstellen<\/p>\n <\/p>\n Ganz ähnlich arbeitet die Funktion GetDatatype <\/b>(s. Listing 4<\/a><\/span>): Sie erwartet ebenfalls den Verweis auf das aktuelle Field<\/b>-Objekt und ermittelt in einem Select Case<\/b>-Konstrukt den Datentyp für diesen Ausdruck, also beispielsweise String <\/b>oder Integer<\/b>.<\/p>\n Listing 4: Datentyp eines Feldes ermitteln<\/p>\n Deklaration von Database und Recordset<\/b><\/p>\n Danach folgt die Deklaration einiger wichtiger Objekte. Auf jeden Fall benötigt die Prozedur ein Database<\/b>-Objekt, dessen Deklaration die folgende Zeile hinzufügt:<\/p>\n Wenn die Daten per DAO hinzugefügt oder geändert werden sollen, brauchen Sie außerdem ein Recordset<\/b>-Objekt. Ob dieses deklariert wird oder nicht, legt der Wert der Optionsgruppe ogrZugriffstechnik <\/b>fest. Der Wert 1 <\/b>steht für DAO <\/b>und erfordert das Anlegen der entsprechenden Zeile:<\/p>\n Deklaration in der Prozedur<\/b><\/p>\n Die folgende Zeile ruft die Funktion GetDeclarations <\/b>auf und fügt so die Deklarationszeilen zur Prozedur hinzu (s. Listing 5<\/a><\/span>):<\/p>\n Listing 9: Aktionsabfrage zusammenbauen<\/p>\n GetDeclarations <\/b>liefert allerdings nur ein Ergebnis zurück, wenn die Optionsgruppe ogrVariablen <\/b>den Wert 2 <\/b>enthält, die Variablen also innerhalb der Prozedur deklariert werden sollen.<\/p>\n Dies wird in einer If…Then<\/b>-Bedingung geprüft. Innerhalb dieser Bedingung durchläuft die Funktion zwei For…Next<\/b>-Schleifen. Die erste durchläuft alle markierten Einträge des Listenfeldes lstFelder<\/b>, das zweite kümmert sich um die markierten Einträge von lstKriterien<\/b>.<\/p>\n Innerhalb dieser Schleifen befinden sich jeweils zwei Anweisungen. Die erste füllt eine Field<\/b>-Variable mit einem Verweis auf das Feld der Zieltabelle, dessen Name dem im Listenfeld ausgewählten Eintrag entspricht. Dieser Objektverweis wird im Aufruf der Funktion GetDeclaration <\/b>in der zweiten Zeile als Parameter übergeben. <\/p>\n GetDeclaration <\/b>liefert einen Ausdruck nach dem Schema Dim [Praefix]Feldname[Suffix] As [Datentyp] <\/b>zurück. Dabei kommen die bereits weiter oben vorgestellten Funktionen GetPraefix <\/b>und GetDatatype <\/b>zum Einsatz.<\/p>\n Das Suffix wird nur von der zweiten Schleife aus übergeben und unterscheidet die Variablennamen der Kriterienfelder gegenüber den Variablen für die zu ändernden beziehungsweise einzufügenden Werte.<\/p>\n Die Ausdrücke werden mit der Variablen str<\/b> zusammengefasst und als Funktionswert zurückgegeben.<\/p>\n Database-Objekt zuweisen<\/b><\/p>\n Die folgende Zeile der Hauptprozedur CreateCode<\/b> fügt der Prozedur eine unabkömmliche Zeile hinzu, nämlich die folgende:<\/p>\n Dafür sorgt diese Anweisung:<\/p>\n Recordset öffnen<\/b><\/p>\n Wenn der Benutzer für die Optionsgruppe ogrZugriffstechnik <\/b>den Wert 1 <\/b>(für DAO) ausgewählt hat, soll die zu erstellende Prozedur ein Recordset auf Basis der angegebenen Felder und Kriterien öffnen. Die Erstellung der Zeile mit der OpenRecordset<\/b>-Anweisung wird über die Funktion GetSelect <\/b>abgewickelt (s. Listing 6<\/a><\/span>).<\/p>\n Listing 6: OpenRecordset-Anweisung konstruieren<\/p>\n Die Prozedur prüft zunächst, ob als Zugriffstechnik überhaupt DAO eingesetzt werden soll. Falls ja, folgen weitere Schritte. Diese unterscheiden sich dadurch, ob der Benutzer Kriterien ausgewählt hat oder nicht. Falls nein, wird die SELECT<\/b>-Anweisung ohne WHERE<\/b>-Klausel erstellt, sonst mit einer Bedingung.<\/p>\n In beiden Fällen kommt die Funktion GetFields <\/b>zum Einsatz. Diese stellt eine Liste aller Felder zusammen, die per DAO bearbeitet werden sollen. Die Funktion durchläuft in einer For…Next<\/b>-Schleife alle markierten Einträge des Listenfeldes lstFelder<\/b> und erstellt dabei eine durch Kommata getrennte Liste aller Felder. Nach dem Entfernen des letzten, überflüssigen Kommas wird die Liste an die aufrufende Routine zurückgegeben:<\/p>\n Etwas aufwendiger ist die Zusammenstellung der Liste der Kriterien. Dies erledigt die Funktion GetCriteria<\/b> (s. Listing 7<\/a><\/span>).<\/p>\n Listing 7: Zusammenstellen des Kriteriums der SELECT-Abfrage<\/p>\n Diese arbeitet grundsätzlich wie die Funktion GetFields<\/b>, muss jedoch ein wenig mehr Informationen zusammenstellen. Jeder Ausdruck der WHERE<\/b>-Bedingung hat die folgende Form, wobei noch vom Datentyp abhängige Varianten hinzukommen:<\/p>\n Sie können durch Aktivieren des Kontrollkästchens chk <\/b>die Funktion IsoDatum<\/b> hinzufügen:<\/p>\n Wenn das Feld ein Textfeld ist, kommen etwa noch Hochkommata hinzu wie in folgendem Beispiel:<\/p>\n Bei Dezimalzahlen ersetzt die Funktion nach Wunsch die Kommata als Dezimaltrennzeichen durch den Punkt – SQL fasst das Komma sonst als Aufzählungszeichen auf.<\/p>\n Außerdem muss die Funktion sich um die Operatoren zum Verknüpfen mehrerer Bedingungen kümmern. Mit der Optionsgruppe ogrKriterien <\/b>legen Sie fest, ob die Bedingungen mit OR <\/b>oder AND <\/b>verknüpft werden.<\/p>\n Die Funktion durchläuft alle markierten Einträge des Listenfeldes lstKriterien<\/b>. Dabei füllt sie wieder jeweils eine Field<\/b>-Variable mit einem Verweis auf das entsprechende Feld der betroffenen Tabelle, um die notwendigen Informationen zum Datentyp zu erhalten. Von diesem hängt nämlich beispielsweise ab, ob der Vergleichsausdruck in Hochkommata eingefasst wird (bei Text- und Memofeldern), ob die IsoDatum<\/b>-Funktion für Datumsfelder eingesetzt werden soll oder ob Kommata bei Dezimalzahlen durch Punkte ersetzt werden sollen.<\/p>\n Der Vergleichsoperator wird gleich zu Beginn in Abhängigkeit vom Wert von ogrKriterien <\/b>per Choose<\/b>-Anweisung aus AND <\/b>und OR <\/b>ermittelt. Das überflüssige AND <\/b>oder OR <\/b>wird am Ende der Funktion abgeschnitten.<\/p>\n Variablenwerte zuweisen<\/b><\/p>\n Wenn die Variablen nicht als Parameter übergeben, sondern innerhalb der Routine deklariert werden, möchten Sie diese möglicherweise gleich füllen.<\/p>\n Dazu bereitet die Prozedur die notwendigen Zeilen vor, etwa so:<\/p>\n Diese Aufgabe erledigt diese Zeile:<\/p>\n Die dadurch aufgerufene Funktion GetAssignmentsVariables <\/b>sieht wie in Listing 8<\/a><\/span> aus. Sie durchläuft alle ausgewählten Einträge des Listenfeldes lstFelder <\/b>und erstellt für jedes Feld eine entsprechende Wertzuweisung – dies jedoch nur, wenn ogrVariablen <\/b>den Wert 2<\/b> aufweist.<\/p>\n Listing 8: Zusammenstellung der Wertzuweisungen<\/p>\n Bearbeitung per DAO<\/b><\/p>\n Für das Anlegen beziehungsweise die Bearbeitung per DAO sollen nun folgende Zeilen zur zu erzeugenden Routine hinzukommen (beim Bearbeiten wird AddNew <\/b>durch Edit <\/b>ersetzt):<\/p>\n Ob AddNew <\/b>oder Edit <\/b>zum Einsatz kommt, entscheidet sich in der folgenden Select Case<\/b>-Anweisung:<\/p>\n Danach folgt die eigentliche Wertzuweisung.<\/p>\n Die notwendigen Anweisungen liefert die Funktion GetAssignmentsDAO<\/b>, die wie folgt aufgerufen wird:<\/p>\n Diese Funktion durchläuft alle aktivierten Felder des Listenfeldes lstFelder <\/b>und stellt die benötigten Name-Wert-Paare zusammen:<\/p>\n Fehlen noch die Anweisungen, die sich um das Aktualisieren und Schließen des Recordset<\/b>-Objekts und um die Leerung der Objektvariablen kümmern:<\/p>\n Bearbeitung per Aktionsabfrage<\/b><\/p>\n Wenn als Zugriffstechnik die SQL-Aktionsabfrage ausgewählt wurde, wird der Code anders erweitert, und zwar durch folgende Anweisung:<\/p>\n Die GetExecute<\/b>-Funktion prüft zunächst, ob eine Anfüge- oder eine Aktualisierungsabfrage verwendet werden soll (s. Listing 9<\/a><\/span>). Dazu untersucht sie den Wert des Steuerelements ogrZugriffsart<\/b>. Im Falle einer Anfügeabfrage wird eine entsprechende INSERT INTO<\/b>-Anweisung erstellt.<\/p>\n Diese enthält einige variable Anteile: den Tabellennamen, die Feldliste und die Wertliste. Die letzten beiden werden durch entsprechende Funktionen ermittelt. GetFields <\/b>wurde bereits weiter vorn vorgestellt, GetValues <\/b>ist neu und in Listing 10<\/a><\/span> zu finden.<\/p>\n Listing 10: Wertliste zusammenstellen<\/p>\n INSERT INTO-Werte zusammenstellen<\/b><\/p>\n Die Funktion GetValues <\/b>stellt den Ausdruck zusammen, der hinter dem VALUES<\/b>-Schlüsselwort einer INSERT INTO<\/b>-Anweisung in Klammern angegeben wird – etwa so:<\/p>\n Dabei durchläuft sie alle selektierten Felder des Listenfeldes lstFelder <\/b>und fügt die Wertliste entsprechend dem jeweiligen Felddatentyp zusammen.<\/p>\n UPDATE-Zuweisungen ermitteln<\/b><\/p>\n Für die Aktualisierungsabfrage benötigen Sie einen Ausdruck, der die Zuweisung der neuen Werte zu den Feldern enthält. Diesen Ausdruck liefert die Funktion GetUpdates<\/b> (s. Listing 11<\/a><\/span>).<\/p>\n Listing 11: Feldzuweisungen zusammenstellen<\/p>\nSELECT Name FROM MSysObjects WHERE Type = 1 AND Name NOT LIKE ''MSYS*'';<\/pre>\n
Private Sub cmdAlleAuswaehlen_Click()\r\n Dim i As Integer\r\n For i = 0 To Me!lstFelder.ListCount - 1\r\n Me!lstFelder.Selected(i) = True\r\n Next i\r\n End Sub<\/pre>\n
Private Sub cboTabelle_AfterUpdate()\r\n If Not IsNull(Me!cboTabelle) Then\r\n Me!lstFelder.RowSource = Me!cboTabelle\r\n Me!lstKriterien.RowSource = Me!cboTabelle\r\n Else\r\n Me!lstFelder.RowSource = ""\r\n Me!lstKriterien.RowSource = ""\r\n End If\r\n End Sub<\/pre>\n
\n
Private Sub cmdCodeErstellen_Click()\r\n If IsNull(Me!cboTabelle) Then\r\n MsgBox "Bitte wählen Sie eine Tabelle aus."\r\n Exit Sub\r\n End If\r\n If Me!lstFelder.ItemsSelected.Count = 0 Then\r\n MsgBox "Bitte wählen Sie die betroffenen\r\n Felder aus."\r\n Exit Sub\r\n End If\r\n Me!txtZugriffscode = CreateCode\r\n End Sub<\/pre>\n
Private Function CreateCode() As String\r\n Dim strCode As String\r\n ...\r\nEnd Function<\/pre>\n
strCode = strCode & "Public Sub " & GetCodename & "(" & GetParameters & ")" & vbCrLf<\/pre>\nPrivate Function GetCodename() As String\r\n Dim strCodename As String\r\n strCodename = Choose(Me!ogrZugriffsart, "Add_", "Update_")\r\n strCodename = strCodename & Me!cboTabelle\r\n strCodename = strCodename & Choose(Me!ogrZugriffstechnik, "_DAO", "_SQL")\r\n GetCodename = strCodename\r\nEnd Function<\/pre>\n
Private Function GetParameters() As String\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n If Me!ogrVariablen = 1 Then\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.ItemsSelected(i))\r\n str = str & GetPraefix(fld) & fld.Name & " As " & GetDatatype(fld) & ", "\r\n Next i\r\n For i = 0 To Me!lstKriterien.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstKriterien.ItemsSelected(i))\r\n str = str & GetPraefix(fld) & fld.Name & "_Crit As " & GetDatatype(fld) & ", "\r\n Next i\r\n GetParameters = Left(str, Len(Trim(str)) - 1)\r\n End If\r\nEnd Function<\/pre>\n
Private Function GetPraefix(fld As DAO.Field) As String\r\n Select Case fld.Type\r\n Case dbBoolean\r\n GetPraefix = "bol"\r\n Case dbInteger\r\n GetPraefix = "int"\r\n Case dbLong\r\n GetPraefix = "lng"\r\n Case dbCurrency\r\n GetPraefix = "cur"\r\n Case dbSingle\r\n GetPraefix = "sng"\r\n Case dbDouble\r\n GetPraefix = "dbl"\r\n Case dbText, dbMemo\r\n GetPraefix = "str"\r\n Case dbDate\r\n GetPraefix = "dat"\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\nEnd Function<\/pre>\n
Private Function GetDeclarations()\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n If Me!ogrVariablen = 2 Then\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.ItemsSelected(i))\r\n str = str & GetDeclaration(fld)\r\n Next i\r\n For i = 0 To Me!lstKriterien.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstKriterien.ItemsSelected(i))\r\n str = str & GetDeclaration(fld, "_Crit")\r\n Next i\r\n GetDeclarations = str\r\n End If\r\nEnd Function\r\nPrivate Function GetDeclaration(fld As DAO.Field, Optional strSuffix As String) As String\r\n GetDeclaration = " Dim " & GetPraefix(fld) & fld.Name & strSuffix & " As " _\r\n & GetDatatype(fld) & vbCrLf\r\nEnd Function<\/pre>\n
Private Function GetDatatype(fld As DAO.Field) As String\r\n Select Case fld.Type\r\n Case dbBoolean\r\n GetDatatype = "Boolean"\r\n Case dbInteger\r\n GetDatatype = "Integer"\r\n Case dbLong\r\n GetDatatype = "Long"\r\n Case dbCurrency\r\n GetDatatype = "Currency"\r\n Case dbSingle\r\n GetDatatype = "Single"\r\n Case dbDouble\r\n GetDatatype = "Double"\r\n Case dbText, dbMemo\r\n GetDatatype = "String"\r\n Case dbDate\r\n GetDatatype = "Date"\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\nEnd Function<\/pre>\n
strCode = strCode & " Dim db As\r\n DAO.Database" & vbCrLf<\/pre>\n
If Me!ogrZugriffstechnik = 1 Then\r\n strCode = strCode & " Dim\r\n rst As DAO.Recordset" & vbCrLf\r\nEnd If<\/pre>\n
Private Function GetExecute() As String\r\n Select Case Me!ogrZugriffsart\r\n Case 1\r\n GetExecute = " db.Execute(""INSERT INTO " & Me!cboTabelle & "(" & GetFields _\r\n & ") VALUES(" & GetValues & ")"")" & vbCrLf\r\n Case 2\r\n If Len(GetCriteria) > 0 Then\r\n GetExecute = " db.Execute(""UPDATE " & Me!cboTabelle & " SET " & GetUpdates _\r\n & " WHERE " & GetCriteria & ")" & vbCrLf\r\n Else\r\n GetExecute = " db.Execute(""UPDATE " & Me!cboTabelle & " SET " & GetUpdates & vbCrLf\r\n End If\r\n End Select\r\nEnd Function\r\nstrCode = strCode & GetDeclarations<\/pre>\nSet db = CurrentDb<\/pre>\n
strCode = strCode & " Set db = CurrentDb"\r\n & vbCrLf<\/pre>\n
Private Function GetSelect() As String\r\n Select Case Me!ogrZugriffstechnik\r\n Case 1\r\n If Me!lstKriterien.ItemsSelected.Count = 0 Then\r\n GetSelect = " Set rst = db.OpenRecordset(""SELECT " & GetFields & " FROM " _\r\n & Me!cboTabelle & """, dbOpenDynaset)" & vbCrLf\r\n Else\r\n GetSelect = " Set rst = db.OpenRecordset(""SELECT " & GetFields & " FROM " _\r\n & Me!cboTabelle & " WHERE " & GetCriteria & """, dbOpenDynaset)" & vbCrLf\r\n End If\r\n End Select\r\nEnd Function<\/pre>\nPrivate Function GetFields()\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.\r\n Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.\r\n ItemsSelected(i))\r\n str = str & fld.Name & ", "\r\n Next i\r\n str = Left(str, Len(Trim(str)) - 1)\r\n GetFields = str\r\nEnd Function<\/pre>\n
Private Function GetCriteria() As String\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim strAndOr As String\r\n Dim i As Integer\r\n Dim str As String\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n strAndOr = Choose(Me!ogrKriterien, "AND", "OR")\r\n For i = 0 To Me!lstKriterien.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstKriterien.ItemsSelected(i))\r\n Select Case fld.Type\r\n Case dbBoolean, dbInteger, dbLong\r\n str = str & fld.Name & " = "" & " & GetPraefix(fld) & fld.Name & " & """\r\n Case dbCurrency, dbSingle, dbDouble\r\n If Me!chkKommaErsetzen Then\r\n str = str & fld.Name & " = "" & Replace(" & GetPraefix(fld) & fld.Name _\r\n & ", "","", ""."") & """\r\n Else\r\n str = str & fld.Name & " = "" & " & GetPraefix(fld) & fld.Name & " & """\r\n End If\r\n Case dbText, dbMemo\r\n str = str & fld.Name & " = ''"" & " & GetPraefix(fld) & fld.Name & " & ""''"\r\n Case dbDate\r\n If Me!chkIsoDatum Then\r\n str = str & fld.Name & " = "" & IsoDatum(" & GetPraefix(fld) & fld.Name & ") & """\r\n Else\r\n str = str & fld.Name & " = "" & " & GetPraefix(fld) & fld.Name & " & """\r\n End If\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\n str = str & " " & strAndOr & " "\r\n Next i\r\n str = Left(str, Len(str) - Len(strAndOr) - 2)\r\n GetCriteria = str\r\nEnd Function<\/pre>\nBestelldatum = " & datBestelldatum & "<\/pre>\n
Bestelldatum = " & IsoDatum(datBestelldatum) & "<\/pre>\n
Empfaenger = ''" & strEmpfaenger & "''"<\/pre>\n
lngPersonalID = 0\r\ndatBestelldatum = 0\r\nstrEmpfaenger = ""<\/pre>\n
strCode = strCode & GetAssignments<\/pre>\n
Private Function GetAssignmentsVariables()\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n Dim strValue As String\r\n If Me!ogrVariablen = 2 Then\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.ItemsSelected(i))\r\n Select Case fld.Type\r\n Case dbBoolean, dbInteger, dbLong, dbCurrency, dbSingle, dbDouble, dbDate\r\n strValue = 0\r\n Case dbText, dbMemo\r\n strValue = """"""\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\n str = str & " " & GetPraefix(fld) & fld.Name & " = " & strValue & vbCrLf\r\n Next i\r\n End If\r\n GetAssignmentsVariables = str\r\nEnd Function<\/pre>\n
rst.AddNew\r\nrst!BestellungID = lngBestellungID\r\nrst!KundeID = lngKundeID\r\nrst!PersonalID = lngPersonalID\r\nrst!Bestelldatum = datBestelldatum\r\nrst!Empfaenger = strEmpfaenger\r\nrst.Update\r\nrst.Close\r\nSet rst = Nothing<\/pre>\n
Select Case Me!ogrZugriffsart\r\nCase 1\r\n strCode = strCode & " rst.AddNew" & vbCrLf\r\nCase 2\r\n strCode = strCode & " rst.Edit" & vbCrLf\r\nEnd Select<\/pre>\n
strCode = strCode & GetAssignmentsDAO<\/pre>\n
Private Function GetAssignmentsDAO() As String\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.\r\n ItemsSelected(i))\r\n str = str & " rst!" & fld.Name & " = "\r\n & GetPraefix(fld) & fld.Name & vbCrLf\r\n Next i\r\n GetAssignmentsDAO = str\r\nEnd Function<\/pre>\n
strCode = strCode & " rst.Update" & vbCrLf\r\nstrCode = strCode & " rst.Close" & vbCrLf\r\nstrCode = strCode & " Set rst = Nothing" & vbCrLf<\/pre>\n
strCode = strCode & GetExecute<\/pre>\n
Private Function GetValues() As String\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n Dim strField As String\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.ItemsSelected(i))\r\n strField = GetPraefix(fld) & fld.Name\r\n Select Case fld.Type\r\n Case dbBoolean, dbInteger, dbLong\r\n str = str & """ & " & strField & " & "", "\r\n Case dbCurrency, dbSingle, dbDouble\r\n If Me!chkKommaErsetzen Then\r\n str = str & " = "" & Replace(" & strField & ", "","", ""."") & """\r\n Else\r\n str = str & " = "" & " & strField & " & """\r\n End If\r\n Case dbText, dbMemo\r\n str = str & "''"" & " & strField & " & ""'', "\r\n Case dbDate\r\n If Me!chkIsoDatum Then\r\n str = str & """ & IsoDatum(" & strField & ") & "", "\r\n Else\r\n str = str & """ & " & strField & " & "", "\r\n End If\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\n Next i\r\n str = Left(str, Len(Trim(str)) - 1)\r\n GetValues = str\r\nEnd Function<\/pre>\nVALUES(" & lngBestellungID & ", " & lngKundeID & ",\r\n" & lngPersonalID & ", " & IsoDatum(datBestelldatum) & ", " & curFrachtkosten & "''" ...<\/pre>\nPrivate Function GetUpdates() As String\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim i As Integer\r\n Dim str As String\r\n Dim strField As String\r\n Set db = CurrentDb\r\n Set tdf = db.TableDefs(Me!cboTabelle)\r\n For i = 0 To Me!lstFelder.ItemsSelected.Count - 1\r\n Set fld = tdf.Fields(Me!lstFelder.ItemsSelected(i))\r\n strField = GetPraefix(fld) & fld.Name\r\n Select Case fld.Type\r\n Case dbBoolean, dbInteger, dbLong\r\n If Me!chkKommaErsetzen Then\r\n str = str & fld.Name & " = "" & Replace(" & strField & ", "","", ""."") & "", "\r\n Else\r\n str = str & fld.Name & " = "" & " & strField & " & "", "\r\n End If\r\n Case dbCurrency, dbSingle, dbDouble\r\n str = str & fld.Name & " = "" & " & strField & " & "", "\r\n Case dbText, dbMemo\r\n str = str & fld.Name & " = ''"" & " & strField & " & ""'', "\r\n Case dbDate\r\n If Me!chkIsoDatum Then\r\n str = str & fld.Name & " = "" & IsoDatum(" & strField & ") & "", "\r\n Else\r\n str = str & fld.Name & " = "" & " & strField & " & "", "\r\n End If\r\n Case Else\r\n Debug.Print fld.Type, fld.Name\r\n End Select\r\n Next i\r\n str = Left(str, Len(Trim(str)) - 1)\r\n GetUpdates = str\r\nEnd Function<\/pre>\n