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 allgemeiner Protokoll-bezogener Aufgaben für Oracle DB-Instances Im Folgenden erfahren Sie, wie Sie bestimmte allgemeine DBA-Aufgaben durchführen können, die mit der Protokollierung 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. Weitere Informationen finden Sie unter [Datenbankprotokolldateien von Amazon RDS für Oracle](USER_LogAccess.Concepts.Oracle.md). **Topics** + [Einstellen der erzwungenen Protokollierung](#Appendix.Oracle.CommonDBATasks.SettingForceLogging) + [Einstellen der ergänzenden Protokollierung](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging) + [Wechseln zwischen Online-Protokolldateien](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles) + [Hinzufügen von Online-Redo-Log-Dateien](#Appendix.Oracle.CommonDBATasks.RedoLogs) + [Löschen von Online-Redo-Log-Dateien](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs) + [Anpassen der Größe von Online-Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md) + [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md) + [Zugriff auf Online- oder archivierte Redo-Protokolle](Appendix.Oracle.CommonDBATasks.Log.Download.md) + [Herunterladen von archivierten Redo-Protokolle aus Amazon S3](Appendix.Oracle.CommonDBATasks.download-redo-logs.md) ## Einstellen der erzwungenen Protokollierung Im Modus für erzwungene Protokollierung protokolliert Oracle alle Änderungen in einer Datenbank, außer Änderung in temporären Tabellenräumen und temporären Segmenten (`NOLOGGING` Klauseln werden ignoriert). Weitere Informationen finden Sie unter [Specifying FORCE LOGGING Mode](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) in der Oracle-Dokumentation. Um die erzwungene Protokollierung festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.force_logging`. Die Prozedur `force_logging` hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Ja | Beschreibung | | --- | --- | --- | --- | --- | | `p_enable` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um die Datenbank in den Modus für erzwungene Protokollierung zu setzen, oder auf `false`, um Datenbanken aus diesem Modus zu entfernen. | Im folgenden Beispiel wird eine Datenbank in den Modus für erzwungene Protokollierung gesetzt. ``` EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true); ``` ## Einstellen der ergänzenden Protokollierung Wenn Sie die zusätzliche Protokollierung aktivieren, LogMiner verfügt es über die erforderlichen Informationen, um verkettete Zeilen und geclusterte Tabellen zu unterstützen. Weitere Informationen finden Sie unter [Supplemental Logging](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) in der Oracle-Dokumentation. In Oracle Database ist die ergänzende Protokollierung standardmäßig deaktiviert. Um die erzwungene Protokollierung festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Weitere Informationen über die Verwaltung der Aufbewahrung von archivierten Redo-Log-Dateien für Oracle-DB-Instances in Amazon RDS finden Sie unter [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md). Die Prozedur `alter_supplemental_logging` hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `p_action` | varchar2 | — | Ja | `'ADD'`, um ergänzende Protokollierung hinzuzufügen, `'DROP'` um ergänzende Protokollierung zu verwerfen. | | `p_type` | varchar2 | Null | Nein | Der Typ der ergänzenden Protokollierung. Gültige Werte sind `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` oder `PROCEDURAL`. | Im folgenden Beispiel wird die ergänzende Protokollierung aktiviert. ``` begin rdsadmin.rdsadmin_util.alter_supplemental_logging( p_action => 'ADD'); end; / ``` Im folgenden Beispiel wird die ergänzende Protokollierung für alle Spalten mit fester Länge für Maximalgröße aktiviert. ``` begin rdsadmin.rdsadmin_util.alter_supplemental_logging( p_action => 'ADD', p_type => 'ALL'); end; / ``` Im folgenden Beispiel wird die ergänzende Protokollierung für primäre Schlüsselspalten aktiviert. ``` begin rdsadmin.rdsadmin_util.alter_supplemental_logging( p_action => 'ADD', p_type => 'PRIMARY KEY'); end; / ``` ## Wechseln zwischen Online-Protokolldateien Um die Protokolldateien zu wechseln, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.switch_logfile`. Die Prozedur `switch_logfile` hat keine Parameter. Im folgenden Beispiel wird zwischen Protokolldateien gewechselt. ``` EXEC rdsadmin.rdsadmin_util.switch_logfile; ``` ## Hinzufügen von Online-Redo-Log-Dateien Eine Amazon-RDS-DB-Instance, die Oracle ausführt, beginnt mit vier Online-Redo-Log-Dateien, jede 128 MB groß. Um weitere Wiederherstellungsprotokolle hinzuzufügen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.add_logfile`. Die Prozedur `add_logfile` hat die folgenden Parameter. **Anmerkung** Die Parameter schließen sich gegenseitig aus. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `bytes` | positiv | Null | Nein | Die Größe der Protokolldatei in Bytes Verwenden Sie diesen Parameter nur, wenn die Größe des Protokolls unter 2147483648 Byte (2 GiB) liegt. Andernfalls gibt RDS einen Fehler aus. Verwenden Sie für Protokollgrößen, die über diesem Bytewert liegen, stattdessen den Parameter `p_size`. | | `p_size` | varchar2 | — | Ja | Die Größe der Protokolldatei in Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB). | Mit dem folgenden Befehl wird eine Protokolldatei der Größe 100 MB hinzugefügt. ``` EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M'); ``` ## Löschen von Online-Redo-Log-Dateien Um Wiederherstellungsprotokolle zu löschen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.drop_logfile`. Die Prozedur `drop_logfile` hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `grp` | positiv | — | Ja | Die Gruppennummer des Protokolls | Im folgenden Beispiel wird das Protokoll mit der Gruppennummer 3 verworfen. ``` EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3); ``` Sie können nur Protokolle verwerfen, die den Status "unbenutzt" oder "inaktiv" haben. Im folgenden Beispiel werden die Stati der Protokolle abgerufen. ``` SELECT GROUP#, STATUS FROM V$LOG; GROUP# STATUS ---------- ---------------- 1 CURRENT 2 INACTIVE 3 INACTIVE 4 UNUSED ``` # Anpassen der Größe von Online-Redo-Log-Dateien Eine Amazon RDS-DB-Instance, die Oracle ausführt, beginnt mit vier Online-Redo-Log-Dateien, jede 128 MB groß. Im folgenden Beispiel wird gezeigt, wie Sie Amazon RDS-Prozeduren verwenden können, um die Größe für jedes Ihrer Protokolle von 128 MB auf 512 MB anzupassen. ``` /* Query V$LOG to see the logs. */ /* You start with 4 logs of 128 MB each. */ SELECT GROUP#, BYTES, STATUS FROM V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 1 134217728 INACTIVE 2 134217728 CURRENT 3 134217728 INACTIVE 4 134217728 INACTIVE /* Add four new logs that are each 512 MB */ EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912); EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912); EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912); EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912); /* Query V$LOG to see the logs. */ /* Now there are 8 logs. */ SELECT GROUP#, BYTES, STATUS FROM V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 1 134217728 INACTIVE 2 134217728 CURRENT 3 134217728 INACTIVE 4 134217728 INACTIVE 5 536870912 UNUSED 6 536870912 UNUSED 7 536870912 UNUSED 8 536870912 UNUSED /* Drop each inactive log using the group number. */ EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 1); EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3); EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 4); /* Query V$LOG to see the logs. */ /* Now there are 5 logs. */ select GROUP#, BYTES, STATUS from V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 2 134217728 CURRENT 5 536870912 UNUSED 6 536870912 UNUSED 7 536870912 UNUSED 8 536870912 UNUSED /* Switch logs so that group 2 is no longer current. */ EXEC rdsadmin.rdsadmin_util.switch_logfile; /* Query V$LOG to see the logs. */ /* Now one of the new logs is current. */ SQL>SELECT GROUP#, BYTES, STATUS FROM V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 2 134217728 ACTIVE 5 536870912 CURRENT 6 536870912 UNUSED 7 536870912 UNUSED 8 536870912 UNUSED /* If the status of log 2 is still "ACTIVE", issue a checkpoint to clear it to "INACTIVE". */ EXEC rdsadmin.rdsadmin_util.checkpoint; /* Query V$LOG to see the logs. */ /* Now the final original log is inactive. */ select GROUP#, BYTES, STATUS from V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 2 134217728 INACTIVE 5 536870912 CURRENT 6 536870912 UNUSED 7 536870912 UNUSED 8 536870912 UNUSED # Drop the final inactive log. EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 2); /* Query V$LOG to see the logs. */ /* Now there are four 512 MB logs. */ SELECT GROUP#, BYTES, STATUS FROM V$LOG; GROUP# BYTES STATUS ---------- ---------- ---------------- 5 536870912 CURRENT 6 536870912 UNUSED 7 536870912 UNUSED 8 536870912 UNUSED ``` # Beibehaltung von archivierten Redo-Log-Dateien Sie können archivierte Redo-Logs lokal auf Ihrer DB-Instance speichern, um sie mit Produkten wie Oracle LogMiner (`DBMS_LOGMNR`) zu verwenden. Nachdem Sie die Redo-Logs aufbewahrt haben, können Sie sie LogMiner zur Analyse der Logs verwenden. Weitere Informationen finden Sie in der [ LogMiner Oracle-Dokumentation unter Verwendung zur Analyse von Redo-Log-Dateien](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm). Um archivierte Wiederherstellungsprotokolle zu erhalten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.set_configuration`. Wenn Sie dieses Verfahren auf einer primären Instance in Oracle Data Guard anwenden, ändert RDS die Aufbewahrungseinstellung für Archivprotokolle auf der primären Instance und öffnet Lesereplikate, aber nicht auf aufgespielten Replikaten. RDS speichert die neuesten Archiv-Redo-Protokolle auf aufgespielten Replikaten für einen kurzen Zeitraum. RDS löscht automatisch ältere Protokolle, die auf gemountete Replikate heruntergeladen wurden. Die Prozedur `set_configuration` hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `name` | varchar | — | Ja | Der Name für die zu aktualisierende Konfiguration Um die Aufbewahrungszeiten für archivierte Redo-Protokolle zu ändern, legen Sie den Namen auf `archivelog retention hours` fest. | | `value` | varchar | — | Ja | Der Wert für die Konfiguration Geben Sie als Wert die Anzahl der Stunden an, für die die Protokolle aufbewahrt werden sollen. | Im folgenden Beispiel werden 24 Stunden an Redo-Logs aufbewahrt. ``` begin rdsadmin.rdsadmin_util.set_configuration( name => 'archivelog retention hours', value => '24'); end; / commit; ``` **Anmerkung** Das Commit muss durchgeführt werden, damit die Änderungen wirksam werden. Um zu sehen, wie lange archivierte Wiederherstellungsprotokolle für Ihre DB-Instance aufbewahrt werden, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.show_configuration`. Im folgenden Beispiel wird die Protokoll-Aufbewahrungszeit angezeigt. ``` set serveroutput on EXEC rdsadmin.rdsadmin_util.show_configuration; ``` Der Ausgang zeigt die aktuelle Einstellung für `archivelog retention hours`. Die folgende Ausgabe zeigt, dass archivierte Wiederherstellungsprotokolle 48 Stunden lang aufbewahrt werden. ``` NAME:archivelog retention hours VALUE:48 DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted. ``` Da die archivierten Redo-Log-Dateien in Ihrer DB-Instance aufbewahrt werden, stellen Sie sicher, dass Ihre DB-Instance genügend zugewiesenen Speicherplatz für die aufbewahrten Protokolle bietet. Um festzustellen, wie viel Speicherplatz Ihre DB-Instance in den letzten X Stunden belegt hat, können Sie die folgende Abfrage ausführen. Dabei ersetzen Sie X durch die Anzahl von Stunden. ``` SELECT SUM(BLOCKS * BLOCK_SIZE) bytes FROM V$ARCHIVED_LOG WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1; ``` RDS für Oracle generiert nur dann archivierte Redo-Protokolle, wenn die Backup-Aufbewahrungsdauer Ihrer DB-Instance größer als null ist. Standardmäßig ist der Aufbewahrungszeitraum für Backups größer als null. Wenn der Aufbewahrungszeitraum für archivierte Protokolle abläuft, entfernt RDS für Oracle die archivierten Redo-Protokolle aus Ihrer DB-Instance. Um die Backup Ihrer DB-Instance zu einem bestimmten Zeitpunkt zu unterstützen, bewahrt Amazon RDS die archivierten Redo-Protokolle außerhalb Ihrer DB-Instance basierend auf dem Aufbewahrungszeitraum für Backups auf. Informationen zum Ändern des Aufbewahrungszeitraums für Backups finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md). **Anmerkung** In einigen Fällen kann es vorkommen, das beim Verwenden von JDBC unter Linux zum Herunterladen von Redo-Logs lange Latenzzeiten auftreten und Verbindungen zurückgesetzt werden. Das Problem wird in solchen Fällen vielleicht durch die Standardeinstellung des Zufallszahlengenerators in Ihrem Java-Client verursacht. Wir empfehlen, dass Sie für die JDBC-Treiber die Verwendung eines blockierungsfreien Zufallszahlengenerators festlegen. # Zugriff auf Online- oder archivierte Redo-Protokolle Möglicherweise möchten Sie mit externen Tools wie Attunity, Informatica und anderen auf Ihre Online- und archivierten Redo-Log-Dateien für das Mining zugreifen. GoldenGate Gehen Sie folgendermaßen vor, um auf diese Dateien zuzugreifen: 1. Erstellen Sie Verzeichnisobjekte, die schreibgeschützten Zugriff auf die physischen Dateipfade bieten. Verwendung von `rdsadmin.rdsadmin_master_util.create_archivelog_dir` und `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`. 1. Lesen Sie die Dateien mit PL/SQL. Sie können die Dateien mit PL/SQL lesen. Weitere Informationen über das Lesen von Dateien in Verzeichnisobjekten finden Sie unter [Auflisten von Dateien in einem DB-Instance-Verzeichnis](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) und [Lesen von Dateien in einem DB-Instance-Verzeichnis](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles). Der Zugriff auf Transaktionsprotokolle wird für die folgenden Versionen unterstützt: + Oracle Database 21c + Oracle Database 19c Der folgende Code erstellt Verzeichnisse, die schreibgeschützten Zugriff auf Ihre Online- und archivierte Redo-Log-Dateien bieten: **Wichtig** Dieser Code widerruft das Sonderrecht `DROP ANY DIRECTORY`. ``` EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir; EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir; ``` Der folgende Code verwirft die Verzeichnisse für Ihre Online- und archivierten Redo-Log-Dateien. ``` EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir; EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir; ``` Der folgende Code erteilt oder widerruft die Berechtigung `DROP ANY DIRECTORY`. ``` EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory; EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory; ``` # Herunterladen von archivierten Redo-Protokolle aus Amazon S3 Sie können archivierte Redo-Protokolle auf Ihrer DB-Instance mit dem `rdsadmin.rdsadmin_archive_log_download`-Paket. Wenn sich archivierte Redo-Protkolle nicht mehr auf Ihrer DB-Instance befinden, sollten Sie sie möglicherweise erneut von Amazon S3 herunterladen. Dann können Sie die Protokolle durchsuchen oder sie verwenden, um Ihre Datenbank wiederherzustellen oder zu replizieren. **Anmerkung** Sie können keine archivierten Redo-Logs auf Read Replica-Instanzen herunterladen. ## Archivierte Redo-Protokolle herunterladen: Grundlegende Schritte Die Verfügbarkeit Ihrer archivierten Redo-Protokolle hängt von den folgenden Aufbewahrungsrichtlinien ab: + Backup-Aufbewahrungsrichtlinie – Protokolle innerhalb dieser Richtlinie sind in Amazon S3 verfügbar. Protokolle außerhalb dieser Richtlinie werden entfernt. + Aufbewahrungsrichtlinie für archivierte Protokolle – Protokolle innerhalb dieser Richtlinie sind auf Ihrer DB-Instance verfügbar. Protokolle außerhalb dieser Richtlinie werden entfernt. Wenn sich Protokolle nicht auf Ihrer Instance befinden, aber durch Ihre Backup-Aufbewahrungsdauer geschützt sind, verwenden Sie `rdsadmin.rdsadmin_archive_log_download`, um sie erneut herunterzuladen. RDS for Oracle speichert die Protokolle im `/rdsdbdata/log/arch`-Verzeichnis auf Ihrer DB-Instance. **Herunterladen von archivierten Redo-Protokolle aus Amazon S3** 1. Konfigurieren Sie Ihren Aufbewahrungszeitraum, um sicherzustellen, dass Ihre heruntergeladenen archivierten Redo-Protokolle so lange aufbewahrt werden, wie Sie sie benötigen. Stellen Sie sicher, dass Sie die Änderungen `COMMIT` RDS speichert Ihre heruntergeladenen Protokolle gemäß der Aufbewahrungsrichtlinie für archivierte Protokolle, und zwar ab dem Zeitpunkt, zu dem die Protokolle heruntergeladen wurden. Informationen zum Festlegen der Aufbewahrungsrichtlinie finden Sie unter [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md). 1. Warten Sie bis zu 5 Minuten, bis die Änderung der Aufbewahrungsrichtlinie für archivierte Protokolle wirksam wird. 1. Laden Sie die archivierten Redo-Protokolle von Amazon S3 mit`rdsadmin.rdsadmin_archive_log_download` herunter. Weitere Informationen erhalten Sie unter [Herunterladen eines einzelnen archivierten Redo-Protokoll](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) und [Herunterladen einer Reihe archivierter Redo-Protokolle](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series). **Anmerkung** RDS überprüft automatisch den verfügbaren Speicher vor dem Herunterladen. Wenn die angeforderten Protokolle einen hohen Anteil an Speicherplatz verbrauchen, erhalten Sie eine Warnung. 1. Bestätigen Sie, dass die Protokolle erfolgreich von Amazon S3 heruntergeladen wurden. Sie können den Status Ihrer Download-Aufgabe in einer bdump-Datei anzeigen. Die bdump-Dateien haben den Pfadnamen `/rdsdbdata/log/trace/dbtask-task-id.log`. Im vorherigen Download-Schritt führen Sie eine `SELECT`-Anweisung aus, die die Aufgaben-ID im Datentyp `VARCHAR2` zurückgibt. Weitere Informationen finden Sie in ähnlichen Beispielen in [Überwachen des Status einer Dateiübertragung](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status). ## Herunterladen eines einzelnen archivierten Redo-Protokoll Um ein einzelnes archiviertes Redo-Protkoll in das `/rdsdbdata/log/arch`-Verzeichnis herunterzuladen, verwenden Sie `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Dieses Verfahren hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `seqnum` | Zahl | — | Ja | Die Sequenznummer des archivierten Redo-Protokolls. | Im folgenden Beispiel wird das Protokoll mit der Sequenznummer 20 heruntergeladen. ``` SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20) AS TASK_ID FROM DUAL; ``` ## Herunterladen einer Reihe archivierter Redo-Protokolle Um eine Reihe archivierter Redo-Protokolle in das `/rdsdbdata/log/arch`-Verzeichnis herunterzuladen, verwenden Sie `download_logs_in_seqnum_range`. Ihr Download ist auf 300 Protokolle pro Anfrage beschränkt. Die Prozedur `download_logs_in_seqnum_range` hat die folgenden Parameter. **** | Parametername | Datentyp | Standard | Erforderlich | Beschreibung | | --- | --- | --- | --- | --- | | `start_seq` | Zahl | — | Ja | Die Anfangssequenznummer für die Reihe. | | `end_seq` | Zahl | — | Ja | Die Endsequenznummer für die Reihe. | Im folgenden Beispiel werden die Protokolle von Sequenz 50 auf 100 heruntergeladen. ``` SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100) AS TASK_ID FROM DUAL; ```