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.
# Durchführen allgemeiner Systemaufgaben für Oracle DB-Instances
Im Folgenden erfahren Sie, wie Sie bestimmte allgemeine DBA-Aufgaben durchführen können, die mit dem System Ihrer Amazon-RDS-DB-Instances in Oracle zusammenhängen. Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff zu DB-Instances bereit und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern.
**Topics**
+ [
# Trennen einer Sitzung
](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [
# Beenden einer Sitzung
](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [
# Abbrechen einer SQL-Anweisung in einer Sitzung
](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [
# Aktivieren und Deaktivieren von beschränkten Sitzungen
](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [
# Bereinigen des freigegebenen Pools
](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [
# Erteilen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [
# Widerrufen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [
# Verwalten von RDS\$1X\$1-Ansichten für Oracle-DB-Instances
](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [
# Erteilen von Berechtigungen an Nicht-Hauptbenutzer
](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [
# Erstellen von benutzerdefinierten Funktionen für das Überprüfen von Passwörtern
](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [
## Einrichten eines benutzerdefinierten DNS-Servers
](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [
# Festlegen und Aufheben von Systemdiagnoseereignissen
](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Trennen einer Sitzung
Um die aktuelle Sitzung zu trennen, indem Sie den dedizierten Serverprozess beenden, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.disconnect`. Die Prozedur `disconnect` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `method` | varchar | 'IMMEDIATE' | Nein | Gültige Werte sind `'IMMEDIATE'` oder `'POST_TRANSACTION'`. |
Im folgenden Beispiel wird die Verbindung mit einer Sitzung getrennt.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Stellen Sie an die Ansicht `V$SESSION` eine Abfrage, um die Sitzungskennung und die -seriennummer zu erhalten. Im folgenden Beispiel werden alle Sitzungen für den Benutzer abgerufen `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Die Datenbank muss offen sein, um diese Methode zu verwenden. Weitere Informationen über das Trennen der Verbindung zu einer Sitzung finden Sie unter [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) in der Oracle-Dokumentation.
# Beenden einer Sitzung
Um eine Sitzung zu beenden, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.kill`. Die Prozedur `kill` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `method` | varchar | Null | Nein | Gültige Werte sind `'IMMEDIATE'` oder `'PROCESS'`. Wenn Sie `IMMEDIATE` angeben, hat dies den gleichen Effekt wie das Ausführen der folgenden Anweisung: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Wenn Sie `PROCESS` angeben, beenden Sie die mit einer Sitzung verbundenen Prozesse. Geben Sie `PROCESS` nur an, wenn Sie die Sitzung mit `IMMEDIATE` nicht beenden konnten. |
Stellen Sie an die Ansicht `V$SESSION` eine Abfrage, um die Sitzungskennung und die -seriennummer zu erhalten. Im folgenden Beispiel werden alle Sitzungen für den Benutzer abgerufen *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Im folgenden Beispiel wird eine Sitzung beendet.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
Im folgenden Beispiel werden die mit einer Sitzung verbundenen Prozesse beendet.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Abbrechen einer SQL-Anweisung in einer Sitzung
Um eine SQL-Anweisung in einer Sitzung abzubrechen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.cancel`.
**Anmerkung**
Dieses Verfahren wird für Oracle Database 19c (19.0.0) und alle höheren Haupt- und Nebenversionen von RDS for Oracle unterstützt.
Die Prozedur `cancel` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `sql_id` | varchar2 | Null | Nein | Die SQL-ID der SQL-Anweisung. |
Das folgende Beispiel bricht eine SQL-Anweisung in einer Sitzung ab.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Um die Sitzungs-ID, die Sitzungsseriennummer und die SQL-ID einer SQL-Anweisung abzurufen, rufen Sie die `V$SESSION`-Ansicht ab. Das folgende Beispiel ruft alle Sitzungen und SQL-IDs für den Benutzer a `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Aktivieren und Deaktivieren von beschränkten Sitzungen
Um eine SQL-Anweisung in einer Sitzung abzubrechen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.restricted_session`. Die Prozedur `restricted_session` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Ja | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_enable` | Boolean | true | Nein | Setzen Sie diesen Parameter auf `true`, um beschränkte Sitzungen zu aktivieren, oder auf `false`, um beschränkte Sitzungen zu deaktivieren. |
Im folgenden Beispiel wird gezeigt, wie beschränkte Sitzungen aktiviert und deaktiviert werden können.
```
/* Verify that the database is currently unrestricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
/* Enable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => true);
/* Verify that the database is now restricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
----------
RESTRICTED
/* Disable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => false);
/* Verify that the database is now unrestricted again. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
```
# Bereinigen des freigegebenen Pools
Um den freigegebenen Pool zu bereinigen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.flush_shared_pool`. Die Prozedur `flush_shared_pool` hat keine Parameter.
Im folgenden Beispiel wird der geteilte Pool bereinigt.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Bereinigen des Buffer-Cache
Um den gemeinsamen Pool zu leeren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.flush_buffer_cache`. Die Prozedur `flush_buffer_cache` hat keine Parameter.
Im folgenden Beispiel wird der Buffer-Cache bereinigt.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Leeren des Smart-Flash-Caches der Datenbank
Wenn Sie den Smart-Flash-Cache der Datenbank leeren möchten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.flush_flash_cache`. Die Prozedur `flush_flash_cache` hat keine Parameter. Im folgenden Beispiel wird der Smart-Flash-Cache der Datenbank geleert.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Weitere Informationen zur Verwendung des Smart-Flash-Caches der Datenbank mit RDS für Oracle finden Sie unter [Speichern temporärer Daten in einem Instance-Speicher von RDS für Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Erteilen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
Im Normalfall werden Sonderrechte mithilfe von Rollen übertragen, die viele Objekte beinhalten können. Um den Puffer-Cache zu leeren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.grant_sys_object`. Die Prozedur gewährt nur Berechtigungen, die dem Masterbenutzer bereits über eine Rolle oder direkte Erteilung gewährt wurden.
Die Prozedur `grant_sys_object` hat die folgenden Parameter.
**Wichtig**
Verwenden Sie für alle Parameterwerte Großbuchstaben, es sei denn, Sie haben den Benutzer mit einer Kennung mit bedeutsamer Groß- und Kleinschreibung erstellt. Wenn Sie z. B. `CREATE USER myuser` oder `CREATE USER MYUSER` ausführen , wird im Datenwörterbuch `MYUSER` gespeichert. Wenn Sie jedoch doppelte Anführungszeichen in `CREATE USER "MyUser"` verwenden, speichert das Datenwörterbuch `MyUser`.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ja | Der Name des Objekts dem die Sonderrechte erteilt werden sollen. Das Objekt kann ein Verzeichnis, eine Funktion, ein Paket, eine Prozedur, eine Sequenz, eine Tabelle oder eine Ansicht sein. Objektnamen müssen genauso angegeben werden, wie sie in sin `DBA_OBJECTS`. Die meisten Systemobjekte sind in Großbuchstaben definiert. Daher empfehlen wir Ihnen, zuerst diese Schreibweise zu verwenden. |
| `p_grantee` | varchar2 | — | Ja | Der Name des Objekts, dem die Sonderrechte erteilt werden sollen. Das Objekt kann ein Schema oder eine Rolle sein. |
| `p_privilege` | varchar2 | Null | Ja | — |
| `p_grant_option` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um ihn mit der Genehmigungsoption zu verwenden. |
Im folgenden Beispiel werden einem Objekt mit dem Namen `V_$SESSION` für einen Benutzer mit dem Namen `USER1` ausgewählte Berechtigungen erteilt.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
Im folgenden Beispiel werden einem Objekt mit dem Namen `V_$SESSION` für einen Benutzer mit dem Namen `USER1` mit der Erteilungsoption ausgewählte Berechtigungen erteilt.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Um Sonderrechte für ein Objekt erteilen zu können, muss Ihr Konto über diese Sonderrechte verfügen, die ihm entweder direkt, mithilfe der Genehmigungsoption oder einer Rolle mithilfe von erteilt wurde `with admin option`. Im häufigsten Fall wird das Sonderrecht `SELECT` an eine DBA-Ansicht erteilt, das an die Rolle `SELECT_CATALOG_ROLE` erteilt wurde. Wenn diese Rolle Ihrem Benutzer nicht bereits direkt mithilfe von `with admin option` erteilt wurde, können Sie die Berechtigung nicht übertragen. Wenn Sie über das DBA-Sonderrecht verfügen, können Sie die Rolle direkt an einen anderen Benutzer übertragen.
Im folgenden Beispiel wird die `SELECT_CATALOG_ROLE` und `EXECUTE_CATALOG_ROLE` an `USER1` übertragen. Da `with admin option` verwendet wird, kann `USER1` jetzt Zugriffsrechte auf SYS-Objekte erteilen, die an `SELECT_CATALOG_ROLE` erteilt wurden.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Objekte, die bereits an `PUBLIC` erteilt wurden, müssen nicht erneut erteilt werden. Wenn Sie die Prozedur `grant_sys_object` verwenden, um erneut Zugriffsrechte zu erteilen, ist der Prozeduraufruf erfolgreich.
# Widerrufen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
Um Berechtigungen für ein einzelnes Objekt zu entziehen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.revoke_sys_object`. Das Verfahren widerruft nur Privilegien, die dem Masterkonto bereits über eine Rolle oder direkte Erteilung gewährt wurden.
Die Prozedur `revoke_sys_object` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ja | Der Name des Objekts, für das Berechtigungen widerrufen werden sollen. Das Objekt kann ein Verzeichnis, eine Funktion, ein Paket, eine Prozedur, eine Sequenz, eine Tabelle oder eine Ansicht sein. Objektnamen müssen genauso angegeben werden, wie sie in sin `DBA_OBJECTS`. Die meisten Systemobjekte sind in Großbuchstaben definiert, von daher empfehlen wir Ihnen, diese Schreibweise zuerst auszuprobieren. |
| `p_revokee` | varchar2 | — | Ja | Der Name des Objekts, für das Berechtigungen widerrufen werden sollen. Das Objekt kann ein Schema oder eine Rolle sein. |
| `p_privilege` | varchar2 | Null | Ja | — |
Im folgenden Beispiel werden ausgewählte Berechtigungen für ein Objekt mit dem Namen `V_$SESSION` von einem Benutzer mit dem Namen `USER1` widerrufen.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Verwalten von RDS\$1X\$1-Ansichten für Oracle-DB-Instances
Möglicherweise müssen Sie auf feste `SYS.X$`-Tabellen zugreifen, die nur über`SYS` aufgerufen werden können. Verwenden Sie die im `rdsadmin.rdsadmin_util`-Paket enthaltenen Verfahren, um `SYS.RDS_X$`-Ansichten für berechtigte `X$`-Tabellen zu erstellen. Ihrem Masterbenutzer wird automatisch die Berechtigung `SELECT … WITH GRANT OPTION` für die `RDS_X$`-Ansichten erteilt.
Die `rdsadmin.rdsadmin_util`-Verfahren sind in den folgenden Fällen verfügbar:
+ Vorhandene DB-Instances, die noch nie aktualisiert wurden und die folgenden Versionen verwenden:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` und höhere 21c-Versionen
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` und höhere 19c-Versionen
+ Jede neue DB-Instance, die Sie erstellen
+ Jede vorhandene DB-Instance, die Sie aktualisiert haben
**Wichtig**
Intern erstellt das `rdsadmin.rdsadmin_util`-Paket Ansichten für `X$`-Tabellen. Die `X$`-Tabellen sind interne Systemobjekte, die in der Dokumentation zu Oracle Database nicht beschrieben werden. Wir empfehlen, dass Sie bestimmte Ansichten in Ihrer Nicht-Produktionsdatenbank testen und Ansichten in Ihrer Produktionsdatenbank nur unter der Anleitung von Oracle Support festlegen.
## Listet feste X\$1-Tabellen auf, die für die Verwendung in RDS\$1X\$1-Ansichten berechtigt sind
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`, um X\$1-Tabellen aufzulisten, die für die Verwendung in `RDS_X$` Ansichten berechtigt sind. Dieses Verfahren akzeptiert keine Parameter. In den folgenden Anweisungen werden alle berechtigten `X$`-Tabellen aufgeführt (einschließlich Beispielausgabe).
```
SQL> SET SERVEROUTPUT ON
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_allowed_sys_x$_views);
'X$BH'
'X$K2GTE'
'X$KCBWBPD'
'X$KCBWDS'
'X$KGLLK'
'X$KGLOB'
'X$KGLPN'
'X$KSLHOT'
'X$KSMSP'
'X$KSPPCV'
'X$KSPPI'
'X$KSPPSV'
'X$KSQEQ'
'X$KSQRS'
'X$KTUXE'
'X$KQRFP'
```
Die Liste der berechtigten `X$`-Tabellen kann sich im Laufe der Zeit ändern. Um sicherzustellen, dass Ihre Liste der berechtigten festen `X$`-Tabellen aktuell ist, sollten Sie `list_allowed_sys_x$_views` regelmäßig erneut ausführen.
## Erstellen von SYS.RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.create_sys_x$_view`, um eine `RDS_X$`-Ansicht für eine berechtigte `X$`-Tabelle zu erstellen. Sie können nur Ansichten für die in der Ausgabe von `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` aufgelisteten Tabellen erstellen. Das `create_sys_x$_view`-Verfahren akzeptiert die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ja | Ein gültiger `X$`-Tabellenname. Der Wert muss eine der von `list_allowed_sys_x$_views` gemeldeten `X$`-Tabellen sein. |
| `p_force_creation` | Boolesch | FALSE | Nein | Ein Wert, der angibt, ob die Erstellung einer `RDS_X$`-Ansicht erzwungen werden soll, die bereits für eine `X$`-Tabelle vorhanden ist. Standardmäßig erstellt RDS keine Ansicht, wenn sie bereits vorhanden ist. Um die Erstellung zu erzwingen, legen Sie diesen Parameter auf `TRUE` fest. |
Das folgende Beispiel erstellt die `SYS.RDS_X$KGLOB`-Ansicht aus der Tabelle `X$KGLOB`. Das Format für den Ansichtsnamen ist `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
In der folgenden Datenwörterbuchabfrage werden die Ansicht `SYS.RDS_X$KGLOB` und ihr Status aufgeführt. Ihrem Masterbenutzer wird automatisch die Berechtigung `SELECT ... WITH GRANT OPTION` für diese Ansicht erteilt.
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
OWNER OBJECT_NAME STATUS
------------------------------ ------------------------------ ------------------------------
SYS RDS_X$KGLOB VALID
```
**Wichtig**
Es kann nicht garantiert werden, dass `X$`-Tabellen vor und nach einem Upgrade unverändert bleiben. RDS für Oracle löscht die `RDS_X$`-Ansichten der `X$`-Tabellen während eines Engine-Upgrades und erstellt sie neu. Anschließend wird dem Masterbenutzer die `SELECT ... WITH GRANT OPTION`-Berechtigung gewährt. Erteilen Sie Datenbankbenutzern nach einem Upgrade nach Bedarf Berechtigungen für die entsprechenden `RDS_X$`-Ansichten.
## Erstellen von SYS.RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `RDS_X$`, um vorhandene `rdsadmin.rdsadmin_util.list_created_sys_x$_views`-Ansichten aufzulisten. Das Verfahren listet nur Ansichten auf, die mit dem Verfahren `create_sys_x$_view` erstellt wurden. Das folgende Beispiel listet `X$`-Tabellen mit entsprechenden `RDS_X$`-Ansichten auf (einschließlich Beispielausgabe).
```
SQL> SET SERVEROUTPUT ON
SQL> COL XD_TBL_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_created_sys_x$_views);
XD_TBL_NAME STATUS
------------------------------ ------------------------------
X$BH VALID
X$K2GTE VALID
X$KCBWBPD VALID
3 rows selected.
```
## Löschen von RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.drop_sys_x$_view`, um eine `SYS.RDS_X$`-Ansicht zu löschen. Sie können nur Ansichten festlegen, die in der Ausgabe von `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` aufgeführt sind. Das `drop_sys_x$_view`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ja | Ein gültiger fester `X$`-Tabellenname. Der Wert muss eine der von `list_created_sys_x$_views` gemeldeten festen `X$`-Tabellen sein. |
Das folgende Beispiel löscht die `RDS_X$KGLOB`-Ansicht, die in der Tabelle `X$KGLOB` erstellt wurde.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
Das folgende Beispiel zeigt, dass die Ansicht `SYS.RDS_X$KGLOB` gelöscht wurde (einschließlich Beispielausgabe).
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
no rows selected
```
# Erteilen von Berechtigungen an Nicht-Hauptbenutzer
Sie können Auswahl-Sonderrechte für viele Objekte im `SYS`-Schema mithilfe der `SELECT_CATALOG_ROLE`-Rolle erteilen. Die Rolle `SELECT_CATALOG_ROLE` gibt Benutzern `SELECT`-Sonderrechte für Datenverzeichnisansichten. Im folgenden Beispiel wird die Rolle `SELECT_CATALOG_ROLE` einem Benutzer mit dem Namen `user1` erteilt.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
Sie können `EXECUTE`-Sonderrechte für viele Objekte im `SYS`-Schema mithilfe der `EXECUTE_CATALOG_ROLE`-Rolle erteilen. Die Rolle `EXECUTE_CATALOG_ROLE` gibt Benutzern `EXECUTE`-Sonderrechte für Pakete und Prozeduren im Datenverzeichnis. Im folgenden Beispiel wird die Rolle `EXECUTE_CATALOG_ROLE` einem Benutzer mit dem Namen *user1* erteilt.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
Im folgenden Beispiel werden die Berechtigungen abgerufen, die durch die Rollen `SELECT_CATALOG_ROLE` und `EXECUTE_CATALOG_ROLE` gewährt werden.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
Im folgenden Beispiel wird ein Nicht-Masterbenutzer mit dem Namen `user1` erstellt, die Berechtigung `CREATE SESSION` gewährt und die Berechtigung `SELECT` für eine Datenbank mit dem Namen *sh.sales* erteilt.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Erstellen von benutzerdefinierten Funktionen für das Überprüfen von Passwörtern
Es gibt verschiedene Möglichkeiten, eine benutzerdefinierte Funktion für die Passwortüberprüfung zu erstellen:
+ Um die Standardüberprüfungslogik zu verwenden und Ihre Funktion im `SYS`-Schema zu speichern, verwenden Sie die Prozedur `create_verify_function`.
+ Um eine benutzerdefinierte Überprüfungslogik zu verwenden und Ihre Funktion nicht im `SYS`-Schema zu speichern, verwenden Sie die Prozedur `create_passthrough_verify_fcn`.
# Die Prozedur create\$1verify\$1function
Sie können eine benutzerdefinierte Funktion erstellen, um Passwörter mithilfe der Amazon-RDS-Prozedur `rdsadmin.rdsadmin_password_verify.create_verify_function` zu überprüfen. Das Verfahren `create_verify_function` wird für alle Versionen von RDS für Oracle unterstützt.
Die Prozedur `create_verify_function` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ja | Der Name für Ihre benutzerdefinierte Funktion. Diese Funktion wird für Sie im SYS-Schema erstellt. Sie teilen diese Funktion den Benutzerprofilen zu. |
| `p_min_length` | Zahl | 8 | Nein | Die erforderliche Mindestzeichenanzahl. |
| `p_max_length` | Zahl | 256 | Nein | Die maximale Anzahl der erlaubten Zeichen |
| `p_min_letters` | Zahl | 1 | Nein | Die Mindestanzahl der erforderlichen Buchstaben |
| `p_min_uppercase` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Großbuchstaben |
| `p_min_lowercase` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Kleinbuchstaben |
| `p_min_digits` | Zahl | 1 | Nein | Die Mindestanzahl der erforderlichen Zahlen |
| `p_min_special` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Sonderzeichen |
| `p_min_different_chars` | Zahl | 3 | Nein | Die Mindestanzahl der zwischen dem alten und dem neuen Passwort erforderlichen unterschiedlichen Zeichen. |
| `p_disallow_username` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um den Benutzernamen im Passwort nicht zu erlauben. |
| `p_disallow_reverse` | Boolean | true | Nein | Auf `true` festlegen, um die Umkehrung des Benutzernamens im Passwort zu verbieten. |
| `p_disallow_db_name` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um den Datenbank- oder Servernamen im Passwort nicht zu erlauben. |
| `p_disallow_simple_strings` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um einfache Zeichenfolgen im Passwort nicht zu erlauben. |
| `p_disallow_whitespace` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um Leerzeichen im Passwort nicht zu erlauben. |
| `p_disallow_at_sign` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um das @-Zeichen im Passwort nicht zu erlauben. |
Sie können mehrere benutzerdefinierte Funktionen für die Passwortüberprüfung erstellen.
Es gibt Einschränkungen im Hinblick auf den Namen für Ihre benutzerdefinierte Funktion. Der Name Ihrer benutzerdefinierten Funktion darf nicht mit dem Namen eines vorhandenen Systemobjekts identisch sein. Der Name darf nicht mehr als 30 Zeichen lang sein. Der Name muss außerdem eine der folgenden Zeichenfolgen enthalten: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` oder `STRENGTH`.
Im folgenden Beispiel wird die Funktion mit dem Namen erstell `CUSTOM_PASSWORD_FUNCTION`. Die Funktion erfordert ein Passwort mit mindestens 12 Zeichen, 2 Großbuchstaben, 1 Zahl und 1 Sonderzeichen. Außerdem ist das @-Zeichen im Passwort nicht erlaubt.
```
begin
rdsadmin.rdsadmin_password_verify.create_verify_function(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_min_length => 12,
p_min_uppercase => 2,
p_min_digits => 1,
p_min_special => 1,
p_disallow_at_sign => true);
end;
/
```
Tätigen Sie die Abfrage `DBA_SOURCE`, um den Text Ihrer Überprüfungsfunktion anzusehen. Im folgenden Beispiel wird der Text einer benutzerdefinierten Passwortfunktion mit dem Namen erhalte `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Verwenden Sie `ALTER PROFILE`, um Ihre Überprüfungsfunktion einem Benutzerprofil zuzuordnen. Im folgenden Beispiel wird eine PL/SQL Bestätigungsfunktion `CUSTOM_PASSWORD_FUNCTION` mit dem Namen des `DEFAULT` Benutzerprofils verknüpft. `PASSWORD_VERIFY_FUNCTION`ist der Ressourcenname des Oracle-Profils.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Um zu sehen, welche Benutzerprofile mit welchen Überprüfungsfunktionen verknüpft sind, fragen Sie ab`DBA_PROFILES`. Im folgenden Beispiel wird das Profil erhalten, dem die benutzerdefinierte Überprüfungsfunktion mit dem Namen zugehörig is `CUSTOM_PASSWORD_FUNCTION`.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION' AND LIMIT = 'CUSTOM_PASSWORD_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
```
Im folgenden Beispiel werden alle Profile und Passwortüberprüfungsfunktionen erhalten, die miteinander verknüpft sind.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
RDSADMIN PASSWORD_VERIFY_FUNCTION PASSWORD NULL
```
# Die Prozedur create\$1passthrough\$1verify\$1fcn
Das Verfahren `create_passthrough_verify_fcn` wird für alle Versionen von RDS für Oracle unterstützt.
Sie können eine benutzerdefinierte Funktion erstellen, um Passwörter mithilfe der Amazon-RDS-Prozedur `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn` zu überprüfen. Die Prozedur `create_passthrough_verify_fcn` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ja | Der Name für Ihre benutzerdefinierte Überprüfungsfunktion. Dies ist eine Wrapper-Funktion, die für Sie im SYS-Schema erstellt wird und keine Überprüfungslogik beinhaltet. Sie teilen diese Funktion den Benutzerprofilen zu. |
| `p_target_owner` | varchar2 | — | Ja | Der Schemabesitzer für Ihre benutzerdefinierte Überprüfungsfunktion |
| `p_target_function_name` | varchar2 | — | Ja | Der Name für Ihre bestehende benutzerdefinierte Funktion, der die Überprüfungslogik beinhaltet. Ihre benutzerdefinierte Funktion muss einen Booleschen Wert zurückgeben. Ihre Funktion sollte `true`zurückgeben, wenn das Passwort gültig ist, und `false`, wenn das Passwort ungültig ist. |
Im folgenden Beispiel wird eine Passwortüberprüfungsfunktion erstellt, die die Logik aus der Funktion mit dem Namen verwende `PASSWORD_LOGIC_EXTRA_STRONG`.
```
begin
rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_target_owner => 'TEST_USER',
p_target_function_name => 'PASSWORD_LOGIC_EXTRA_STRONG');
end;
/
```
Verwenden Sie , um die Überprüfungsfunktion Ihrem Benutzerprofil zuzuordne `alter profile`. Im folgenden Beispiel wird die Überprüfungsfunktion mit dem `DEFAULT`-Benutzerprofil verknüpft.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Einrichten eines benutzerdefinierten DNS-Servers
Amazon RDS unterstützt ausgehenden Netzwerkzugriff auf Ihre DB-Instance, auf der Oracle ausgeführt wird. Weitere Informationen zu ausgehendem Netzwerkzugriff, einschließlich Voraussetzungen, finden Sie unter [Konfigurieren des UTL\$1HTTP-Zugriffs mit Zertifikaten und einer Oracle Wallet](Oracle.Concepts.ONA.md).
Amazon-RDS-Oracle erlaubt Domain Name Service (DNS)-Auflösung aus einem benutzerdefinierten DNS-Server, der im Besitz des Kunden ist. Sie können nur vollständig geeignete Domänenamen aus Ihrer Amazon-RDS-DB-Instance über Ihren benutzerdefinierten DNS-Server auflösen.
Nachdem Sie Ihren benutzerdefinierten DNS-Namensserver eingerichtet haben, dauert es bis zu 30 Minuten, um die Änderungen an Ihre DB-Instance zu übertragen. Nachdem die Änderungen an Ihre DB-Instance übertragen wurden, wird ausgehender Datenverkehr, der eine DNS-Abfrage tätigen muss, Ihren DNS-Server über Port 53 abrufen.
Führen Sie folgende Schritte aus, um einen benutzerdefinierten DNS-Server für Ihre Amazon RDS für Oracle-DB-Instance einzurichten:
+ Legen Sie in dem Ihrer Virtual Private Cloud (VPC) beigefügten DHCP-Optionsset die Option `domain-name-servers` für die IP-Adresse Ihres DNS-Namensservers fest. Weitere Informationen finden Sie unter [DHCP-Optionssets](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**Anmerkung**
Die Option `domain-name-servers` akzeptiert bis zu vier Werte, Ihre Amazon-RDS-DB-Instance verwendet jedoch nur den ersten Wert.
+ Stellen Sie sicher, dass Ihr DNS-Server die Suchabfragen auflösen kann, einschließlich DNS-Namen, Amazon EC2-private-DNS-Namen und benutzerspezifischen DNS-Namen. Wenn der ausgehende Datenverkehr DNS-Abfragen beinhaltet, die Ihr DNS-Server nicht handhaben kann, müssen für Ihren DNS-Server angemessene DNS-Provider für einen Upstream konfiguriert sein.
+ Konfigurieren Sie Ihren DNS-Server, um User Datagram Protocol (UDP)-Antworten in der Größenordnung von 512 Bytes oder weniger zu erhalten.
+ Konfigurieren Sie Ihren DNS-Server, um Transmission Control Protocol (TCP)-Antworten in der Größenordnung von 1 024 Bytes oder weniger zu erhalten.
+ Konfigurieren Sie Ihren DNS-Server, um eingehenden Datenverkehr aus Ihrer Amazon-RDS-DB-Instance über Port 53 zu erlauben. Wenn sich Ihr DNS-Server in einer Amazon VPC befindet, muss die VPC über eine Sicherheitsgruppe verfügen, die eingehende Regeln für das Erlauben von UDP und TCP über Port 53 beinhaltet. Wenn sich Ihr DNS-Server nicht in einer Amazon VPC befindet, muss er über eine angemessene Firewall-Whitelist verfügen, die UDP- und TCP-Übertragungen über Port 53 zulassen.
Weitere Informationen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) und unter [Hinzufügen und Entfernen von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Konfigurieren Sie die VPC Ihrer Amazon-RDS-DB-Instance, um ausgehenden Datenverkehr über Port 53 zu erlauben. Ihre VPC muss über eine Sicherheitsgruppe mit ausgehenden Regeln verfügen, die UDP- und TCP-Übertragungen über Port 53 erlauben.
Weitere Informationen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) und unter [Hinzufügen und Entfernen von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Der Routing-Pfad zwischen der Amazon-RDS-DB-Instance und dem DNS-Server muss korrekt konfiguriert werden, um DNS-Datenverkehr zu erlauben.
+ Wenn sich die Amazon-RDS-DB-Instance und der DNS-Server nicht in der selben VPC befinden, muss zwischen ihnen eine Peer-to-Peer-Verbindung eingerichtet werden. Weitere Informationen finden Sie unter [Was ist VPC Peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Festlegen und Aufheben von Systemdiagnoseereignissen
Um Diagnoseereignisse auf Sitzungsebene festzulegen und aufzuheben, können Sie die Oracle SQL-Anweisung verwende `ALTER SESSION SET EVENTS`. Um Ereignisse auf Systemebene festzulegen, können Sie Oracle SQL jedoch nicht verwenden. Verwenden Sie stattdessen die Systemereignisprozesse im `rdsadmin.rdsadmin_util`-Paket. Die Systemereignisprozesse sind in den folgenden Engine-Versionen verfügbar:
+ Alle Versionen von Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 oder höhere Versionen von Oracle Database 19c
Weitere Informationen finden Sie unter [Version 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) in den *Versionshinweisen zu Amazon RDS für Oracle*.
**Wichtig**
Intern legt das `rdsadmin.rdsadmin_util`-Paket Ereignisse mithilfe der `ALTER SYSTEM SET EVENTS`-Anweisung fest. Diese `ALTER SYSTEM`-Aussage ist nicht in der Oracle Database-Dokumentation dokumentiert. Einige Systemdiagnoseereignisse können große Mengen an Rückverfolgungsinformationen generieren, Konflikte verursachen oder die Datenbankverfügbarkeit beeinträchtigen. Wir empfehlen, dass Sie bestimmte Diagnoseereignisse in Ihrer Nicht-Produktionsdatenbank testen und Ereignisse in Ihrer Produktionsdatenbank nur unter Anleitung von Oracle Support festlegen.
## Auflisten zulässiger Systemdiagnoseereignisse
Verwenden Sie das Amazon-RDS-Verfahren , um die Systemereignisse aufzulisten, die Sie festlegen könne `rdsadmin.rdsadmin_util.list_allowed_system_events`. Dieses Verfahren akzeptiert keine Parameter.
Im folgenden Beispiel werden alle Systemereignisse aufgeführt, die Sie festlegen können.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
Die folgende Beispielausgabe listet Ereignisnummern und ihre Beschreibungen auf. Verwenden Sie die Amazon-RDS-Verfahren `set_system_event`, um diese Ereignisse festzulegen und `unset_system_event`, um sie aufzuheben.
```
604 - error occurred at recursive SQL level
942 - table or view does not exist
1401 - inserted value too large for column
1403 - no data found
1410 - invalid ROWID
1422 - exact fetch returns more than requested number of rows
1426 - numeric overflow
1427 - single-row subquery returns more than one row
1476 - divisor is equal to zero
1483 - invalid length for DATE or NUMBER bind variable
1489 - result of string concatenation is too long
1652 - unable to extend temp segment by in tablespace
1858 - a non-numeric character was found where a numeric was expected
4031 - unable to allocate bytes of shared memory ("","","","")
6502 - PL/SQL: numeric or value error
10027 - Specify Deadlock Trace Information to be Dumped
10046 - enable SQL statement timing
10053 - CBO Enable optimizer trace
10173 - Dynamic Sampling time-out error
10442 - enable trace of kst for ORA-01555 diagnostics
12008 - error in materialized view refresh path
12012 - error on auto execute of job
12504 - TNS:listener was not given the SERVICE_NAME in CONNECT_DATA
14400 - inserted partition key does not map to any partition
31693 - Table data object failed to load/unload and is being skipped due to error:
```
**Anmerkung**
Die Liste der erlaubten Systemereignisse kann sich im Laufe der Zeit ändern. Um sicherzustellen, dass Sie die aktuellste Liste der berechtigten Ereignisse haben, verwenden Sie `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Festlegen von Systemdiagnoseereignissen
Verwenden Sie das Amazon-RDS-Verfahren , um ein Systemereignis festzulege `rdsadmin.rdsadmin_util.set_system_event`. Sie können nur Ereignisse festlegen, die in der Ausgabe von aufgeführt sin `rdsadmin.rdsadmin_util.list_allowed_system_events`. Das `set_system_event`-Verfahren akzeptiert die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_event` | Zahl | — | Ja | Die Systemereignisnummer. Der Wert muss eine der von gemeldeten Ereignisnummern sei `list_allowed_system_events`. |
| `p_level` | Zahl | — | Ja | Das Event-Level. In der Oracle Database-Dokumentation oder bei Oracle Support finden Sie Beschreibungen von Werten verschiedener Ebenen. |
Das Verfahren `set_system_event` konstruiert und führt die erforderlichen `ALTER SYSTEM SET EVENTS`-Aussagen nach folgenden Grundsätzen aus:
+ Der Ereignistyp (`context` oder `errorstack`) wird automatisch bestimmt.
+ Eine Anweisung im Formular `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` legt die Kontextereignisse fest. Diese Notation entspricht `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Eine Anweisung im Formular `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` legt die Fehler-Stack-Ereignisse fest. Diese Notation entspricht `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
Im folgenden Beispiel werden Ereignis 942 auf Ebene 3 und Ereignis 10 442 auf Ebene 10 festgelegt. Die Beispielausgabe ist enthalten.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(942,3);
Setting system event 942 with: alter system set events '942 errorstack (3)'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(10442,10);
Setting system event 10442 with: alter system set events '10442 level 10'
PL/SQL procedure successfully completed.
```
## Auflisten der festgesetzten Systemdiagnoseereignisse
Verwenden Sie das Amazon-RDS-Verfahren , um die derzeit festgelegten Systemereignisse aufzuliste `rdsadmin.rdsadmin_util.list_set_system_events`. Dieses Verfahren meldet nur Ereignisse, die auf Systemebene von festgelegt wurde `set_system_event`.
Im folgenden Beispiel werden die aktiven Systemereignisse aufgeführt.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
Die folgende Beispielausgabe zeigt die Liste der Ereignisse, den Ereignistyp, die Ebene, auf der die Ereignisse derzeit festgelegt sind, und den Zeitpunkt, zu dem das Ereignis festgelegt wurde.
```
942 errorstack (3) - set at 2020-11-03 11:42:27
10442 level 10 - set at 2020-11-03 11:42:41
PL/SQL procedure successfully completed.
```
## Aufheben von Systemdiagnoseereignissen
Verwenden Sie das Amazon-RDS-Verfahren , um ein Systemereignis aufzuhebe `rdsadmin.rdsadmin_util.unset_system_event`. Sie können nur die in der Ausgabe von aufgelisteten Ereignisse aufhebe `rdsadmin.rdsadmin_util.list_allowed_system_events`. Das `unset_system_event`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_event` | Zahl | — | Ja | Die Systemereignisnummer. Der Wert muss eine der von gemeldeten Ereignisnummern sei `list_allowed_system_events`. |
Im folgenden Beispiel werden die Ereignisse 942 und 10 442 aufgezeichnet. Die Beispielausgabe ist enthalten.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(942);
Unsetting system event 942 with: alter system set events '942 off'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(10442);
Unsetting system event 10442 with: alter system set events '10442 off'
PL/SQL procedure successfully completed.
```