<\/p>\n
Access 2007 bringt einige Features, welche die Entwicklergemeinde spalten. Eines davon sind die mehrwertigen Felder, auch Multivalue Fields genannt: Sie erlauben dem Einsteiger, leicht mehrere Werte zu einem Nachschlagefeld einer Tabelle hinzuzufügen. Wir werfen einen genauen Blick auf dieses Feature, was auch für Gegner dieser Technik interessant sein dürfte: Immerhin ist keiner davor gefeit, eine mit mehrwertigen Feldern gespickte Datenbank in eine mit sauberer Datenmodellierung zu überführen – hier erfahren Sie deshalb auch, wie Sie an die Daten aus solchen Feldern herankommen.<\/b><\/p>\n
Der Ausgangspunkt für den Microsoft“schen Ansatz, mehrwertige Felder einzuführen, ist der Wunsch, Access-Einsteigern die Verwendung von Nachschlage- beziehungsweise Kombinationsfeldern möglichst einfach zu machen. Dies aber nicht nur für die Verwendung von Daten aus 1:n-Beziehungen, sondern auch für m:n-Beziehungen!<\/p>\n
Das bedeutet prinzipiell, dass ein Feld mehrere Werte speichern kann. Ein Beispiel verdeutlicht dies: Wenn jeder Mitarbeiter eines Unternehmens an mehreren Projekten beteiligt sein kann, und jedes Projektteam wiederum aus einem oder mehrere Mitarbeitern besteht, dann verwenden Sie eine Mitarbeitertabelle, eine Projektetabelle und eine Verknüpfungstabelle, mit der Sie die Mitarbeiter den Projekten zuweisen und umgekehrt (siehe Bild 1).<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic001.png\")
<\/p>\n
Bild 1: Der herkömmliche Weg, m:n-Beziehungen im Datenmodell nachzubilden<\/span><\/b><\/p>\n Mehrwertige Felder bilden dies ohne die notwendigen Felder im Hintergrund nach und gleichzeitig gibt es auch noch eine Erweiterung von Kombinations- und Listenfeldern, die das Auswählen und Bearbeiten der enthaltenen Daten erlaubt.<\/p>\n Nachschlagefelder in Access 2007<\/b><\/p>\n Mit der Einführung mehrwertiger Felder hat Microsoft gleich auch noch die Bedienung von Nachschlagefeldern und deren Einrichtung verändert. Beginnen wir mit einem einfachen Nachschlagefeld, das seine Werte aus einer Wertliste beziehen soll und per Nachschlage-Assistent hergestellt wird. Dort geben Sie zunächst an, dass Sie die im Nachschlagefeld anzuzeigenden Werte selbst eingeben, also eine Wertliste anlegen möchten (siehe Bild 2).<\/p>\n Bild 2: Festlegen einer Wertliste anstelle einer Tabelle oder Abfrage als Datensatzherkunft eines Nachschlagefelds<\/span><\/b><\/p>\n Anschließend legen Sie fest, wie viele Spalten das Nachschlagefeld anzeigen soll und wie die enthaltenen Daten lauten (siehe Bild 3). Die Angabe eines Wertes größer 1 <\/b>macht hier insofern Sinn, als dass man statt eines Kombinationsfelds als Nachschlagefeld auch gleich ein Listenfeld verwenden kann.<\/p>\n Bild 3: Festlegen der Spaltenzahl und eingeben der Werte des Nachschlagefeldes<\/span><\/b><\/p>\n Schließlich legen Sie im dritten Schritt den Namen des Nachschlagefeldes fest und geben an, ob Sie jeweils nur einen oder mehrere Werte auswählen möchten (siehe Bild 4) – später wählen wir die Option Mehrere Werte <\/b>zulassen aus, um ein mehrwertiges Feld zu erstellen. Der Assistent hat alle notwendigen Eigenschaften eingestellt, damit Sie die beiden angegebenen Werte per Kombinationsfeld auswählen können (siehe Bild 5). Gegenüber Access 2003 und älter finden Sie hier vier neue Eigenschaften vor:<\/p>\n Bild 4: Letzte Angaben vor Fertigstellung des Nachschlagefeldes<\/span><\/b><\/p>\n Bild 5: Die Einstellung dieser Eigenschaften ist das Resultat des Nachschlage-Assistenten.<\/span><\/b><\/p>\n Wenn Sie alle vier Eigenschaften auf Nein<\/b> belassen beziehungsweise Bearbeitungsformular für Listenelemente <\/b>leer lassen, bedient man das Nachschlagefeld wie in früheren Access-Versionen.<\/p>\n Stellen Sie testweise zunächst die Eigenschaft Wertlistenbearbeitung zulassen <\/b>auf den Wert Ja <\/b>ein. Wenn Sie nun in die Datenblattansicht der Tabelle wechseln und das Nachschlagefeld aufklappen, erscheint ein kleines Symbol, über das Sie per Mausklick den Dialog aus Bild 6 öffnen können.<\/p>\n Bild 6: Komfortable Bearbeitung von Wertlisteneinträgen<\/span><\/b><\/p>\n änderungen an der Liste werden klaglos in die semikola-separierte Eigenschaft Wertliste <\/b>übernommen, und auch die Eigenschaft Standardwert <\/b>lässt sich hier komfortabel einstellen.<\/p>\n Die Bearbeitung der Listenelemente ist auch in Formularen möglich – am einfachsten aktivieren Sie dies, indem Sie Wertlistenbearbeitung zulassen <\/b>im Tabellenentwurf auf Ja <\/b>einstellen und das Formular einfach mit den Feldern der Wertliste füllen, nachdem Sie als Datenherkunft die betroffene Tabelle angegeben haben. Sie können diese und weitere Eigenschaften dann aber für jedes Formular individuell einstellen (siehe Bild 7).<\/p>\n Bild 7: Die Eigenschaften bezüglich der Nachschlagefelder werden auf die Steuerelemente im Formular übertragen.<\/span><\/b><\/p>\n Nachteil bearbeitbarer Wertlisten<\/b><\/p>\n Eine Wertliste sollten Sie wirklich nur dann einsetzen, wenn die enthaltenen Daten für alle Zeiten gleich bleiben. Bedenken Sie, dass es sich bei der Eigenschaft Wertliste <\/b>prinzipiell um ein Element des Datenmodells handelt und dieses nicht so einfach durch den Benutzer geändert werden sollte. <\/p>\n Der große Nachteil bearbeitbarer Wertlisten ist, dass es keine Möglichkeit gibt, die vom Benutzer geänderten Daten zu validieren. Der Eingabe redundanter und in der Folge inkonsistenter Daten ist also Tür und Tor geöffnet.<\/p>\n Ein weiterer Nachteil resultiert aus der Beobachtung, dass der Inhalt der Wertliste unter bestimmten Umständen, die wir später aufdecken werden, in einer Eigenschaft eines Steuerelements steckt. Eine änderung der Wertliste erfordert das anschließende Speichern des Formulars und somit eine änderung des Entwurfs eines Objekts – und das ist in der Runtime-Version von Access grundsätzlich nicht möglich. Wenn Sie dem Benutzer Ihrer Datenbank also eine solche Funktion bereitstellen möchten, ziehen Sie in Betracht, dass dies mit der Runtime nicht funktionieren wird.<\/p>\n Vom Nachschlagefeld zum mehrwertigen Feld<\/b><\/p>\n Als Beispiel für ein mehrwertiges Feld haben wir in der Beispieltabelle tblMitarbeiter <\/b>das Feld Funktionen <\/b>eingerichtet, aus dem mehrere Werte ausgewählt werden können. Ausgehend von einem normalen Nachschlagefeld, das wie oben beschrieben per Assistent erstellt wurde, brauchen wir nur die Eigenschaft Mehrere Werte zulassen <\/b>auf Ja <\/b>einzustellen. Es erscheint dann eine Meldung, die besagt, dass dies nicht rückgängig zu machen sei.<\/p>\n Das Ergebnis sieht wie in Bild 8 aus. Wählt man die Listeneinträge wie in dieser Abbildung aus, erscheinen diese anschließend in der folgenden Form als Feldinhalt:<\/p>\n Bild 8: Ein mehrwertiges Feld<\/span><\/b><\/p>\n Im Hintergrund<\/b><\/p>\n Gehen wir ein wenig in die Tiefe und schauen uns an, was sich in den Systemtabellen getan hat. Dazu aktivieren wir zunächst deren Anzeige, indem wir aus dem Kontextmenü der Überschrift des Navigationsbereichs den Eintrag Navigationsoptionen… <\/b>auswählen und dort die Option Systemobjekte anzeigen <\/b>aktivieren.<\/p>\n Im Navigationsbereich erschienen nun einige zuvor nicht sichtbare Tabellen, von denen uns zunächst die Tabelle MSysComplexColumns<\/b> interessiert. Diese sieht aktuell wie in Bild 9 aus und enthält, was wir suchen: einen Hinweis darauf, dass Access im Hintergrund mehr als eine semikola-separierte Liste ausgewählter Elemente speichert.<\/p>\n Bild 9: Diese Tabelle enthält Informationen über die Speicherung des Inhalts mehrwertiger Felder.<\/span><\/b><\/p>\n In dieser Tabelle taucht der Name unseres Feldes auf, eine ComplexID<\/b>, die möglicherweise als eindeutiger Index der mehrwertigen Felder dient, und eine ComplexTypeObjectID<\/b>. Interessant sind die beiden Einträge ConceptualTableID <\/b>und FlatTableID<\/b>: Diese enthalten Einträge, die wir in einer anderen Systemtabelle, nämlich MSysObjects<\/b>, wiederfinden. Nach dem Ausblenden einiger Spalten und dem Filtern nach den Werten 70 <\/b>und 138 <\/b>im Feld Id <\/b>liefert die Tabelle das Bild aus Bild 10. Auf die Tabelle aus der zweiten Zeile können wir leider nicht zugreifen – Access meldet, dieses Objekt sei nicht vorhanden.<\/p>\n Bild 10: Die zweite Tabelle enthält die Daten des mehrwertigen Feldes der ersten Tabelle.<\/span><\/b><\/p>\n <\/p>\n Wertliste erben<\/b><\/p>\n Eine Eigenschaft von Kombinations- und Listenfeldern heißt Wertliste erben<\/b>. Diese Eigenschaft legt schlicht und einfach fest, ob änderungen an der Wertliste über Kombinations- und Listenfelder an die Wertliste der zugrunde liegenden Tabelle weitergegeben werden. Wenn ein Feld also in mehr als einem Formular vorkommt und Sie dem Benutzer änderungen am Inhalt der Wertliste erlauben (was Sie aus den weiter oben erläuterten Gründen aber gar nicht tun sollten), dann sollten Sie die Eigenschaft Wertliste erben <\/b>auf Ja <\/b>einstellen, damit die übrigen Formulare auch etwas davon haben.<\/p>\n Genau genommen verhält es sich so: Wenn Wertliste erben <\/b>auf Ja <\/b>eingestellt ist, werden sowohl änderungen an der Wertliste des Nachschlagefeldes im Formular an die zugrunde liegende Tabelle weitergegeben als auch umgekehrt. Wenn die Eigenschaft den Wert Nein <\/b>aufweist, dann erfährt die Tabelle nichts von neuen Listenwerten im Formular und umgekehrt.<\/p>\n Im Hintergrund sieht es so aus, dass Access beim Anlegen eines Kombinationsfeldes auf Basis eines Nachschlagefeldes aus einer Tabelle mit Wertliste die zum Zeitpunkt des Hinzufügens vorliegende Wertliste in die entsprechende Eigenschaft einträgt. Wenn Wertliste erben <\/b>den Wert Ja <\/b>aufweist, liest Access aber den aktuellen Inhalt der Wertliste aus der Tabelle aus und schreibt diesen in die entsprechende Eigenschaft des Kombinationsfeldes.<\/p>\n Formular nach Wertlistenänderung schließen<\/b><\/p>\n Da Sie mit der änderung der Wertliste auch den Entwurf des Formulars ändern, liefert das Schließen des Formulars die Rückfrage, ob die änderungen am Entwurf des Formulars gespeichert werden sollen – aber nur, wenn die Eigenschaft Wertliste erben <\/b>den Wert Nein <\/b>aufweist! Denn nur dann wird die Wertliste tatsächlich im Entwurf des Formulars geändert. Hat Wertliste erben <\/b>den Wert Ja<\/b>, dann bezieht sich die änderung der Wertliste auf die zugrunde liegende Tabelle, welche Access stillschweigend speichert.<\/p>\n Damit der Benutzer sich nicht über eine solche Meldung wundern muss, sollten Sie eine Schließen-Schaltfläche vorsehen, welche das Formular „leise“ speichert, also ohne Meldung. Die Schaltfläche versehen Sie einfach mit folgender Anweisung:<\/p>\n Bearbeitungsformular für Listenelemente<\/b><\/p>\n Diese Eigenschaft ist nur für den Einsatz mit einer Tabelle oder Abfrage als Datensatzherkunft vorgesehen. Sie können damit eines der vorhandenen Formulare auswählen, wobei dieses für die Bearbeitung der im jeweiligen Nachschlagefeld angegebenen Datenherkunft vorgesehen sein sollte. Wenn Sie also ein einfaches Formular auf Basis der Tabelle tblTitel <\/b>der Beispieldatenbank erstellen und dieses frmTitel <\/b>nennen, können Sie dieses für die Eigenschaft Bearbeitungsformular für Listenelemente <\/b>in die entsprechende Eigenschaft des Nachschlagefelds im Tabellenentwurf eintragen. Ein Klick auf das beim Aufklappen des Nachschlagefeldes erscheinende Bearbeiten-Symbol öffnet dann das angegebene Formular, in dem Sie die vorhandenen Einträge bearbeiten und\/oder ergänzen können.<\/p>\n Unvollständiges Feature<\/b><\/p>\n Diese Funktion ist im ersten Ansatz lobenswert, jedoch fehlen entscheidende Elemente. So wäre es zum Beispiel wichtig, wenn das aufgerufene Formular irgendwie mitgeteilt bekäme, welchen Wert das Nachschlagefeld zum Zeitpunkt des Aufrufs besitzt – man könnte dann Code im aufgerufenen Formular unterbringen, der gleich den Datensatzmarkierer auf den aktuell ausgewählten Eintrag setzt.<\/p>\n Andererseits scheint zumindest etwas in der Richtung geplant zu sein: Bei unseren Versuchen brachte die Eigenschaft OpenArgs <\/b>des aufgerufenen Formulars jedenfalls den folgenden Ausdruck zu Tage (hier für den Aufruf des Formulars von der Tabelle aus):<\/p>\n Von einem Formular aus sah der Ausdruck etwas anders aus:<\/p>\n Hätte Microsoft hier den Wert der gebundenen Spalte des Nachschlagefelds mitgeliefert, wäre dies ein richtig praktisches Feature geworden. Mit ein wenig Geschick lässt sich dennoch die notwendige Erweiterung einbauen, um das Feature interessant zu gestalten. Dazu brauchen Sie im aufgerufenen Formular (in der Beispieldatenbank frmTitel<\/b>) zwei Variablen, welche das aufrufende Formular und das aktive Steuerelement referenzieren sollen:<\/p>\n Dann legen Sie ein Ereignis an, das durch die Ereigniseigenschaft Beim Öffnen <\/b>des Formulars frmTitel <\/b>ausgelöst wird. Zu diesem Zeitpunkt sind das aufrufende Formular und das aufrufende Steuerelement die aktiven Elemente der Benutzeroberfläche. Sie können diese daher über die Funktionen ActiveForm <\/b>und ActiveControl <\/b>des Screen<\/b>-Objekts ermitteln und speichern einen Verweis auf beide in den zuvor angelegten Variablen. Außerdem sorgen Sie mit einer weiteren Anweisung dafür, dass der aktuell im aufrufenden Steuerelement ausgewählte Datensatz im Formular frmTitel <\/b>markiert wird:<\/p>\n Schließlich soll der zuletzt bearbeitete Datensatz im aufrufenden Nachschlagefeld ausgewählt werden. Die entsprechende Routine wird durch das Ereignis Beim Entladen <\/b>ausgelöst. Sie prüft, ob das Primärschlüsselfeld der hier bearbeiteten Tabelle und gleichzeitig das gebundene Feld des Nachschlagefelds einen Wert enthält (das ist zum Beispiel nicht der Fall, wenn der Datensatzzeiger auf einem neuen Datensatz steht), und stellt das aufrufende Nachschlagefeld auf den entsprechenden Datensatz ein:<\/p>\n Bild 11 zeigt, wie dies in der Beispieldatenbank aussieht. Alternativ kann man natürlich auch noch Schaltflächen wie Auswahl übernehmen<\/b> oder Abbrechen <\/b>verwenden.<\/p>\n Bild 11: Beim Aufrufen des Bearbeitungsformulars wird direkt der aktuelle Datensatz markiert.<\/span><\/b><\/p>\n Mehrwertige Felder unter VBA<\/b><\/p>\n Natürlich können Sie auch per VBA auf mehrwertige Felder zugreifen. Der primäre Reiz, dies zu tun, ist wohl die Überführung der in einer nicht näher definierbaren Tabelle enthaltenen Daten in das ordnungsgemäße Konstrukt einer m:n-Beziehung. Erst einmal untersuchen wir, was DAO für grundsätzliche Informationen über ein mehrwertiges Feld liefert. Die folgende Routine zeichnet die Struktur sehr gut nach. Dazu deklariert sie zunächst ein Recordset<\/b>-Objekt auf Basis der Tabelle tblMitarbeiter<\/b>. Anschließend erzeugt sie ein zweites Recordset, das auf die Value<\/b>-Eigenschaft des mehrwertigen Feldes Funktionen <\/b>verweist. Die anschließende For Each<\/b>-Schleife durchläuft alle Felder dieses Recordsets, was nicht besonders viele sind: Es gibt nämlich nur ein einziges Feld namens Value <\/b>mit dem Wert 10 <\/b>für die Eigenschaft Type<\/b>, was der Konstanten dbText <\/b>entspricht und auf ein Textfeld hindeutet:<\/p>\n Hinweis: Recordset2<\/b> und Field2 <\/b>sind zwei neue Objekte der Bibliothek Microsoft Office 12.0 Access Database Engine Object Library<\/b>, die speziell für den Einsatz mit mehrwertigen Feldern ausgelegt sind. Sie können auch die alten Objekte verwenden, Access setzt dann offensichtlich automatisch die neuere Variante ein.<\/p>\n Schauen wir uns eine weitere Prozedur an, die diesmal den Inhalt der Tabelle tblMitarbeiter <\/b>und die im Feld Funktionen <\/b>enthaltenen Informationen durchläuft und deren Ausgabe beispielsweise wie in Bild 12 aussieht:<\/p>\n Bild 12: Ausgabe der Prozedur MWFAuslesen<\/span><\/b><\/p>\n Sie sehen: Wir können die Datensätze eines mehrwertigen Feldes genau durchlaufen wie die einer verknüpften Tabelle. Wenn es rein darum geht, die in allen Datensätzen enthaltenen Werte des Feldes Funktionen <\/b>zu ermitteln, können Sie auch die folgende Prozedur anwenden. Sie verwendet eine entsprechende SQL-Abfrage, um direkt auf das Feld Value <\/b>der im Feld Funktionen <\/b>hinterlegten Tabelle zuzugreifen:<\/p>\n Der Nachteil hierbei ist, dass Werte, die mehreren Mitarbeitern zugewiesen sind, auch mehrmals ausgegeben werden und dass Werte, die keinem Mitarbeiter zugeordnet wurden, gar nicht in der Liste erscheinen. Zumindest das erste Problem lässt sich leicht beheben. Dazu erweitern Sie die verwendete SQL-Abfrage einfach durch das Schlüsselwort DISTINCT<\/b>:<\/p>\n Wenn Sie auch alle überhaupt vorhandenen Elemente der hinter dem mehrwertigen Feld steckenden Wertliste ermitteln möchten, verwenden Sie eine Prozedur ähnlich der folgenden:<\/p>\n Die Liste aller Einträge wird nämlich (wahrscheinlich unter anderem) in der Eigenschaft Datensatzherkunft <\/b>des Nachschlagefeldes gespeichert, die sich per VBA über die RowSource<\/b>-Eigenschaft des Field<\/b>-Objekts auslesen lässt.<\/p>\n Der mehrwertige Bug<\/b><\/p>\n Dass die Technik der mehrwertigen Felder zumindest unter Access 2007 noch nicht ausgereift ist, zeigt sich an folgendem Beispiel:<\/p>\n Der erste Datensatz zeigt richtigerweise die zuvor ausgewählten Einträge an und lässt den gelöschten vierten Eintrag weg. Beim zweiten Datensatz jedoch ist der vierte Eintrag noch vorhanden, wie Bild 13 zeigt. Diese Inkonsistenz macht mehrwertige Felder quasi unbrauchbar – Grund genug, die enthaltenen Daten schnellstmöglich in eine richtige m:n-Beziehung zu überführen.<\/p>\n Bild 13: Mehrwertige Felder löschen verknüpfte Daten nicht, obwohl diese aus der Menge der zur Auswahl stehenden Daten entfernt wurden.<\/span><\/b><\/p>\n Vom mehrwertigen Feld zur m:n-Beziehung<\/b><\/p>\n Somit haben wir alles Handwerkszeug parat, um das mehrwertige Feld in eine handelsübliche m:n-Beziehung zu überführen. Die Prozedur aus Listing 1 erzeugt zunächst die beiden Tabellen tblFunktionen <\/b>und tblMitarbeiterFunktionen <\/b>als Verknüpfungstabelle. Dabei legt sie für das Feld Funktion <\/b>der Tabelle tblFunktionen <\/b>einen eindeutigen Index an, um Redundanzen zu vermeiden. Auch die Beziehungen zwischen tblMitarbeiterFunktionen <\/b>und den beiden Tabellen tblMitarbeiter <\/b>und tblFunktionen <\/b>stellt die Prozedur her. Zuvor werden eventuell bereits existierende Tabellen gleichen Namens gelöscht, damit die Tabellen neu erstellt werden können.<\/p>\n Listing 1: Überführen von mehrwertigen Feldern in eine m:n-Beziehung<\/p>\n Danach kommt eine modifizierte Version der Prozedur MWFAlleWerte <\/b>zum Einsatz. Diese liest alle in der Eigenschaft Datensatzherkunft <\/b>des mehrwertigen Feldes enthaltenen Werte ein und schreibt diese in die Tabelle tblFunktionen<\/b>. Dabei behalten wir im Hinterkopf, dass diese Eigenschaft unter Umständen nicht mehr alle später benötigten Elemente enthält – andererseits kann sie aber Einträge liefern, die noch nicht in Verwendung sind und daher bei der nun folgenden Analyse der Feldinhalte des Feldes Funktionen <\/b>der Tabelle tblMitarbeiter <\/b>nicht gefunden werden.<\/p>\n Dabei durchlaufen zwei Schleifen alle Datensätze der Tabelle tblMitarbeiter <\/b>und der im Feld Funktionen <\/b>enthaltenen Tabelle und schreiben dabei zunächst alle Funktionen in tblFunktionen<\/b>, um direkt im Anschluss die Verknüpfungstabelle tblMitarbeiterFunktionen <\/b>mit den entsprechenden Daten zu versehen. Somit ergibt sich ein sauberes Datenmodell, das keine Gefahr von Inkonsistenzen hervorrufen wird. Für eigene Zwecke passen Sie einfach die Tabellen- und Feldnamen an oder parametrisieren die Prozedur gleich, wenn Sie diese mehrfach einsetzen möchten.<\/p>\n Enthaltene Beispieldateien:<\/p>\n MehrwertigeFelder.accdb<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic002.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic004.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic005.png\")
<\/p>\n\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic006.png\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic007.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic008.png\")
<\/p>\nKaffeekocher; Mädchen für alles; Programmierer<\/pre>\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic009.png\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic010.png\")
<\/p>\nPrivate Sub cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name, acSaveYes\r\n End Sub<\/pre>\n
[tblMitarbeiter]![Titel]=<\/pre>\n
[frmMitarbeiter]![Titel]=<\/pre>\n
Dim frm As Form\r\nDim ctl As Control<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Set frm = Screen.ActiveForm\r\n Set ctl = Screen.ActiveControl\r\n Me.Recordset.FindFirst "TitelID = " _\r\n & ctl.Value\r\n RunCommand acCmdSelectRecord\r\n End Sub<\/pre>\n
Private Sub Form_Unload(Cancel As Integer)\r\n If Not IsNull(Me!TitelID) Then\r\n ctl.Value = Me!TitelID\r\n End If\r\n End Sub<\/pre>\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic011.png\")
<\/p>\nPublic Sub MWFFelder()\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nDim rstMWF As DAO.Recordset2\r\nDim fld As DAO.Field2\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT * FROM\r\ntblMitarbeiter", dbOpenDynaset)\r\nSet rstMWF = rst!Funktionen.Value\r\nFor Each fld In rstMWF.Fields\r\n Debug.Print fld.Name, fld.Type\r\nNext fld\r\nSet db = Nothing\r\nEnd Sub<\/pre>\n![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic012.png\")
<\/p>\nPublic Sub MWFAuslesen()\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nDim fld As DAO.Field2\r\nDim rstMWF As DAO.Recordset2\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT * FROM\r\ntblMitarbeiter", dbOpenDynaset)\r\nDo While Not rst.EOF\r\nDebug.Print "Mitarbeiter: " _\r\n& rst!Vorname & " " & rst!Nachname\r\nSet rstMWF = rst!Funktionen.Value\r\nDebug.Print " Funktionen:"\r\nDo While Not rstMWF.EOF\r\n Debug.Print " " & rstMWF.Fields(0)\r\n rstMWF.MoveNext\r\nLoop\r\nrst.MoveNext\r\nLoop\r\nEnd Sub<\/pre>\nPublic Sub MWFWerteAuslesen()\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT\r\nFunktionen.Value FROM tblMitarbeiter",\r\ndbOpenDynaset)\r\nDo While Not rst.EOF\r\nDebug.Print rst("Funktionen.Value")\r\nrst.MoveNext\r\nLoop\r\nSet db = Nothing\r\nEnd Sub<\/pre>\nSELECT DISTINCT Funktionen.Value\r\nFROM tblMitarbeiter<\/pre>\n
Public Sub MWFAlleWerte()\r\nDim db As DAO.Database\r\nDim tdf As DAO.TableDef\r\nDim fld As DAO.Field\r\nDim strValues() As String\r\nDim i As Integer\r\nSet db = CurrentDb\r\nSet tdf = db.TableDefs("tblMitarbeiter")\r\nSet fld = tdf.Fields("Funktionen")\r\nstrValues = _\r\nSplit(fld.Properties("RowSource"), ";")\r\nFor i = LBound(strValues) To\r\nUBound(strValues)\r\nDebug.Print Replace(strValues(i),\r\nChr(34), "")\r\nNext i\r\nSet fld = Nothing\r\nSet tdf = Nothing\r\nSet db = Nothing\r\nEnd Sub<\/pre>\n\n
![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2010_02\/MehrwertigeFelder-web-images\/pic013.png\")
<\/p>\nPublic Sub VonMWFZuMN()\r\nDim db As DAO.Database\r\nDim tdf As DAO.TableDef\r\nDim fld As DAO.Field2\r\nDim strValues() As String\r\nDim i As Integer\r\nDim rst As DAO.Recordset\r\nDim rstMWF As DAO.Recordset2\r\nDim lngFunktionID As Long\r\nSet db = CurrentDb\r\nOn Error Resume Next\r\ndb.Execute "DROP TABLE tblMitarbeiterFunktionen", dbFailOnError\r\ndb.Execute "DROP TABLE tblFunktionen", dbFailOnError\r\nOn Error GoTo 0\r\ndb.Execute "CREATE TABLE tblFunktionen(FunktionID COUNTER CONSTRAINT PK PRIMARY KEY,\r\nFunktion TEXT(255) CONSTRAINT UK UNIQUE)", dbFailOnError\r\ndb.Execute "CREATE TABLE tblMitarbeiterFunktionen(ID COUNTER CONSTRAINT PK PRIMARY KEY,\r\nMitarbeiterID INTEGER, FunktionID INTEGER, CONSTRAINT FKMitarbeiter FOREIGN\r\nKEY(MitarbeiterID) REFERENCES tblMitarbeiter, CONSTRAINT FKFunktionen FOREIGN\r\nKEY(FunktionID) REFERENCES tblFunktionen)", dbFailOnError\r\nSet tdf = db.TableDefs("tblMitarbeiter")\r\nSet fld = tdf.Fields("Funktionen")\r\nstrValues = Split(fld.Properties("RowSource"), ";")\r\nFor i = LBound(strValues) To UBound(strValues)\r\n db.Execute "INSERT INTO tblFunktionen(Funktion) VALUES(''" & Replace(strValues(i), \r\n Chr(34), "") & "'')", dbFailOnError\r\nNext i\r\nSet rst = db.OpenRecordset("SELECT * FROM tblMitarbeiter", dbOpenDynaset)\r\nDo While Not rst.EOF\r\n Set rstMWF = rst!Funktionen.Value\r\n Do While Not rstMWF.EOF\r\n On Error Resume Next\r\n db.Execute "INSERT INTO tblFunktionen(Funktion) VALUES(''" & rstMWF!Value & "'')",\r\n dbFailOnError\r\n On Error GoTo 0\r\n lngFunktionID = DLookup("FunktionID", "tblFunktionen", "Funktion = ''" & rstMWF!Value & "''")\r\n db.Execute "INSERT INTO tblMitarbeiterFunktionen(MitarbeiterID, FunktionID) VALUES("\r\n & rst!MitarbeiterID & ", " & lngFunktionID & ")", dbFailOnError\r\n rstMWF.MoveNext\r\n Loop\r\n rst.MoveNext\r\nLoop\r\nSet db = Nothing\r\nEnd Sub<\/pre>\nDownloads zu diesem Beitrag<\/h3>\n