{"id":55000431,"date":"2007-02-01T00:00:00","date_gmt":"2021-02-11T21:08:00","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=431"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Trigger_im_SQL_Server_","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/","title":{"rendered":"Trigger im SQL Server"},"content":{"rendered":"

\"\" <\/p>\n

Auch wenn Access und die Jet-Engine bereits zahlreiche Möglichkeiten einer „richtigen“ Datenbank enthalten, fehlen immer noch wichtige Funktionen: So finden Sie etwa beim Umstieg auf SQL Server-Backends viel Bekanntes, aber auch Unbekanntes – zum Beispiel Trigger. Im vorliegenden Beitrag stellen wir den Nutzen von und den Umgang mit Triggern vor.<\/b><\/p>\n

Welche Aufgaben haben Trigger im SQL Server eigentlich Laut übersetzungshilfe beschreibt das Substantiv „Trigger“ den Auslöser, den Anstoß oder den Abzugsbügel und das Verb entsprechend ansteuern, auslösen, einleiten.<\/p>\n

Ein Trigger löst also bei bestimmten Aktionen etwas aus. Da wir uns im SQL Server befinden, kann also nur ein SQL-Befehl etwas auslösen und das kann hier natürlich auch nur wieder ein SQL-Statement sein. Damit realisieren Trigger etwa die Funktionalität, die wir vom Client und dabei etwa aus Access als VBA-Ereignisprozedur kennen. Mit Ereignisprozeduren können Sie beispielsweise beim Einfügen eines Datensatzes eine Aktion auslösen und diesen Vorgang unter bestimmten Bedingungen abbrechen (s. Listing 1).<\/p>\n\n\n\n\n
\n

Listing 1: Eine Ereignisprozedur in VBA<\/p>\n<\/td>\n<\/tr>\n

\n

Private Sub Form_BeforeInsert(Cancel As Integer)<\/p>\n

If Name = "Doofmann" Then<\/p>\n

MsgBox "Solche Namen wollen wir hier nicht!"<\/p>\n

Cancel = True<\/p>\n

End If<\/p>\n

End Sub<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Die unterschiedlichen Client-Programmierumgebungen unterstützen unterschiedliche Ereignisse. Was in VBA unter Access geht, ist vielleicht unter ADO.NET nicht verfügbar, und andersherum, unter ADO und C++ wiederum finden Sie wieder ganz andere Möglichkeiten.<\/p>\n

Wenn aber die unterschiedlichen Clients solche Funktionen kennen, warum brauchen wir sie dann noch einmal im SQL Server In einer richtigen Client-Server-Umgebung ist es eben nicht sichergestellt, dass alle Veränderungen an den Daten einer Datenbank über denselben Client abgewickelt werden. Wenn Sie eine Access-Anwendung auf einer SQL Server 2005-Datenbank programmieren und vor dem Löschen eines Datensatzes diesen unbedingt in eine „Ist-gelöscht-worden“-Tabelle schreiben möchten, dann ist die Ereignisprozedur in Access nicht der richtige Weg, da jeder Berechtigte direkt auf die SQL Server-Datenbank zugreifen und ein DELETE FROM tblMeineDaten WHERE ID=9 <\/b>absetzen kann. Der Datensatz wäre ohne Dokumentation verschwunden (die Syntax „DELETE * FROM…“, also mit „*“ ist im übrigen Access-Dialekt und nicht ANSI SQL).<\/p>\n

Die Funktionalität wird also vom Client auf den Server verschoben. ähnliches kennen Sie schon von der referentiellen Integrität. Auch das Löschen von Master-Datensätzen bei existierenden Detail-Datensätzen kann man mit einer client-seitigen Ereignisprozedur überwachen und gegebenenfalls verhindern, doch Access kann dies auch automatisch unterlassen.<\/p>\n

Im SQL Server haben Sie noch viel mehr Möglichkeiten: Angenommen, Sie möchten die erwähnte Funktionalität umsetzen und jeden Datensatz vor dem Löschen in eine Dokumentations- oder Historisierungstabelle schreiben, dann sind Trigger genau das Richtige für Sie.<\/p>\n

Zum Nachvollziehen der Beispiele bauen Sie am besten direkt eine kleine Testdatenbank auf. Dazu können Sie das Skript aus Listing 2 verwenden, das Sie am einfachsten über das SQL Server Management Studio des SQL Servers 2005 eingeben und ausgeführen (weitere Informationen siehe [1]). Die Syntax wird aber auch vom SQL Server 2000 unterstützt, die ersten Beispiele können Sie daher auch auf diesem nachvollziehen und das Skript beispielsweise im Query Analyser des SQL Servers 2000 ausführen. Wenn Sie die Beispiele wieder löschen wollen, löschen Sie einfach die gesamte Test-Datenbank mit dem Befehl DROP DATABASE TestTrigger<\/b>. Falls Sie die Fehlermeldung erhalten, dass die Datenbank nicht gelöscht werden kann, weil sie in Benutzung ist (wahrscheinlich von Ihnen selbst durch die Tests), hilft der folgende kleine Trick beim Schließen aller bestehenden Verbindungen:<\/p>\n

USE master\r\ngo\r\nALTER DATABASE TriggerTest SET SINGLE_USER WITH ROLLBACK IMMEDIATE\r\ngo\r\nDROP DATABASE TriggerTest<\/pre>\n
Das Skript aus Listing 2 erledigt Folgendes: Der Befehl USE<\/b> wechselt den aktuellen Datenbankkontext, weil es im SQL Server in einer Instanz mehrere Datenbanken geben kann (und meistens auch gibt). Nach dem Erstellen der Datenbank TestTrigger <\/b>erstellt das Skript mit der CREATE TABLE<\/b>-Anweisung zwei Tabellen. Die erste Tabelle MyData <\/b>enthält die Ausgangsdaten, die zweite Tabelle MyDataHistory<\/b> soll die Löschvorgänge mit Uhrzeit (DEFAULT <\/b>entspricht dem Standardwert eines Feldes unter Access) und aktuellem Benutzer dokumentieren. Der Befehl GO <\/b>beendet einen Batch, wobei zur Vereinfachung beinahe alle Befehle in einem einzigen Batch untergebracht sind. Die Anweisungen können dann einzeln markiert und nacheinander ausgeführt werden (wenn Sie F5<\/b> oder STRG+E <\/b>drücken, wird sowohl im Query Analyser des SQL Server 2000 als auch im SQL Server Management Studio des SQL Server 2005 nur die Markierung ausgeführt).<\/p>\n\n\n\n\n
\n
Listing 2: Erstellen der benötigten Objekte für die Beispiele<\/p>\n<\/td>\n<\/tr>\n
\n
-- SETUP der Beispieldatenbank ----------<\/pre>\n
USE master<\/pre>\n
go<\/pre>\n
CREATE DATABASE TriggerTest<\/pre>\n
GO<\/pre>\n
USE TriggerTest<\/pre>\n
GO<\/pre>\n
CREATE TABLE MyData<\/pre>\n
    ID int identity Primary Key,<\/pre>\n
    Name nvarchar(80)<\/pre>\n
)<\/pre>\n
GO<\/pre>\n
INSERT INTO MyData VALUES ('Müller')<\/pre>\n
INSERT INTO MyData VALUES ('Maier')<\/pre>\n
INSERT INTO MyData VALUES ('Schmidt')<\/pre>\n
INSERT INTO MyData VALUES ('Schulz')<\/pre>\n
INSERT INTO MyData VALUES ('Schäfer')<\/pre>\n
GO<\/pre>\n
SELECT * FROM myData<\/pre>\n
GO<\/pre>\n
CREATE TABLE MyDataHistory<\/pre>\n
    ID int,<\/pre>\n
    Name nvarchar(80),<\/pre>\n
    DeletedAt datetime DEFAULT GETDATE(),<\/pre>\n
    DeletedFrom nvarchar(80) DEFAULT SYSTEM_USER<\/pre>\n
)<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ein einfacher Trigger<\/b><\/p>\n
Einen Trigger erstellt man wie andere Objekte in SQL mit dem CREATE<\/b>-Befehl, hier mit CREATE TRIGGER<\/b>. Trigger wie der geplante werden immer für eine bestimmte Tabelle erstellt. Diese Tabelle legt man mit dem Schlüsselwort ON <\/b>fest (s. Listing 3).<\/p>\n\n\n\n\n
\n
Listing 3: Erstellen eines einfachen Triggers<\/p>\n<\/td>\n<\/tr>\n
\n
CREATE TRIGGER DataHistory ON myData FOR DELETE<\/p>\n
    AS<\/p>\n
BEGIN<\/p>\n
     INSERT INTO MyDataHistory (ID, Name) SELECT ID, Name FROM deleted<\/p>\n
END<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Beachten Sie das Schlüsselwort FOR DELETE<\/b>. Genauso können Sie auch Trigger für das Einfügen und ändern erstellen, dann verwenden Sie das Schlüsselwort FOR INSERT <\/b>oder FOR UPDATE<\/b>. Es gibt auch gleichnamige gemeinsame Trigger.<\/p>\n
Löschen Sie nun mit den folgenden Anweisungen einmal ein paar Datensätze:<\/p>\n
DELETE FROM MyData where ID=2\r\nDELETE FROM MyData where ID=5\r\nGO<\/pre>\n
Schauen Sie sich das Ergebnis in den beiden Tabellen an:<\/p>\n
SELECT * FROM myData\r\nSELECT * FROM myDataHistory<\/pre>\n
Interessant ist hier der Befehl, der im Trigger selbst ausgeführt wird: INSERT INTO… SELECT … FROM deleted<\/b>. Um welche Tabelle handelt es sich denn bei deleted<\/b><\/p>\n
Dies ist keine tatsächlich im SQL Server vorhandene Tabelle. Die Abfrage SELECT * FROM deleted <\/b>wird vom SQL Server dementsprechend mit der Fehlermeldung Invalid object name 'deleted“<\/b> beantwortet.<\/p>\n
Die Trigger-Tabellen<\/b><\/p>\n
Der SQL Server stellt die Tabelle deleted<\/b> allein im Kontext eines Triggers bereit und auch nur für die Dauer der Durchführung des Triggers. Es handelt sich tatsächlich um eine Tabelle, wenn auch keine im üblichen Sinne, und nicht etwa um einen einzelnen Datensatz, denn in einem SQL-Statement können durchaus mehrere Datensätze gelöscht werden. Für jedes Statement wird der Trigger aber nur einmal ausgelöst. Wenn Sie drei Datensätze wie im unten stehenden Listing löschen, wird der Trigger trotzdem nur einmal ausgelöst, die Tabelle deleted <\/b>enthält dann eben drei Datensätze, wie wir einfach nachweisen können.<\/p>\n
Bemerkenswert ist, dass der SQL Server beim Löschen von Datensätzen auch zwei Meldungen erzeugt (siehe Bild 1). (3 row(s) affected) <\/b>bezieht sich bei der ersten Meldung auf das Einfügen in die History-Tabelle und bei der zweiten Meldung auf den Löschvorgang in MyData<\/b>. Ob dies tatsächlich die richtige Reihenfolge ist, lässt sich leicht prüfen. Dazu ändern Sie den Trigger wie folgt, was dazu führt, dass der Datensatz mit dem Wert Beethoven <\/b>für das Feld Name<\/b> nicht in die History-Tabelle geschrieben wird.<\/p>\n
ALTER TRIGGER [dbo].[DataHistory] ON [dbo].[MyData] FOR DELETE\r\nAS\r\nBEGIN\r\nINSERT INTO MyDataHistory (ID, NAME)\r\nSELECT ID, Name FROM deleted WHERE Name<>'Beethoven'\r\nEND<\/pre>\n
            \"Trigger01.bmp\"<\/p>\n
Bild 1: Ausgabe im SQL Server Management Studio<\/span><\/b><\/p>\n
<\/p>\n
Dementsprechend sollten nun beim Löschen dreier Datensätze zwei Meldungen erscheinen, von denen die eine drei und die andere zwei Datensätze betrifft. Wie Bild 2 zeigt, führt der SQL Server tatsächlich zunächst die im Trigger enthaltenen Operationen und erst dann den eigentlichen Löschvorgang durch.<\/p>\n
            \"Trigger02.bmp\"<\/p>\n
Bild 2: Der Trigger fügt erst die gelöschten Datensätze ein und löscht diese dann aus der Originaltabelle.<\/span><\/b><\/p>\n
So jedenfalls scheint es. Die Aktion des Triggers wird aber laut Dokumentation erst nach der eigentlichen Aktion des SQL-Statements ausgeführt. Alle Trigger im SQL Server 2000 und 2005 sind standardmäßig AFTER-Trigger. Das Schlüsselwort FOR ist dabei gleichbedeutend mit AFTER. <\/p>\n
INSERT- und UPDATE-Trigger<\/b><\/p>\n
Wir haben bislang immer mit einem DELETE-Trigger experimentiert, wie verhalten sich die anderen DML (Data Manipulation Language)-Trigger, die beim Einfügen (Insert<\/b>) und Aktualisieren (Update<\/b>) ausgeführt werden<\/p>\n
Im Prinzip genauso, nur werden unterschiedliche Tabellen innerhalb der Trigger vom SQL Server verwaltet. Um dies nachzuvollziehen, erweitern wir die History-Tabelle um einen Eintrag, der anzeigt, ob die Daten gelöscht, eingefügt oder geändert wurden (s. Listing 4).<\/p>\n\n\n\n\n
\n
Listing 4: Historisieren eingefügter Datensätze<\/p>\n<\/td>\n<\/tr>\n
\n
ALTER TABLE MyDataHistory ADD Type nvarchar(8)<\/pre>\n
GO<\/pre>\n
UPDATE MyDataHistory SET Type='delete'<\/pre>\n
GO<\/pre>\n
ALTER TRIGGER dbo.DataHistory ON dbo.MyData FOR DELETE<\/pre>\n
AS<\/pre>\n
BEGIN<\/pre>\n
     INSERT INTO MyDataHistory (ID, Name, Type)<\/pre>\n
     Select ID, Name, 'delete' FROM deleted <\/pre>\n
END<\/pre>\n
GO<\/pre>\n
CREATE TRIGGER dbo.InsertHistory ON dbo.MyData AFTER INSERT<\/pre>\n
AS<\/pre>\n
BEGIN<\/pre>\n
    INSERT INTO MyDataHistory (ID, Name, Type) <\/pre>\n
    Select ID, Name, 'insert' FROM inserted <\/pre>\n
END<\/pre>\n
GO<\/pre>\n
INSERT INTO MyData VALUES ('Wagner')<\/pre>\n
GO<\/pre>\n
SELECT * FROM MyData<\/pre>\n
SELECT * FROM MyDataHistory<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Wie Sie sehen, wird beim Einfügen innerhalb des INSERT-Triggers eine Tabelle inserted <\/b>bereitgestellt. Und beim UPDATE-Trigger Falsch geraten! Es gibt keine Tabelle namens updated<\/b>. Stattdessen benutzt der Update-Trigger beide von den anderen Triggern verwendeten Tabellen. In der Tabelle inserted <\/b>werden die neuen Werte abgelegt und in der Tabelle deleted <\/b>die gelöschten (s. Listing 5).<\/p>\n\n\n\n\n\n\n\n
\n
Listing 5: Update-Trigger greifen auf die beiden Tabellen deleted und inserted zu.<\/p>\n<\/td>\n<\/tr>\n
\n
CREATE TRIGGER dbo.UpdateHistory ON dbo.MyData AFTER UPDATE<\/pre>\n
AS<\/pre>\n
BEGIN<\/pre>\n
     INSERT INTO MyDataHistory (ID, Name, Type) <\/pre>\n
     SELECT inserted.ID, <\/pre>\n
     isnull(deleted.Name,'(NULL)')+'->'+isnull(inserted.<\/pre>\n
     name,'(NULL)'), 'update' <\/pre>\n
     FROM inserted inner join deleted on<\/pre>\n
     inserted.ID=deleted.ID<\/pre>\n
END<\/pre>\n<\/td>\n<\/tr>\n
\n                        <\/td>\n<\/tr>\n
\n                        <\/td>\n<\/tr>\n
\n                        <\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ein kleiner Tipp: Viele clientseitige Zugriffstechnologien wie ADO und ADO.NET können Probleme mit den Meldungen der Trigger und allen anderen Statusmeldungen bekommen. Wie Sie im Screenshot aus Bild 3 sehen, würden Sie zu Recht ein gültiges Recordset erwarten. Durch die Löschmeldung aber ist es nicht mehr möglich, auf dieses zuzugreifen.<\/p>\n
            \"Trigger03.bmp\"<\/p>\n
Bild 3: ADO und Löschmeldungen<\/span><\/b><\/p>\n
Sie können daher im obigen Beispiel den Open<\/b>-Befehl durch den folgenden ersetzen, dann funktioniert auch wieder der Zugriff auf das Recordset:<\/p>\n
SET NOCOUNT ON;\r\nDELETE FROM MyData WHERE Name LIKE 'B%'\r\nSELECT * FROM MyData<\/pre>\n
Der Befehl SET NOCOUNT ON <\/b>sorgt dafür, dass keine Statusmeldungen über die Anzahl der vom Löschen, Einfügen oder ändern betroffenen Datensätze mehr vom SQL Server gesendet werden:<\/p>\n
SET NOCOUNT ON\r\nINSERT INTO MyData VALUES ('Bach')\r\nGO\r\nDELETE FROM MYData WHERE Name='Bach'<\/pre>\n
Transaktionen und Trigger<\/b><\/p>\n
Wie aber verhält es sich mit der Möglichkeit, SQL-Aktionen in einem Trigger abzubrechen Im ersten Beispiel, der Ereignisprozedur in VBA, war dies möglich – aber genauso einfach geht es auch im Trigger. Dazu muss man das Transaktionshandling des SQL Servers ein bisschen genauer verstehen. Eine Transaktion ist, wie Sie sicher wissen, ein Satz von SQL-Anweisungen, der entweder vollständig oder gar nicht ausgeführt wird. Daher ist auch jeder einzelne SQL-Befehl eine Transaktion, denn Sie würden sicher zu Recht davon ausgehen, dass bei der Anweisung<\/p>\n
UPDATE Employee SET Gehalt=Gehalt*1.1<\/pre>\n
entweder alle Angestellten eine Gehaltserhöhung bekommen oder keiner. Eine solche Transaktion wird im SQL Server „implizit“ genannt. Eine explizite Transaktion wird mit dem Schlüsselwort BEGIN TRAN <\/b>oder BEGIN TRANSACTION <\/b>eingeführt und dann mit COMMIT TRAN <\/b>bestätigt oder mit ROLLBACK TRAN <\/b>abgebrochen.<\/p>\n
Alternativ können Sie natürlich auch clientseitige Methoden verwenden: etwa die BeginTrans<\/b>– oder RollbackTrans<\/b>– und CommitTrans<\/b>-Methode des ADODB.Connection<\/b>-Objektes oder den TransactionContext <\/b>von ADO.NET. Folgendes Listing zeigt ein Beispiel für eine explizite Transaktion:<\/p>\n
SET NOCOUNT OFF\r\nGO\r\nBEGIN TRANSACTION\r\n UPDATE MyData Set Name='Haydn' WHERE ID=1\r\n UPDATE MyData Set Name='Gluck' WHERE ID=2\r\nIF @@ROWCOUNT =0 ROLLBACK TRAN ELSE COMMIT TRAN\r\nGO\r\nSELECT * FROM MyData<\/pre>\n
Im Listing wird die Transaktion „zurückgerollt“, wenn die letzte Anweisung keinen Datensatz betrifft (@@ROWCOUNT=0<\/b>), was hier der Fall ist. Da die gesamte Transaktion verworfen wird, ist also auch der Datensatz mit ID 1<\/b> und dem Namen Müller <\/b>noch vorhanden.<\/p>\n
Wann aber wird der Trigger aufgerufen Vor, nach oder während der Transaktion ändern wir den Trigger so, dass er eine Meldung ausgibt, wenn er aufgerufen wird (siehe Bild 4).<\/p>\n
            \"Trigger04.bmp\"<\/p>\n
Bild 4: Der Trigger sorgt für die Ausgabe einer Meldung.<\/span><\/b><\/p>\n
Auch wenn kein Datensatz wirklich gelöscht wurde, wird der Trigger durch den DELETE-Befehl ausgelöst und fügt 0 Datensätze in die History-Tabelle ein.<\/p>\n
Bestimmte Aspekte einer Datenbank beziehungsweise einer Tabelle werden vom SQL Server überprüft, bevor eine Transaktion ausgeführt wird. Dazu gehören beispielsweise die Einschränkungen auf Tabellenebene. So kennt der SQL Server etwa die Foreign-Key-Einschränkung. Das Skript aus Listing 6 erstellt eine weitere Tabelle namens MyDataDetail <\/b>und fügt Datensätze ein, die über den Fremdschlüssel der ID des Komponisten miteinander verbunden sind. Interessant ist es, nun ein DELETE<\/b>-Statement auszuführen, das versucht, einen Datensatz aus MyData <\/b>(also der „Komponisten“-Tabelle) zu löschen, für den Detaildatensätze vorhanden sind (ID 14 natürlich, hier „Mozart“):<\/p>\n
GO\r\nDELETE FROM MyData Where Name='Mozart'<\/pre>\n\n\n\n\n
\n
Listing 6: Erstellen einer 1:n-Relation<\/p>\n<\/td>\n<\/tr>\n
\n
UPDATE MyData Set Name='Haydn' WHERE ID=1<\/pre>\n
UPDATE MyData Set Name='Gluck' WHERE ID=3<\/pre>\n
UPDATE MyData Set Name='Brahms' WHERE ID=4<\/pre>\n
INSERT INTO MyData VALUES ('Bach')<\/pre>\n
INSERT INTO MyData VALUES ('Mozart')<\/pre>\n
INSERT INTO MyData VALUES ('Beethoven')<\/pre>\n
GO<\/pre>\n
SELECT * FROM MyData<\/pre>\n
GO<\/pre>\n
CREATE TABLE MyDataDetail<\/pre>\n
    ID int identity PRIMARY KEY,<\/pre>\n
    MasterID int,<\/pre>\n
    Opus varchar(180)<\/pre>\n
)<\/pre>\n
GO<\/pre>\n
ALTER TABLE dbo.MyDataDetail WITH CHECK ADD CONSTRAINT FK_MasterData FOREIGN KEY(MasterID)<\/pre>\n
REFERENCES dbo.MyData (ID)<\/pre>\n
GO<\/pre>\n
INSERT INTO MyDataDetail VALUES (14,'KV 550 1788 Symphonie Nr. 40 g-moll')<\/pre>\n
INSERT INTO MyDataDetail VALUES (14,'KV 551 1788 Symphonie Nr. 41 ''Jupiter'' C-Dur')<\/pre>\n
INSERT INTO MyDataDetail VALUES (14,'KV 552 1788 Klavierlied ''Beim Auszug in das Feld, ...')<\/pre>\n
GO<\/pre>\n
DELETE FROM MyData Where Name='Mozart'<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Der SQL Server antwortet mit einer Fehlermeldung, da die Fremdschlüssel-Einschränkung referentielle Integrität definiert, ohne Löschweitergabe zu konfigurieren – auch dies ist im SQL Server seit Version 2000 möglich. Dann jedoch hätte das FOREIGN KEY CONSTRAINT <\/b>mit der Option ON DELETE CASCADE <\/b>erstellt werden müssen.<\/p>\n
Wenn Sie das DELETE<\/b>-Statement ausführen, werden Sie allerdings beobachten, dass zwar die Fehlermeldung ausgegeben wird, aber keine Ausgabe aus dem Trigger erfolgt. Der SQL Server beachtet nämlich alle CONSTRANTS<\/b>, bevor er eine Transaktion ausführt.<\/p>\n
Tatsächlich wird der Trigger innerhalb der Transaktion aufgerufen, das heißt, dass man eine solche Transaktion tatsächlich auch im Trigger abbrechen kann. Dazu ändern Sie den bestehenden Trigger und verhindern, dass ein Datensatz mit dem Namen „Brahms“ gelöscht wird (siehe Bild 5).<\/p>\n
            \"Trigger05.bmp\"<\/p>\n
Bild 5: Der Datensatz mit dem Namen „Brahms“ wird nun nicht mehr gelöscht.<\/span><\/b><\/p>\n
Einen anderen Datensatz können sie etwa mit folgender Anweisung problemlos löschen:<\/p>\n
DELETE FROM MyData WHERE Name='Haydn'<\/pre>\n
Vorsicht bei Trigger-Transaktionen<\/b><\/p>\n
Da Trigger innerhalb der Transaktionen aufgerufen werden, sind sie entsprechend vorsichtig einzusetzen. Beachten Sie, dass die Transaktion umso länger dauert, je mehr Aktionen innerhalb von Triggern ausgeführt werden. Gerade bei stark belasteten Datenbanken und Servern sind Trigger daher ein gefährlicher Performance-Engpass, da sie unweigerlich bei jeder Transaktion, für die sie definiert sind, aufgerufen werden. Besonders abzuraten ist es daher, im Trigger Anweisungen auszuführen, die auf Daten oder Objekte außerhalb des SQL Servers zugreifen, also etwa über Systemprozeduren E-Mails zu verschicken oder ähnliches. Im neuen SQL Server 2005 könnte man in solchen Szenarien eine Service Broker Nachricht verschicken, die ein anderes System darüber informiert, dass eine E-Mail zu versenden sei, um so den Trigger und das Versenden der E-Mail zu entkoppeln.<\/p>\n
Trigger an- und abschalten<\/b><\/p>\n
Oftmals ist es daher wünschenswert, dass die Trigger zwar während der normalen Dateneingabe aktiv, aber bei Massenimporten wegen der starken Leistungseinschränkung abschaltbar sind. Zudem kann man beim Import die vom Trigger ausgeführten Aktionen mit beachten und gleich ausführen. Daher besteht die Möglichkeit, einen Trigger auch temporär aus- und dann natürlich auch wieder anzuschalten. Dies geschieht mit einem der folgenden Befehle:<\/p>\n
DISABLE TRIGGER triggername \r\nENABLE TRIGGER triggername.<\/pre>\n
Instead of Trigger<\/p>\n
Eine vielfach unbekannte Möglichkeit der Trigger ist es, nicht aktualisierbare Views (deutsch: Sichten, das abgespeckte Pendant zu Access-Abfragen, deren Funktion im SQL Server meist nur mit gespeicherten Prozeduren realisiert werden kann), dennoch aktualisierbar zu machen.<\/p>\n
Das folgende Listing erstellt eine View mit einem Inner Join, die die Namen der Komponisten mit ihren Werken ausgibt. Natürlich kann eine solche View normalerweise nicht aktualisiert werden, aber im Beispiel wird ein Einfügen ermöglicht. Das Löschen und ändern müsste man noch entsprechend implementieren.<\/p>\n
Daher erklärt sich auch der Name dieser Trigger: Statt wirklich in die Tabellen einzufügen und den Trigger im Transaktionskontext aufzurufen, wird allein der Trigger angestoßen. Innerhalb des Beispiel-Triggers wird versucht zu ermitteln, ob es den Komponisten schon in der Tabelle MyData <\/b>gibt. In @masterID <\/b>ist nach dem ersten SELECT <\/b>entweder die ID <\/b>des Namens oder eben NULL<\/b> gespeichert. Falls der Name nicht gefunden wird, wird er über einen INSERT<\/b>-Befehl eingefügt, danach die ID des soeben eingefügten Namens ermittelt.<\/p>\n
Benutzen Sie in solchen Zusammenhängen immer die Funktion IDENT_CURRENT('NameDerTabelle“)<\/b>. Es gibt im SQL Server eine System-Variable namens @@IDENTITY<\/b>, die den zuletzt eingefügten ID-Wert ausgibt. Ich habe einmal ein halben Tag damit verbracht, zu verstehen, warum dieser Wert immer ein völlig anderer war als der der Tabelle, in die ich gerade einfügte. Die Lösung war schließlich ganz einfach: Ein Trigger fügte munter auch in andere Tabellen noch Datensätze ein (ähnlich unserem History-Trigger), deren ID <\/b>lieferte mir dann @@IDENTITY<\/b>. IDENT_CURRENT <\/b>gibt jedoch immer genau den letzten Identitätswert der angegebenen Tabelle aus.<\/p>\n
Nachteile von Triggern<\/b><\/p>\n
Dies deutet auf einen anderen negativen Aspekt von Triggern hin: Sie sind schwer zu entdecken und schwer zu verwalten. Ein INSERT <\/b>kann durch einen Trigger völlig unerwartete Resultate erhalten, wenn man die Datenbank nicht selbst geschrieben hat oder eine wirklich gute Dokumentation vorliegt, was nur sehr selten der Fall ist. Es sei noch angemerkt, dass die Möglichkeiten von Instead of<\/b>-Triggern sich nicht im Behandeln von Views erschöpfen. Auch auf Tabellen können sie angewendet werden und so alle möglichen Funktionen implementieren.<\/p>\n
SQL Server 2005<\/b><\/p>\n
Mit dem SQL Server 2005 wurden zudem so genannte DDL <\/b>(Data Definition Language<\/b>)-Trigger eingeführt – Trigger, die auf die änderung der Struktur der Daten reagieren. Der folgende Trigger macht es unmöglich, Tabellen zu ändern oder zu löschen, bevor er nicht abgeschaltet oder gelöscht wird.<\/p>\n
CREATE TRIGGER safety \r\nON DATABASE \r\nFOR DROP_TABLE, ALTER_TABLE \r\nAS \r\n PRINT 'You must disable Trigger "safety" \r\n to drop or alter tables!' \r\n ROLLBACK;<\/pre>\n
Zusammenfassung<\/b><\/p>\n
Mit Triggern kann man, wie mit den Ereignisprozeduren, die wir vom Client kennen, auf SQL-Ereignisse reagieren. Trigger stellen die Tabellen inserted <\/b>und deleted <\/b>bereit, die es möglich machen, die Werte, mit denen das Statement ausführt werden soll, zu erkennen.<\/p>\n
Dabei wird der Trigger innerhalb der Transaktion ausgeführt – entgegen den Einschränkungen (constraints), die immer vor einer solchen Transaktion beachtet werden. Daher kann die Transaktion auch innerhalb des Triggers mit ROLLBACK TRAN abgebrochen werden. Deshalb ist große Vorsicht geboten, wenn es um die Programmierung von Triggern geht. Alle Trigger-Aktionen sollten so kurz und schnell wie irgend möglich erstellt werden, um Performance-Probleme zu umgehen.<\/p>\n
Trigger sind für den Client völlig transparent. Man kann daher auch bei einer funktionierenden und laufenden Anwendung Trigger implementieren, die neue Funktionalitäten mitbringen, wie etwa das Dokumentieren von änderungen, ohne die bestehenden Anwendungen zu ändern. Diese Transparenz macht ihre Wartung teilweise jedoch auch schwierig und aufwändig. Nicht immer ist sofort zu erkennen, welche Phänomene in einer Datenbank von Triggern hervorgerufen werden.<\/p>\n
Quellen<\/p>\n
[1] Das SQL Server Management Studio Express, Ausgabe 6\/2006, Shortlink 410<\/p>\n\n\n\n\n
\n
Listing 7: Beispiel für einen Instead-of-Trigger<\/p>\n<\/td>\n<\/tr>\n
\n
CREATE VIEW dbo.MyKompData AS<\/pre>\n
SELECT d.ID,d.Name,dd.Opus FROM MyData d INNER JOIN MyDataDetail dd ON d.ID=dd.MasterID<\/pre>\n
GO<\/pre>\n
CREATE TRIGGER meinInsteadOfTrigger ON dbo.MyKompData INSTEAD OF INSERT<\/pre>\n
AS<\/pre>\n
BEGIN<\/pre>\n
     declare @masterID int<\/pre>\n
     SELECT @masterID=mydata.ID FROM MyData<\/pre>\n
     INNER JOIN inserted ON MyData.Name=inserted.Name <\/pre>\n
     IF @masterID is NULL begin<\/pre>\n
     INSERT INTO MyData SELECT Name FROM inserted<\/pre>\n
     SET @masterID=IDENT_CURRENT('MyData')<\/pre>\n
     END<\/pre>\n
     INSERT INTO MyDataDetail (masterID, opus)<\/pre>\n
SELECT @masterID,Opus FROM inserted<\/pre>\n
END<\/pre>\n
GO<\/pre>\n
INSERT INTO MyKompData (Name, opus)<\/pre>\n
VALUES ('Vivaldi','Die vier Jahreszeiten')<\/pre>\n
GO<\/pre>\n
SELECT * FROM MyData<\/pre>\n
GO<\/pre>\n
SELECT * FROM MyKompData<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Downloads zu diesem Beitrag<\/h3>\n
Enthaltene Beispieldateien:<\/p>\n
Trigger.sql<\/p>\n
Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Auch wenn Access und die Jet-Engine bereits zahlreiche Möglichkeiten einer „richtigen“ Datenbank enthalten, fehlen immer noch wichtige Funktionen: So finden Sie etwa beim Umstieg auf SQL Server-Backends viel Bekanntes, aber auch Unbekanntes – zum Beispiel Trigger. Im vorliegenden Beitrag stellen wir den Nutzen von und den Umgang mit Triggern vor.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012007,662007,44000022],"tags":[],"class_list":["post-55000431","post","type-post","status-publish","format-standard","hentry","category-66012007","category-662007","category-SQL_Server_und_Co"],"yoast_head":"\nTrigger im SQL Server  - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Trigger im SQL Server\" \/>\n<meta property=\"og:description\" content=\"Auch wenn Access und die Jet-Engine bereits zahlreiche Möglichkeiten einer "richtigen" Datenbank enthalten, fehlen immer noch wichtige Funktionen: So finden Sie etwa beim Umstieg auf SQL Server-Backends viel Bekanntes, aber auch Unbekanntes - zum Beispiel Trigger. Im vorliegenden Beitrag stellen wir den Nutzen von und den Umgang mit Triggern vor.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2021-02-11T21:08:00+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"19\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Trigger im SQL Server\",\"datePublished\":\"2021-02-11T21:08:00+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/\"},\"wordCount\":3070,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg03.met.vgwort.de\\\/na\\\/9b5a1aa86864483e9363fc7c0e3d5015\",\"articleSection\":[\"1\\\/2007\",\"2007\",\"SQL Server und Co.\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/\",\"name\":\"Trigger im SQL Server - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg03.met.vgwort.de\\\/na\\\/9b5a1aa86864483e9363fc7c0e3d5015\",\"datePublished\":\"2021-02-11T21:08:00+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg03.met.vgwort.de\\\/na\\\/9b5a1aa86864483e9363fc7c0e3d5015\",\"contentUrl\":\"http:\\\/\\\/vg03.met.vgwort.de\\\/na\\\/9b5a1aa86864483e9363fc7c0e3d5015\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Trigger_im_SQL_Server_\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Trigger im SQL Server\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Trigger im SQL Server  - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/","og_locale":"de_DE","og_type":"article","og_title":"Trigger im SQL Server","og_description":"Auch wenn Access und die Jet-Engine bereits zahlreiche Möglichkeiten einer \"richtigen\" Datenbank enthalten, fehlen immer noch wichtige Funktionen: So finden Sie etwa beim Umstieg auf SQL Server-Backends viel Bekanntes, aber auch Unbekanntes - zum Beispiel Trigger. Im vorliegenden Beitrag stellen wir den Nutzen von und den Umgang mit Triggern vor.","og_url":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/","og_site_name":"Access im Unternehmen","article_published_time":"2021-02-11T21:08:00+00:00","og_image":[{"url":"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"19\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Trigger im SQL Server","datePublished":"2021-02-11T21:08:00+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/"},"wordCount":3070,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#primaryimage"},"thumbnailUrl":"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015","articleSection":["1\/2007","2007","SQL Server und Co."],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/","url":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/","name":"Trigger im SQL Server - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#primaryimage"},"thumbnailUrl":"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015","datePublished":"2021-02-11T21:08:00+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#primaryimage","url":"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015","contentUrl":"http:\/\/vg03.met.vgwort.de\/na\/9b5a1aa86864483e9363fc7c0e3d5015"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Trigger_im_SQL_Server_\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Trigger im SQL Server"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000431","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000431"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000431\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000431"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000431"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000431"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}