{"id":55000940,"date":"2014-08-01T00:00:00","date_gmt":"2020-05-22T21:11:21","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=940"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Neue_Werte_in_LookupFeldern","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Neue_Werte_in_LookupFeldern\/","title":{"rendered":"Neue Werte in Lookup-Feldern"},"content":{"rendered":"

\"\"<\/p>\n

Manchmal möchten Sie schnell mit ein paar Zeilen Code eine Funktion programmieren, mit der ein neuer Datensatz zu einer Tabelle mit einem eindeutigen Index hinzugefügt wird. Dies geschieht bevorzugt bei Lookup-Tabellen. Dort kommt es aber schnell dazu, dass der Benutzer einen neuen Datensatz hinzufügt, der bereits vorhanden ist. In diesem Beitrag zeigen wir, wie Sie solche Fälle umschiffen oder den Benutzer gegebenenfalls einen neuen Wert eingeben lassen.<\/b><\/p>\n

Lookup-Tabellen<\/b><\/p>\n

Warum benutzt man eigentlich Lookup-Tabellen Der wichtigste Grund ist wohl, dass man die möglichen Werte nur je einmal in eine separate Tabelle eingibt und von anderen Tabellen darauf verweisen kann, indem man diese über ein Fremdschlüsselfeld mit dem Primärschlüsselwert dieser Tabelle verknüpft.<\/p>\n

Nun legt man nicht immer nur über die Benutzeroberfläche neue Datensätze an, bei denen man bequem etwa per Kombinationsfeld einen der vorhandenen verknüpften Datensätze auswählt – zum Beispiel eine Anrede oder eine Kategorie. Gelegentlich sollen auch neue Datensätze beim Anlegen über die Benutzeroberfläche hinzugefügt werden oder Sie wollen vielleicht Daten aus einer anderen Datenbank importieren, wo die Daten noch in einer Tabelle vorliegen.<\/p>\n

Eindeutiger Schlüssel<\/b><\/p>\n

Wenn Sie eine solche Lookup-Tabelle verwenden – wie etwa die Tabelle tblKategorien <\/b>aus Bild 1 -, dann haben Sie verschiedene Möglichkeiten, um sicherzustellen, dass jede Kategorie nur einmal eingegeben wird. Die einfachste ist, einfach wie in der Abbildung einen eindeutigen Index für dieses Feld anzulegen. Dazu wählen Sie für die Eigenschaft Indiziert <\/b>einfach den Wert Ja (Ohne Duplikate) <\/b>aus.<\/p>\n

\"Tabelle<\/p>\n

Bild 1: Tabelle mit eindeutig indiziertem Feld<\/span><\/b><\/p>\n

Achtung: Dies ist für Tabellen mit bestehenden Daten etwas komplizierter. Es kann immerhin vorkommen, dass Benutzer es geschafft haben, den gleichen Datensatz mehrfach in einer Lookup-Tabelle einzugeben. Wenn dort also beispielsweise zwei Mal die gleiche Kategorie enthalten ist und Sie dann versuchen, für das Feld Kategorie <\/b>einen eindeutigen Index zu definieren, erhalten Sie eine entsprechende Fehlermeldung (s. Bild 2).<\/p>\n

\"Fehlermeldung<\/p>\n

Bild 2: Fehlermeldung beim Versuch, einen eindeutigen Index für ein Feld mit nicht eindeutigen Daten anzulegen<\/span><\/b><\/p>\n

In diesem Fall müssen Sie die Daten zuvor noch vereinheitlichen. Wie das gelingt, lesen Sie im Beitrag Lookup-Daten: Aus zwei mach eins <\/b>(www.access-im-unternehmen.de\/946<\/b>).<\/p>\n

Wenn die Daten jedoch keine Redundanzen aufweisen, können Sie den eindeutigen Index problemlos anlegen. Anschließend führt der Versuch, einen neuen Datensatz mit einem bereits vorhandenem Wert in dem eindeutig indizierten Feld anzulegen, wiederum zu einem Fehler. Interessanterweise erhalten wir hier genau die gleiche Fehlermeldung wie bei dem Versuch, einen eindeutigen Index für ein Feld mit nicht eindeutigen Werten anzulegen.<\/p>\n

Nun wollen wir dem Benutzer sicher nicht diese Fehlermeldung präsentieren, sondern eine, mit der er etwas mehr anfangen kann.<\/p>\n

Lookup-Werte per Formular eingeben<\/b><\/p>\n

In Bild 3 haben wir die einfachste Konstellation für die Eingabe von Werten in eine Lookup-Tabelle geschaffen. Der Benutzer kann aus dem Kombinationsfeld eine Kategorie auswählen, aber auch neue Werte eingeben – zumindest scheinbar. Denn wenn er wirklich einen neuen Wert dort eingibt, der noch nicht in der Datensatzherkunft dieses Steuerelements vorhanden ist, erscheint wiederum eine Fehlermeldung (s. Bild 4).<\/p>\n

\"Einfaches<\/p>\n

Bild 3: Einfaches Formular mit einem Kombinationsfeld zur Eingabe oder Auswahl von Lookup-Werten<\/span><\/b><\/p>\n

\"Fehler<\/p>\n

Bild 4: Fehler beim Versuch, einen Wert in ein unvorbereitetes Lookup-Feld einzugeben<\/span><\/b><\/p>\n

Um dies zu verhindern und den neuen Wert gleich in die Tabelle tblKategorien<\/b> zu schreiben, legen Sie eine Ereignisprozedur an, die durch das Ereignis Bei nicht in Liste <\/b>des Kombinationsfeldes ausgelöst wird. Diese sieht wie in Listing 1 aus. Diese Ereignisprozedur liefert gleich zwei entsprechende Parameter, wobei der erste, NewData<\/b>, den Wert des neuen Eintrags liefert und der zweite, Response<\/b>, einen Wert erwartet, der die weitere Vorgehensweise festlegt. In diesem Fall legt die Prozedur gleich einen neuen Eintrag in der Tabelle tblKategorien <\/b>mit dem mit NewData <\/b>gelieferten Kategorienamen an. Dann stellt sie Response auf acDataErrAdded <\/b>ein, was für den weiteren Verlauf festlegt, dass Access keine Fehlermeldung liefert, sondern direkt den neuen Wert im Kombinationsfeld auswählt. Die Datensatzherkunft wird auf diesem Wege gleich mit aktualisiert.<\/p>\n

Private Sub <\/span>KategorieID_NotInList(NewData As String<\/span>, Response As Integer<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Set<\/span> db = CurrentDb\r\n     db.Execute \"INSERT INTO tblKategorien(Kategorie) VALUES(''\" & NewData & \"'')\", dbFailOnError\r\n     Response = acDataErrAdded\r\n     Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n
<\/p>\n
Listing 1: Hinzufügen eines neuen Datensatzes über die Eingabe in ein Kombinationsfeld<\/span><\/b><\/p>\n
Hinzufügen mit Rückfrage<\/b><\/p>\n
Gegebenenfalls möchten Sie den Benutzer dennoch darauf hinweisen, dass er gerade einen neuen Wert zur Liste hinzufügt. Zu Beispielzwecken kopieren wir das Kombinationsfeld cboKategorien<\/b> in ein neues Steuerelement namens cboKategorien_II<\/b>. Für dieses hinterlegen wir nun wiederum eine Ereignisprozedur für das Ereignis Bei Nicht in Liste<\/b>. Diese sieht nun wie in Listing 2 aus.<\/p>\n
Private Sub <\/span>cboKategorien_II_NotInList(NewData As String<\/span>, Response As Integer<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>bolHinzufuegen As Boolean<\/span>\r\n     bolHinzufuegen = MsgBox<\/span>(\"Diesen Eintrag zur Liste hinzufügen\", _\r\n         vbYesNo + vbExclamation, \"Neuer Eintrag\") = vbYes\r\n     If <\/span>bolHinzufuegen = True<\/span> Then<\/span>\r\n         Set<\/span> db = CurrentDb\r\n         db.Execute \"INSERT INTO tblKategorien(Kategorie) VALUES(''\" & NewData & \"'')\", dbFailOnError\r\n         Response = acDataErrAdded\r\n         Set<\/span> db = Nothing\r\n     Else<\/span>\r\n         Response = acDataErrContinue\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Hinzufügen eines neuen Datensatzes mit Rückfrage<\/span><\/b><\/p>\n
Die Prozedur zeigt ein Meldungsfenster an, mit dem es den Benutzer fragt, ob der Eintrag wirklich zur Liste hinzugefügt werden soll. Das Ergebnis dieses Meldungsfensters (vbYes <\/b>oder vbNo<\/b>) vergleicht die Prozedur dann mit dem Wert vbYes<\/b>. Dieses Resultat wiederum landet in der Variablen bolHinzufuegen<\/b>. An dieser Stelle ist es wichtig, das Ergebnis des Meldungsfensters nicht direkt in der Variablen bolHinzufuegen<\/b> zu speichern: vbYes <\/b>hat nämlich den Wert 6<\/b>, vbNo <\/b>hat den Wert 7<\/b>. Wenn Sie einer Boolean-Variablen den Wert 6 <\/b>oder 7 <\/b>(oder eine andere positive Zahl) zuweisen, erhält diese den Wert True<\/b>. Das bedeutet: Egal, ob der Benutzer auf Ja <\/b>oder Nein <\/b>klickt, die Variable bolHinzufuegen <\/b>würde immer mit dem Wert True <\/b>gefüllt werden.<\/p>\n
Also schreiben wir ordnungsgemäß das Ergebnis aus dem Vergleich der MsgBox<\/b>-Funktion mit dem Wert vbYes <\/b>in die Variable bolHinzufuegen<\/b>. Beim Eintragen eines noch nicht vorhandenen Wertes in das Kombinationsfeld erscheint nun die Meldung aus Bild 5.<\/p>\n
\"Rückfrage<\/p>\n
Bild 5: Rückfrage vor dem Hinzufügen eines neuen Wertes<\/span><\/b><\/p>\n
Klickt der Benutzer auf Ja<\/b>, werden die Anweisungen ausgeführt, die wir bereits aus dem vorherigen Beispiel kennen. Anderenfalls gibt die Prozedur über den Parameter Response <\/b>den Wert acDataErrContinue <\/b>zurück. Das heißt: Access soll keine Fehlermeldung ausgeben. Stattdessen wird einfach nur das aufgeklappte Kombinationsfeld angezeigt (s. Bild 6). Zusätzlich könnten Sie noch das Kombinationsfeld leeren – etwa mit folgender Anweisung, die Sie ebenfalls in den Else<\/b>-Zweig der If…Then<\/b>-Bedingung schreiben:<\/p>\n
\"Soll<\/p>\n
Bild 6: Soll der Wert nicht zur Liste hinzugefügt werden, bleibt dieser im Feld stehen und das Kombinationsfeld wird aufgeklappt.<\/span><\/b><\/p>\n
Me!cboKategorien_II = Null<\/pre>\n
Neuer Lookup-Wert per InputBox<\/b><\/p>\n
Nun gibt es allerdings Benutzer, die nicht ständig mit Access arbeiten und auch von anderen Anwendungen möglicherweise nicht die Möglichkeit kennen, neue Werte direkt in ein Auswahlfeld einzugeben. Formulare auf Internetangeboten bieten dies beispielsweise gar nicht an – dort gibt es lediglich reine Auswahlsteuerelemente.<\/p>\n
Um die Dateneingabe etwas intuitiver zu gestalten, fügen wir neben dem Kombinationsfeld also noch ein Steuerelement mit der Beschriftung Hinzufügen <\/b>hinzu (je nach Platzangebot lässt sich dies auch auf ein Plus-Zeichen (+) verkürzen oder, wenn Sie eine aktuelle Version von Access verwenden, durch ein entsprechendes Icon). Die Schaltfläche erhält den Namen cmdHinzufuegen <\/b>und soll beim Anklicken eine Inputbox anzeigen, die den Benutzer zur Eingabe eines neuen Wertes für die Lookup-Tabelle auffordert.<\/p>\n
Für die Schaltfläche cmdHinzufuegen <\/b>hinterlegen Sie die Ereignisprozedur aus Listing 3, die durch das Ereignis Beim Klicken <\/b>ausgelöst wird. Die Prozedur ermittelt zunächst mit einer Inputbox den neuen Eintrag für das Kombinationsfeld (s. Bild 7) und speichert diesen in der Variablen strInhalt<\/b>. Wenn die Variable eine leere Zeichenkette enthält, spricht dies dafür, dass der Benutzer entweder tatsächlich nichts eingegeben oder auf die Abbrechen<\/b>-Schaltfläche geklickt hat. In diesem Fall soll nichts geschehen – genauso wie in dem Fall, dass der Benutzer einfach auf OK <\/b>geklickt hat und somit der in der InputBox<\/b>-Anweisung angegebene Default-Wert (hier [Neue Kategorie eingeben]<\/b>) in die Variable strInhalt <\/b>übernommen wurde.<\/p>\n
\"Eingabe<\/p>\n
Bild 7: Eingabe des neuen Wertes per Inputbox<\/span><\/b><\/p>\n
Die Prozedur ruft nun eine eigene Funktion auf, die sich um das Hinzufügen des neuen Datensatzes kümmert – und um noch mehr! Denn immerhin geraten wir mit der Inputbox außerhalb der Kontrolle des Kombinationsfeldes. Dieses hat ja, wie in den vorherigen Beispielen zu sehen, sehr schön aufgepasst, dass wir keine bereits vorhandenen Werte in die Lookup-Tabelle eintragen. Diese Funktion heißt LookupIDErmitteln <\/b>und wird gleich im Anschluss beschrieben.<\/p>\n
Sie erwartet einige für die Verarbeitung nötige Parameter und liefert den Primärschlüsselwert für den neuen oder gegebenenfalls einen bereits vorhandenen Datensatz mit dem gleichen Wert im indizierten Feld zurück. Diesen verarbeitet die Prozedur cmdHinzufügen_Click <\/b>derart, dass das Kombinationsfeld nach der Aktualisierung seiner Datensatzherkunft direkt auf den neuen Wert eingestellt wird.<\/p>\n
Lookup-Wert per Code einfügen<\/b><\/p>\n
Die soeben erwähnte Funktion Lookup-ID-Ermitteln <\/b>sieht wie in Listing 4 aus. Sie erwartet die folgenden Parameter:<\/p>\n
Public Function <\/span>LookupIDErmitteln(strTabelle As String<\/span>, strPrimaerschluesselfeld As String<\/span>, _\r\n         strInhaltsfeld As String<\/span>, strInhalt As String<\/span>) As Long<\/span>\r\n     Dim <\/span>lngTempID As Long<\/span>\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     lngTempID = Nz(DLookup(strPrimaerschluesselfeld, strTabelle, strInhaltsfeld & \" = ''\" _\r\n         & strInhalt & \"''\"), 0)\r\n     If <\/span>lngTempID = 0 Then<\/span>\r\n         Set<\/span> db = CurrentDb\r\n         db.Execute \"INSERT INTO \" & strTabelle & \"(\" & strInhaltsfeld & \") VALUES(''\" _\r\n             & strInhalt & \"'')\", dbFailOnError\r\n         lngTempID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n     End If<\/span>\r\n     LookupIDErmitteln = lngTempID\r\nEnd Function<\/span><\/pre>\n
Listing 4: Primärschlüsselwert eines neuen oder gegebenenfalls vorhandenen Wertes zurückliefern<\/span><\/b><\/p>\n