Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Migration von SQL Server zu PostgreSQL mit AWS Schema Conversion Tool
Sie können das Erweiterungspaket SQL Server to PostgreSQL in verwenden. AWS SCT Dieses Erweiterungspaket emuliert SQL Server-Datenbankfunktionen im konvertierten PostgreSQL-Code. Verwenden Sie das Erweiterungspaket SQL Server to PostgreSQL, um SQL Server Agent und SQL Server Database Mail zu emulieren. Weitere Informationen zu Erweiterungspaketen finden Sie unter [Verwenden von Erweiterungspaketen mit AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Rechte für PostgreSQL als Zieldatenbank](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [Einstellungen für die Konvertierung von SQL Server in PostgreSQL](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [Konvertieren von SQL Server-Partitionen in PostgreSQL Version 10-Partitionen](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [Überlegungen zur Migration](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [Verwenden eines AWS SCT Erweiterungspakets zum Emulieren des SQL Server-Agents in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [Verwenden eines AWS SCT Erweiterungspakets zum Emulieren von SQL Server-Datenbank-Mail in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## Rechte für PostgreSQL als Zieldatenbank
Um PostgreSQL als Ziel zu verwenden, ist das AWS SCT Privileg erforderlich. `CREATE ON DATABASE` Stellen Sie sicher, dass Sie dieses Recht für jede PostgreSQL-Zieldatenbank gewähren.
Um die konvertierten öffentlichen Synonyme zu verwenden, ändern Sie den Standardsuchpfad der Datenbank in. `"$user", public_synonyms, public`
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```
Ersetzen Sie ihn im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *db\$1name* durch den Namen Ihrer Zieldatenbank. Schließlich ersetzen Sie es *your\$1password* durch ein sicheres Passwort.
In PostgreSQL kann nur der Schemaeigentümer oder ein `superuser` ein Schema entfernen. Der Besitzer kann ein Schema und alle Objekte, die dieses Schema enthält, löschen, auch wenn der Eigentümer des Schemas einige seiner Objekte nicht besitzt.
Wenn Sie verschiedene Benutzer verwenden, um verschiedene Schemas zu konvertieren und auf Ihre Zieldatenbank anzuwenden, erhalten Sie möglicherweise eine Fehlermeldung, wenn ein Schema nicht gelöscht AWS SCT werden kann. Verwenden Sie die Rolle `superuser`, um diese Fehlermeldung zu vermeiden.
## Einstellungen für die Konvertierung von SQL Server in PostgreSQL
Um die Einstellungen für die Konvertierung von SQL Server in PostgreSQL zu bearbeiten, wählen Sie **Einstellungen** und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **SQL Server** und dann **SQL Server — PostgreSQL** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SQL Server zu PostgreSQL an.
Die Einstellungen für die Konvertierung von SQL Server in PostgreSQL AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die Verwendung von Indizes mit demselben Namen in verschiedenen Tabellen in SQL Server zu ermöglichen.
In PostgreSQL müssen alle Indexnamen, die Sie im Schema verwenden, eindeutig sein. Um sicherzustellen, dass dadurch eindeutige Namen für alle Ihre Indizes AWS SCT generiert werden, wählen Sie **Eindeutige Namen für Indizes generieren** aus.
+ Um SQL Server-Prozeduren in PostgreSQL-Funktionen zu konvertieren.
PostgreSQL Version 10 und früher unterstützt keine Prozeduren. Kunden, die mit der Verwendung von Prozeduren in PostgreSQL nicht vertraut sind, AWS SCT können Prozeduren in Funktionen konvertieren. Wählen Sie dazu **Verfahren in Funktionen konvertieren** aus.
+ Um die Ausgabe von `EXEC` in einer Tabelle zu emulieren.
Ihre SQL Server-Quelldatenbank kann die Ausgabe von `EXEC` in einer Tabelle speichern. AWS SCT erstellt temporäre Tabellen und eine zusätzliche Prozedur, um diese Funktion zu emulieren. Um diese Emulation zu verwenden, wählen Sie **Zusätzliche Routinen für den Umgang mit offenen Datensätzen erstellen** aus.
+ Um die Vorlage zu definieren, die für die Schemanamen im konvertierten Code verwendet werden soll. Wählen Sie für die **Vorlage zur Generierung von Schemanamen** eine der folgenden Optionen aus:
+ ****— Verwendet den SQL Server-Datenbanknamen als Schemanamen in PostgreSQL.
+ ****— Verwendet den SQL Server-Schemanamen als Schemanamen in PostgreSQL.
+ **\$1** — Verwendet eine Kombination aus der SQL Server-Datenbank und Schemanamen als Schemanamen in PostgreSQL.
+ Um die Groß- und Kleinschreibung Ihrer Quellobjektnamen beizubehalten.
Um zu verhindern, dass Objektnamen in Kleinbuchstaben umgewandelt werden, wählen Sie bei **Operationen, bei denen Groß- und Kleinschreibung beachtet wird, die Option Kleinschreibung vermeiden** aus. Diese Option gilt nur, wenn Sie die Option zur Berücksichtigung von Groß- und Kleinschreibung in Ihrer Zieldatenbank aktivieren.
+ Um die Parameternamen aus Ihrer Quelldatenbank beizubehalten.
Um den Namen der Parameter im konvertierten Code doppelte Anführungszeichen hinzuzufügen, wählen Sie **Ursprüngliche Parameternamen beibehalten** aus.
## Konvertieren von SQL Server-Partitionen in PostgreSQL Version 10-Partitionen
Beachten Sie Folgendes, wenn Sie eine Microsoft SQL Server-Datenbank in Amazon Aurora PostgreSQL-Compatible Edition (Aurora PostgreSQL) oder Amazon Relational Database Service for PostgreSQL (Amazon RDS for PostgreSQL) konvertieren.
In SQL Server können Sie Partitionen mit Partitionsfunktionen erstellen. Bei der Umwandlung einer partitionierten SQL Server-Tabelle in eine partitionierte PostgreSQL Version 10-Tabelle sind die folgenden potenziellen Probleme zu beachten:
+ SQL Server ermöglicht es Ihnen, eine Tabelle mit einer Spalte ohne NOT NULL-Einschränkung zu partitionieren. In diesem Fall werden alle NULL-Werte in die ganz links befindliche Partition verschoben. PostgreSQL unterstützt keine NULL-Werte für RANGE-Partitionierungen.
+ SQL Server ermöglicht Ihnen die Erstellung primärer und eindeutiger Schlüssel für partitionierte Tabellen. Sie erstellen für PostgreSQL primäre oder eindeutige Schlüssel direkt für jede Partition. Daher muss bei einer Migration in PostgreSQL die PRIMARY KEY- oder UNIQUE KEY-Einschränkung von ihrer übergeordneten Tabelle entfernt werden. Die `_` resultierenden Schlüsselnamen haben das folgende Format.
+ SQL Server ermöglicht Ihnen die Erstellung von Einschränkungen für Fremdschlüsselverweise aus und in partitionierte Tabellen. PostgreSQL unterstützt keine Fremdschlüssel, die auf partitionierte Tabellen verweisen. PostgreSQL unterstützt auch keine Fremdschlüsselverweise aus einer partitionierten Tabelle in eine andere Tabelle.
+ SQL Server ermöglicht Ihnen die Erstellung von Indizes für partitionierte Tabellen. Für PostgreSQL sollte für jede Partition direkt ein Index erstellt werden. Folglich müssen Indizes bei der Migration in PostgreSQL aus den ihnen übergeordneten Tabellen entfernt werden. Die sich ergebenden Indexnamen weisen das Format `_` auf.
+ PostgreSQL unterstützt keine partitionierten Indizes.
## Überlegungen zur Migration
Einige Dinge, die Sie bei der Migration eines SQL Server-Schemas nach PostgreSQL beachten sollten:
+ In PostgreSQL müssen alle Objektnamen in einem Schema eindeutig sein. Dies gilt auch für Indizes. Indexnamen müssen im Schema der Basistabelle eindeutig sein. In SQL Server kann ein Indexname für verschiedene Tabellen gleich sein.
Um die Eindeutigkeit von Indexnamen zu gewährleisten, AWS SCT haben Sie die Möglichkeit, eindeutige Indexnamen zu generieren, falls Ihre Indexnamen nicht eindeutig sind. Wählen Sie hierzu die Option **Generate unique index names (Eindeutige Indexnamen generieren)** in den Projekteigenschaften. Diese Funktion ist standardmäßig aktiviert. Wenn diese Option aktiviert ist, werden eindeutige Indexnamen im Format IX\$1table\$1name\$1index\$1name erstellt. Wenn diese Option deaktiviert ist, werden Indexnamen nicht geändert.
+ Mithilfe einer GOTO-Anweisung und einer Bezeichnung lässt sich die Reihenfolge ändern, in der Anweisungen ausgeführt werden. Alle Transact-SQL-Anweisungen, die auf eine GOTO-Anweisung folgen, werden übersprungen, und die Verarbeitung wird ab der Bezeichnung fortgesetzt. GOTO-Anweisungen und Bezeichnungen können an beliebiger Stelle innerhalb eines Verfahrens, Stapels oder Anweisungsblocks verwendet werden. GOTO-Anweisungen können auch verschachtelt werden.
PostgreSQL verwendet keine GOTO-Anweisungen. Wenn Code AWS SCT konvertiert wird, der eine GOTO-Anweisung enthält, wird die Anweisung so konvertiert, dass sie eine BEGIN... END- oder LOOP... END LOOP-Anweisung verwendet. In der folgenden Tabelle finden Sie Beispiele dafür, wie GOTO-Anweisungen AWS SCT konvertiert werden.
**SQL Server GOTO-Anweisungen und die konvertierten PostgreSQL-Anweisungen**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL unterstützt keine MERGE-Anweisung. AWS SCT emuliert das Verhalten einer MERGE-Anweisung auf folgende Weise:
+ Durch INSERT ON CONFLICT-Konstruktion.
+ Durch die Verwendung der UPDATE FROM DML-Anweisung, wie z. B. MERGE ohne WHEN NOT MATCHED-Klausel.
+ Durch die Verwendung von CURSOR, z. B. mit einer MERGE-Anweisung mit DELETE-Klausel, oder durch die Verwendung einer komplexen MERGE ON-Bedingungsanweisung.
+ AWS SCT kann Datenbank-Trigger zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ AWS SCT kann Trigger auf Serverebene zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ SQL Server erstellt `deleted` und verwaltet automatisch `inserted` Tabellen. Sie können diese temporären, speicherresidenten Tabellen verwenden, um die Auswirkungen bestimmter Datenänderungen zu testen und Bedingungen für DML-Triggeraktionen festzulegen. AWS SCT kann die Verwendung dieser Tabellen innerhalb von DML-Triggeranweisungen konvertieren.
+ AWS SCT kann verknüpfte Server zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ Bei der Migration von Microsoft SQL Server zu PostgreSQL wird die integrierte SUSER\$1SNAME-Funktion wie folgt umgewandelt:
+ SUSER\$1SNAME – Gibt den Anmeldenamen zurück, der einer Sicherheits-ID (SID) zugeordnet ist.
+ SUSER\$1SNAME() – Nicht unterstützt.
+ SUSER\$1SNAME() CURRENT\$1USER – Gibt den Benutzernamen des aktuellen Ausführungskontexts zurück.
+ SUSER\$1SNAME(NULL) – Gibt NULL zurück.
+ Die Umwandlung von Tabellenwertfunktionen wird unterstützt. Tabellenwertfunktionen geben eine Tabelle zurück und können in einer Abfrage die Stelle einer Tabelle einnehmen.
+ PATINDEX gibt die Startposition des ersten Auftretens eines Musters in einem bestimmten Ausdruck zurück. Dabei werden alle gültigen Text und Zeichendatentypen unterstützt. Nullen werden zurückgegeben, wenn das Muster nicht gefunden wird. AWS SCT Ersetzt bei der Konvertierung von SQL Server zu Amazon RDS for PostgreSQL den Anwendungscode, der PATINDEX verwendet, durch aws\$1sqlserver\$1ext.patindex (,).
+ In SQL Server ist ein benutzerdefinierter Tabellentyp ein Typ, der die Definition einer Tabellenstruktur darstellt. Sie verwenden einen benutzerdefinierten Tabellentyp, um table-value-Parameter für gespeicherte Prozeduren oder Funktionen zu deklarieren. Sie können auch einen benutzerdefinierten Tabellentyp verwenden, um Tabellenvariablen zu deklarieren, die Sie in einem Batch oder im Hauptteil einer gespeicherten Prozedur oder Funktion verwenden möchten. AWS SCT emulierte diesen Typ in PostgreSQL, indem eine temporäre Tabelle erstellt wurde.
AWS SCT Konvertiert bei der Konvertierung von SQL Server nach PostgreSQL SQL Server-Systemobjekte in erkennbare Objekte in PostgreSQL. Die folgende Tabelle zeigt, wie die Systemobjekte umgewandelt werden.
| Anwendungsfälle für MS SQL Server | PostgreSQL-Substitution |
| --- | --- |
| SYS.SCHEMAS | AWS\$1SQLSERVER\$1EXT.SYS\$1SCHEMAS |
| SYS.TABLES | AWS\$1SQLSERVER\$1EXT.SYS\$1TABELLEN |
| SYS.VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ANSICHTEN |
| SYS.ALL\$1VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1ANSICHTEN |
| SYS.TYPES | AWS\$1SQLSERVER\$1EXT.SYS\$1TYPEN |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1SPALTEN |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1SPALTEN |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FREMDSCHLÜSSEL |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYS FREMDSCHLÜSSEL |
| SYS.FOREIGN\$1KEY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEY\$1COLUMNS |
| SYS.KEY\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.SYS\$1KEY\$1CONSTRAINTS |
| SYS.IDENTITY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1IDENTITY\$1COLUMNS |
| SYS.PROCEDURES | AWS\$1SQLSERVER\$1EXT.SYS\$1PROZEDUREN |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1INDIZES |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXE |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJECTS |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1OBJEKTE |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJEKTE |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULE |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1DATENBANKEN |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SCHEMATA |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1ANSICHTEN |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABELLEN |
| INFORMATION\$1SCHEMA.COLUMNS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1COLUMNS |
| INFORMATION\$1SCHEMA.CHECK\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CHECK\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.REFERENTIAL\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1REFERENTIAL\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.TABLE\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLE\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.KEY\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1KEY\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1TABLE\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1TABLE\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.ROUTINES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1ROUTINEN |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSPROZESSE |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSTEM\$1OBJECTS |
# Verwenden eines AWS SCT Erweiterungspakets zum Emulieren des SQL Server-Agents in PostgreSQL
SQL Server Agent ist ein Microsoft Windows-Dienst, der SQL Server-Jobs ausführt. Der SQL Server-Agent führt Jobs nach einem Zeitplan, als Reaktion auf ein bestimmtes Ereignis oder bei Bedarf aus. Weitere Informationen zum SQL Server-Agent finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15).
PostgreSQL hat kein Äquivalent für SQL Server Agent. AWS SCT Erstellt ein Erweiterungspaket, um die Funktionen des SQL Server-Agents zu emulieren. Dieses Erweiterungspaket verwendet AWS Lambda Amazon CloudWatch. AWS Lambda implementiert die Schnittstelle, die Sie zum Verwalten von Zeitplänen und zum Ausführen von Jobs verwenden. Amazon CloudWatch hält die Zeitplanregeln ein.
AWS Lambda und Amazon CloudWatch verwendet einen JSON-Parameter für die Interaktion. Dieser JSON-Parameter hat die folgende Struktur.
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
Im vorherigen Beispiel *`mode`* ist dies der Typ der Aufgabe und `list of parameters` besteht aus einer Reihe von Parametern, die vom Typ der Aufgabe abhängen. Dies `procedure name` ist auch der Name der Prozedur, die nach Abschluss der Aufgabe ausgeführt wird.
AWS SCT verwendet eine Lambda-Funktion zur Steuerung und Ausführung von Jobs. Die CloudWatch Regel startet die Ausführung des Jobs und stellt die erforderlichen Informationen zum Starten des Jobs bereit. Wenn die CloudWatch Regel ausgelöst wird, startet sie die Lambda-Funktion mit den Parametern aus der Regel.
Verwenden Sie das folgende Format, um einen einfachen Job zu erstellen, der eine Prozedur aufruft.
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
Verwenden Sie das folgende Format, um einen Job mit mehreren Schritten zu erstellen.
```
{
"mode": "run_job",
"parameters": {
"job_name": "Job1",
"enabled": "true",
"start_step_id": 1,
"notify_level_email": [0|1|2|3],
"notify_email": email,
"delete_level": [0|1|2|3],
"job_callback": "ProcCallBackJob(job_name, code, message)",
"step_callback": "ProcCallBackStep(job_name, step_id, code, message)"
},
"steps": [
{
"id":1,
"cmd": "ProcStep1",
"cmdexec_success_code": 0,
"on_success_action": [|2|3|4],
"on_success_step_id": 1,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
{
"id":2,
"cmd": "ProcStep2",
"cmdexec_success_code": 0,
"on_success_action": [1|2|3|4],
"on_success_step_id": 0,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
...
]
}
```
Um das Verhalten des SQL Server-Agents in PostgreSQL zu emulieren, erstellt das AWS SCT Erweiterungspaket auch die folgenden Tabellen und Prozeduren.
## Tabellen, die den SQL Server-Agent in PostgreSQL emulieren
Um den SQL Server-Agent zu emulieren, verwendet das Erweiterungspaket die folgenden Tabellen:
**sysjobs**
Speichert die Informationen über die Jobs.
**sysjobsteps**
Speichert die Informationen über die Schritte eines Jobs.
**Sysschedules**
Speichert die Informationen über die Jobpläne.
**sysjobschedules**
Speichert die Zeitplaninformationen für einzelne Jobs.
**sysjobhistory**
Speichert die Informationen über die Ausführung von geplanten Aufträgen.
## Verfahren, die den SQL Server-Agent in PostgreSQL emulieren
Um den SQL Server-Agent zu emulieren, verwendet das Erweiterungspaket die folgenden Verfahren:
**sp\$1add\$1job**
Fügt einen neuen Job hinzu.
**sp\$1add\$1jobstep**
Fügt einem Job einen Schritt hinzu.
**sp\$1add\$1schedule**
Erstellt eine neue Zeitplanregel in Amazon CloudWatch. Sie können diesen Zeitplan für eine beliebige Anzahl von Jobs verwenden.
**sp\$1attach\$1schedule**
Legt einen Zeitplan für den ausgewählten Job fest.
**sp\$1add\$1jobschedule**
Erstellt eine Zeitplanregel für einen Job in Amazon CloudWatch und legt das Ziel für diese Regel fest.
**sp\$1update\$1job**
Aktualisiert die Attribute des zuvor erstellten Jobs.
**sp\$1update\$1jobstep**
Aktualisiert die Attribute des Schritts in einem Job.
**sp\$1update\$1schedule**
Aktualisiert die Attribute einer Zeitplanregel in Amazon CloudWatch.
**sp\$1update\$1jobschedule**
Aktualisiert die Attribute des Zeitplans für den angegebenen Job.
**sp\$1delete\$1job**
Löscht einen Job.
**sp\$1delete\$1jobstep**
Löscht einen Auftragsschritt aus einem Job.
**sp\$1delete\$1schedule**
Löscht einen Zeitplan.
**sp\$1delete\$1jobschedule**
Löscht die Zeitplanregel für den angegebenen Job von Amazon CloudWatch.
**sp\$1detach\$1schedule**
Entfernt eine Verknüpfung zwischen einem Zeitplan und einem Job.
**get\$1jobs, update\$1job**
Interne Verfahren, die interagieren mit. AWS Elastic Beanstalk
**sp\$1verify\$1job\$1date, sp\$1verify\$1job\$1time, sp\$1verify\$1job, sp\$1verify\$1jobstep, sp\$1verify\$1schedule, sp\$1verify\$1job\$1identifiers, sp\$1verify\$1schedule\$1identifiers**
Interne Verfahren, die Einstellungen überprüfen.
## Syntax für Prozeduren, die den SQL Server-Agent in PostgreSQL emulieren
Die `aws_sqlserver_ext.sp_add_job` Prozedur im Erweiterungspaket emuliert die Prozedur. `msdb.dbo.sp_add_job` Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-job-transact-sql?view=sql-server-ver15).
```
par_job_name varchar,
par_enabled smallint = 1,
par_description varchar = NULL::character varying,
par_start_step_id integer = 1,
par_category_name varchar = NULL::character varying,
par_category_id integer = NULL::integer,
par_owner_login_name varchar = NULL::character varying,
par_notify_level_eventlog integer = 2,
par_notify_level_email integer = 0,
par_notify_level_netsend integer = 0,
par_notify_level_page integer = 0,
par_notify_email_operator_name varchar = NULL::character varying,
par_notify_netsend_operator_name varchar = NULL::character varying,
par_notify_page_operator_name varchar = NULL::character varying,
par_delete_level integer = 0,
inout par_job_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_jobstep` Prozedur emuliert die `msdb.dbo.sp_add_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
par_step_name varchar = NULL::character varying,
par_subsystem varchar = 'TSQL'::bpchar,
par_command text = NULL::text,
par_additional_parameters text = NULL::text,
par_cmdexec_success_code integer = 0,
par_on_success_action smallint = 1,
par_on_success_step_id integer = 0,
par_on_fail_action smallint = 2,
par_on_fail_step_id integer = 0,
par_server varchar = NULL::character varying,
par_database_name varchar = NULL::character varying,
par_database_user_name varchar = NULL::character varying,
par_retry_attempts integer = 0,
par_retry_interval integer = 0,
par_os_run_priority integer = 0,
par_output_file_name varchar = NULL::character varying,
par_flags integer = 0,
par_proxy_id integer = NULL::integer,
par_proxy_name varchar = NULL::character varying,
inout par_step_uid char = NULL::bpchar,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_schedule` Prozedur emuliert die `msdb.dbo.sp_add_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_name varchar,
par_enabled smallint = 1,
par_freq_type integer = 0,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
par_owner_login_name varchar = NULL::character varying,
*inout par_schedule_uid char = NULL::bpchar,*
inout par_schedule_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_attach_schedule` Prozedur emuliert die `msdb.dbo.sp_attach_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-attach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_automatic_post smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_jobschedule` Prozedur emuliert die `msdb.dbo.sp_add_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_enabled smallint = 1,
par_freq_type integer = 1,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
inout par_schedule_id integer = NULL::integer,
par_automatic_post smallint = 1,
inout par_schedule_uid char = NULL::bpchar,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_job` Prozedur emuliert die `msdb.dbo.sp_delete_job` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_originating_server varchar = NULL::character varying,
par_delete_history smallint = 1,
par_delete_unused_schedule smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_jobstep` Prozedur emuliert die `msdb.dbo.sp_delete_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobsteplog-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_jobschedule` Prozedur emuliert die `msdb.dbo.sp_delete_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_keep_schedule integer = 0,
par_automatic_post smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_schedule` Prozedur emuliert die `msdb.dbo.sp_delete_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_force_delete smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_detach_schedule` Prozedur emuliert die `msdb.dbo.sp_detach_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-detach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_delete_unused_schedule smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_job` Prozedur emuliert die `msdb.dbo.sp_update_job` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_description varchar = NULL::character varying
par_start_step_id integer = NULL::integer
par_category_name varchar = NULL::character varying
par_owner_login_name varchar = NULL::character varying
par_notify_level_eventlog integer = NULL::integer
par_notify_level_email integer = NULL::integer
par_notify_level_netsend integer = NULL::integer
par_notify_level_page integer = NULL::integer
par_notify_email_operator_name varchar = NULL::character varying
par_notify_netsend_operator_name varchar = NULL::character varying
par_notify_page_operator_name varchar = NULL::character varying
par_delete_level integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_jobschedule` Prozedur emuliert die `msdb.dbo.sp_update_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_jobstep` Prozedur emuliert die `msdb.dbo.sp_update_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_step_id integer = NULL::integer
par_step_name varchar = NULL::character varying
par_subsystem varchar = NULL::character varying
par_command text = NULL::text
par_additional_parameters text = NULL::text
par_cmdexec_success_code integer = NULL::integer
par_on_success_action smallint = NULL::smallint
par_on_success_step_id integer = NULL::integer
par_on_fail_action smallint = NULL::smallint
par_on_fail_step_id integer = NULL::integer
par_server varchar = NULL::character varying
par_database_name varchar = NULL::character varying
par_database_user_name varchar = NULL::character varying
par_retry_attempts integer = NULL::integer
par_retry_interval integer = NULL::integer
par_os_run_priority integer = NULL::integer
par_output_file_name varchar = NULL::character varying
par_flags integer = NULL::integer
par_proxy_id integer = NULL::integer
par_proxy_name varchar = NULL::character varying
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_schedule` Prozedur emuliert die `msdb.dbo.sp_update_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_owner_login_name varchar = NULL::character varying
par_automatic_post smallint = 1
out returncode integer
```
## Beispiele für die Verwendung von Prozeduren, die den SQL Server-Agent in PostgreSQL emulieren
Gehen Sie wie `aws_sqlserver_ext.sp_add_job` folgt vor, um einen neuen Job hinzuzufügen.
```
SELECT * FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_job',
par_enabled := 1::smallint,
par_start_step_id := 1::integer,
par_category_name := '[Uncategorized (Local)]',
par_owner_login_name := 'sa');
```
Gehen Sie wie `aws_sqlserver_ext.sp_add_jobstep` folgt vor, um einen neuen Auftragsschritt hinzuzufügen.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_job',
par_step_id := 1::smallint,
par_step_name := 'test_job_step1',
par_subsystem := 'TSQL',
par_command := 'EXECUTE [dbo].[PROC_TEST_JOB_STEP1];',
par_server := NULL,
par_database_name := 'GOLD_TEST_SS');
```
Gehen Sie wie `aws_sqlserver_ext.sp_add_schedule` folgt vor, um einen einfachen Zeitplan hinzuzufügen.
```
SELECT * FROM aws_sqlserver_ext.sp_add_schedule(
par_schedule_name := 'RunOnce',
par_freq_type := 1,
par_active_start_time := 233000);
```
`aws_sqlserver_ext.sp_attach_schedule`Gehen Sie wie folgt vor, um einen Zeitplan für einen Job festzulegen.
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
`aws_sqlserver_ext.sp_add_jobschedule`Gehen Sie wie folgt vor, um einen Zeitplan für einen Job zu erstellen.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_job2',
par_name := 'test_schedule2',
par_enabled := 1::smallint,
par_freq_type := 4,
par_freq_interval := 1,
par_freq_subday_type := 4,
par_freq_subday_interval := 1,
par_freq_relative_interval := 0,
par_freq_recurrence_factor := 0,
par_active_start_date := 20100801,
par_active_end_date := 99991231,
par_active_start_time := 0,
par_active_end_time := 0);
```
## Anwendungsbeispiele für die Emulation des SQL Server-Agents in PostgreSQL
Wenn Ihr Quelldatenbankcode den SQL Server-Agent zum Ausführen von Aufträgen verwendet, können Sie das SQL Server to PostgreSQL-Erweiterungspaket für verwenden, um diesen Code AWS SCT nach PostgreSQL zu konvertieren. Das Erweiterungspaket verwendet AWS Lambda Funktionen, um das Verhalten des SQL Server-Agents zu emulieren.
Sie können eine neue AWS Lambda Funktion erstellen oder eine vorhandene Funktion registrieren.
**Um eine neue AWS Lambda Funktion zu erstellen**
1. Öffnen Sie in der Zieldatenbankstruktur das Kontextmenü (Rechtsklick), wählen Sie **Erweiterungspaket anwenden für** und wählen Sie dann **PostgreSQL**. AWS SCT
Der Assistent des Erweiterungspakets wird angezeigt.
1. Gehen Sie auf der Registerkarte **SQL Server-Agent-Emulationsdienst** wie folgt vor:
+ Wählen Sie ** AWS Lambda Funktion erstellen** aus.
+ Geben Sie für **Datenbank-Login** den Namen des Zieldatenbankbenutzers ein.
+ Geben Sie unter **Datenbankkennwort** das Passwort für den Benutzernamen ein, den Sie im vorherigen Schritt eingegeben haben.
+ Geben Sie für **Python-Bibliotheksordner** den Pfad zu Ihrem Python-Bibliotheksordner ein.
+ Wählen Sie „** AWS Lambda Funktion erstellen**“ und dann „**Weiter**“.
**Um eine AWS Lambda Funktion zu registrieren, die Sie zuvor bereitgestellt haben**
+ Führen Sie das folgende Skript in Ihrer Zieldatenbank aus.
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
Im vorherigen Beispiel *`ARN`* ist dies der Amazon-Ressourcenname (ARN) der bereitgestellten AWS Lambda Funktion.
Das folgende Beispiel erstellt eine einfache Aufgabe, die aus einem Schritt besteht. Diese Aufgabe führt alle fünf Minuten die zuvor erstellte `job_example` Funktion aus. Diese Funktion fügt Datensätze in die `job_example_table` Tabelle ein.
**Um diese einfache Aufgabe zu erstellen**
1. Erstellen Sie einen Job mit der `aws_sqlserver_ext.sp_add_job` Funktion wie folgt.
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. Erstellen Sie einen Auftragsschritt mithilfe der `aws_sqlserver_ext.sp_add_jobstep` Funktion, wie im Folgenden gezeigt.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_simple_job',
par_step_name := 'test_simple_job_step1',
par_command := 'PERFORM job_simple_example;');
```
Der Job-Schritt gibt an, was die Funktion macht.
1. Erstellen Sie mithilfe der `aws_sqlserver_ext.sp_add_jobschedule` Funktion einen Scheduler für den Job, wie im Folgenden gezeigt.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_simple_job',
par_name := 'test_schedule',
par_freq_type := 4, /* Daily */
par_freq_interval := 1, /* frequency_interval is unused */
par_freq_subday_type := 4, /* Minutes */
par_freq_subday_interval := 5 /* 5 minutes */);
```
Der Job-Schritt gibt an, was die Funktion macht.
Um diesen Job zu löschen, verwenden Sie die `aws_sqlserver_ext.sp_delete_job` Funktion wie folgt.
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# Verwenden eines AWS SCT Erweiterungspakets zum Emulieren von SQL Server-Datenbank-Mail in PostgreSQL
Sie können SQL Server Database Mail verwenden, um E-Mail-Nachrichten von der SQL Server Database Engine oder Azure SQL Managed Instance aus an Benutzer zu senden. Diese E-Mail-Nachrichten können Abfrageergebnisse oder Dateien aus beliebigen Ressourcen in Ihrem Netzwerk enthalten. Weitere Informationen zu SQL Server Database Mail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15).
PostgreSQL hat kein Äquivalent für SQL Server Database Mail. AWS SCT Erstellt ein Erweiterungspaket, um die Funktionen von SQL Server Database Mail zu emulieren. Dieses Erweiterungspaket verwendet AWS Lambda einen Amazon Simple Email Service (Amazon SES). AWS Lambda bietet Benutzern eine Schnittstelle zur Interaktion mit dem Amazon SES SES-E-Mail-Versandservice. Um diese Interaktion einzurichten, fügen Sie den Amazon-Ressourcennamen (ARN) Ihrer Lambda-Funktion hinzu.
Verwenden Sie für ein neues E-Mail-Konto den folgenden Befehl.
```
do
$$
begin
PERFORM sysmail_add_account_sp (
par_account_name :='your_account_name',
par_email_address := 'your_account_email',
par_display_name := 'your_account_display_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
Verwenden Sie den folgenden Befehl, um den ARN Ihrer Lambda-Funktion zum vorhandenen E-Mail-Konto hinzuzufügen.
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
In den vorherigen Beispielen *`ARN`* ist das der ARN Ihrer Lambda-Funktion.
Um das Verhalten von SQL Server-Datenbankmail in PostgreSQL zu emulieren, verwendet das AWS SCT Erweiterungspaket die folgenden Tabellen, Ansichten und Prozeduren.
## Tabellen, die SQL Server-Datenbankmail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, verwendet das Erweiterungspaket die folgenden Tabellen:
**sysmail\$1account**
Speichert die Informationen über die E-Mail-Konten.
**sysmail\$1profile**
Speichert die Informationen zu den Benutzerprofilen.
**sysmail\$1server**
Speichert die Informationen über die E-Mail-Server.
**sysmail\$1mailitems**
Speichert die Liste der E-Mail-Nachrichten.
**sysmail\$1attachments**
Enthält eine Zeile für jeden E-Mail-Anhang.
**sysmail\$1log**
Speichert die Dienstinformationen zum Senden von E-Mail-Nachrichten.
**sysmail\$1profile\$1account**
Speichert die Informationen zu den Benutzerprofilen und E-Mail-Konten.
## Ansichten, die SQL Server-Datenbankmail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, AWS SCT erstellt die folgenden Ansichten in der PostgreSQL-Datenbank, um die Kompatibilität sicherzustellen. Das Erweiterungspaket verwendet sie nicht, aber Ihr konvertierter Code kann diese Ansichten abfragen.
**sysmail\$1allitems**
Enthält eine Liste aller E-Mails.
**sysmail\$1faileditems**
Enthält eine Liste von E-Mails, die nicht gesendet werden konnten.
**sysmail\$1sentitems**
Enthält eine Liste der gesendeten E-Mails.
**sysmail\$1unsentitems**
Enthält eine Liste von E-Mails, die noch nicht gesendet wurden.
**sysmail\$1mailattachments**
Enthält eine Liste der angehängten Dateien.
## Verfahren, die SQL Server-Datenbank-Mail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, verwendet das Erweiterungspaket die folgenden Verfahren:
**sp\$1send\$1dbmail**
Sendet eine E-Mail an die angegebenen Empfänger.
**sysmail\$1add\$1profile\$1sp**
Erstellt ein neues Benutzerprofil.
**sysmail\$1add\$1account\$1sp**
Erstellt ein neues E-Mail-Konto, in dem Informationen wie SMTP-Anmeldeinformationen (Simple Mail Transfer Protocol) usw. gespeichert werden.
**sysmail\$1add\$1profileaccount\$1sp**
Fügt dem angegebenen Benutzerprofil ein E-Mail-Konto hinzu.
**sysmail\$1update\$1profile\$1sp**
Ändert die Attribute des Benutzerprofils wie Beschreibung, Name usw.
**sysmail\$1update\$1account\$1sp**
Ändert die Informationen im vorhandenen E-Mail-Konto.
**sysmail\$1update\$1profileaccount\$1sp**
Aktualisiert die E-Mail-Kontoinformationen im angegebenen Benutzerprofil.
**sysmail\$1delete\$1profileaccount\$1sp**
Entfernt ein E-Mail-Konto aus dem angegebenen Benutzerprofil.
**sysmail\$1delete\$1account\$1sp**
Löscht das E-Mail-Konto.
**sysmail\$1delete\$1profile\$1sp**
Löscht das Benutzerprofil.
**sysmail\$1delete\$1mailitems\$1sp**
Löscht E-Mails aus internen Tabellen.
**sysmail\$1help\$1profile\$1sp**
Zeigt Informationen über das Benutzerprofil an.
**sysmail\$1help\$1account\$1sp**
Zeigt Informationen über das E-Mail-Konto an.
**sysmail\$1help\$1profileaccount\$1sp**
Zeigt Informationen zu E-Mail-Konten an, die dem Benutzerprofil zugeordnet sind.
**sysmail\$1dbmail\$1json**
Eine interne Prozedur, die JSON-Anfragen für Funktionen generiert. AWS Lambda
**sysmail\$1verify\$1profile\$1sp, sysmail\$1verify\$1account\$1sp, sysmail\$1verify\$1addressparams\$1sp**
Interne Verfahren, die Einstellungen überprüfen.
**sp\$1get\$1dbmail, sp\$1set\$1dbmail, sysmail\$1dbmail\$1xml**
Veraltete interne Prozeduren.
## Syntax für Prozeduren, die SQL Server-Datenbankmail in PostgreSQL emulieren
Die `aws_sqlserver_ext.sp_send_dbmail` Prozedur im Erweiterungspaket emuliert die Prozedur. `msdb.dbo.sp_send_dbmail` Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar = NULL::character varying,
par_recipients text = NULL::text,
par_copy_recipients text = NULL::text,
par_blind_copy_recipients text = NULL::text,
par_subject varchar = NULL::character varying,
par_body text = NULL::text,
par_body_format varchar = NULL::character varying,
par_importance varchar = 'NORMAL'::character varying,
par_sensitivity varchar = 'NORMAL'::character varying,
par_file_attachments text = NULL::text,
par_query text = NULL::text,
par_execute_query_database varchar = NULL::character varying,
par_attach_query_result_as_file smallint = 0,
par_query_attachment_filename varchar = NULL::character varying,
par_query_result_header smallint = 1,
par_query_result_width integer = 256,
par_query_result_separator VARCHAR = ' '::character varying,
par_exclude_query_output smallint = 0,
par_append_query_error smallint = 0,
par_query_no_truncate smallint = 0,
par_query_result_no_padding smallint = 0,
out par_mailitem_id integer,
par_from_address text = NULL::text,
par_reply_to text = NULL::text,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_mailitems_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_mailitems_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-mailitems-sp-transact-sql?view=sql-server-ver15).
```
par_sent_before timestamp = NULL::timestamp without time zone,
par_sent_status varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar,
par_description varchar = NULL::character varying,
out par_profile_id integer,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_name varchar
par_email_address varchar
par_display_name varchar = NULL::character varying
par_replyto_address varchar = NULL::character varying
par_description varchar = NULL::character varying
par_mailserver_name varchar = NULL::character varying
par_mailserver_type varchar = 'SMTP'::bpchar
par_port integer = 25
par_username varchar = NULL::character varying
par_password varchar = NULL::character varying
par_use_default_credentials smallint = 0
par_enable_ssl smallint = 0
out par_account_id integer
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_description varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_force_delete smallint = 1,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_email_address varchar = NULL::character varying,
par_display_name varchar = NULL::character varying,
par_replyto_address varchar = NULL::character varying,
par_description varchar = NULL::character varying,
par_mailserver_name varchar = NULL::character varying,
par_mailserver_type varchar = NULL::character varying,
par_port integer = NULL::integer,
par_username varchar = NULL::character varying,
par_password varchar = NULL::character varying,
par_use_default_credentials smallint = NULL::smallint,
par_enable_ssl smallint = NULL::smallint,
par_timeout integer = NULL::integer,
par_no_credential_change smallint = NULL::smallint,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
## Beispiele für die Verwendung von Prozeduren, die SQL Server-Datenbankmail emulieren, in PostgreSQL
Gehen Sie wie `aws_sqlserver_ext.sp_send_dbmail` folgt vor, um eine E-Mail zu senden.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
Das folgende Beispiel zeigt, wie eine E-Mail mit Abfrageergebnissen gesendet wird.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Account with id = 1',
par_query := 'SELECT COUNT(*)FROM Account WHERE id = 1'
);
```
Das folgende Beispiel zeigt, wie eine E-Mail mit HTML-Code gesendet wird.
```
DECLARE var_tableHTML TEXT;
SET var_tableHTML := CONCAT(
'Work Order Report
',
'',
'| Work Order ID | Product ID | ',
'Name | Order Qty | Due Date | ',
'Expected Revenue |
|---|
',
'
'
);
PERFORM sp_send_dbmail (
par_recipients := 'hello@rusgl.info',
par_subject := 'Work Order List',
par_body := var_tableHTML,
par_body_format := 'HTML'
);
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_delete_mailitems_sp` folgt vor, um E-Mails zu löschen.
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
Das folgende Beispiel zeigt, wie die ältesten E-Mails gelöscht werden.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
Das folgende Beispiel zeigt, wie Sie alle E-Mails löschen, die nicht gesendet werden können.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_add_profile_sp` folgt vor, um ein neues Benutzerprofil zu erstellen.
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
Das folgende Beispiel zeigt, wie Sie ein neues Profil erstellen und die eindeutige Profil-ID in einer Variablen speichern.
```
DECLARE var_profileId INT;
SELECT par_profile_id
FROM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := ' Profile used for administrative mail.')
INTO var_profileId;
SELECT var_profileId;
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_add_account_sp` folgt vor, um ein neues E-Mail-Konto zu erstellen.
```
PERFORM sysmail_add_account_sp (
par_account_name :='Audit Account',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_description := 'Account for administrative e-mail.',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'arn:aws:lambda:us-west-2:555555555555:function:pg_v3'
);
```
`aws_sqlserver_ext.sysmail_add_profileaccount_sp`Gehen Sie wie folgt vor, um dem Benutzerprofil ein E-Mail-Konto hinzuzufügen.
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## Anwendungsbeispiele für die Emulation von SQL Server-Datenbank-Mail in PostgreSQL
Wenn Ihr Quelldatenbankcode SQL Server Database Mail zum Senden von E-Mails verwendet, können Sie das AWS SCT Erweiterungspaket verwenden, um diesen Code nach PostgreSQL zu konvertieren.
**Um eine E-Mail aus Ihrer PostgreSQL-Datenbank zu senden**
1. Erstellen und konfigurieren Sie Ihre AWS Lambda Funktion.
1. Wenden Sie das AWS SCT Erweiterungspaket an.
1. Erstellen Sie mit der folgenden `sysmail_add_profile_sp` Funktion ein Benutzerprofil.
1. Erstellen Sie mit der folgenden `sysmail_add_account_sp` Funktion ein E-Mail-Konto.
1. Fügen Sie dieses E-Mail-Konto mithilfe der folgenden `sysmail_add_profileaccount_sp` Funktion zu Ihrem Benutzerprofil hinzu.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_settings_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sysmail_add_profile_sp(
par_profile_name := 'Administrator',
par_description := 'administrative mail'
);
PERFORM aws_sqlserver_ext.sysmail_add_account_sp(
par_account_name := 'Audit Account',
par_description := 'Account for administrative e-mail.',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'your_ARN'
);
PERFORM aws_sqlserver_ext.sysmail_add_profileaccount_sp(
par_profile_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
END;
$BODY$
LANGUAGE plpgsql;
```
1. Senden Sie eine E-Mail mit der `sp_send_dbmail` Funktion wie unten gezeigt.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_send_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sp_send_dbmail(
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_body := 'The stored procedure finished',
par_subject := 'Automated Success Message'
);
END;
$BODY$
LANGUAGE plpgsql;
```
`sysmail_help_profile_sp`Gehen Sie wie folgt vor, um die Informationen zu allen Benutzerprofilen anzuzeigen.
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
Im folgenden Beispiel werden die Informationen über das spezifische Benutzerprofil angezeigt.
```
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_name := 'Administrator');
```
`sysmail_help_account_sp`Gehen Sie wie folgt vor, um die Informationen zu allen E-Mail-Konten anzuzeigen.
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
Im folgenden Beispiel werden die Informationen zu dem jeweiligen E-Mail-Konto angezeigt.
```
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_name := 'Audit Account');
```
`sysmail_help_profileaccount_sp`Gehen Sie wie folgt vor, um die Informationen zu allen E-Mail-Konten anzuzeigen, die mit den Benutzerprofilen verknüpft sind.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
Im folgenden Beispiel werden die Datensätze nach ID, Profilname oder Kontoname gefiltert.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1, par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_name := 'Administrator');
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_account_name := 'Audit Account');
```
`sysmail_update_profile_sp`Gehen Sie wie folgt vor, um den Namen oder die Beschreibung des Benutzerprofils zu ändern.
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
Gehen Sie wie `ysmail_update_account_sp` folgt vor, um die E-Mail-Kontoeinstellungen zu ändern.
```
select from aws_sqlserver_ext.sysmail_update_account_sp (
par_account_name := 'Audit Account',
par_mailserver_name := 'arn:aws:lambda:region:XXXXXXXXXXXX:function:func_test',
par_mailserver_type := 'AWSLAMBDA'
);
```