![\"Dieses](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_001.png\")
<\/p>\nEine sehr praktische Funktion findet sich in den Office-Anwendungen und auch in vielen anderen Produkten. Wo auch immer Dateien verwendet werden, finden Sie beim Öffnen der jeweiligen Anwendung eine Liste der zuletzt verwendeten Dateien vor. Warum sollte man dies nicht auch in einer Access-Datenbank nutzen, um die zuletzt angezeigten Datensätze in Formularen zur Auswahl anzubieten Wenn Sie zum Beispiel eine Bestellverwaltung nutzen, könnte es sehr sinnvoll sein, die zuletzt angezeigten oder bearbeiteten Kunden in einer Schnellauswahl zum erneuten Aufrufen vorzufinden. Wie das gelingt und welche Erweiterungen dazu notwendig sind, zeigt der vorliegende Beitrag.<\/b><\/p>\nFeature wie unter Office<\/h2>\n
Wenn Sie mit Anwendungen wie Word, Excel oder Access arbeiten, kennen Sie die Anzeige der zuletzt verwendeten Dateien, die beim Starten der Anwendung über die jeweilige Verknüpfung erscheint.<\/p>\n
Hier wählen Sie immer aus den zuletzt verwendeten Dateien aus oder alternativ aus einer Liste von angehefteten Dateien, die unabhängig davon, wann sie zuletzt benutzt wurden, angezeigt werden sollen.<\/p>\n
Wir wollen zunächst nur den ersten Teil auch für die Datensätze einer Tabelle realisieren, in diesem Fall für die Kunden einer Bestellverwaltung.<\/p>\n
Wir nutzen dazu wieder die Tabellen der Beispieldatenbank Südsturm<\/b>, wobei für uns die Tabelle tblKunden <\/b>interessant ist.<\/p>\n
Als Basis dient das Formular frmKundenZuletzt<\/b>, für dessen Eigenschaft Datensatzquelle <\/b>wir die Tabelle tblKunden <\/b>angeben.<\/p>\n
Aus der Feldliste ziehen wir alle Felder der Tabelle in den Detailbereich des Entwurfs des Formulars (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Dieses Formular wollen wir mit einer Liste der zuletzt verwendeten Kunden ausstatten.<\/span><\/b><\/p>\n Bevor wir loslegen und dem Formular ein Listenfeld zur Anzeige der zuletzt verwendeten Datensätze hinzufügen, stellen wir ein paar grundlegende Überlegungen an.<\/p>\n Die erste Frage, die sich uns stellt, ist folgende: Zu welchen Datensätzen beziehungsweise wann soll ein Datensatz überhaupt gespeichert und in der Liste der zuletzt verwendeten Datensätze angezeigt werden<\/p>\n Es gibt verschiedene Möglichkeiten:<\/p>\n Wir wollen im ersten Entwurf den ersten Ansatz umsetzen und alle Datensätze in der Liste der zuletzt angezeigten Datensätze speichern, die überhaupt im Formular frmKundenZuletzt <\/b>angezeigt wurden.<\/p>\n Die zweite Frage lautet: Wo wollen wir überhaupt die Information speichern, welche Datensätze der Tabelle tblKunden <\/b>zuletzt verwendet wurden<\/p>\n Hier gibt es wiederum mindestens zwei Möglichkeiten:<\/p>\n Hier wählen wir ebenfalls den ersten Ansatz. Dies ist praktikabler, weil wir dann nicht den Entwurf der Tabelle tblKunden <\/b>anpassen müssen. Gegebenenfalls handelt es sich bei dieser Tabelle um eine per ODBC eingebundene SQL Server-Tabelle und es ist gar nicht möglich, diese Tabelle anzupassen. Außerdem spricht für die Speicherung in einer eigenen Tabelle, dass diese im Frontend gespeichert werden kann und somit die zuletzt verwendeten Datensätze für den jeweiligen Benutzer sichert.<\/p>\n Die Tabelle wollen wir tblKundenZuletzt <\/b>nennen. Wir könnten auch den Namen tblZuletztGeoeffnet <\/b>oder ähnlich verwenden, aber vielleicht wollen wir die gleiche Funktion auch noch für die Artikel hinzufügen – daher ist es sinnvoller, den Namen der betroffenen Elemente direkt im Tabellennamen anzugeben.<\/p>\n Nun wird es interessanter. Wenn es nur um die Anzeige der zuletzt verwendeten Einträge der Tabelle tblKunden <\/b>geht, könnte man neben dem Primärschlüsselfeld nur noch ein Feld mit der Bezeichnung des jeweiligen Elements, in diesem Falle der Kunden, anlegen. Allerdings wollen Sie den jeweiligen Kunden ja auch über das Listenfeld öffnen, und dazu müssen wir genau wissen, um welchen Datensatz es sich handelt. Also benötigen wir auch noch den Primärschlüsselwert aus der Tabelle tblKunden<\/b>.<\/p>\n Wenn wir aber den Primärschlüsselwert und auch den Namen des Kunden aus der Tabelle tblKunden <\/b>in der Tabelle tblKundenZuletzt <\/b>speichern, laufen wir Gefahr, inkonsistente Daten anzuzeigen. Es kann nämlich sein, dass wir im Formular frmKundenLetzte <\/b>den Namen eines Kunden ändern, nachdem wir diesen angezeigt haben.<\/p>\n Dem können wir allerdings vorbeugen, indem wir im Formular frmKundenLetzte <\/b>nicht nur eine Ereignisprozedur anlegen, die beim Anzeigen eines Kunden ausgelöst wird und dessen Daten in der Tabelle tblKundenZuletzt<\/b> speichert, sondern auch noch eine, die beim Ändern eines Datensatzes ausgelöst wird und den aktuellen Kunden dann in der Tabelle tblKundenZuletzt <\/b>überschreibt.<\/p>\n Und bei der Gelegenheit sollten wir auch im Hinterkopf behalten, dass der Benutzer ja auch einmal einen Kundendatensatz löschen kann. Dieser soll dann selbstverständlich auch aus der Tabelle tblKundenZuletzt <\/b>entfernt werden.<\/p>\n Also gestalten wir die Tabelle tblKundenZuletzt<\/b> wie in Bild 2. Neben dem Primärschlüsselfeld legen wir ein Feld an, das den gleichen Namen erhält wie das Feld, aus dem die in der Liste der zuletzt geöffneten Einträge anzuzeigenden Werte stammen. Für das Feld KundeID<\/b>, welches den Primärschlüsselwert der anzuzeigenden Einträge aus der Tabelle tblKunden <\/b>aufnehmen soll, legen wir einen eindeutigen Index fest. Dieser sorgt dafür, dass jeder Datensatz der Tabelle tblKunden <\/b>nur einmal in der Tabelle tblKundenZuletzt <\/b>referenziert werden kann. Später nutzen wir das Auslösen eines Fehlers beim Hinzufügen eines Datensatzes mit einem bereits vorhandenem Wert in diesem Feld für unsere Zwecke – mehr dazu weiter unten.<\/p>\n Bild 2: Entwurf der Tabelle tblKundenZuletzt<\/span><\/b><\/p>\n Wir könnten die Funktion mit noch mehr Features ausstatten und beispielsweise die Zeit anzeigen, wann der Datensatz zuletzt aufgerufen wurde. Fürs erste reicht es uns jedoch, einfach nur die zuletzt verwendeten Kunden so anzuzeigen, dass der zuletzt verwendete Kunde ganz oben erscheint. Benötigen wir dazu ein spezielles Feld Nein, wir können dazu das Primärschlüsselfeld KundeZuletztID <\/b>nutzen und einfach in absteigender Reihenfolge nach dem Inhalt dieses Feldes sortieren.<\/p>\n Nachdem wir diese Tabelle erstellt haben, wollen wir dem Formular frmKundeZuletzt <\/b>zuerst einmal eine Ereignisprozedur hinzufügen, die bei Anzeigen eines Kunden ausgelöst wird und welche die Daten für diesen Kunden in der Tabelle tblKundenZuletzt <\/b>speichert. Erst danach fügen wir das Listenfeld mit den Daten der Tabelle tblKundenZuletzt <\/b>hinzu.<\/p>\n Das passende Ereignis für unsere Zwecke heißt Beim Anzeigen<\/b>. Es wird sowohl beim Anzeigen des ersten Datensatzes beim Öffnen des Formulars als auch beim Wechseln zu einem anderen Datensatz ausgelöst.<\/p>\n Diese Prozedur füllen wir mit dem Code aus Listing 1. Die Prozedur prüft zuerst, ob KundeID <\/b>nicht den Wert Null <\/b>hat, was der Fall ist, wenn der Datensatzzeiger auf einen neuen, leeren Datensatz verschoben wird. Diesen Fall müssten wir später berücksichtigen, wenn wir uns um das Speichern beim Ändern eines Datensatzes kümmern.<\/p>\n Listing 1: Prozedur zum Speichern der Daten für den aktuellen Datensatz in der Tabelle tblKundenZuletzt<\/span><\/b><\/p>\n Danach deaktivieren wir die eingebaute Fehlerbehandlung mit On Error Resume Next<\/b>. Das ist nötig, damit wir versuchen können, den Datensatz mit dem entsprechenden Wert im Feld KundeID <\/b>zur Tabelle tblKundenZuletzt <\/b>hinzuzufügen. Ist bereits ein Datensatz mit diesem Wert für das Feld KundeID <\/b>vorhanden, wird nämlich der Fehler mit der Nummer 3022 <\/b>ausgelöst. In diesem Fall wollen wir den vorhandenen Datensatz mit dem Wert aus KundeID <\/b>aus der Tabelle tblKundenZuletzt <\/b>löschen und diesen erneut anlegen. Warum belassen wir diesen dann nicht einfach in der Tabelle Weil der Datensatz nun der zuletzt verwendeten Datensatz ist und da wir absteigend nach dem Inhalt des Feldes KundeZuletztID <\/b>sortieren, müssen wir den Datensatz löschen und wieder anlegen, um dieses entsprechend zu aktualisieren.<\/p>\n In dem Fall, dass der Kunde noch nicht in der Liste enthalten ist, fügen wir diesen einfach mit der Anweisung aus strINSERT <\/b>zur Tabelle tblKundenZuletzt <\/b>hinzu. Für einen Beispieldatensatz sieht diese Anweisung etwa wie folgt aus:<\/p>\n Falls tatsächlich der Fehler 3022 <\/b>auftritt, den wir in einer Select Case<\/b>-Bedingung über den Wert von Err.Number <\/b>prüfen, stellen wir eine DELETE<\/b>-Anweisung zusammen, um den betroffenen Datensatz zu löschen und diesen anschließend mit der Anweisung aus strINSERT <\/b>erneut anzulegen. Die DELETE<\/b>-Anweisung sieht für diese Fall wie folgt aus:<\/p>\n Die Select Case<\/b>-Bedingung enthält noch zwei weitere Zweige. Der mit dem Wert 0 <\/b>ist für einen fehlerfreien Aufruf der INSERT INTO<\/b>-Anweisung vorgesehen und erledigt nichts. Der Else<\/b>-Zweig zeigt für alle anderen Fehler eine entsprechende Meldung an. Nachdem wir in die Formularansicht gewechselt sind und einige Datensätze durchlaufen haben – inklusive eines Sprungs zum Datensatz mit der Nummer 6 <\/b>am Ende – sieht die Tabelle tblKundenZuletzt <\/b>wie in Bild 3 aus.<\/p>\n Bild 3: Einige zur Tabelle tblKundenZuletzt hinzugefügte Datensätze<\/span><\/b><\/p>\n Nun fügen wir dem Formular frmKundenZuletzt <\/b>auf der linken Seite ein Listenfeld namens lstKundenZuletzt <\/b>hinzu. Zuvor verschieben wir die Textfelder des Formulars weiter nach rechts, damit genug Platz für das Listenfeld vorhanden ist. Das Ergebnis sehen Sie in Bild 4.<\/p>\n Bild 4: Entwurf des Formulars frmKundenZuletzt mit Listenfeld<\/span><\/b><\/p>\n Das Listenfeld füllen wir über die Eigenschaft Datensatzherkunft <\/b>mit einer Abfrage, die auf der Tabelle tblKundenZuletzt <\/b>basiert. Warum benötigen wir dazu eine Abfrage Weil wir die Datensätze absteigend nach dem Primärschlüsselfeld KundeZuletztID <\/b>sortieren wollen. Die Abfrage sieht in der Entwurfsansicht wie in Bild 5 aus.<\/p>\n <\/p>\n Bild 5: Abfrage mit den Daten für das Listenfeld lstKundenZuletzt<\/span><\/b><\/p>\n Sie enthält alle Felder der Tabelle tblKundenZuletzt <\/b>und sortiert die Datensätze absteigend nach dem Feld KundeZuletztID<\/b>. Das Feld KundeZuletztID <\/b>benötigen wir allerdings nur zum Sortieren, aber nicht für die Anzeige im Listenfeld. Also blenden wir es durch Entfernen des Hakens im Feld Anzeigen <\/b>aus. Außerdem wollen wir das Feld KundeID <\/b>als erstes Feld zurückliefern und als zweites das Feld Firma<\/b>. Warum, erläutern wir gleich im Anschluss.<\/p>\n Die Abfrage liefert die beiden Felder KundeID <\/b>und Firma <\/b>zurück. Wir möchten aber nur das Feld Firma <\/b>anzeigen. Das Feld KundeID <\/b>möchten wir als gebundenes Feld nutzen. Deshalb stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm <\/b>ein (siehe Bild 6).<\/p>\n Bild 6: Einstellungen für die Spalten im Listenfeld<\/span><\/b><\/p>\n Dadurch wird die erste Spalte praktisch ausgeblendet und nur die zweite Spalte angezeigt. Das Ergebnis sehen Sie in Bild 7.<\/p>\n Bild 7: Die Anzeige der zuletzt geöffneten Datensätze<\/span><\/b><\/p>\n Hier sehen wir allerdings ein kleines Problem: Der erste Datensatz im Listenfeld erscheint gleich als #Gelöscht<\/b>. Der Effekt tritt auf, weil dieser Datensatz derjenige ist, der gerade oben stand und auch als erster angezeigt wird. Diese Aktualisierung erledigt Access im Gegensatz zu den anderen, wie das Neuanlegen dieses Datensatzes, automatisch. Also fügen wir der Beim Anzeigen<\/b>-Prozedur noch eine Zeile hinzu, die das Listenfeld aktualisiert:<\/p>\n Damit können Sie nun durch die Datensätze navigieren und das Listenfeld nimmt immer den aktuellen Datensatz als ersten Datensatz in die Liste auf.<\/p>\n Hier stellt sich die Frage, ob der aktuelle Datensatz immer gleich beim Anzeigen im Formular auch an die erste Stelle in die Liste der zuletzt angezeigten Datensätze aufgenommen werden soll. Immerhin wird er ja gerade erst im Formular angezeigt, warum sollte man ihn dann direkt als ersten Datensatz in der Liste anzeigen<\/p>\n Also prüfen wir, ob wir das auch so umsetzen können, dass der Datensatz immer erst beim Anzeigen des nächsten Datensatzes in die Liste aufgenommen werden kann. Das gelingt zumindest nicht so einfach, denn im Gegensatz zu Beim Anzeigen <\/b>gibt es kein Ereignis, dass beim Ausblenden eines Datensatzes ausgelöst wird.<\/p>\n Wir müssten uns also überlegen, welches Ereignis wir stattdessen nutzen können. Wir könnten zum Beispiel den Primärschlüsselwert des aktuellen Datensatzes in einer Variablen speichern und diesen dann beim nächsten Aufruf von Beim Anzeigen <\/b>als neuen zuletzt aufgerufenen Datensatz speichern.<\/p>\n Das misslingt aber, wenn das Formular geschlossen wird, da dann kein weiterer Datensatz mehr angezeigt wird, und spätestens wenn man zwischendurch die Anwendung schließt, wird es aufwendig.<\/p>\n Aber es gibt eine einfachere Lösung: Wir zeigen einfach alle Einträge der Tabelle mit Ausnahme des zuletzt hinzugefügten Eintrags an! Das ist immer der aktuell sichtbare Eintrag, den wir einfach als Kriterium über die als Datensatzherkunft verwendete Abfrage ausschließen.<\/p>\n Um dies zu erreichen, brauchen wir nur das Kriterium aus Bild 8 zum Formular hinzuzufügen. Dieses referenziert das Feld KundeID <\/b>des aktuell im Formular frmKundenZuletzt <\/b>angezeigten Datensatzes.<\/p>\n Bild 8: Anpassen der Datensatzherkunft des Listenfeldes so, dass es den aktuell angezeigten Datensatz nicht enthält.<\/span><\/b><\/p>\n Ein passendes Ereignis, um einen der Datensätze aus dem Listenfeld lstKundenZuletzt <\/b>im Formular anzuzeigen, ist das Beim Doppelklicken<\/b>-Ereignis. Für dieses hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Die Prozedur prüft zuerst, ob der aktuelle Wert im Listenfeld nicht Null <\/b>ist. In diesem Fall soll nichts geschehen. Anderenfalls stellt die Prozedur eine Where<\/b>-Bedingung zusammen, die anschließend der FindFirst<\/b>-Methode des Recordset<\/b>-Objekts des Formulars übergeben wird.<\/p>\n Diese sieht beispielsweise wie folgt aus:<\/p>\n Das Formular zeigt anschließend genau diesen Kunden an. Die vorher beschriebene Prozedur für das Ereignis Beim Anzeigen <\/b>sowie die Anpassung der Abfrage, die wir als Datensatzquelle für das Formular verwenden, sorgen dann dafür, dass der so aufgerufene Datensatz nicht in der Liste angezeigt wir.<\/p>\n Im Detail wird dieser, wenn er bereits vorhanden ist, aus der Tabelle tblKundenZuletzt <\/b>gelöscht und dann erneut eingefügt. Dass die Abfrage für das Listenfeld den aktuell im Formular angezeigten Datensatz nicht anzeigt, erscheint dieser nicht im Listenfeld.<\/p>\n Wenn der Benutzer den Inhalt des Feldes Firma <\/b>der Tabelle tblKunden<\/b> ändert und es in der Tabelle tblKundenZuletzt <\/b>bereits einen Datensatz zu diesem Kunden gibt, dann müsste die Firma auch in dieser Tabelle geändert werden.<\/p>\n Dazu hinterlegen wir eine Ereignisprozedur für das Ereignis Nach Aktualisierung <\/b>des Formulars. Diese löst den Code aus Listing 2 aus. Die Prozedur ruft einfach nur eine Routine namens LetzteDatensaetzeAktualisieren <\/b>auf. Aber was tut diese Routine und wie sieht sie aus<\/p>\n Listing 2: Prozedur zum Anpassen der Bezeichnung des aktuellen Datensatzes in der Tabelle der zuletzt geöffneten Datensätze<\/span><\/b><\/p>\n Ganz einfach: Wenn der Benutzer einen Datensatz aktualisiert hat, soll genau das gleiche geschehen, als wenn ein Datensatz angezeigt wurde – der aktuelle Datensatz soll als neuer Datensatz in der Tabelle tblKundenZuletzt <\/b>angelegt werden.<\/p>\n Daher erstellen wir eine neue Prozedur namens LetzteDatensaetzeAktualisieren <\/b>und fügen dieser alle Anweisungen der Prozedur Form_Current <\/b>hinzu, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird und die wir bereits weiter oben erläutert haben. LetzteDatensaetzeAktualisieren <\/b>sieht also in gekürzter Form wie folgt aus.<\/p>\n Es gibt nur einen Unterschied zu der vorherigen Version – die Anweisung zum Aktualisieren des Listenfeldes haben wir aus der If…Then<\/b>-Bedingung herausgenommen:<\/p>\n Die Ereignisprozedur Form_Current <\/b>passen wir dementsprechend wie folgt an:<\/p>\n Das war es schon: Wenn der Benutzer nun eine Änderung an einem Datensatz vornimmt und den Datensatz speichert, löst dies das Ereignis Nach Aktualisierung <\/b>auf, welches wiederum die Routine LetzteDatensaetzeAktualisieren <\/b>aufruft.<\/p>\n Wie aber reagiert die bisher erstellte Version darauf, wenn wir nach dem Anzeigen einiger Datensätze zu einem neuen, leeren Datensatz springen<\/p>\n Wir leeren der besseren Übersicht halber einmal die Tabelle tblKundenZuletzt <\/b>und öffnen das Formular erneut. Dies speichert direkt den Datensatz mit dem Wert 1 <\/b>im Feld KundeID<\/b> in der Tabelle tblKundenZuletzt<\/b>, zeigt diesen aber noch nicht an, da der aktuell im Formular angezeigte Datensatz ja nicht im Listenfeld erscheinen soll.<\/p>\n Springen wir zum zweiten Datensatz, erscheint der erste Datensatz in der Liste, der zweite jedoch wie gewünscht noch nicht. Dann klicken wir im Bereich der Navigationsschaltflächen auf die Schaltfläche zum Anzeigen eines neuen, leeren Datensatzes.<\/p>\n Das Ergebnis überrascht: Das Formular zeigt zwar den gewünschten neuen, leeren Datensatz an, aber das Listenfeld ist plötzlich leer! Das liegt aber nicht daran, dass die zugrunde liegende Tabelle leer ist, dort befinden sich die zwei zuvor angezeigten Datensätze.<\/p>\n Der Grund, warum das Listenfeld keine Daten anzeigt, ist nicht so einfach zu finden. Um zu verstehen, was hier geschieht, schauen wir uns das Kriterium für die zugrunde liegende Abfrage an. Dieses lautet:<\/p>\n In dem Moment, wo wir einen neuen, leeren Datensatz im Formular anzeigen, hat das Primärschlüsselfeld KundeID <\/b>der Tabelle tblKunden <\/b>noch den Wert Null<\/b>. Das Kriterium lautet also dann, wenn wir diesen Wert einsetzen:<\/p>\n Normalerweise würde man denken, dass dieses Kriterium alle Datensätze liefert, deren Feld KundeID <\/b>einen Wert enthält, der nicht gleich Null <\/b>ist. Allerdings bildet die Abfrage aus dem Ausdruck KundeID<>Null <\/b>den Wert Null<\/b>. Das ist etwa so, als wenn Sie eine Zeichenkette und den Wert Null<\/b> mit dem Plus-Operator verbinden wollen.<\/p>\n Wann immer ein Element einer Verkettung den Wert Null <\/b>hat, ist auch die Verkettung Null<\/b>. Wir wollen noch versuchen, dies konkret nachzuweisen. Dazu erstellen wir eine neue, leere Abfrage und fügen dem ersten Feld lediglich den folgenden Ausdruck zu:<\/p>\n Wenn Sie diese Abfrage aufrufen, wenn im Formular frmKundenZuletzt<\/b> ein neuer, leerer Datensatz mit dem Wert Null <\/b>im Feld KundeID <\/b>angezeigt wird, liefert sie das Ergebnis aus Bild 9. Das Ergebnis lautet -1<\/b>, also ist IstNull <\/b>wahr, also liefert 123<>Null <\/b>den Wert Null<\/b>.<\/p>\n Bild 9: Ergebnis einer Abfrage mit einem Vergleich mit Null<\/span><\/b><\/p>\n Wie kommen wir aus diesem Dilemma wieder heraus Ganz einfach: Wir fassen einfach den Vergleichsausdruck wie in Bild 10 in die Funktion Nz <\/b>ein, die den Wert 0 <\/b>zurückliefern soll, wenn der enthaltene Ausdruck den Wert Null <\/b>enthält.<\/p>\n Bild 10: Entwurf einer Abfrage für die zuletzt angezeigten Kunden<\/span><\/b><\/p>\n Zeigt das Formular nun einen neuen, leeren Datensatz an, ist KundeID <\/b>gleich Null <\/b>und als Vergleichswert macht die Abfrage daraus 0<\/b>. Die Abfrage liefert dann alle Einträge zurück, deren Wert im Feld KundeID<\/b> nicht den Wert 0 <\/b>hat, was allen bisher angelegten Einträgen entspricht.<\/p>\n Legen Sie dann einen neuen Datensatz an und speichern diesen, löst dies das Ereignis Nach Aktualisierung <\/b>aus, was wiederum die Prozedur LetzteDatensaetzeAktualisieren <\/b>aufruft und den neuen Datensatz in die Tabelle tblKundenZuletzt <\/b>einträgt.<\/p>\n Eine weitere Aufgabe besteht darin, beim Löschen von Einträgen in der Tabelle tblKunden <\/b>auch eventuell vorhandene, passende Einträge aus der Tabelle tblKundenZuletzt <\/b>zu löschen.<\/p>\n Dafür gibt es verschiedene Möglichkeiten:<\/p>\n Wir machen es uns einfach und gehen davon aus, dass die Kunden nur über das Formular frmKundenZuletzt <\/b>bearbeitet werden können. Wobei das auch nicht so einfach ist, denn wir müssen noch beachten, ob die Option aktiviert ist, die zur Anzeige von Meldungen wie der aus Bild 11 führt.<\/p>\n Bild 11: Meldung beim Löschen eines Datensatzes<\/span><\/b><\/p>\n Zusammengefasst benötigen wir nun Prozeduren für die Ereignisse Beim Löschen<\/b> und Nach Löschbestätigung <\/b>und noch eine Variable, die insgesamt wie folgt aussehen:<\/p>\n Die Erläuterung, warum die zuvor angeführten Prozeduren so aussehen, beschreiben wir im Detail im Beitrag Löschereignisse und -optionen im Zusammenspiel <\/b>(www.access-im-unternehmen.de\/1366<\/b>).<\/p>\n An dieser Stelle ist wichtig, dass entweder bei Ausbleiben der Bestätigungsmeldung oder beim Erscheinen und Bestätigen der Meldung die folgende Prozedur namens KundeZuletztLoeschen <\/b>aufgerufen wird:<\/p>\n Diese erhält den Wert des Feldes KundeID <\/b>als Parameter und stellt eine Löschabfrage zusammen, die beispielsweise wie folgt aussieht:<\/p>\n Diese wird im Anschluss mit der Execute<\/b>-Methode ausgeführt. Außerdem wird das Listenfeld lstKundenZuletzt <\/b>aktualisiert.<\/p>\n Eine weitere Frage ist, wie viele Datensätze Sie im Listenfeld der zuletzt geöffneten Datensätze anzeigen wollen und ob Sie überhaupt eine Begrenzung wünschen.<\/p>\n Die Folgefrage wäre dann: Auf welche Weise schränken wir die Anzeige ein Dazu gäbe es zwei Ideen:<\/p>\n Wenn Sie die Anzahl nicht begrenzen wollen, ist die natürliche Grenze die Anzahl der vorhandenen Kunden – irgendwann hat der Benutzer diese vielleicht alle einmal durchgeblättert und so sind sie dann alle in der Tabelle tblKundenZuletzt <\/b>aufgeführt.<\/p>\n Wir gehen allerdings davon aus, dass die Anzahl begrenzt sein soll, beispielsweise auf zehn. Die beiden vorgestellten Varianten schauen wir uns nacheinander an.<\/p>\n Diese Lösung würde etwa wie folgt aussehen – als Erstes deklarieren wir eine passende Konstante mit der Anzahl der maximal anzuzeigenden Datensätze:<\/p>\n Dann fügen wir der Prozedur LetzteDatensaetzeAktualisieren <\/b>einige Zeilen hinzu, die wie in Listing 3 aussehen.<\/p>\n Listing 3: Erweiterung der Prozedur LetzteDatensaetzeAktualisieren zum Herauslöschen überzähliger Einträge<\/span><\/b><\/p>\n Hier durchlaufen wir eine Do While<\/b>-Schleife solange, bis die Anzahl der in der Tabelle enthaltenen Einträge der Anzahl aus der Konstanten clngAnzahlLetzteKunden <\/b>plus Eins entspricht. Plus Eins deshalb, weil der aktuell angezeigte Datensatz immer bereits in der Tabelle tblKundenZuletzt <\/b>enthalten ist, aber nicht angezeigt wird.<\/p>\n Die DELETE<\/b>-Anweisung innerhalb der Do While<\/b>-Schleife löscht den aktuell ersten Datensatz der Tabelle tblKundenZuletzt<\/b>, also den mit dem kleinsten Wert im Feld KundeZuletztID <\/b>– und der sich somit am längsten in der Tabelle befindet. Die ID dieses Datensatzes ermittelt die folgende Unterabfrage:<\/p>\n Das einzige Problem dieser Vorgehensweise taucht auf, wenn Sie einen neuen, leeren Datensatz anzeigen. Dann sind sechs Datensätze in der Tabelle und alle werden angezeigt, weil der neue, leere Datensatz ja noch keinen Primärschlüsselwert hat und dieser entsprechend nicht aus der Anzeige herausgefiltert wird.<\/p>\n Um diesen kleinen Schönheitsfehler zu beheben, können Sie noch die nachfolgend beschriebene Technik hinzufügen.<\/p>\n Um die nun beschriebene Anpassung unabhängig von der vorherigen ausprobieren zu können, kommentieren wir die Do While<\/b>-Schleife vorübergehend wieder aus.<\/p>\n Dann öffnen Sie nochmals den Entwurf der Abfrage, die wir für die Eigenschaft Datensatzherkunft <\/b>des Listenfeldes hinterlegt haben. Für diese zeigen Sie nun das Eigenschaftenblatt an.<\/p>\n Wenn dieses noch nicht angezeigt wird, öffnen Sie es mit einem Rechtsklick auf den grauen Hintergrund im oberen Bereich des Abfrageentwurfs und anschließende Auswahl des Kontextmenüeintrags Eigenschaften<\/b>.<\/p>\n Hier stellen Sie nun die Eigenschaft Spitzenwerte <\/b>auf 5 <\/b>ein – oder auf den jeweils gewünschten Wert für die maximal anzuzeigenden Einträge (siehe Bild 12). <\/p>\n Bild 12: Einstellen der maximalen Anzahl<\/span><\/b><\/p>\n Da wir das Abfrageergebnis bereits absteigend nach dem Wert im Feld KundeZuletztID <\/b>sortieren, erhalten wir genau die richtigen fünf Einträge.<\/p>\n Sie können die beiden vorgenannten Methoden kombinieren, um sowohl nur eine maximale Anzahl von Datensätzen im Listenfeld anzuzeigen als auch um die Menge der Datensätze in der Tabelle tblKundenZuletzt <\/b>überschaubar zu halten.<\/p>\n Wenn Sie beide Methoden nutzen, bedenken Sie nur, dass Sie die maximale Anzahl gegebenenfalls an beiden Stellen, also sowohl für die Konstante im Code als auch für die Eigenschaft Spitzenwerte<\/b> im Abfrageentwurf einstellen müssen.<\/p>\n Sie können die Zeilen zum Löschen der überzähligen Datensätze in der Tabelle tblKundenZuletzt <\/b>natürlich auch nur einmal etwa beim Öffnen oder Schließen des Formulars einfügen, wenn Sie parallel über die Abfrage nur die für Spitzenwerte <\/b>angegebene Menge an Datensätzen zurückliefern. In der Prozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, sieht dies beispielsweise wie in Listing 4 aus.<\/p>\n Listing 4: Löschen überzähliger Einträge beim Laden des Formulars<\/span><\/b><\/p>\n Um die Liste zu leeren, fügen wir über der Liste noch eine Schaltfläche namens cmdLeeren<\/b> hinzu. Diese führt die folgende Prozedur aus und löscht damit alle Einträge der Tabelle tblKundenZuletzt<\/b>:<\/p>\n Dieser Beitrag zeigt, wie Sie ein Formular um ein Listenfeld erweitern, das die zuletzt angezeigten Datensätze des Formulars anzeigt. Dieses Feature ist sehr praktisch, wenn Sie zum Beispiel gerade Kundendaten eingeben und Ihnen auffällt, dass Sie beim vorher bearbeiteten Kunden noch eine Änderung vornehmen wollen – dann können Sie diesen per Doppelklick auf den passenden Eintrag im Listenfeld direkt anzeigen.<\/p>\n Und da der zuvor betrachtete Kunde dann ganz oben in der Liste eingefügt wird, können Sie genauso schnell wieder zu dessen Datensatz zurückspringen.<\/p>\n Es gibt noch weitere Ideen, die wir in folgenden Beiträgen umsetzen werden. So ließe sich beispielsweise die Liste der zuletzt verwendeten Kunden direkt in das Ribbon integrieren. Wie das gelingt, zeigen wir im Beitrag Zuletzt verwendete Datensätze im Ribbon <\/b>(www.access-im-unternehmen.de\/1371<\/b>).<\/p>\n Außerdem wäre es praktisch, wenn man die hier vorgestellte Funktionalität, die ja prinzipiell für alle möglichen Formulare praktisch ist, in eine Klasse auslagern und flexibel einsetzen könnte.<\/p>\n Auch dazu haben wir einen eigenen Beitrag namens Zuletzt verwendete Datensätze per Klasse <\/b>(www.access-im-unternehmen.de\/1374<\/b>) vorgesehen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n ZuletztBenutzteDatensaetzePerListenfeld.accdb<\/p>\nKonzept für die Liste zuletzt verwendeter Datensätze<\/h2>\n
Welche Datensätze speichern wir in der Liste der zuletzt verwendeten Datensätze<\/h2>\n
\n
Wo sollen die Informationen über die zuletzt verwendeten Datensätze gespeichert werden<\/h2>\n
\n
Anlegen der Tabelle zum Speichern der zuletzt angezeigten Datensätze<\/h2>\n
Welche Felder soll die Tabelle für die zuletzt angezeigten Datensätze enthalten<\/h2>\n
Entwurf der Tabelle tblKundenZuletzt<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_002.png\")
<\/p>\nBenötigen wir kein Feld in tblKundenZuletzt, das die Reihenfolge angibt<\/h2>\n
Prozedur erstellen, die den aktuellen Kunden zur Tabelle hinzufügt<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strINSERT As String<\/span>\r\n Dim <\/span>strDELETE As String<\/span>\r\n If <\/span>Not<\/span> IsNull(Me!KundeID) Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n strINSERT = \"INSERT INTO tblKundenZuletzt(Firma, KundeID) VALUES(''\" & Replace<\/span>(Me!Firma, \"''\", \"''''\") & \"'', \" _\r\n & Me!KundeID & \")\"\r\n db.Execute strINSERT, dbFailOnError\r\n Select Case Err.Number\r\n Case <\/span>Is = 3022\r\n strDELETE = \"DELETE FROM tblKundenZuletzt WHERE KundeID = \" & Me!KundeID\r\n db.Execute strDELETE, dbFailOnError\r\n db.Execute strINSERT, dbFailOnError\r\n Case <\/span>0\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler \" & Err.Number & vbCrLf<\/span> & vbCrLf<\/span> & Err.Description\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nINSERT INTO tblKundenZuletzt(Firma, KundeID) VALUES(''Centro comercial Moctezuma'', 13)<\/pre>\nDELETE FROM tblKundenZuletzt WHERE KundeID = 13<\/pre>\n
![\"Einige](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_003.png\")
<\/p>\nZuletzt verwendete Datensätze in Listenfeld anzeigen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_004.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_005.png\")
<\/p>\nDefinition der Anzeige im Listenfeld<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_006.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_007.png\")
<\/p>\nPrivate Sub <\/span>Form_Current()\r\n ...\r\n If <\/span>Not<\/span> IsNull(Me!KundeID) Then<\/span>\r\n ...\r\n Me!lstKundenZuletzt.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDen aktuellen Datensatz sofort anzeigen<\/h2>\n
![\"Anpassen](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_008.png\")
<\/p>\nEinen der zuletzt angezeigten Datensätze aufrufen<\/h2>\n
Private Sub <\/span>lstKundenZuletzt_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>strWhere As String<\/span>\r\n If <\/span>Not<\/span> IsNull(Me!lstKundenZuletzt) Then<\/span>\r\n strWhere = \"KundeID = \" & Me!lstKundenZuletzt\r\n Me.Recordset.FindFirst strWhere\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKundeID = 10<\/pre>\n
Änderungen der Bezeichnung in die Tabelle der zuletzt angezeigten Datensätze übernehmen<\/h2>\n
Private Sub <\/span>Form_AfterUpdate()\r\n LetzteDatensaetzeAktualisieren\r\nEnd Sub<\/span><\/pre>\nAnweisungen von Form_Current in eigene Routine ausgliedern<\/h2>\n
Private Sub <\/span>LetzteDatensaetzeAktualisieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strINSERT As String<\/span>\r\n Dim <\/span>strDELETE As String<\/span>\r\n If <\/span>Not<\/span> IsNull(Me!KundeID) Then<\/span>\r\n ...\r\n End If<\/span>\r\n Me!lstKundenZuletzt.Requery\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n LetzteDatensaetzeAktualisieren\r\nEnd Sub<\/span><\/pre>\nEinen neuen, leeren Datensatz anzeigen<\/h2>\n
... WHERE KundeID<>[Forms]![frmKundenZuletzt]![KundeID]<\/pre>\n
... WHERE KundeID<>Null<\/pre>\n
Test: IstNull(123<>[Forms]![frmKundenZuletzt]![KundeID])<\/pre>\n
![\"Ergebnis](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_009.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_010.png\")
<\/p>\nLöschen von Elementen aus der Tabelle der zuletzt aufgerufenen Datensätze<\/h2>\n
\n
![\"Meldung](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_011.png\")
<\/p>\nDim <\/span>lngKundeDeleteID As Long<\/span>\r\nPrivate Sub <\/span>Form_Delete(Cancel As Integer<\/span>)\r\n If <\/span>GetOption(\"Confirm Record Changes\") = 0 Then<\/span>\r\n KundeZuletztLoeschen Me!KundeID\r\n Else<\/span>\r\n lngKundeDeleteID = Me!KundeID\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_AfterDelConfirm(Status As Integer<\/span>)\r\n KundeZuletztLoeschen lngKundeDeleteID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>KundeZuletztLoeschen(lngKundeID As Long<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strDELETE As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n strDELETE = \"DELETE FROM tblKundenZuletzt WHERE KundeID = \" & lngKundeID\r\n db.Execute strDELETE, dbFailOnError\r\n Me!lstKundenZuletzt.Requery\r\nEnd Sub<\/span><\/pre>\nDELETE FROM tblKundenZuletzt WHERE KundeID = 123<\/pre>\n
Maximale Anzahl zuletzt geöffneter Datensätze<\/h2>\n
\n
Alte Einträge löschen, wenn maximale Anzahl erreicht ist<\/h2>\n
Const clngAnzahlLetzteKunden As Long<\/span> = 5<\/pre>\nPrivate Sub <\/span>LetzteDatensaetzeAktualisieren()\r\n ...\r\n Do While<\/span> DCount(\"KundeZuletztID\", \"tblKundenZuletzt\") > clngAnzahlLetzteKunden + 1\r\n strDELETE = \"DELETE FROM tblKundenZuletzt WHERE KundeZuletztID = (SELECT TOP 1 KundeZuletztID \" _\r\n & \"FROM tblKundenZuletzt)\"\r\n db.Execute strDELETE, dbFailOnError\r\n Loop<\/span>\r\n Me!lstKundenZuletzt.Requery\r\nEnd Sub<\/span><\/pre>\nSELECT TOP 1 KundeZuletztID FROM tblKundenZuletzt <\/pre>\n
Nur die x neuesten Einträge anzeigen<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2022_03\/pic_1365_012.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strDELETE As String<\/span>\r\n Do While<\/span> DCount(\"KundeZuletztID\", \"tblKundenZuletzt\") > clngAnzahlLetzteKunden + 1\r\n Set<\/span> db = CurrentDb\r\n strDELETE = \"DELETE FROM tblKundenZuletzt WHERE KundeZuletztID = (SELECT TOP 1 KundeZuletztID \" _\r\n & \"FROM tblKundenZuletzt)\"\r\n db.Execute strDELETE, dbFailOnError\r\n DoEvents\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nListe leeren<\/h2>\n
Private Sub <\/span>cmdLeeren_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strDELETE As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n strDELETE = \"DELETE FROM tblKundenZuletzt\"\r\n db.Execute strDELETE, dbFailOnError\r\n LetzteDatensaetzeAktualisieren\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n