<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Verwalten von Rezepten – das hört sich gar nicht nach einer Musterlösung für Unternehmen an. Oder sind nur Hotelköche angesprochen Nein. Neben dem Anspruch, ein Muster für eine Vielzahl von Anwendungen zu bieten, soll die vorliegende Musterlösung auch von einer Vielzahl von Anwendern auf ihre eigenen Bedürfnisse zugeschnitten werden können. <\/b><\/p>\n
Schließlich gibt es zu vielen Tätigkeiten „Rezepte“ bzw. Verfahrensvorschriften, deren Durchführung auch noch die Verwendung bestimmter Zutaten – z. B. bestimmter Formulare – erfordert. <\/p>\n
Neben der Verwaltung von Rezepten, Zutaten usw. werden Sie hier mit der Programmierung einer Schnittstelle konfrontiert. Diese dient dem Einlesen von fertigen Rezepten, von denen es im Internet Tausende gibt.<\/p>\n
Wenn Sie sich z. B. einmal unter dem Stichwort Meal-Master die in Google registrierten deutschsprachigen Seiten ausgeben lassen, finden Sie zurzeit etwa 1.200 Einträge. Von vielen Seiten können Sie Dateien herunterladen, die teilweise hunderte von Rezepten enthalten.<\/p>\n
Meal-Master ist ein amerikanisches Programm zur Verwaltung von Rezepten, das ein international anerkanntes Format für den Austausch von Rezepten enthält – die meisten verfügbaren Rezeptverwaltungen besitzen eine Funktion für den Import dieses Formats. <\/p>\n
In diesem Zusammenhang lernen Sie auch, wie Sie mit einer Schnittstelle Daten von anderen Anwendungen in Ihre Datenbank importieren können. Der hier vorgestellte Vorgang lässt sich allerdings nicht mit denjenigen Assistenten vergleichen, die beispielsweise den Import von Daten aus Excel- oder CSV-Dateien erleichtern. Vielmehr zeigt dieser Beitrag, wie Daten in eine komplexe Datenstruktur eingearbeitet werden können.<\/p>\n
Die Rezeptverwaltung soll neben ihrer eigentlichen Aufgabe, der Verwaltung von Rezepten, auch den Import und Export im Meal-Master-Format erlauben. Daher berücksichtigt das Datenmodell auch dessen weltweit gültiges Format, das in den folgenden Abschnitten kurz vorgestellt werden soll.<\/p>\n
Das Meal-Master-Format<\/b><\/p>\n
Meal-Master verwendet herkömmliche Textdateien. Es gibt eine genaue Spezifikation zur Festlegung der einzelnen Abschnitte eines Rezeptes. Ein Rezept besteht demnach aus den folgenden Angaben:<\/p>\n
Aus diesen Informationen können Sie das Datenmodell zur Abbildung der Rezepte in einem relationalen Datenbanksystem – wie es Access ist – direkt ableiten.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Datenmodell der Rezeptverwaltung<\/span><\/b><\/p>\n Das Rezept als Hauptobjekt des Datenmodells benötigt eine eigene Tabelle zur Speicherung der rezeptspezifischen Daten. In diese Tabelle gehören der Rezeptname, die Anzahl der Portionen und die Anleitung – Informationen, die für jedes Rezept genau einmal auftauchen.<\/p>\n Anders verhält es sich mit den Kategorien und Zutaten: Jedes Rezept kann einer oder mehreren Kategorien zugeordnet werden und für jedes Rezept benötigen Sie in der Regel mehrere Zutaten.<\/p>\n Das gilt in beiden Fällen sicher auch umgekehrt: Sie ordnen jeder Kategorie ein oder mehrere Rezepte zu und auch jede Zutat taucht in einem oder in mehreren Rezepten auf.<\/p>\n Sie benötigen also zwei m:n-Beziehungen – sowohl zwischen Rezepten und Kategorien als auch zwischen Rezepten und Zutaten.<\/p>\n Die erste Beziehung realisieren Sie mit einer einfachen Verknüpfungstabelle. Die zweite zwischen Rezepten und Zutaten ist etwas komplizierter. Hier müssen Sie zusätzlich noch Informationen über Einheit und Anzahl der Zutaten hinzufügen.<\/p>\n Da diese Informationen sich unter Umständen bei jeder Kombination aus Rezepten und Zutaten unterscheiden, können Sie diese nur in der Verknüpfungstabelle zwischen den Tabellen der Rezepte und der Zutaten unterbringen.<\/p>\n Die Tabelle tblRezepte<\/b><\/p>\n Der Rezeptname, die Anleitung und die Anzahl der Portionen für die angegebenen Zutatenmengen speichern Sie in einer Tabelle namens tblRezepte. Da die Anleitung vermutlich oft länger als 255 Zeichen ist, verwenden Sie für diese Information ein Memo-Feld.<\/p>\n Die Tabelle tblZutaten<\/b><\/p>\n Alle in der Datenbank verwendeten Zutaten speichern Sie in der Tabelle tblZutaten. Neben der Bezeichnung der Zutat enthält die Tabelle ein Bemerkungsfeld.<\/p>\n Die Tabelle tblKategorien<\/b><\/p>\n Die Tabelle tblKategorien dient dem Speichern der Kategorien. Auch hier ist ein Bemerkungsfeld vorgesehen.<\/p>\n Die Tabelle tblEinheiten<\/b><\/p>\n Da es im Meal-Master-Format fest vorgegebene Einheiten gibt, die immer wieder auftauchen, sollen sie in einer separaten Tabelle gespeichert werden. Da die Bezeichnungen sich der Herkunft des Formats entsprechend auf amerikanische Einheiten beziehen, soll die Tabelle neben der englischen Bezeichnung auch noch eine deutsche Bezeichnung für die Ausgabe enthalten.<\/p>\n Die TabelletblRezepteZutaten<\/b><\/p>\n Diese Tabelle speichert alle Zuordnungen zwischen Rezepten und Zutaten. Zusätzlich soll die Tabelle zu jeder Zuordnung die Einheit, die Anzahl der Einheiten und Bemerkungen speichern. Die Einheiten werden als Zahlenwert eingegeben, der sich auf die verknüpfte Tabelle tblEinheiten bezieht.<\/p>\n <\/b><\/p>\n Bild 2: Beispiel eines Rezeptes im Meal-Master-Format<\/span><\/b><\/p>\n Die beiden Felder RezeptID und ZutatID dienen als Fremdschlüsselfelder zu den entsprechenden Tabellen. Sie bilden allerdings keinen gemeinsamen Primärschlüssel.<\/p>\n Die Tabelle tblRezepteKategorien<\/b><\/p>\n Die Tabelle zur Herstellung der Beziehung zwischen Rezepten und Kategorien ist eine einfache Verknüpfungstabelle mit den Fremdschlüsselfeldern RezeptID und KategorieID zu den Tabellen tblRezepte und tblKategorien.<\/p>\n Die Beziehungen<\/b><\/p>\n Die Beschreibung der verwendeten Tabellen enthält bereits die wichtigsten Informationen zu den Beziehungen zwischen den Tabellen. Bild 1 zeigt eine Zusammenfassung der Tabellen und der Beziehungen zwischen den Tabellen. Für alle Beziehungen soll referentielle Integrität bestehen.<\/p>\n Die Eingabe von Test- und anderen Daten ist in der Regel wenig unterhaltsam – zumindest, wenn Sie die Daten stur von einer Vorlage übernehmen müssen.<\/p>\n Daher sorgen Sie nun zunächst einmal für eine Schnittstelle zum Import von bestehenden Daten im Meal-Master-Format.<\/p>\n Zwar ist auch das Erstellen von Schnittstellen nicht gerade beflügelnd, aber deren anschließende Anwendung und die daraus resultierende Zeitersparnis ist ein guter Grund, diese Arbeit in Kauf zu nehmen. <\/p>\n Das Import-Format<\/b><\/p>\n Die Dateien mit den Meal-Master-Rezepten sind reine Textdateien. Glücklicherweise haben Sie eine einigermaßen regelmäßige Struktur – was bei einem weltweit verwendeten Format vorausgesetzt werden kann. Die Frage, warum ein solch verbreitetes Format nicht auf dem Stand der Zeit ist – beispielsweise in Form einer XML-Datei -, ist wohl ebenfalls mit der weltweiten Verwendung und der Beliebtheit zu erklären. Je mehr Anwender mit einem Produkt arbeiten, desto mehr Widerstand regt sich gegen die Einführung neuer Standards.<\/p>\n Eine Meal-Master-Datei besteht aus einem oder mehreren Rezepten, die untereinander in die Datei eingetragen sind. Jedes Rezept hat eine fest definierte erste und letzte Zeile. Die erste Zeile beginnt mit fünf großen M oder fünf Minuszeichen (-) und beinhaltet irgendwo dahinter die Zeichenfolge Meal-Master. Die letzte Zeile beginnt ebenso, ist aber nach diesen fünf Zeichen bereits zu Ende.<\/p>\n Dazwischen befinden sich drei Abschnitte: Im ersten, fest definierten Teil stehen Angaben zum Namen des Rezepts, zur Anzahl der Portionen für die angegebene Menge Zutaten und zu den Kategorien, denen das Rezept zugeordnet werden kann.<\/p>\n Im zweiten Teil befinden sich die Zutaten. Die Zutaten werden in ein oder zwei Spalten aufgelistet, wobei feste Bereiche der Zeile für die Informationen Menge, Einheit und Zutat vorgesehen sind.<\/p>\n Der dritte Teil beinhaltet schließlich die eigentliche Anleitung. Bild 2 zeigt ein Beispielrezept im Meal-Master-Format.<\/p>\n Diese Darstellung kann als einfachste Ausführung eines Rezeptes in diesem Format angesehen werden. Umfangreichere Rezepte besitzen weitere Zeilen, die z. B. die Zutaten nach den einzelnen Bestandteilen des Rezeptes aufteilen oder die einfach als Kommentarzeilen – beispielsweise zur Angabe der Herkunft eines Rezeptes – dienen. Solche Besonderheiten spart die im Folgenden erstellte Import-Routine aus Gründen der übersichtlichkeit allerdings aus.<\/p>\n Daten importieren<\/b><\/p>\n Quellcode 1<\/b><\/p>\n Die übernahme von Daten aus Textdateien, die auf anderen Formaten als XML oder CSV basieren, bringt in der Regel Nacharbeit mit sich. Da die Dateien teilweise sehr große Mengen Rezepte enthalten – tausend und mehr sind keine Seltenheit -, soll die Datenbank den Inhalt der Datei zunächst einmal einlesen. Anschließend kann der Anwender dann bestimmen, welche Rezepte er in seine eigene Sammlung aufnehmen möchte.<\/p>\n Für die Zwischenspeicherung der Daten benötigen Sie eine Tabelle namens tblRezepttexte. Die Tabelle speichert die Daten so lange, bis der Anwender sie in seine Sammlung übernimmt.<\/p>\n Die Prozedur aus Quellcode 1 liest die Daten aus der Textdatei zeilenweise in die Tabelle tblRezepttexte ein.<\/p>\n Nach dem Deklarieren und Initialisieren der Objektvariablen öffnet die Prozedur mit der Open-Anweisung die Datei mit dem in dem Parameter Quelldatei angegebenen Namen.<\/p>\n Anschließend liest sie die Datei bis zum Erreichen des Dateiendes zeilenweise ein. Dabei berücksichtigt die Prozedur, ob ein neues Rezept beginnt, und setzt die Variable Rezeptnummer auf den Wert, der um 1 größer als der größte bisher vergebene Wert ist. Die Variable Zeilennummer wird mit jeder Zeile um 1 erhöht.<\/p>\n Beide Variablen werden mit dem Inhalt der Zeile und dem Datum des Einlesens in je einem Datensatz für jede Zeile in der Tabelle tblRezepttexte gespeichert.<\/p>\n Nach dem Einlesen ist kein weiterer Zugriff auf die Datei mehr erforderlich. Von nun an können alle benötigten Informationen zu den einzelnen Rezepten aus der Tabelle tblRezepttexte gelesen werden.<\/p>\n <\/b><\/p>\n Bild 3: Formular zur übernahme von Rezepten<\/span><\/b><\/p>\n Die Funktion beinhaltet eine kleine Fehlerbehandlung, die bei Nichtvorhandensein der Datei mit dem übergebenen Namen eine entsprechende Meldung ausgibt.<\/p>\n Daten übernehmen<\/b><\/p>\n Der Import von Daten ist mit dem Einlesen der Daten in die Tabelle tblRezepttexte abgeschlossen, da nunmehr kein weiterer Zugriff auf die verwendete Datei mehr erforderlich ist. Im weiteren Verlauf sollen die Daten allerdings noch in das beschriebene Datenmodell übernommen werden. Zur komfortablen Auswahl der gewünschten Rezepte und zur Einleitung der anschließenden Konvertierung der vorhandenen Daten in das Datenmodell verwenden Sie ein geeignetes Formular.<\/p>\n Daten aus einer Textdatei in einer weiter verwertbaren Form in eine Datenbank zu bugsieren, ist keine besondere Kunst. Viel interessanter ist die übernahme der eingelesenen Daten in ein Datenmodell, das aufgrund seiner relationalen Struktur zwar wesentlich komplexer ist als der Ursprung der Daten, aber auch vielfältigere Möglichkeiten bietet.<\/p>\n <\/p>\n Nun gilt es, die eingelesenen Daten präzise zu identifizieren und in den entsprechenden Tabellen zu speichern. Für den Komfort des Anwenders ist da – wie üblich – ein Formular erforderlich.<\/p>\n Das Formular soll alle eingelesenen Rezepte in einem Listenfeld anzeigen und die Möglichkeit bieten, per Knopfdruck beliebige Rezepte auszuwählen und in die Datenbank zu übernehmen. Außerdem soll eine Schaltfläche zum Löschen und eine zum Einlesen weiterer Dateien vorhanden sein (siehe Bild 3).<\/p>\n Datei einlesen<\/b><\/p>\n Das Einlesen von Dateien sei hier nur in Grundzügen dargestellt: Die Anwendung bietet einen Dialog zur Eingabe der gewünschten Datei an. Der Dialog wird über eine herkömmliche InputBox-Anweisung aufgerufen.<\/p>\n Im Anschluss an die Eingabe des Dateinamens ruft die Prozedur aus Quellcode 2 direkt die Funktion RezepttexteEinlesen auf.<\/p>\n Nach dem Einlesen der Datei aktualisiert die Prozedur die Liste mit den neuen Einträgen per Requery-Anweisung.<\/p>\n <\/b><\/p>\n Bild 4: Eingabe des Dateinamens<\/span><\/b><\/p>\n Anzeige der Einträge<\/b><\/p>\n Quellcode 2<\/b><\/p>\n <\/b><\/p>\n Bild 5: Die Abfrage <\/span><\/b><\/p>\n Nicht ganz einfach ist die Anzeige der Rezeptnamen anhand der Daten aus der Tabelle tblRezepttexte. Da die Tabelle alle Zeilen der eingelesenen Rezepte enthält, müssen zunächst jene Zeilen ausfindig gemacht werden, die den Namen des Rezeptes enthalten. Nur diese sind anschließend zu extrahieren. <\/p>\n Bei dieser Aufgabe hilft Ihnen eine Abfrage namens qryRezepttitel. Diese Abfrage verwendet zwei Funktionen, um die gesuchten Informationen in der Tabelle tblRezepttexte zu finden. Die erste Funktion ermittelt alle Zeilen, in denen die Zeichenkette Title: enthalten ist. Sie gibt einen Wert größer 0 für alle entsprechenden Zeilen zurück:<\/p>\n Die zweite Funktion ermittelt den Titel des Rezeptes in den gefundenen Zeilen:<\/p>\n Leider können Abfragen keine Sortierung auf Felder enthalten, die auf die beschriebene Weise ermittelt wurden. Daher benötigen Sie noch eine weitere Abfrage, um die gefundenen Werte zu sortieren. Diese Abfrage basiert auf der soeben beschriebenen Abfrage und sortiert diese nach dem Feld Titel (siehe Bild 6).<\/p>\n <\/b><\/p>\n Bild 6: Abfrage zur Sortierung des Ergebnisses einer weiteren Abfrage<\/span><\/b><\/p>\n Diese Abfrage dient schließlich als Datenherkunft für das Listenfeld in dem Formular frmUebernehmen.<\/p>\n Rezept übernehmen<\/b><\/p>\n Das übernehmen der Rezepte in das vorliegende Datenmodell ist relativ programmierintensiv. Daher können leider nicht alle verwendeten Prozeduren und Funktionen im Detail vorgestellt werden. Sie erhalten aber in jedem Fall einen überblick über den gesamten Ablauf mit einer Vertiefung zu besonders wichtigen Abschnitten.<\/p>\n Nahezu alle Tabellen der Beispieldatenbank sind mit GUIDs als Primärschlüsseln ausgestattet. GUIDs haben gegenüber herkömmlichen Primärindizes den Vorteil, dass sie sicher einzigartig sind und daher bereits vor dem Abschließen von Datenbankoperationen als Primärschlüsselwert bestimmter Datensätze angenommen und beliebig weiterverarbeitet werden können. Weitere Informationen über diese Art von Primärschlüssel und die Besonderheiten bei deren Verwendung finden Sie im Beitrag Die Geheimnisse der GUID, den Sie im .pdf-Format auf der Heft-CD finden. <\/p>\n Die übernahme eines Rezeptes erfolgt in folgenden Schritten:<\/p>\n Die Steuerung des gesamten Vorgangs erfolgt durch die Prozedur, die beim Betätigen der Schaltfläche Rezept übernehmen des Formulars frmUebernehmen ausgelöst wird.<\/p>\n Diese Prozedur liest sämtliche Informationen in einer Form ein, die weitere Funktionen leicht weiterverarbeiten können.<\/p>\n Die verwendeten Zutaten inklusive Einheit und Menge werden beispielsweise in der temporären Tabelle tblZutatenTemp gespeichert und die durch Komma getrennten Kategorien werden in einer String-Variablen abgelegt, um später weiter verarbeitet werden zu können.<\/p>\n Nach dem Einlesen der Informationen zum jeweiligen Rezept startet die Prozedur noch zwei weitere Prozeduren zum Eintragen der Kategorien und Zutaten in die entsprechenden Tabellen.<\/p>\n Der Vorgang soll am Beispiel des Eintragens der Kategorien erläutert werden – das Eintragen der Zutaten ist wesentlich aufwändiger und würde den Rahmen des vorliegenden Beitrags sprengen.<\/p>\n Quellcode 3<\/b><\/p>\n Eintragen der Kategorien<\/b><\/p>\n Die Kategorien liegen als Zeichenkette in einer entsprechenden Variablen vor. Ziel ist nun, die einzelnen Kategorien in die Tabelle tblKategorien einzutragen – sofern sie dort noch nicht vorhanden sind – und anschließend für jede Kategorie einen Eintrag in der Tabelle tblRezepteKategorien zu erstellen, um die Kategorien dem entsprechenden Rezept zuzuordnen. Diese Aufgabe übernimmt die Funktion KategorienEintragen (s. Quellcode 3).<\/p>\n Die aufrufende Prozedur übergibt als Parameter die Kategorie-Liste und den Wert der RezeptID. In einer Do While-Schleife arbeitet die Funktion die einzelnen Elemente der durch Kommata getrennten Auflistung durch und trägt sie einzeln in die Tabellen ein.<\/p>\n Solange noch mehr als ein Eintrag in der Zeichenkette enthalten ist – also mindestens noch ein Komma gefunden wird -, schneidet die Funktion jeweils den Teil vor dem Komma ab und behandelt ihn als eigene Kategorie. Falls in der Zeichenkette kein Komma mehr vorhanden ist, wird der Rest der Zeichenkette als Kategorie ausgewertet.<\/p>\n Mit einer DLookup-Funktion überprüft die Funktion, ob die Tabelle tblKategorien bereits eine Kategorie gleichen Namens enthält, und ermittelt ggf. die KategorieID des Eintrags in der Tabelle tblKategorien.<\/p>\n <\/b><\/p>\n Bild 7: Das Formular zur Eingabe und zum Bearbeiten der Rezepte<\/span><\/b><\/p>\n Falls der Eintrag noch nicht vorhanden ist, legt die Funktion einen neuen Eintrag für diese Kategorie in der Tabelle tblKategorien mit einer neu ermittelten GUID als KategorieID an.<\/p>\n In beiden Fällen wird anschließend in der Tabelle tblRezepteKategorien ein neuer Eintrag mit den Werten RezeptID und KategorieID angelegt, um die Verknüpfung zwischen Rezept und Kategorie herzustellen. Damit sind die Kategorien des Rezeptes in das Datenmodell eingebunden.<\/p>\n Eintragen der Zutaten<\/b><\/p>\n Aufgrund der größeren Menge der zu erfassenden Daten und wesentlich komplizierteren Struktur der zu verwertenden Daten ist das Eintragen der Zutaten in die Tabellen tblZutaten und tblRezepteZutaten schwieriger als bei den Kategorien. Wenn Sie an dem Algorithmus interessiert sind, sehen Sie sich im Modul mdlSchnittstelle die Funktion ZutatenEintragen an.<\/p>\n Die Benutzeroberfläche besteht aus drei Haupt- und zwei Unterformularen. Schaltzentrale ist das Formular frmRezepte mit seinen Funktionen zur Eingabe und Bearbeitung von Rezepten und zum Aufrufen der anderen beiden Hauptformulare. Das Formular beherbergt außerdem beide Unterformulare der Anwendung.<\/p>\n Das erste der beiden Formulare namens frmUebernehmen haben Sie bereits kennen gelernt.<\/p>\n Das zweite ist das Formular frmSuche. Es bietet einfache Suchmöglichkeiten und kann gefundene Rezepte im Formular frmRezepte anzeigen.<\/p>\n Das Hauptformular frmRezepte<\/b><\/p>\n Das Hauptformular der Anwendung ist das Formular frmRezepte. Es dient der Anzeige eines Rezeptes und bietet die Möglichkeit, mit geeigneten Schaltflächen weitere Funktionen aufzurufen.<\/p>\n Dazu gehören der schon beschriebene Import von Rezeptdateien und einzelnen Rezepten, eine einfache Suche nach Rezepten sowie die Ausgabe eines Rezeptes in Form eines Berichtes.<\/p>\n Bild 7 zeigt die Formularansicht des Formulars frmRezepte. Neben den Schaltflächen beinhaltet das Formular die Steuerelemente zur Anzeige der Rezeptdaten. Dazu gehören drei Textfelder: für den Rezeptnamen, für die Anzahl der Portionen und für die Beschreibung.<\/p>\n <\/b><\/p>\n Bild 8: Das Unterformular sfmKategorien<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 9: Datenherkunft des Unterformulars sfmKategorien<\/span><\/b><\/p>\n Zwei Unterformulare dienen der Anzeige der Kategorien und der Zutaten, die dem Rezept zugeordnet sind.<\/p>\n Das Formular besitzt zwei Schaltflächen zum Anzeigen der Vorschau bzw. zum Ausdrucken des Rezepts in Form eines Berichtes. Beide Schaltflächen verwenden fast die gleiche Ereignisprozedur, um den Bericht repRezepte aufzurufen. Der einzige Unterschied liegt im Parameter View:<\/p>\n Das Unterformular sfmKategorien<\/b><\/p>\n Das erste von zwei Unterformularen des Formulars frmRezepte dient der Anzeige der zugeordneten Kategorien in der Datenblattansicht. Die Entwurfsansicht des Formulars erscheint recht einfach – sie enthält lediglich das Feld KategorieID (siehe Bild 8). Dieses ist an das Feld KategorieID der Datenherkunft des Formulars, der Abfrage qryRezepteKategorien (siehe Bild 9), gebunden und hat als Datensatzherkunft die folgende SQL-Anweisung:<\/p>\n Zusammengefasst bedeutet dies, dass das Unterformular alle Datensätze der Tabelle tblKategorien anzeigt, die mit dem aktuellen Datensatz des Hauptformulars frmRezepte verknüpft sind – und das in aufsteigender alphabetischer Reihenfolge.<\/p>\n Das Kombinationsfeld KategorieID bietet alle Datensätze der Tabelle tblKategorien zur Auswahl an.<\/p>\n Wenn Sie das Unterformular in das Hauptformular einbinden, stellt Access normalerweise automatisch die beiden Eigenschaften Verknüpft von und Verknüpft nach auf den Wert RezeptID ein.<\/p>\n Diese Verknüpfung kann zu Fehlern führen: Sie haben ja in der Tabelle tblRezepteKategorien einen zusammengesetzten Primärschlüssel festgelegt, der aus den beiden Feldern RezeptID und KategorieID besteht.<\/p>\n Der erste denkbare Fehler kann durch die zweimalige Zuordnung einer Kategorie zu ein und demselben Rezept entstehen – der klassische Fall einer Schlüsselverletzung. Die zweite klassische Möglichkeit, einen Fehler in einem mit dem Hauptformular verknüpften Unterformular auszulösen, ist das Anlegen eines Datensatzes im Unterformular vor dem Anlegen eines Datensatzes im Hauptformular.<\/p>\n Die resultierende Fehlermeldung können Sie umgehen und durch eine eigene, für den Benutzer aussagekräftigere Fehlermeldung ersetzen. Dazu hinterlegen Sie für die Ereigniseigenschaft Bei Fehler des Formulars die Prozedur aus Quellcode 4.<\/p>\n Quellcode 4<\/b><\/p>\n Die Prozedur hat zwei Parameter – die Nummer des auslösenden Fehlers, die mit dem Parameter DataErr an die Prozedur übergeben wird, und den Rückgabewert Response. Die Prozedur fragt die Fehlernummer ab und reagiert in einem Select Case-Konstrukt mit einer entsprechenden Aktion.<\/p>\n Für den Fall, dass der Anwender eine Kategorie anlegt, bevor der Datensatz des Hauptformulars gespeichert ist, zeigt die Prozedur eine Meldung an und macht die Eingabe rückgängig.<\/p>\n Falls der Benutzer eine bereits ausgewählte Kategorie erneut auswählt, erscheint ebenfalls eine Meldung. Durch die Angabe des Wertes False für den Rückgabeparameter Response unterbinden Sie die Ausgabe der herkömmlichen Fehlermeldung.<\/p>\n Das Unterformular sfmRezepteZutaten<\/b><\/p>\n Das zweite Unterformular arbeitet prinzipiell wie das Unterformular frmKategorien. Die zwei wesentlichen Unterschiede sind die höhere Anzahl von Feldern sowie die Möglichkeit, eine Zutat auch mehr als einmal auszuwählen. Das ist erforderlich, da Meal-Master die Möglichkeit bietet, die Zutaten auf die einzelnen Bestandteile des Rezeptes aufzuteilen – z. B. Soße, Gemüse, Salat usw.<\/p>\n Das Hauptformular frmSuche<\/b><\/p>\n Das Suchformular dient als kleine Hilfe bei der Auswahl von Rezepten. Dabei bietet es die Möglichkeit, einen Text einzugeben, der im Namen des Rezeptes gesucht wird. Außerdem können Sie gezielt nach den Zutaten suchen, falls Sie Appetit auf etwas Spezielles entwickeln. Wenn Sie beispielsweise etwas Pikantes suchen, wird die Auswahl von Peperoni, Knoblauch und Chili wohl ein geeignetes Rezept liefern – wenn ein entsprechendes gespeichert ist.<\/p>\n Bild 10 zeigt das Suchformular mit den Steuerelementen zum Filtern der Einträge des Listenfeldes.<\/p>\n Die drei Kombinationsfelder haben jeweils die Abfrage qryZutaten als Datensatzherkunft. Die Abfrage hat folgenden SQL-Ausdruck:<\/p>\n <\/b><\/p>\n Bild 10: Formular zur Suche von Rezepten<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 11: Bericht zur Ausgabe von Rezepten<\/span><\/b><\/p>\n Quellcode 5 (erster Teil)<\/b><\/p>\n Das Textfeld und die drei Kombinationsfelder lösen nach ihrer Aktualisierung eine Prozedur aus, die Sie für die entsprechende Ereigniseigenschaft hinterlegen (s. Quellcode 5).<\/p>\n Die Prozedur setzt anhand der gewählten Parameter einen SQL-Ausdruck zusammen.<\/p>\n Dann weist sie den SQL-Ausdruck der Eigenschaft Datensatzherkunft des Listenfeldes zu. Das Listenfeld zeigt die gefundenen Datensätze an und ermöglicht den Aufruf einer Detailansicht durch einen Doppelklick auf den gewünschten Eintrag. Dafür ist eine Prozedur verantwortlich, die Sie für die Ereigniseigenschaft Beim Doppelklicken hinterlegen (s. Quellcode 6).<\/p>\n Die ungewohnte Schreibweise des Wertes, der mit dem Parameter WhereCondition übergeben wird, ist für GUIDs erforderlich. Wenn Sie sich die Beispieldatenbank genau ansehen, werden Sie noch weitere Besonderheiten bezüglich des Umgangs mit GUIDs herausfinden.<\/p>\n Der Bericht repRezepte ist der einzige Bericht der Datenbank und dient der Ausgabe jeweils eines einzigen Rezeptes. Bild 11 zeigt die Vorschauansicht des Berichts für ein Beispielrezept.<\/p>\n Als Datenherkunft des Berichts dient die Tabelle tblRezepte. Sie beinhaltet die wesentlichen Daten mit Ausnahme der Kategorien und der Zutaten. Die Kategorien werden während des Formatierens des Berichts automatisch zusammengestellt. Die Zutaten befinden sich in einem in den Bericht integrierten Unterbericht namens srpRezepte.<\/p>\n Zusammenstellung der Kategorien<\/b><\/p>\n Quellcode 5 (Fortsetzung)<\/b><\/p>\n Quellcode 6<\/b><\/p>\n Quellcode 7<\/b><\/p>\n Die Kategorien werden zum Zeitpunkt des Formatierens des Detailbereichs des Berichts dynamisch zusammengestellt. Dazu benutzt die Anwendung die Ereigniseigenschaft Beim Formatieren, die beim Aufrufen des Berichts mindestens einmal (in Abhängigkeit von der Komplexität des Berichts kann das auch mehrmals geschehen) aufgerufen wird.<\/p>\n Die verantwortliche Prozedur finden Sie in Quellcode 7. Nach den erforderlichen Deklarationen weist die Prozedur dem Objekt rstKategorien eine Datensatzgruppe mit allen Kategorien zu, die mit dem angezeigten Rezept verknüpft sind.<\/p>\n Anschließend durchläuft sie per Do While-Schleife alle gefundenen Kategorien und setzt diese zu einer durch Kommata getrennten, vom Wort Kategorien: angeführten Liste zusammen. <\/p>\n Der Unterbericht zur Anzeige der Zutaten<\/b><\/p>\n Der Unterbericht srpRezepteZutaten dient der Anzeige der Zutaten des im Hauptbericht angezeigten Rezeptes.<\/p>\n Es enthält die drei Felder Anzahl, Einheit (in der Abbildung nicht genau zu erkennen) und Zutat. Wichtig ist hier, dass Sie die Eigenschaft Vergrößerbar des Feldes Zutat auf den Wert Ja einstellen. Anderenfalls zeigt der Bericht nur den Text an, der in die erste Zeile des Textfeldes passt und unterschlägt den Rest.<\/p>\n <\/b><\/p>\n Bild 12: Unterbericht zur Anzeige der Zutaten eines Rezeptes<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 13: Datenherkunft des Unterberichts<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 14: Seiteneigenschaften des Unterberichts<\/span><\/b><\/p>\n Als Datenherkunft des Unterberichts verwenden Sie die Abfrage qryRezepteZutaten (siehe Bild 13). Der Wert des Feldes RezeptID wird zwar nicht im Unterbericht angezeigt, aber Sie benötigen ihn für die Verknüpfung zum Hauptbericht. Der Unterbericht soll schließlich nur die Zutaten anzeigen, die mit dem im Hauptbericht angezeigten Rezept verknüpft sind.<\/p>\n Die Datensätze sollen in zwei Spalten angezeigt werden. Die dafür nötige Einstellung nehmen Sie bei aktivierter Entwurfsansicht in den Seiteneigenschaften vor, die Sie nur über den Menübefehl Datei\/Seiten einrichten… aufrufen können.<\/p>\n Passen Sie die Werte entsprechend Bild 14 an. Wichtig ist vor allem die Einstellung des Spaltenlayouts. Wenn Sie die erste Hälfte der Zutaten in der entsprechenden Reihenfolge auf der linken Seite und die zweite Hälfte auf der rechten Seite sehen möchten, werden Sie hier enttäuscht:<\/p>\n Wenn Sie nämlich die Option Nach unten, dann quer wählen, teilt Access die Zutaten nicht auf beide Spalten gleich auf, sondern füllt erst die linke Spalte bis zum unteren Rand. Beachten Sie bei Angabe der Spaltenbreite und des Spaltenabstands, dass die Summe der Breiten und Abstände nicht größer als die Breite des verfügbaren Bereichs im Hauptbericht werden darf.<\/p>\n Aufbau des Hauptberichts<\/b><\/p>\n Der Hauptbericht birgt keine weiteren Besonderheiten. Beachten Sie, dass die Eigenschaften Verknüpft von und Verknüpft nach des Unterberichts beide auf den Wert RezeptID eingestellt sind.<\/p>\n Die Musterlösung enthält eine Menge Stoff, den Sie vermutlich erst bei genauerer Untersuchung der Beispieldatenbank finden werden.<\/p>\n Die Anwendung bietet zahllose Erweiterungsmöglichkeiten:<\/p>\n Enthaltene Beispieldateien:<\/p>\n Rezepte2000.mdb<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic002.png\")
<\/p>\nHinweis<\/h3>\n
Function RezepttexteEinlesen(Quelldatei As String)\r\n Dim Zeile As String\r\n Dim Rezepttext As String\r\n Dim Rezeptnummer As Integer\r\n Dim Zeilennummer As Integer\r\n Dim db As Database\r\n Dim rstRezepttexte As Recordset\r\n On Error GoTo RezepttexteEinlesen_Err\r\n Set db = CurrentDb\r\n Set rstRezepttexte = _ db.OpenRecordset(\"tblRezepttexte\", _ dbOpenDynaset)\r\n Open Quelldatei For Input As #1\r\n Do While Not EOF(1)\r\n Line Input #1, Zeile\r\n If (Left(Zeile, 5) = \"MMMMM\" _ Or Left(Zeile, 5) = \"-----\") _ And InStr(1, Zeile, \"Meal-Master\") > 0 Then\r\n Zeilennummer = 1\r\n Rezeptnummer = Nz(DMax(\"Rezeptnummer\", _ \"tblRezepttexte\"), 0) + 1\r\n End If\r\n rstRezepttexte.AddNew\r\n rstRezepttexte!Rezepttext = Zeile\r\n rstRezepttexte!Rezeptnummer = Rezeptnummer\r\n rstRezepttexte!Zeilennummer = Zeilennummer\r\n rstRezepttexte!EingelesenAm = Date\r\n rstRezepttexte.Update\r\n Zeilennummer = Zeilennummer + 1\r\n Loop\r\n Close #1\r\n Exit Sub\r\nRezepttexteEinlesen_Err:\r\n If Err.Number = 76 Then\r\n MsgBox \"Die Datei konnte nicht gefunden \" _ & \"werden.\", vbExclamation + vbOKOnly, _ \"Dateifehler\"\r\n Exit Function\r\n Else\r\n MsgBox \"Fehler: \" & Err.Number & \" \" _ & Err.Description\r\n End If\r\nEnd Function<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic004.png\")
<\/p>\nPrivate Sub cmdDateiEinlesen_Click()\r\n Dim Dateiname As String\r\n Dateiname = InputBox(\"Bitte geben Sie den Namen der Datei im \" _ & \"Meal-Master-Format ein.\", \"Dateinamen eingeben\")\r\n RezepttexteEinlesen Dateiname\r\n Me.lstRezepte.Requery\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic005.png\")
<\/p>\nTitelVorhanden: TeilStr(1;[Rezepttext];\"Title:\")<\/pre>\n
Titel: TeilStr([Rezepttext];[TitelVorhanden]+7;Länge([Rezepttext])-[TitelVorhanden]+6)<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic006.png\")
<\/p>\nHinweis<\/h3>\n
Function KategorienEintragen(Kategorien As String, RezeptID As String)\r\n Dim Kategorie As String\r\n Dim KategorieID As String\r\n Dim strSQL As String\r\n Do While Not Len(Trim(Kategorien)) = 0\r\n If InStr(1, Kategorien, \",\") > 0 Then\r\n Kategorie = Trim(Left(Kategorien, InStr(1, Kategorien, \",\") - 1))\r\n Kategorien = Mid(Kategorien, InStr(1, Kategorien, \",\") + 1, _ Len(Kategorien) - InStr(1, Kategorien, \",\"))\r\n Else\r\n Kategorie = Trim(Kategorien)\r\n Kategorien = \"\"\r\n End If\r\n KategorieID = Nz(DLookup(\"StringFromGuid([KategorieID])\", \"tblKategorien\", _ \"Kategorie = ''\" & Kategorie & \"''\"), \"\")\r\n If KategorieID = \"\" Then\r\n KategorieID = CreateGUID\r\n strSQL = \"INSERT INTO tblKategorien(KategorieID, Kategorie) \" _ & \"VALUES({guid \" & KategorieID & \"}, ''\" & Kategorie & \"'')\"\r\n DoCmd.RunSQL strSQL\r\n End If\r\n DoCmd.RunSQL \"INSERT INTO tblRezepteKategorien(RezeptID, KategorieID) \" _ & \" VALUES({guid \" & RezeptID & \"}, {guid \" & KategorieID & \"})\"\r\n Loop\r\nEnd Function<\/pre>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic007.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic008.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic009.png\")
<\/p>\nRezept drucken und Vorschau anzeigen<\/h3>\n
Private Sub cmdRezeptDrucken_Click()\r\n DoCmd.OpenReport \"repRezept\", _ View:=acNormal, _ WhereCondition:=\"RezeptID = \" _ & StringFromGUID _ (Forms!frmRezepte!RezeptID)\r\nEnd Sub<\/pre>\n
SELECT tblKategorien.KategorieID, tblKategorien.Kategorie\r\nFROM tblKategorien\r\nORDER BY tblKategorien.Kategorie;<\/pre>\n
Unterbinden von Eingabefehlern<\/h3>\n
Private Sub Form_Error(DataErr As Integer, Response As Integer)\r\n Select Case DataErr\r\n Case 3058\r\n MsgBox \"Bitte geben Sie zunächst einen Rezeptnamen ein.\", _ vbExclamation + vbOKOnly, \"Eingabefehler\"\r\n Me.Undo\r\n Response = False\r\n Case 3022\r\n MsgBox \"Sie haben diese Kategorie bereits ausgewählt. Bitte wählen Sie \" _ & \" eine andere Kategorie aus.\", vbExclamation + vbOKOnly, _ \"Eingabefehler\"\r\n Me.Undo\r\n Response = False\r\n Case Else\r\n MsgBox DataErr\r\n Response = False\r\n End Select\r\nEnd Sub<\/pre>\n
SELECT tblZutaten.ZutatID, tblZutaten.Zutat\r\nFROM tblZutaten\r\nORDER BY tblZutaten.Zutat;<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic010.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic011.png\")
<\/p>\nPrivate Sub SucheStarten()\r\n Dim strSQL As String\r\n strSQL = \"SELECT tblRezepte.RezeptID, \" _ & \"tblRezepte.Rezept FROM tblRezepte WHERE \" _ & \"Rezept LIKE ''*\" & Me.txtRezeptname & \"*''\"<\/pre>\n
If Not IsNull(Me.cboZutat1) Then\r\n strSQL = strSQL & \" AND RezeptID IN (SELECT \" _ & \" tblRezepteZutaten.RezeptID FROM \" _ & \"tblRezepteZutaten WHERE ZutatID = \" _ & \"{guid \" & Me.cboZutat1 & \"})\"\r\n End If\r\n '' entsprechende Anweisungen für die beiden weiteren Kombinationsfelder\r\n Me.lstSuchergebnis.RowSource = strSQL\r\n Me.lstSuchergebnis.Requery\r\nEnd Sub<\/pre>\nPrivate Sub lstSuchergebnis_DblClick(Cancel As Integer)\r\n DoCmd.OpenForm \"frmRezepte\", WhereCondition:=\"RezeptID = {guid \" & Me.lstSuchergebnis & \"}\"\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\nPrivate Sub Detailbereich_Format(Cancel As Integer, _ FormatCount As Integer)\r\n Dim db As Database\r\n Dim rstKategorien As Recordset\r\n Dim Kategorien As String\r\n Set db = CurrentDb\r\n Set rstKategorien = db.OpenRecordset(\"SELECT \" _ & \"Kategorie FROM qryRezepteKategorien WHERE \" _ & \" RezeptID = \" & _ StringFromGUID(Forms!frmRezepte!RezeptID), _ dbOpenDynaset)\r\n Do While Not rstKategorien.EOF\r\n Kategorien = Kategorien & \", \" _ & rstKategorien!Kategorie\r\n rstKategorien.MoveNext\r\n Loop\r\n If Len(Trim(Kategorien)) > 0 Then\r\n Me.txtKategorien = \"Kategorien: \" _ & Trim(Mid(Kategorien, 2, _\r\n Len(Kategorien) - 1))\r\n End If\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic012.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic013.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{87641AC0-06C4-4CCF-99DD-320F3284CC08}\/pic014.png\")
<\/p>\nDownloads zu diesem Beitrag<\/h3>\n