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.
# Ausführen verschiedener Aufgaben für Oracle-DB-Instances
Im Folgenden erfahren Sie, wie Sie verschiedene DBA-Aufgaben für Ihre Amazon-RDS-DB-Instances, auf denen Oracle ausgeführt wird, durchführen können. 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**
+ [Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [Auflisten von Dateien in einem DB-Instance-Verzeichnis](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [Lesen von Dateien in einem DB-Instance-Verzeichnis](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [Zugreifen auf Opatch-Dateien](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [Verwalten von Berateraufgaben](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [Transport von Tabellenbereichen](rdsadmin_transport_util.md)
## Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich
Um die Dateien in einem Verzeichnis aufzulisten, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.create_directory`. Sie können bis zu 10 000 Verzeichnisse erstellen, die sich alle in Ihrem Hauptdatenspeicherplatz befinden. Um Verzeichnisse zu entfernen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.drop_directory`.
Die Prozeduren `create_directory` und `drop_directory` haben den folgenden erforderlichen Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Ja | Der Name des Verzeichnisses |
Im folgenden Beispiel wird ein neues Verzeichnis mit dem Namen erstell `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Das Datenwörterbuch speichert den Verzeichnisnamen in Großbuchstaben. Sie können die Verzeichnisse durch das Abfragen von auflisten lasse `DBA_DIRECTORIES`. Das System wählt den tatsächlichen Host-Pfadnamen automatisch aus. Im folgenden Beispiel wird der Verzeichnispfad für das Verzeichnis mit dem Namen erhalte `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Der Hauptbenutzername für die DB-Instance hat Lese- und Schreibsonderrechte im neuen Verzeichnis und kann anderen Benutzern Zugriff gewähren. `EXECUTE`-Sonderrechte sind für die Verzeichnisse in einer DB-Instance nicht verfügbar. Verzeichnisse werden in Ihrem Hauptdatenspeicher erstellt und verbrauchen Speicherplatz und I/O Bandbreite.
Im folgenden Beispiel wird das Verzeichnis mit dem Namen „“ entfern `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**Anmerkung**
Sie können ein Verzeichnis auch löschen, indem Sie den Oracle SQL-Befehl verwende `DROP DIRECTORY`.
Das Verwerfen eines Verzeichnisses entfernt nicht seine Inhalte. Da die Prozedur „`rdsadmin.rdsadmin_util.create_directory`“ Pfadnamen wiederverwenden kann, werden in Verzeichnissen verworfene Dateien in einem neu erstellten Verzeichnis wieder auftauchen. Bevor Sie ein Verzeichnis löschen, wird empfohlen, Dateien mit `UTL_FILE.FREMOVE` aus dem Verzeichnis zu entfernen. Weitere Informationen finden Sie unter [FREMOVE Procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) in der Oracle-Dokumentation.
## Auflisten von Dateien in einem DB-Instance-Verzeichnis
Um die Dateien in einem Verzeichnis aufzulisten, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rds_file_util.listdir`. Dieses Verfahren wird auf einem Oracle-Replikat nicht unterstützt. Die Prozedur `listdir` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ja | Der Name des aufzulistenden Verzeichnisses |
Das folgende Beispiel gewährt dem Benutzer read/write `rdsadmin` Rechte `PRODUCT_DESCRIPTIONS` für das Verzeichnis und listet dann die Dateien in diesem Verzeichnis auf.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Lesen von Dateien in einem DB-Instance-Verzeichnis
Um eine Textdatei zu lesen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rds_file_util.read_text_file`. Die Prozedur `read_text_file` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ja | Der Verzeichnisname der die Datei beinhaltet |
| `p_filename` | varchar2 | — | Ja | Der Name der zu lesenden Datei |
Im folgenden Beispiel wird die Datei `rice.txt` im Verzeichnis `PRODUCT_DESCRIPTIONS` erstellt.
```
declare
fh sys.utl_file.file_type;
begin
fh := utl_file.fopen(location=>'PRODUCT_DESCRIPTIONS', filename=>'rice.txt', open_mode=>'w');
utl_file.put(file=>fh, buffer=>'AnyCompany brown rice, 15 lbs');
utl_file.fclose(file=>fh);
end;
/
```
Im folgenden Beispiel wird die Datei `rice.txt` aus dem Verzeichnis `PRODUCT_DESCRIPTIONS` gelesen.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Zugreifen auf Opatch-Dateien
Opatch ist ein Oracle-Dienstprogramm, das die Anwendung und das Rollback von Patches auf Oracle-Software ermöglicht. Die Oracle-Methode, mit der bestimmt wird, welche Patches auf eine Datenbank angewendet wurden, ist der Befehl `opatch lsinventory`. Um Serviceanfragen für Kunden mit Bring Your Own License (BYOL) zu öffnen, fordert Oracle Support die `lsinventory`-Datei und manchmal die von Opatch generierte `lsinventory_detail`-Datei an.
Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf Opatch. Stattdessen enthält die Datei `lsinventory-dbv.txt` im BDUMP-Verzeichnis die Patch-Informationen zu Ihrer aktuellen Engine-Version. Wenn Sie ein Upgrade der Neben- oder Hauptversion durchführen, aktualisiert Amazon RDS `lsinventory-dbv.txt` innerhalb einer Stunde nach Patch-Anwendung. Informationen zur Überprüfung der angewendeten Patches finden Sie in der `lsinventory-dbv.txt`. Diese Aktion entspricht der Ausführung des Befehls `opatch lsinventory`.
**Anmerkung**
In den Beispielen in diesem Abschnitt wird davon ausgegangen, dass das BDUMP-Verzeichnis als benannt is `BDUMP`. Bei einem Lesereplikat unterscheidet sich der Name des BDUMP-Verzeichnisses. Informationen zum Abrufen des BDUMP-Namens durch Abfragen von `V$DATABASE.DB_UNIQUE_NAME` auf einem Lesereplikat finden Sie unter [Auflisten von Dateien](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
Die Inventardateien verwenden die Amazon RDS-Namenskonvention `lsinventory-dbv.txt` und`lsinventory_detail-dbv.txt`, wo *dbv* ist der vollständige Name Ihrer DB-Version. Die Datei `lsinventory-dbv.txt` ist auf allen DB-Versionen verfügbar. Die entsprechende Version `lsinventory_detail-dbv.txt` ist auf 19.0.0.0, ru-2020-01.r1 oder höher verfügbar.
Wenn Ihre DB-Version beispielsweise 19.0.0.0.ru-2021-07.rur-2021-07.r1 ist, haben die Bestandsdateien die folgenden Namen.
```
lsinventory-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
lsinventory_detail-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
```
Stellen Sie sicher, dass Sie die Dateien herunterladen, die mit der aktuellen Version Ihrer DB-Engine übereinstimmen.
### Konsole
**So laden Sie eine Bestandsdatei über die Konsole herunter**
1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie den Namen der DB-Instance, welche die anzuzeigende Protokolldatei enthält.
1. Wählen Sie die Registerkarte **Logs & events** (Protokolle und Ereignisse).
1. Scrollen Sie nach unten bis zum Abschnitt **Protokolle**.
1. Suchen Sie im Abschnitt **Protokolle** nach `lsinventory`.
1. Wählen Sie die Datei aus, auf die Sie zugreifen möchten, und klicken Sie dann auf **Herunterladen**.
### SQL
Zum Lesen der `lsinventory-dbv.txt` auf einem SQL-Client können Sie eine `SELECT`-Anweisung verwenden. Für diese Methode verwenden Sie eine der folgenden `rdsadmin`-Funktionen: `rdsadmin.rds_file_util.read_text_file` oder `rdsadmin.tracefile_listing`.
Ersetzen Sie in der folgenden Beispielabfrage *dbv* durch Ihre Oracle-DB-Version. Ihre DB-Version könnte beispielsweise 19.0.0.0.ru-2020-04.rur-2020-04.r1 sein.
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
Um das `lsinventory-dbv.txt` in einem SQL-Client zu lesen, können Sie ein PL/SQL Programm schreiben. Dieses Programm verwendet `utl_file`, um die Datei zu lesen, und `dbms_output`, um sie zu drucken. Dies sind von Oracle bereitgestellte Pakete.
Ersetzen Sie es im folgenden Beispielprogramm *dbv* durch Ihre Oracle-DB-Version. Ihre DB-Version könnte beispielsweise 19.0.0.0.ru-2020-04.rur-2020-04.r1 sein.
```
SET SERVEROUTPUT ON
DECLARE
v_file SYS.UTL_FILE.FILE_TYPE;
v_line VARCHAR2(1000);
v_oracle_home_type VARCHAR2(1000);
c_directory VARCHAR2(30) := 'BDUMP';
c_output_file VARCHAR2(30) := 'lsinventory-dbv.txt';
BEGIN
v_file := SYS.UTL_FILE.FOPEN(c_directory, c_output_file, 'r');
LOOP
BEGIN
SYS.UTL_FILE.GET_LINE(v_file, v_line,1000);
DBMS_OUTPUT.PUT_LINE(v_line);
EXCEPTION
WHEN no_data_found THEN
EXIT;
END;
END LOOP;
END;
/
```
Oder fragen Sie `rdsadmin.tracefile_listing` ab und spoolen Sie die Ausgabe in eine Datei. Im folgenden Beispiel wird die Ausgabe in gespool `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Verwalten von Berateraufgaben
Oracle Database enthält eine Reihe von Beratern. Jeder Berater unterstützt automatisierte und manuelle Aufgaben. Sie können Prozeduren im `rdsadmin.rdsadmin_util`-Paket zur Verwaltung einiger Berateraufgaben verwenden.
Die Prozesse der Berateraufgaben sind in den folgenden Engine-Versionen verfügbar:
+ Oracle Database 21c (21.0.0)
+ Version 19.0.0.0.ru-2021-01.rur-2021-01.r1 und höhere Versionen von Oracle Database 19c
Weitere Informationen finden Sie unter [Version 19.0.0.0.ru-2021-01.rur-2021-01.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2021-01.rur-2021-01.r1) in den *Versionshinweisen zu Amazon RDS für Oracle*.
**Topics**
+ [Festlegen von Parametern für Berateraufgaben](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [Deaktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [Erneutes Aktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Festlegen von Parametern für Berateraufgaben
Um Parameter für einige Berateraufgaben festzulegen, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. Die Prozedur `advisor_task_set_parameter` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ja | Der Name der Berateraufgabe, deren Parameter Sie ändern möchten. Die folgenden Werte sind gültig: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Ja | Der Name des Aufgaben-Parameters. Um gültige Parameter für eine Berateraufgabe zu finden, führen Sie die folgende Abfrage aus. *p\$1task\$1name*Ersetzen Sie durch einen gültigen Wert für`p_task_name`: COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
| `p_value` | varchar2 | — | Ja | Der Wert für einen Aufgabenparameter. Um gültige Werte für Aufgabenparameter zu finden, führen Sie die folgende Abfrage aus. Ersetze *p\$1task\$1name* durch einen gültigen Wert für`p_task_name`: COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
Das folgende PL/SQL Programm setzt `ACCEPT_PLANS` auf `FALSE` for`SYS_AUTO_SPM_EVOLVE_TASK`. Die automatisierte Aufgabe „SQL-Planverwaltung“ überprüft die Pläne und erstellt einen Bericht über ihre Ergebnisse, entwickelt die Pläne jedoch nicht automatisch weiter. Sie können einen Bericht verwenden, um neue SQL-Plan-Baselines zu identifizieren und sie manuell zu akzeptieren.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Das folgende PL/SQL Programm setzt `EXECUTION_DAYS_TO_EXPIRE` auf `10` for`AUTO_STATS_ADVISOR_TASK`. Die vordefinierte Aufgabe `AUTO_STATS_ADVISOR_TASK` läuft automatisch einmal täglich im Wartungsfenster. Im Beispiel wird der Aufbewahrungszeitraum für die Aufgabenausführung auf 10 Tage festgelegt.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'AUTO_STATS_ADVISOR_TASK',
p_parameter => 'EXECUTION_DAYS_TO_EXPIRE',
p_value => '10');
END;
```
### Deaktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
Um `AUTO_STATS_ADVISOR_TASK` zu deaktivieren, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.advisor_task_drop`. Das `advisor_task_drop`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ja | Der Name der Berateraufgabe, die deaktiviert werden soll. Der einzige gültige Wert ist `AUTO_STATS_ADVISOR_TASK`. |
Der folgenden Befehl wird verworfen: `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Sie können `AUTO_STATS_ADVISOR_TASK` unter Verwendung von `rdsadmin.rdsadmin_util.dbms_stats_init` erneut aktivieren.
### Erneutes Aktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
Um `AUTO_STATS_ADVISOR_TASK` wieder zu aktivieren, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.dbms_stats_init`. Die `dbms_stats_init`-Prozedur verwendet keine Parameter.
Der folgende Befehl reaktiviert `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Transport von Tabellenbereichen
Verwenden Sie das Amazon-RDS-Paket `rdsadmin.rdsadmin_transport_util`, um eine Reihe von Tabellenbereichen aus einer On-Premises-Oracle-Datenbank auf eine DB-Instance von RDS für Oracle zu kopieren. Auf physischer Ebene kopiert die Funktion für transportable Tabellenbereiche inkrementell Quelldatendateien und Metadatendateien auf Ihre Ziel-Instance. Sie können die Dateien entweder mit Amazon EFS oder mit Amazon S3 übertragen. Weitere Informationen finden Sie unter [Migrieren mithilfe von Oracle Transportable Tablespaces](oracle-migrating-tts.md).
**Topics**
+ [Importieren transportabler Tabellenbereiche in Ihre DB-Instance](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [Importieren von Metadaten transportabler Tabellenbereiche in Ihre DB-Instance](rdsadmin_transport_util_import_xtts_metadata.md)
+ [Auflisten verwaister Dateien nach einem Tabellenbereichimport](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [Löschen verwaister Dateien nach einem Tabellenbereichimport](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importieren transportabler Tabellenbereiche in Ihre DB-Instance
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, um Tabellenbereiche wiederherzustellen, die Sie zuvor aus einer Quell-DB-Instance exportiert haben. In der Transportphase sichern Sie Ihre schreibgeschützten Tabellenbereiche und exportieren Data-Pump-Metadaten, übertragen diese Dateien auf Ihre Ziel-DB-Instance und importieren dann die Tabellenbereiche. Weitere Informationen finden Sie unter [Phase 4: Transportieren der Tabellenbereiche](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Syntax
```
FUNCTION import_xtts_tablespaces(
p_tablespace_list IN CLOB,
p_directory_name IN VARCHAR2,
p_platform_id IN NUMBER DEFAULT 13,
p_parallel IN INTEGER DEFAULT 0) RETURN VARCHAR2;
```
## Parameters
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Ja | Die Liste der zu importierenden Tabellenbereiche. |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die Backups der Tabellenbereiche enthält. |
| `p_platform_id` | `NUMBER` | `13` | Nein | Geben Sie eine Plattform-ID an, die mit der in der Backup-Phase angegebenen ID übereinstimmt. Fragen Sie `V$TRANSPORTABLE_PLATFORM` ab, um eine Liste der Plattformen zu finden. Die Standardplattform ist Linux x86 64-Bit, was das Little-Endian-Format ist. |
| `p_parallel` | `INTEGER` | `0` | Nein | Der Grad der Parallelität. In der Standardeinstellung ist Parallelität deaktiviert. |
## Beispiele
Im folgenden Beispiel werden die Tablespaces *TBS1**TBS2*, und *TBS3* aus dem Verzeichnis importiert. *DATA\$1PUMP\$1DIR* Die Quellplattform ist ein AIX-basiertes System (64-Bit) mit der Plattform-ID `6`. Sie können die Plattform finden, IDs indem Sie sie abfragen. `V$TRANSPORTABLE_PLATFORM`
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
# Importieren von Metadaten transportabler Tabellenbereiche in Ihre DB-Instance
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`, um Metadaten transportabler Tabellenbereiche in Ihre DB-Instance von RDS für Oracle zu importieren. Während des Vorgangs wird der Status des Metadatenimports in der Tabelle `rdsadmin.rds_xtts_operation_info` angezeigt. Weitere Informationen finden Sie unter [Schritt 5: Importieren der Tabellenbereich-Metadaten in Ihre Ziel-DB-Instance](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Syntax
```
PROCEDURE import_xtts_metadata(
p_datapump_metadata_file IN SYS.DBA_DATA_FILES.FILE_NAME%TYPE,
p_directory_name IN VARCHAR2,
p_exclude_stats IN BOOLEAN DEFAULT FALSE,
p_remap_tablespace_list IN CLOB DEFAULT NULL,
p_remap_user_list IN CLOB DEFAULT NULL);
```
## Parameters
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Ja | Der Name der Oracle-Data-Pump-Datei, die die Metadaten für Ihre transportablen Tabellenbereiche enthält. |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die Data-Pump-Datei enthält. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | Nein | Flag, das angibt, ob Statistiken ausgeschlossen werden sollen. |
| `p_remap_tablespace_list` | `CLOB` | NULL | Nein | Eine Liste von Tabellenbereichen, die beim Metadatenimport neu zugeordnet werden sollen. Verwenden Sie dabei das Format `from_tbs:to_tbs`. Geben Sie beispielsweise `users:user_data` an. |
| `p_remap_user_list` | `CLOB` | NULL | Nein | Eine Liste von Benutzerschemata, die beim Metadatenimport neu zugeordnet werden sollen. Verwenden Sie dabei das Format `from_schema_name:to_schema_name`. Geben Sie beispielsweise `hr:human_resources` an. |
## Beispiele
Das Beispiel importiert die Tablespace-Metadaten aus der Datei*xttdump.dmp*, die sich im Verzeichnis *DATA\$1PUMP\$1DIR* befindet.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Auflisten verwaister Dateien nach einem Tabellenbereichimport
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`, um Datendateien aufzulisten, die nach einem Tabellenbereichimport verwaist waren. Nachdem Sie die Datendateien identifiziert haben, können Sie sie löschen, indem Sie `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` aufrufen.
## Syntax
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Beispiele
Das folgende Beispiel führt die Prozedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` aus. Die Ausgabe zeigt zwei verwaiste Datendateien.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Löschen verwaister Dateien nach einem Tabellenbereichimport
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`, um Datendateien zu löschen, die nach einem Tabellenbereichimport verwaist waren. Wenn Sie diesen Befehl ausführen, wird eine Protokolldatei generiert, die das Namensformat `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` im Verzeichnis `BDUMP` verwendet. Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`, um die verwaisten Dateien zu finden. Sie können die Protokolldatei lesen, indem Sie das Verfahren `rdsadmin.rds_file_util.read_text_file` aufrufen. Weitere Informationen finden Sie unter [Phase 6: Bereinigen übrig gebliebener Dateien](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Syntax
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameters
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die verwaisten Datendateien enthält. |
## Beispiele
Im folgenden Beispiel werden die verwaisten Datendateien in gelöscht. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
Das folgende Beispiel liest die durch den vorherigen Befehl generierte Protokolldatei.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```