<\/p>\n
![\"Anpassen](\"..\/fileadmin\/_temp_\/2023_02\/pic_1420_001.png\")
<\/p>\n
Bild 1: Anpassen der Beschriftung eines Feldes<\/span><\/b><\/p>\n Wozu sollte man Tabellenfeldbeschriftungen im Griff haben? Und was ist das überhaupt? Die Eigenschaft „Beschriftung“ von Tabellenfeldern kennen viele Entwickler gar nicht. Dabei könnten sie sich eine Menge Zeit sparen, wenn sie diese Eigenschaft nutzen würden. Trägt man nämlich beispielsweise für ein Feld wie „EMail“ eine Beschriftung wie „E-Mail“ ein, dann wird diese statt des Feldnamens als Spaltenüberschrift der Tabelle in der Datenblattansicht angezeigt. Und es geht noch weiter: Wenn man in Formularen und Berichten Steuerelemente auf Basis dieser Felder anlegt, übernimmt Access auch dort den Wert der Eigenschaft Beschriftung statt des Feldnamens für die Bezeichnungsfelder Steuerelemente. Man braucht als nur an einer Stelle eine Änderung vorzunehmen und profitiert an vielen anderen Stellen davon. Und wenn man nun nicht in jeder neuen Datenbank die Beschriftungen erneut anlegen müsste … doch auch dafür haben wir in diesem Beitrag eine Lösung.<\/b><\/p>\n Eigentlich ist es gar nicht viel Arbeit: Wir erstellen eine neue Tabelle, und für Felder wie KundeID<\/b>, AnredeID<\/b>, Strasse<\/b>, EMail <\/b>et cetera hinterlegen wir für die Eigenschaft Beschriftung <\/b>jeweils den anzuzeigende Text wie ID<\/b>\/Kunde-ID<\/b>, Anrede<\/b>, Straße <\/b>oder E-Mail<\/b>. In Bild 1 sehen Sie, wie wir das Feld Strasse <\/b>entsprechend angepasst haben.<\/p>\n Bild 1: Anpassen der Beschriftung eines Feldes<\/span><\/b><\/p>\n Wechseln wir in die Datenblattansicht, sehen wir direkt die Werte der Eigenschaft Beschriftung <\/b>der jeweiligen Felder statt der Feldnamen (siehe Bild 2).<\/p>\n Bild 2: Die Beschriftung wird beispielsweise in der Datenblattansicht angewendet.<\/span><\/b><\/p>\n Allerdings ist das eine von vielen Aktionen, die man beim Anlegen neuer Tabellen berücksichtigen muss, und die dafür aufzuwendende Zeit summiert sich. Vor allem wenn man bedenkt, dass man diese Aufgabe im Laufe eines Entwicklerlebens sehr oft durchführt. Also sieht es so aus, als ob wir uns über die Automatisierung dieser Aufgabe Gedanken machen sollten!<\/p>\n Aber lässt sich das überhaupt automatisieren? Ist das nicht ein individueller Vorgang, der mit jeder Datenbank, jeder Tabelle und jedem Feld einzeln durchgeführt und vom Programmierer intensiv überdacht werden muss? Nein, das ist nicht der Fall. Außer, man möchte sich mit ein wenig Routinearbeit entspannen.<\/p>\n Wie also können wir diesen Vorgang automatisieren? Fest steht: Für die meisten Feldnamen gibt es genau eine passende Beschriftung, zumindest wenn man sich einmal auf einen Standard festgelegt hat. Ob zum Beispiel die Inhalte von Primärschlüssel-\/Autowertfeldern angezeigt werden müssen, sei dahingestellt, aber in vielen Fällen geschieht das. Dann sollte der Benutzer statt eines Feldnamens wie KundeID <\/b>oder BestellungID <\/b>eine passendere Beschriftung wie Kunde-ID<\/b>\/Bestellung-ID<\/b>, Kundennummer<\/b>\/Bestellnummer <\/b>oder schlicht ID <\/b>angezeigt bekommen.<\/p>\n Da einige Entwickler, wie auch ich, für Primärschlüsselfelder und Fremdschlüsselfelder die gleichen Bezeichnungen wählen – also zum Beispiel KundeID <\/b>als Primärschlüsselfeld in der Tabelle tblKunden <\/b>und KundeID <\/b>als Fremdschlüsselfeld in der Tabelle tblBestellungen <\/b>-, wollen wir hier unterscheiden. Während wir für das Fremdschlüsselfeld KundeID <\/b>vermutlich die Beschriftung Kunde <\/b>wählen werden, erhält das Primärschlüsselfeld KundeID <\/b>eher eine Beschriftung wie Kunde-ID <\/b>oder auch nur ID<\/b>.<\/p>\n Unsere Idee ist, dass wir die üblichen Zuordnungen von Feldnamen und Beschriftungen in einer Tabelle speichern, die wir beispielsweise tblCaptions <\/b>nennen. Diese soll vier Felder enthalten – CaptionID<\/b>, Fieldname<\/b>, Caption<\/b> und IsPrimaryKey<\/b>.<\/p>\n Für die Kombination aus den Feldern Fieldname <\/b>und IsPrimaryKey <\/b>definieren wir einen eindeutigen Index, damit zu jedem Feldnamen für einfache Felder und für Primärschlüsselfelder nur jeweils eine Beschriftung hinterlegt werden kann (siehe Bild 3).<\/p>\n Bild 3: Tabelle zum Speichern der Zuordnung von Feldern und Beschriftungen<\/span><\/b><\/p>\n Zusätzlich wollen wir eine Prozedur programmieren, mit der wir die Felder einer Tabelle, die mit Beschriftungen ausgestattet werden soll, durchlaufen und prüfen, ob wir für die Feldnamen bereits entsprechende Beschriftungen in unserer Tabelle tblCaptions <\/b>hinterlegt haben. Falls ja, soll die Beschriftung einfach für die Eigenschaft Beschriftung <\/b>hinterlegt werden.<\/p>\n Für eine Tabelle wie tblKunden<\/b> sieht der Inhalt der Tabelle tblCaption <\/b>also wie in Bild 4 aus.<\/p>\n Bild 4: Die Tabelle tblCaptions mit einigen Beispieldaten<\/span><\/b><\/p>\n Nun fehlt noch die passende Automatisierung. Diese erledigen wir mit einer VBA-Prozedur ApplyCaptions<\/b>, die wir in Listing 1 abgebildet haben. Die Prozedur erwartet den Namen der Tabelle, deren Felder mit Beschriftungen ausgestattet werden sollen. Wir deklarieren vorsorglich schon einmal zwei Variablen für Database<\/b>-Objekte: eines für die aktuelle Datenbank und eines für eine Add-In-Datenbank, denn wir werden die hier produzierten Elemente für die Automatisierung vermutlich nicht zu jeder neuen Datenbank hinzufügen, sondern diese über ein Add-In aufrufen wollen. Und bei Verwendung eines Add-Ins muss man unterscheiden, ob man auf die Daten der Tabellen der Add-In-Datenbank oder der aufrufenden Datenbank zugreifen möchte. Deshalb füllt die Prozedur auch die Variable db <\/b>über die Funktion CurrentDb <\/b>mit einem Verweis auf die Host-Datenbank und die Variable dbc <\/b>über die Funktion CodeDb <\/b>mit einem Verweis auf die Add-In-Datenbank. Und auch wenn wir aktuell noch direkt in der Host-Datenbank programmieren, ist das kein Problem, denn in diesem Fall greifen CurrentDb <\/b>und CodeDb <\/b>einfach beide auf die aktuelle Datenbank zu.<\/p>\n Listing 1: Anwenden von Beschriftungen auf die Felder der per Parameter übergebenen Tabelle<\/span><\/b><\/p>\n Weiter im Code: Dort referenzieren wir mit der TableDef<\/b>-Variable tdf <\/b>das TableDef<\/b>-Objekt für die mit dem Parameter strTable <\/b>übergebene Tabelle. Dann öffnen wir ein Recordset für den Zugriff auf die Daten der Tabelle tblCaptions <\/b>und speichern den Verweis in rstCaptions<\/b>.<\/p>\n Anschließend durchläuft die Prozedur alle Felder der Tabelle, deren Felder wir mit Beschriftungen ausstatten wollen, in einer For Each<\/b>-Schleife. Innerhalb der Schleife prüft die Prozedur zunächst, ob es sich bei dem aktuell untersuchten Feld um ein Primärschlüsselfeld handelt. Dies geschieht mit der Funktion IsPrimaryKey<\/b>, die wir weiter unten beschreiben.<\/p>\n Ob es sich um ein Primärschlüsselfeld handelt oder nicht, ist wie oben bereits erwähnt wichtig, da wir bei gleicher Benennung von Primärschlüsselfeldern und Fremdschlüsselfeldern gegebenenfalls unterschiedliche Beschriftungen verwenden wollen. Danach versucht die Prozedur, im Recordset mit den Beschriftungen einen Eintrag zu finden, dessen Feld Fieldname <\/b>dem Namen des aktuell durchlaufenen Feldes entspricht und das, je nachdem, welches Ergebnis die Funktion IsPrimaryKey <\/b>geliefert hat, auch dieses Feld in die Bedingung einbezieht.<\/p>\n Wurde ein Eintrag gefunden, liefert die in der kommenden If…Then<\/b>-Bedingung überprüfte Eigenschaft NoMatch <\/b>den Wert False<\/b>. In diesem Fall werden die Anweisungen innerhalb der If…Then<\/b>-Bedingung durchgeführt. Wir schreiben dort die zu dem Feld passende Beschriftung in die Variable strCaption <\/b>und weisen diese dann der Eigenschaft Beschriftung <\/b>zu.<\/p>\n Das ist nicht ganz trivial, denn im Gegensatz zum Tabellenentwurf in der Benutzeroberfläche, wo die Eigenschaft jederzeit zur Verfügung steht, ist die dahinter stehende Eigenschaft Caption <\/b>standardmäßig gar nicht in der Auflistung der Properties eines Field<\/b>-Objekts vorhanden. Das entsprechende Property<\/b>-Objekt wird erst angelegt, wenn der Benutzer eine Beschriftung einträgt.<\/p>\n Um nicht prüfen zu müssen, ob die Property bereits vorhanden ist, versuchen wir einfach, diese bei deaktivierter Fehlerbehandlung anzulegen. Dazu nutzen wir zwei Anweisungen.<\/p>\n Die erste ruft die CreateProperty<\/b>-Methode für das Feld auf und legt für die Eigenschaft Caption <\/b>mit dem Datentyp dbText <\/b>den Wert aus strCaption <\/b>fest. Danach hängt sie das neu erstellte Property<\/b>-Objekt an die Properties<\/b>-Auflistung des Field<\/b>-Objekts für das Feld an.<\/p>\n Ist die Property bereits vorhanden, löst dieser Vorgang einen Fehler aus. Das prüfen wir in der folgenden If…Then<\/b>-Bedingung und legen in diesem Fall einfach den Wert der Eigenschaft Caption <\/b>auf den Wert aus strCaption <\/b>fest.<\/p>\n Dies wiederholen wir für alle Felder der angegebenen Tabelle und tragen so für alle Felder, für die wir in der Tabelle tblCaptions <\/b>eine alternative Beschriftung angegeben haben, die jeweilige Beschriftung ein.<\/p>\n Die Funktion IsPrimaryKey <\/b>erwartet das TableDef<\/b>-Objekt und das Field<\/b>-Objekt des zu untersuchenden Feldes als Parameter (siehe Listing 2). Sie durchläuft alle Index<\/b>-Elemente des übergebenen TableDef<\/b>-Objekts in einer For Each<\/b>-Schleife. Wenn der Index ein Primärschlüssel ist, durchläuft sie außerdem alle Felder, die zu diesem Primärschlüsselindex gehören (ein Primärschlüssel kann ja auch aus mehreren Feldern bestehen). Ist das zu untersuchende Feld hier enthalten, handelt es sich bei diesem um ein Primärschlüsselfeld und wir können die Funktion wieder verlassen.<\/p>\n Listing 2: Funktion zum Prüfen, ob ein Feld ein Primärschlüsselfeld ist<\/span><\/b><\/p>\n Da wir uns nun schon ein wenig in das Thema eingearbeitet haben, können wir auch noch weiter automatisieren. Wieso sollten wir eigentlich die Felder und die dafür vorgesehenen Beschriftungen von Hand in die Tabelle tblCaptions <\/b>eintragen?<\/p>\n Nicht, dass das nicht auch eine entspannende Beschäftigung wäre … Aber noch praktischer wäre es doch, wenn wir die Beschriftung für alle vorhandenen Felder einer Tabelle auch per VBA einlesen könnten. Und genau dazu können wir die Prozedur SaveCaptions <\/b>aus Listing 3 nutzen.<\/p>\n [<\/p>\n Listing 3: Auslesen von Beschriftungen aus der angegebenen Tabelle<\/span><\/b><\/p>\n Diese Prozedur erwartet den Namen der Tabelle, die ausgelesen werden soll, als Parameter. Auch hier arbeiten wir wieder mit zwei Database<\/b>-Objekten, um die Funktionalität gegebenenfalls schnell in ein Add-In umwandeln zu können. Wir referenzieren die zu untersuchende Tabelle als TableDef<\/b>-Objekt (tdf<\/b>) und die Tabelle mit den Beschriftungen als Recordset (rstCaptions<\/b>).<\/p>\n Dann durchlaufen wir alle Felder der Tabelle über die Fields<\/b>-Auflistung. Dabei prüft die Prozedur zuerst wieder, ob es sich bei dem aktuell untersuchten Feld um ein Primärschlüsselfeld handelt. Falls ja, soll dies später im Feld IsPrimaryKey <\/b>der Tabelle tblCaptions <\/b>vermerkt werden.<\/p>\n Wir wissen auch bereits, dass die Caption<\/b>-Property nur für Felder existiert, für die bereits eine Beschriftung hinterlegt wurde. Also können wir auch hier nicht einfach auf diese Eigenschaft zugreifen, sondern müssen damit rechnen, dass beim Zugriff auf die nicht vorhandene Eigenschaft ein Fehler ausgelöst wird.<\/p>\n Also umgehen wir dies, indem wir die Variable strCaption <\/b>zum Speichern der Beschriftung erst auf eine leere Zeichenkette setzen und dann bei deaktivierter eingebauter Fehlerbehandlung versuchen, auf fld.Properties(„Caption“) <\/b>zuzugreifen. Ist strCaption <\/b>danach nicht leer, haben wir ein Feld mit einer Beschriftung gefunden und wollen den Feldnamen und die Beschriftung in die Tabelle tblCaptions <\/b>eintragen. Das erledigen wir wieder bei deaktivierter Fehlerbehandlung mit einer INSERT INTO<\/b>-Anweisung. Das hat den Hintergrund, dass wir für die Kombination der Felder Fieldname <\/b>und IsPrimaryKey<\/b> einen eindeutigen Index definiert haben, und wenn es in der Tabelle bereits einen Datensatz für die Kombination dieser Felder gibt, löst der Versuch, diesen erneut anzulegen, einen Fehler aus.<\/p>\n Diesen behandeln wir diesmal, indem wir auf die Fehlernummer 3022 <\/b>prüfen. Haben wir einen Treffer, lesen wir die für diesen Feldnamen gespeicherte Beschriftung in die Variable strCaptionOld <\/b>ein. Unterscheidet sich dieser von der Beschriftung, die wir gerade anlegen wollten, zeigt die Prozedur eine MsgBox <\/b>an, die den Benutzer fragt, ob die bisher gespeicherte Beschriftung für Felder dieses Namens überschrieben werden soll. Beantwortet der Benutzer diese Frage mit Ja<\/b>, führt die Prozedur eine UPDATE<\/b>-Abfrage durch, welche die Beschriftung im vorhandenen Datensatz für diesen Feldnamen aktualisiert. Auf diese Weise durchlaufen wir alle Felder der angegebenen Tabelle und tragen für die Felder, die eine Beschriftung enthalten, einen Datensatz in die Tabelle tblCaptions <\/b>ein.<\/p>\n Bevor wir uns darum kümmern, wie wir diese Funktionen in Form eine Access-Add-Ins abbilden können, wollen wir noch erläutern, wie wir die Beschriftungen aller Tabellen einer Datenbank in einem Rutsch auslesen können – und wie wir die Felder aller Tabellen einer neuen Datenbank auf einmal mit diesen Beschriftungen versehen.<\/p>\n Dazu nutzen wir die Prozedur SaveAllCaptions<\/b> aus Listing 4. Diese Prozedur definiert ein Recordset auf Basis der Systemtabelle MSysObjects<\/b>. Das Recordset soll die Namen aller Elemente mit dem Typ 1 (entspricht lokalen Tabellen) enthalten, die nicht mit ~<\/b>, USys<\/b>, MSys <\/b>oder f_ <\/b>beginnen – dies sind alles temporäre Tabellen oder Systemtabellen. Was ist mit verknüpften Access-Tabellen? Diese müssen wir direkt in der jeweiligen Backenddatenbank bearbeiten. Was ist mit SQL Server- und anderen per ODBC verknüpften Tabellen? Diese stellen die gewünschte Eigenschaft ohnehin nicht zur Verfügung. Hier könnte man Abfragen erstellen, die auf diesen Tabellen basieren, und für die Felder der Abfrage entsprechende Beschriftungen hinterlegen.<\/p>\n Listing 4: Auslesen der Beschriftungen der Felder aller Tabellen<\/span><\/b><\/p>\n Die Prozedur durchläuft alle Tabellen des Recordsets und ruft für jede dieser Tabellen die Prozedur SaveCaptions <\/b>auf, um die Beschriftungen der jeweils enthaltenen Felder in der Tabelle tblCaptions <\/b>zu speichern.<\/p>\n Die nächste Prozedur funktioniert genauso – mit dem Unterschied, dass sie die Beschriftungen auf alle Tabellen der aktuellen Datenbank anwendet. Hier die gekürzte Form:<\/p>\n Es kann passieren, dass Sie eine Datenbank von einem anderen Entwickler erhalten, der ausgiebig mit Beschriftungen für Tabellenfelder gearbeitet hat, aber Sie kommen aufgrund der eigenwilligen Benennungskonvention absolut nicht mit der Zuordnung von Beschriftungen und tatsächlichen Feldnamen klar. Nun wollen Sie auch nicht immer erst in den Entwurf einer Tabelle wechseln, um den tatsächlichen Namen eines Feldes auszulesen.<\/p>\n Die Option wäre, alle Beschriftungen zu diesem Zweck aus den Tabellen zu entfernen – zumindest temporär. Man könnte die Beschriftungen ja in einer Tabelle im Add-In zwischenspeichern und wiederherstellen (oder in einer anderen Eigenschaft wie beispielsweise der Tag<\/b>-Eigenschaft).<\/p>\n Sobald die Arbeiten an der Datenbank abgeschlossen sind, können Sie die Bezeichnungen dann wieder in die Beschriftung<\/b>-Eigenschaft zurückschreiben. Wir schauen uns auch diese Vorgehensweise noch an.<\/p>\n Die Prozedur DeleteCaptions <\/b>aus Listing 5 sorgt dafür, dass für alle Felder, die eine Property namens Caption <\/b>enthalten, der Wert dieser Property in eine noch anzulegende Property gesichert wird. Die Property Caption <\/b>wird anschließend gelöscht. Dazu durchlaufen wir in einer For Each<\/b>-Schleife alle Felder der mit dem Parameter strTable <\/b>angegebenen Tabelle. Direkt zu Beginn leeren wir die Variable strCaption <\/b>und lesen dann bei deaktivierter Fehlerbehandlung den Wert oder Eigenschaft Caption <\/b>ein. strCaption <\/b>enthält danach nur einen Wert, wenn die Eigenschaft vorhanden und gefüllt ist. Nur in diesem Fall werden die Anweisungen der folgenden If…Then<\/b>-Bedingung ausgeführt. Diese versuchen wiederum bei deaktivierter Fehlerbehandlung, eine neue Eigenschaft anzulegen, die den Namen des Wertes des zweiten Parameters strInProperty <\/b>erhält. Dieser Eigenschaft weisen wir den Datentyp dbText <\/b>und den Wert aus strCaption <\/b>zu. Anschließend hängen wir das neue Property<\/b>-Objekt an die Auflistung Properties <\/b>des Feldes aus fld <\/b>an. Sollte prp <\/b>danach leer sein, war die Eigenschaft vermutlich bereits vorhanden und wir können diese einfach über die Value<\/b>-Eigenschaft mit dem Wert aus strCaption <\/b>füllen. Danach brauchen wir nur noch die Caption<\/b>-Eigenschaft zu löschen, was wir mit der Delete<\/b>-Methode der Properties<\/b>-Auflistung erledigen.<\/p>\n Listing 5: Schreiben der Beschriftungen in eine temporäre Eigenschaft und Leeren der Eigenschaft Beschriftung<\/span><\/b><\/p>\n Dieser Vorgang wird für alle Felder der per Parameter übergebenen Tabelle erledigt, sodass wir die Tabelle in der Datenblattansicht wieder mit den eigentlichen Feldnamen als Spaltenüberschriften erhalten.<\/p>\n Der Aufruf dieser Prozedur sieht beispielsweise wie folgt aus:<\/p>\n Wenn Sie die Arbeiten beispielsweise an einer Datenbank eines anderen Entwicklers abgeschlossen haben und den Ausgangszustand bezüglich der Beschriftungen der Tabellenfelder wiederherstellen möchten, nutzen Sie die Prozedur RestoreCaptions<\/b>. Diese erwartet den Namen der zu bearbeitenden Tabelle und den Namen der Eigenschaft, aus welcher die Beschriftungen wiederhergestellt werden sollen (siehe Listing 6). Die Prozedur arbeitet innerhalb der For Each<\/b>-Schleife umgekehrt wie die zuvor beschriebene. Sie ermittelt, ob in dem mit strFromProperty <\/b>angegebenen Feld, beispielsweise CaptionTemp<\/b>, eine Beschriftung gesichert wurde. Ist das der Fall, versucht die Prozedur, die Eigenschaft Property <\/b>zu erstellen, was erfolgreich ist, wenn diese zuvor gelöscht wurde.<\/p>\n<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2023_02\/pic_1420_002.png\")
<\/p>\nAutomatisieren der Beschriftungen<\/h2>\n
Automatisieren der Festlegung von Feldbeschriftungen<\/h2>\n
Automatisierung per VBA<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_02\/pic_1420_003.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2023_02\/pic_1420_004.png\")
<\/p>\nBeschriftungen per VBA zuweisen<\/h2>\n
Public Sub <\/span>ApplyCaptions(strTable As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>rstCaptions As <\/span>DAO.Recordset\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>strCaption As String<\/span>\r\n Dim <\/span>bolPrimaryKey As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> tdf = db.TableDefs(strTable)\r\n Set<\/span> rstCaptions = dbc.OpenRecordset(\"SELECT * FROM tblCaptions\", dbOpenDynaset)\r\n For Each fld In tdf.Fields\r\n bolPrimaryKey = IsPrimaryKey(tdf, fld)\r\n rstCaptions.FindFirst \"Fieldname = ''\" & fld.Name & \"'' AND IsPrimaryKey = \" & CInt(bolPrimaryKey)\r\n If <\/span>Not<\/span> rstCaptions.NoMatch Then<\/span>\r\n strCaption = rstCaptions!Caption\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = fld.CreateProperty(\"Caption\", dbText, strCaption)\r\n fld.Properties.Append prp\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n fld.Properties(\"Caption\") = strCaption\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n Next<\/span> fld\r\nEnd Sub<\/span><\/pre>\nHerausfinden, ob ein Feld ein Primärschlüsselfeld ist<\/h2>\n
Public Function <\/span>IsPrimaryKey(tdf As <\/span>DAO.TableDef, fld As <\/span>DAO.Field) As Boolean<\/span>\r\n Dim <\/span>idx As <\/span>DAO.Index\r\n Dim <\/span>fldPK As <\/span>DAO.Field\r\n For Each idx In tdf.Indexes\r\n If <\/span>idx.Primary Then<\/span>\r\n For Each fldPK In idx.Fields\r\n If <\/span>fld.Name = fldPK.Name Then<\/span>\r\n IsPrimaryKey = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> fldPK\r\n End If<\/span>\r\n Next<\/span> idx\r\nEnd Function<\/span><\/pre>\nNoch mehr Automation: Beschriftungen einlesen<\/h2>\n
Public Sub <\/span>SaveCaptions(strTable As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>rstCaptions As <\/span>DAO.Recordset\r\n Dim <\/span>strCaption As String<\/span>\r\n Dim <\/span>strCaptionOld As String<\/span>\r\n Dim <\/span>bolPrimaryKey As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> tdf = db.TableDefs(strTable)\r\n Set<\/span> rstCaptions = dbc.OpenRecordset(\"SELECT * FROM tblCaptions\", dbOpenDynaset)\r\n For Each fld In tdf.Fields\r\n bolPrimaryKey = IsPrimaryKey(tdf, fld)\r\n strCaption = \"\"\r\n On Error Resume Next<\/span>\r\n strCaption = fld.Properties(\"Caption\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strCaption) = 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n dbc.Execute \"INSERT INTO tblCaptions(Fieldname, Caption, IsPrimaryKey) VALUES(''\" & fld.Name & \"'', ''\" _\r\n & strCaption & \"'', \" & CInt(bolPrimaryKey) & \")\", dbFailOnError\r\n Select Case Err.Number\r\n Case <\/span>3022\r\n rstCaptions.FindFirst (\"Fieldname = ''\" & fld.Name & \"'' AND IsPrimaryKey = \" & CInt(bolPrimaryKey))\r\n strCaptionOld = rstCaptions!Caption\r\n If <\/span>Not<\/span> strCaption = strCaptionOld Then<\/span>\r\n If MsgBox<\/span>(\"Für das Feld ''\" & fld.Name & \"'' wurde bereits die Beschriftung ''\" & strCaptionOld _\r\n & \"'' hinterlegt. Soll die in der Tabelle ''\" & strTable & \"'' gefundene Beschriftung ''\" _\r\n & strCaption & \"'' dafür gespeichert werden?\", vbYesNo + vbExclamation, _\r\n \"Beschriftung bereits vorhanden.\") = vbYes Then\r\n dbc.Execute \"UPDATE tblCaptions SET Caption = ''\" & strCaption & \"'', IsPrimaryKey = \" _\r\n & CInt(bolPrimaryKey) & \" WHERE Fieldname = ''\" & fld.Name & \"''\", dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\n Case <\/span>0\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler: \" & Err.Number & \", \" & Err.Description\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> fld\r\nEnd Sub<\/span> <\/pre>\nBeschriftungen aller Tabellen der aktuellen Datenbank auslesen<\/h2>\n
Public Sub <\/span>SaveAllCaptions()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Name FROM MSysObjects WHERE Type = 1 AND NOT Name LIKE ''~*'' AND \" _\r\n & \"NOT Name LIKE ''USys*'' AND NOT Name LIKE ''MSys*'' AND NOT Name LIKE ''f_*''\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n SaveCaptions rst!Name\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nBeschriftungen auf Felder aller Tabellen anwenden<\/h2>\n
Public Sub <\/span>ApplyAllCaptions()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Name FROM \" _\r\n & \"MSysObjects WHERE Type = 1 ...\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n ApplyCaptions rst!Name\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nBeschriftungen entfernen<\/h2>\n
Beschriftungen sichern und aus Tabelle entfernen<\/h2>\n
Public Sub <\/span>DeleteCaptions(strTable As String<\/span>, strInProperty As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>strCaption As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(strTable)\r\n For Each fld In tdf.Fields\r\n strCaption = \"\"\r\n On Error Resume Next<\/span>\r\n strCaption = fld.Properties(\"Caption\")\r\n On Error GoTo<\/span> 0\r\n Debug.Print<\/span> fld.Name, strCaption\r\n If <\/span>Not<\/span> Len<\/span>(strCaption) = 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = fld.CreateProperty(strInProperty, dbText, strCaption)\r\n fld.Properties.Append prp\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> prp Is Nothing Then<\/span>\r\n prp.Value = strCaption\r\n End If<\/span>\r\n fld.Properties.Delete \"Caption\"\r\n End If<\/span>\r\n Next<\/span> fld\r\nEnd Sub<\/span><\/pre>\nDeleteCaptions \"tblKunden2\", \"CaptionTemp\"<\/pre>\n
Beschriftungen wiederherstellen<\/h2>\n
Public Sub <\/span>RestoreCaptions(strTable As String<\/span>, strFromProperty As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld