<\/p>\n
Datenmakros dienen dazu, Aktionen automatisch beim Ändern der Daten einer Tabelle auszulösen – nämlich beim Anlegen, Bearbeiten oder Löschen eines Datensatzes. Diese legt man in der Regel über die Benutzeroberfläche an. Leider kann man damit immer nur sehen, welche Datenmakros für die aktuelle im Entwurf oder in der Datenblattansicht angezeigte Tabelle zur Verfügung stehen. Dieser Beitrag zeigt, wie Sie sich einen besseren Überblick über die vorhandenen Datenmakros verschaffen, diese anzeigen und bearbeiten und sogar neue Datenmakros anlegen können – und das auch noch parametrisiert für gleichartige Datenmakros und mehrere Tabellen gleichzeitig.<\/b><\/p>\n
Genau genommen sind wir durch die Lösung des Beitrags Zugriffsrechte mit Datenmakros <\/b>(www.access-im-unternehmen.de\/1193<\/b>) auf die Idee zu diesem Beitrag gekommen. Dort haben wir die Tabellen der Beispieldatenbank mit einigen Datenmakros ausgestattet, die dafür sorgen, dass die Daten der Tabelle nur durch Benutzer mit entsprechenden Zugriffsrechten geändert werden dürfen.<\/p>\n
Es wäre etwas mühselig, diese Datenmakros bei großen Datenbankanwendungen für jede Tabelle einzelnen hinzuzufügen. Daher haben wir dort schon gezeigt, wie Sie per VBA-Funktion ein Datenmakro zu der im Parameter der Funktion genannten Tabelle hinzufügen können. Aber wir wollen etwas grundlegender starten.<\/p>\n
Die erste Frage ist: Wie können wir überhaupt auf die bereits in den Tabellen der Anwendung vorhandenen Datenmakros zugreifen Gibt es eine Art VBA-Auflistung Oder auf welche Technik können wir zugreifen, um die vorhandenen Datenmakros zu analysieren<\/p>\n
Schauen wir uns erst einmal an, wie wir über die Benutzeroberfläche auf die Datenmakros zugreifen. Der erste Weg ist über die Entwurfsansicht einer Tabelle. Dann finden Sie im Ribbon-Tab Entwurf<\/b> unter Feld-, Datensatz- und Tabellenereignisse <\/b>den Befehl Datenmakros erstellen<\/b>. Wenn man diese Schaltfläche anklickt, öffnet sich eine Liste aller möglichen Daten-makros. In Bild 1 sind beispielsweise noch keine Datenmakros angelegt.<\/p>\n
![\"Datenmakros](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_001.png\")
<\/p>\n
Bild 1: Datenmakros über die Entwurfsansicht verwalten<\/span><\/b><\/p>\n Wenn wir hier das Makro Nach Einfügung <\/b>anlegen, wird das Icon mit einem roten Rand versehen (siehe Bild 2).<\/p>\n Bild 2: Kennzeichnung eines vorhandenen Datenmakros<\/span><\/b><\/p>\n In der Datenblattansicht ist es noch übersichtlicher (siehe Bild 3). Hier finden Sie im Ribbon-Tab Tabelle <\/b>einige Schaltflächen, mit denen Sie Datenmakros anlegen oder bearbeiten können. Wenn das Daten-makro bereits vorhanden ist, hinterlegt Access die Schaltfläche mit einem Hintergrund wie hier beim Datenmakro Nach Einfügung<\/b>.<\/p>\n Bild 3: Datenmakros über die Datenblattansicht verwalten<\/span><\/b><\/p>\n Wenn Sie auf eine der Schaltflächen klicken, öffnet Access die Entwurfsansicht für das Erstellen und Bearbeiten von Datenmakros. Diese steht aber in diesem Beitrag nicht im Mittelpunkt – daher schauen wir uns diese nun nicht im Detail an.<\/p>\n Nun möchten wir herausfinden, wie wir per VBA auf die Datenmakros einer Tabelle beziehungsweise der kompletten Datenbank zugreifen können. Welches Werkzeug im VBA-Editor hilft uns weiter, etwas über die Befehle in Zusammenhang mit Makros herauszufinden Der Objektkatalog.<\/p>\n Diesen öffnen wir und suchen nach dem Schlüsselwort Macro<\/b>. Hier finden wir zunächst einige acCmd…<\/b>-Konstanten, die letztlich zum Ausführen der Ribbonbefehle per VBA dienen. Außerdem entdecken wir allerdings auch ein paar weitere Elemente, die interessant sein könnten: besonders die Auflistung AllMacros<\/b> (siehe Bild 4).<\/p>\n Bild 4: Befehle, welche die Zeichenkette Macro enthalten<\/span><\/b><\/p>\n Wir schauen uns einmal in einer kleinen Prozedur an, welches Ergebnis diese Auflistung liefert:<\/p>\n Dies liefert allerdings kein Ergebnis, wenn Sie nur Datenmakros angelegt haben. Die Auflistung dient allein dem Zugriff auf die herkömmlichen Makros, die auch im Navigationsbereich unter Makros <\/b>angezeigt werden.<\/p>\n Es gibt also in der Tat keine Möglichkeit, per VBA direkt auf die Datenmakros zuzugreifen. Also gehen wir einen kleinen Umweg.<\/p>\n Wir wissen, dass Datenmakros in Zusammenhang mit Tabellen gespeichert werden. Weiterhin wissen wir, dass es eine Möglichkeit gibt, Access-Objekte über die Anweisung SaveAsText <\/b>auf der Festplatte zu speichern und etwa über einen Texteditor auf diese Dateien zuzugreifen. Also schauen wir uns diesen Befehl einmal genauer an. Dies gelingt etwa über die IntelliSense-Funktion im Direktbereich des VBA-Editors. Dort finden wir dann ganz unten in der Liste eine interessante Konstante, nämlich acTableDataMacro <\/b>(siehe Bild 5).<\/p>\n Bild 5: Die neue Konstante acTableDataMakro<\/span><\/b><\/p>\n Auch für diese Konstante geben wir als zweiten Parameter den Namen des zu speichernden Objekts an sowie als dritten Parameter den Dateinamen, unter dem das Objekt gespeichert werden soll. Nach kurzem Experimentieren wird klar, dass wir für den zweiten Parameter den Tabellennamen angeben, dessen Datenmakros wir im Dateisystem speichern wollen.<\/p>\n Also legen wir für die Tabelle tblArtikel <\/b>einmal je ein Makro für die verschiedenen Typen an (das Ribbon sieht dann für diese Makros wie in Bild 6 aus).<\/p>\n Bild 6: Die Einträge für die Datenmakros im Ribbon<\/span><\/b><\/p>\n Zusätzlich fügen wir auch ein benanntes Makro zu der Tabelle hinzu, für das wir allerdings im Gegensatz zu den vorgegebenen Makros einen Namen angeben müssen. Das ist logisch, denn es kann mehr als ein benanntes Makro je Tabelle geben.<\/p>\n Danach rufen wir den folgenden Befehl auf, um den Code der Datenmakros auf der Festplatte zu speichern:<\/p>\n Das Ergebnis sieht dann in der neu angelegten Datei tblArtikel_Makros.txt <\/b>wie in Listing 1 aus. Hier sehen wir, dass es sich um eine XML-Datei handelt. Diese verwendet als Hauptobjekt das Element DataMacros<\/b>. Darunter finden Sie einige Elemente namens DataMacro<\/b>, die mit einem Attribut namens Event <\/b>ausgestattet sind. Dieses gibt an, durch welches Ereignis das Datenmakro ausgelöst wird:<\/p>\n Listing 1: Die in eine Textdatei exportieren Datenmakros<\/span><\/b><\/p>\n Das ist aber nicht das einzige mögliche Attribut. Genau genommen wird dieses nur für die Datenmakros eingesetzt, die durch ein Ereignis ausgelöst werden. Für die anderen Makros von Tabellen, also die benannten Makros, gibt es das Attribut Name<\/b>.<\/p>\n Unterhalb der DataMacro<\/b>-Elemente finden wir ein Statements<\/b>-Element, das dann die eigentlichen Befehle enthält. In unserem Beispiel haben wir für alle Makros einfach nur den Makrobefehl Kommentar <\/b>eingefügt.<\/p>\n Hier finden dann auch die übrigen Befehle und Strukturen Platz, wobei bei den Strukturen noch untergeordnete Elemente integriert werden. Gleiches gilt für die Datenmakros.<\/p>\n Wie aber nun können wir ermitteln, für welche Tabelle welche Datenmakros existieren und diese etwa im Direktfenster ausgeben Wir müssen tatsächlich über den Umweg des Dateiexports auf die Festplatte gehen. Dort würden wir die so gespeicherte Datei dann mit der Open<\/b>-Anweisung öffnen und mit den Methoden der Bibliothek Microsoft XML, v3.0 <\/b>analysieren.<\/p>\n Diese Bibliothek fügen Sie zunächst über den Verweise<\/b>-Dialog hinzu (siehe Bild 7). Achtung: Mit der Version v6.0 <\/b>funktioniert der nachfolgend angegebene VBA-Code nicht.<\/p>\n Bild 7: Hinzufügen eines Verweises auf die XML-Bibliothek<\/span><\/b><\/p>\n Danach bauen wir zunächst ein Grundgerüst, mit dem wir alle Tabellen einer Datenbank durchlaufen. Dieses sieht wie folgt aus:<\/p>\n Damit durchlaufen wir alle Tabellen der Anwendung, deren Name nicht mit MSys…<\/b> beginnt – also alle Tabellen außer den Systemtabellen. Innerhalb der If…Then<\/b>-Bedingung können wir dann den Aufruf einer weiteren Prozedur unterbringen, welche die Makros in eine Datei exportiert und in ein XML-Dokument einliest – in diesem Fall eine Funktion namens EnthaeltMakros<\/b>.<\/p>\n Diese soll den Wert True <\/b>liefern, wenn eine Tabelle Datenmakros enthält und False<\/b>, wenn dies nicht der Fall ist.<\/p>\n Die Funktion EnthaeltMakros <\/b>erwartet den Namen der zu untersuchenden Tabelle als Parameter sowie eine Variable des Typs MSXML2.DOMDocument<\/b>. Aus diesen bildet sie zunächst einen Dateinamen, der aus dem Pfad zur aktuellen Datenbank, einem Backslash, dem Namen der Tabelle und der Dateiendung .xml <\/b>besteht:<\/p>\n Dann versuchen wir, bei deaktivierter Fehlerbehandlung die SaveAsText<\/b>-Anweisung mit dem Namen der Tabelle für die zu exportierenden Datenmakros und dem Dateinamen als Parameter aufzurufen. Wenn die Tabelle keine Datenmakros enthält, wird der Fehler mit der Nummer 2950 <\/b>ausgelöst (Reservierter Fehler<\/b>). In diesem Fall soll die Funktion enden, ohne den Funktionswert auf True <\/b>einzustellen:<\/p>\n Konnten die Datenmakros hingegen erfolgreich exportiert werden, erstellt die Funktion ein neues Objekt des Typs DOMDocument60<\/b>, das wir im nächsten Schritt mit dem XML-Dokument aus der soeben mit SaveAsText <\/b>angelegten Datei füllen und danach den Inhalt des XML-Dokuments testweise im Direktbereich ausgeben:<\/p>\n In diesem Fall gibt die Funktion den Wert True <\/b>zurück – und auch der Parameter objXML <\/b>liefert das gewünschte XML-Dokument.<\/p>\n In der aufrufenden Prozedur TabellenAnalysieren <\/b>ersetzen wir nun die Debug.Print<\/b>-Anweisung im If<\/b>-Teil der If…Then<\/b>-Bedingung durch den Aufruf der Prozedur XMLAnalysieren<\/b>. Diesem stellen wir die Ausgabe des Tabellennamens voran. Dann übergeben wir das mit objXML <\/b>referenzierte XML-Dokument als Parameter, sodass die Prozedur nun wie folgt aussieht:<\/p>\n Die dadurch aufgerufene Prozedur XMLAnalysieren <\/b>finden Sie in Listing 2.<\/p>\n Listing 2: Diese Prozedur analysiert den Code der enthaltenen Makrodefinitionen anhand der Attribute.<\/span><\/b><\/p>\n Die Prozedur erwartet das XML-Dokument als Parameter. Sie deklariert zwei Variablen: Eine für ein Element des Typs Element <\/b>des XML-Dokuments und eines für ein Attribut<\/b>-Element. Die erste verwendet sie als Laufvariable für eine For Each<\/b>-Schleife über alle mit einer per selectNodes <\/b>abgesetzten XPath-Abfrage. Die Abfrage lautet DataMacros\/DataMacro <\/b>und liefert alle DataMacro<\/b>-Elemente unterhalb des DataMacros<\/b>-Elements. Das sind für unser obiges Beispiel sechs Elemente – die fünf Daten-makros, die durch die verschiedenen Ereignisse ausgelöst werden, und ein benanntes Makro.<\/p>\n Innerhalb der Schleife versucht die Prozedur, mit einer weiteren XPath-Abfrage, diesmal für das bereits in objDataMacro <\/b>gespeicherte XML-Element des Typs DataMacro<\/b>, das Attribut Event <\/b>zu referenzieren. Um Attribute zu referenzieren, stellt man unter XPath dem Attributnamen das @<\/b>-Zeichen voran.<\/p>\n Wenn objAttribute <\/b>danach nicht leer ist, wurde das Attribut gefunden und die Prozedur gibt den Wert des Attributs über die Eigenschaft NodeTyped-Value <\/b>aus. Wurde kein Attribut namens Event <\/b>gefunden, versucht die Prozedur im Else<\/b>-Teil, auf die gleiche Art ein Attribut namens Name <\/b>zu finden. Ist dieses vorhanden, gibt die Prozedur auch dessen Wert samt Attributnamen aus.<\/p>\n Auf diese Weise durchläuft die Prozedur alle Elemente des Typs DataMacro<\/b>. Wenn wir noch für eine weitere Tabelle namens tblBestelldetails <\/b>ein Datenmakro hinzufügen, sieht die Ausgabe im Direktfenster wie folgt aus:<\/p>\n Wir wollen nun nicht weiter ins Detail gehen, was die in den Datenmakros enthaltenen Makroaktionen angeht, sondern eine Möglichkeit schaffen, die Tabellen und die enthaltenen Makros übersichtlich in der Datenbank anzuzeigen, damit der Benutzer diese auf die Schnelle öffnen und bearbeiten kann. Dazu benötigen wir zwei Tabellen zum Speichern der Tabellennamen und der enthaltenen Datenmakros. Auf diese greifen wir dann später von einer Kombination aus Formular und Bericht zu.<\/p>\n <\/p>\n Dazu legen wir zwei Tabellen an. Die erste heißt tblTabellen <\/b>und speichert die Namen der Tabellen, die Datenmakros enthalten. Sie enthält ein Primärschlüsselfeld namens TabelleID <\/b>und ein Textfeld namens Tabelle<\/b>, welches den Namen der Tabelle speichert. Für dieses Feld haben wir einen eindeutigen Index angelegt (siehe Bild 8).<\/p>\n Bild 8: Tabelle zum Speichern der Tabellennamen<\/span><\/b><\/p>\n Die zweite Tabelle heißt tblDatenmakros<\/b>. Das Primärschlüsselfeld nennen wir logischerweise DatenmakroID<\/b>. Aber wie speichern wir die Informationen aus den beiden Attributen Event <\/b>und Name<\/b> Wir legen in einem Nachschlagefeld namens DatenmakrotypID <\/b>den Typ des Datenmakros fest, der einen der folgenden sechs Werte annehmen können soll:<\/p>\n Diese Werte speichern wir in der Lookuptabelle tblDatenmakrotypen<\/b>, die im Entwurf wie in Bild 9 aussieht.<\/p>\n Bild 9: Tabelle zum Speichern der Datenmakrotypen<\/span><\/b><\/p>\n Jetzt fehlt noch ein Feld, das den Namen des Datenmakros speichert. Dieses nennen wir Makroname. Es soll für Datenmakros, die durch Ereignisse ausgelöst werden, den gleichen Wert erhalten, der auch über das Nachschlagefeld ausgewählt wurde, also Vor Änderung<\/b>, Vor Löschung <\/b>und so weiter. Für die benannten Makros hinterlegen wir den angegebenen Namen. Schließlich geben wir in einem weiteren Nachschlagefeld namens TabelleID <\/b>noch an, zu welcher Tabelle das Datenmakro gehört. Der Entwurf der Tabelle tblDatenmakros <\/b>sieht dann wie in Bild 10 aus.<\/p>\n Bild 10: Tabelle zum Speichern der Datenmakro-Eigenschaften<\/span><\/b><\/p>\n Die Beziehungen der Tabellen haben wir in Bild 11 abgebildet.<\/p>\n Bild 11: Beziehung der beteiligten Tabellen<\/span><\/b><\/p>\n Nun passen wir die Prozeduren TabellenAnalysieren <\/b>und XML-Analysieren <\/b>noch so an, dass die ermittelten Daten nicht im Direktbereich des VBA-Editors landen, sondern in den soeben erstellten Tabellen. Die Frage hierbei ist noch, ob wir nur die Tabellen in die Tabelle tblTabellen <\/b>schreiben sollen, die bereits über Datenmakros verfügen, oder ob wir dort alle Tabellen eintragen sollen. Das wäre sinnvoll, wenn wir in unserer noch zu erstellenden Benutzeroberfläche nicht nur per Klick den Entwurf eines Makros öffnen, sondern auch noch neue Datenmakros anlegen wollen. Wir belassen es zunächst bei den Tabellen, die bereits Datenmakros enthalten.<\/p>\n Dazu haben wir die Prozedur TabellenAnalysieren <\/b>wie in Listing 3 angepasst. Sie löscht zunächst alle Einträge der Tabelle tblTabellen<\/b>.<\/p>\n Listing 3: Die neue Version der Prozedur TabellenAnalysieren schreibt direkt die Tabellen in tblTabellen.<\/span><\/b><\/p>\n Damit dies ausreicht, um auch die mit diesen Einträgen verknüpften Datensätze der Tabelle tblDatenmakros <\/b>zu löschen, haben wir für die Beziehung zwischen diesen beiden Tabellen referenzielle Integrität mit Löschweitergabe definiert (siehe Bild 12).<\/p>\n Bild 12: Referenzielle Integrität mit Löschweitergabe<\/span><\/b><\/p>\n Die Prozedur durchläuft nach wie vor alle benutzerdefinierten Tabellen der Datenbank und prüft mit der Funktion EnthaeltMakros<\/b>, ob die Tabelle Datenmakros enthält. In diesem Fall schreibt sie die Tabelle als neuen Datensatz in die Tabelle tblTabellen <\/b>und ermittelt den Primärschlüsselwert des neuen Datensatzes. Damit ausgestattet, ruft sie die Prozedur XMLAnalysieren <\/b>auf.<\/p>\n Diese Prozedur erwartet neben dem Verweis auf das XML-Dokument nun noch zwei weitere Parameter: den Primärschlüsselwert des durch die Prozedur TabellenAnalysieren <\/b>hinzugefügten Datensatzes und den Verweis auf das Database<\/b>-Objekt der aktuellen Datenbank (siehe Listing 4).<\/p>\n![\"Kennzeichnung](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_002.png\")
<\/p>\nDatenmakros per Datenblatt<\/h2>\n
![\"Datenmakros](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_003.png\")
<\/p>\nPer VBA auf die Datenmakros zugreifen<\/h2>\n
![\"Befehle,](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_004.png\")
<\/p>\nPublic Sub <\/span>AlleMakros()\r\n Dim <\/span>mac As Object<\/span>\r\n For Each mac In CurrentProject.AllMacros\r\n Debug.Print<\/span> TypeName(mac), mac.Name\r\n Next<\/span> mac\r\nEnd Sub<\/span><\/pre>\nUmweg über SaveAsText<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_005.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_006.png\")
<\/p>\nSaveAsText acTableDataMacro, \"tblArtikel\", Currentproject.Path & \"\tblArtikel_Makros.txt\"<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\">\r\n<DataMacros xmlns=\"http:\/\/schemas.microsoft.com\/office\/accessservices\/2009\/11\/application\">\r\n <DataMacro Event=\"AfterInsert\">\r\n <Statements>\r\n <Comment>Kommentar Nach Einfügung<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n <DataMacro Event=\"AfterUpdate\">\r\n <Statements>\r\n <Comment>Kommentar Nach Aktualisierung<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n <DataMacro Event=\"AfterDelete\">\r\n <Statements>\r\n <Comment>Kommentar Nach Löschung<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n <DataMacro Event=\"BeforeChange\">\r\n <Statements>\r\n <Comment>Kommentar Vor Änderung<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n <DataMacro Event=\"BeforeDelete\">\r\n <Statements>\r\n <Comment>Kommentar Vor Löschung<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n <DataMacro Name=\"dmkBeispiel\">\r\n <Statements>\r\n <Comment>Kommentar Benanntes Makro<\/Comment>\r\n <\/Statements>\r\n <\/DataMacro>\r\n<\/DataMacros><\/pre>\n
\n
Datenmakro analysieren<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_007.png\")
<\/p>\nAlle Tabellen durchlaufen<\/h2>\n
Public Sub <\/span>TabellenAnalysieren()\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>tbl As <\/span>dao.TableDef\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument60\r\n Set<\/span> db = CurrentDb\r\n For Each tbl In db.TableDefs\r\n If <\/span>Not<\/span> (Left<\/span>(tbl.Name, 4) = \"MSys\") Then<\/span>\r\n If <\/span>EnthaeltMakros(tbl.Name, objXML) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Makros vorhanden in ''\" & tbl.Name & \"''.\"\r\n Else<\/span>\r\n Debug.Print<\/span> \"Keine Makros in ''\" & tbl.Name & \"''.\"\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> tbl\r\nEnd Sub<\/span><\/pre>\nMakros nach XML<\/h2>\n
Public Function <\/span>EnthaeltMakros(strTabelle As String<\/span>, objXML As <\/span>MSXML2.DOMDocument60) As Boolean<\/span>\r\n Dim <\/span>strDateiname As String<\/span>\r\n strDateiname = CurrentProject.Path & \"\" & strTabelle & \".xml\"<\/pre>\n On Error Resume Next<\/span>\r\n SaveAsText acTableDataMacro, strTabelle, strDateiname\r\n If <\/span>Err.Number = 2950 Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0<\/pre>\n Set<\/span> objXML = New<\/span> MSXML2.DOMDocument60\r\n objXML.Load strDateiname\r\n Debug.Print<\/span> objXML.XML\r\n EnthaeltMakros = True<\/span>\r\nEnd Function<\/span><\/pre>\nXML-Dokument analysieren<\/h2>\n
Public Sub <\/span>TabellenAnalysieren()\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>tbl As <\/span>dao.TableDef\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument\r\n Set<\/span> db = CurrentDb\r\n For Each tbl In db.TableDefs\r\n If <\/span>Not<\/span> (Left<\/span>(tbl.Name, 4) = \"MSys\") Then<\/span>\r\n If <\/span>EnthaeltMakros(tbl.Name, objXML) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Tabelle: \" & tbl.Name\r\n Debug.Print<\/span> String(Len<\/span>(\"Tabelle: \" & tbl.Name), \"=\")\r\n XMLAnalysieren objXML\r\n Debug.Print<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> tbl\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>XMLAnalysieren(objXML As <\/span>MSXML2.DOMDocument)\r\n Dim <\/span>objDataMacro As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objAttribute As <\/span>MSXML2.IXMLDOMAttribute\r\n For Each objDataMacro In objXML.selectNodes(\"DataMacros\/DataMacro\")\r\n Set<\/span> objAttribute = objDataMacro.selectSingleNode(\"@Event\")\r\n If <\/span>Not<\/span> objAttribute Is Nothing Then<\/span>\r\n Debug.Print<\/span> \" Event: \" & objAttribute.nodeTypedValue\r\n Else<\/span>\r\n Set<\/span> objAttribute = objDataMacro.selectSingleNode(\"@Name\")\r\n If <\/span>Not<\/span> objAttribute Is Nothing Then<\/span>\r\n Debug.Print<\/span> \" Name: \" & objAttribute.nodeTypedValue\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> objDataMacro\r\nEnd Sub<\/span><\/pre>\nTabelle: tblArtikel\r\n===================\r\n Event: AfterInsert\r\n Event: AfterUpdate\r\n Event: AfterDelete\r\n Event: BeforeChange\r\n Event: BeforeDelete\r\n Name: dmkBeispiel\r\nTabelle: tblBestelldetails\r\n==========================\r\n Event: AfterInsert<\/pre>\n
Datenmakros in Tabelle speichern<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_008.png\")
<\/p>\n\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_009.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_010.png\")
<\/p>\n![\"Beziehung](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_011.png\")
<\/p>\nTabellen mit den Datenmakros füllen<\/h2>\n
Public Sub <\/span>TabellenAnalysieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tbl As <\/span>DAO.TableDef\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>lngTabelleID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblTabellen\", dbFailOnError\r\n For Each tbl In db.TableDefs\r\n If <\/span>Not<\/span> (Left<\/span>(tbl.Name, 4) = \"MSys\") Then<\/span>\r\n If <\/span>EnthaeltMakros(tbl.Name, objXML) = True<\/span> Then<\/span>\r\n db.Execute \"INSERT INTO tblTabellen(Tabelle) VALUES(''\" & tbl.Name & \"'')\", dbFailOnError\r\n lngTabelleID = db.OpenRecordset(\"SELECT @@IDENTITY\", dbOpenDynaset).Fields(0)\r\n XMLAnalysieren objXML, lngTabelleID, db\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> tbl\r\nEnd Sub<\/span><\/pre>\n![\"Referenzielle](\"..\/fileadmin\/_temp_\/2019_05\/pic_1203_012.png\")
<\/p>\nPublic Sub <\/span>XMLAnalysieren(objXML As <\/span>MSXML2.DOMDocument, lngTabelleID As Long<\/span>, db As <\/span>DAO.Database)\r\n Dim <\/span>objDataMacro As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objAttribute As <\/span>MSXML2.IXMLDOMAttribute\r\n Dim <\/span>lngDatenmakrotypID As Long<\/span>\r\n For Each objDataMacro In objXML.selectNodes(\"DataMacros\/DataMacro\")\r\n Set<\/span> objAttribute = objDataMacro.selectSingleNode(\"@Event\")\r\n If <\/span>Not<\/span> objAttribute Is Nothing Then<\/span>\r\n lngDatenmakrotypID = DLookup(\"DatenmakrotypID\", \"tblDatenmakrotypen\", \"Datenmakrotyp = ''\" _\r\n & objAttribute.nodeTypedValue & \"''\")\r\n db.Execute \"INSERT INTO tblDatenmakros(DatenmakrotypID, Makroname, TabelleID) VALUES(\" _\r\n & lngDatenmakrotypID & \", ''\" & objAttribute.nodeTypedValue & \"'', \" & lngTabelleID & \")\", dbFailOnError\r\n Else<\/span>\r\n Set<\/span> objAttribute = objDataMacro.selectSingleNode(\"@Name\")\r\n If <\/span>Not<\/span> objAttribute Is Nothing Then<\/span>\r\n lngDatenmakrotypID = DLookup(\"DatenmakrotypID\", \"tblDatenmakrotypen\", _\r\n \"Datenmakrotyp = ''NamedDataMacro''\")\r\n db.Execute \"INSERT INTO tblDatenmakros(DatenmakrotypID, Makroname, TabelleID) VALUES(\" _\r\n & lngDatenmakrotypID & \", ''\" & objAttribute.nodeTypedValue & \"'', \" & lngTabelleID & \")\", dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> objDataMacro\r\nEnd Sub<\/span><\/pre>\n