Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengelola instans DB RDS for Oracle
Berikut ini adalah tugas pengelolaan umum yang Anda lakukan dengan instans DB RDS for Oracle. Beberapa tugas bersifat sama untuk semua instans DB RDS. Beberapa tugas lain bersifat khusus untuk RDS for Oracle.
Tugas-tugas berikut bersifat umum untuk semua basis data RDS, tetapi Oracle Database memiliki pertimbangan khusus. Misalnya, Anda terhubung ke basis data Oracle menggunakan klien Oracle SQL\$1 Plus dan SQL Developer.
****
| Area tugas | Dokumentasi terkait |
| --- | --- |
| **Kelas instans, penyimpanan, dan PIOPS** Jika Anda membuat instans produksi, pelajari cara kerja kelas instans, jenis penyimpanan, dan pekerjaan IOPS yang Tersedia di Amazon RDS. | [RDS untuk kelas instans Oracle DB](Oracle.Concepts.InstanceClasses.md) [Jenis penyimpanan Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Deployment Multi-AZ** Instans basis data produksi seyogianya menggunakan deployment Multi-AZ. Deployment Multi-AZ memberikan ketersediaan, durabilitas data, dan toleransi kesalahan yang lebih tinggi untuk instans basis data. | [Mengonfigurasi dan mengelola penyebaran Multi-AZ untuk Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Jika AWS akun Anda memiliki virtual private cloud (VPC) default, maka instans DB Anda secara otomatis dibuat di dalam VPC default. Jika akun Anda tidak memiliki VPC default dan Anda ingin instans DB dalam VPC, buat VPC dan grup subnet sebelum Anda membuat instans. | [Menggunakan instans DB di VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Grup keamanan** Secara default, instans basis data menggunakan firewall yang mencegah akses. Pastikan bahwa Anda membuat grup keamanan dengan alamat IP dan konfigurasi jaringan yang benar untuk mengakses instans basis data. | [Mengontrol akses dengan grup keamanan](Overview.RDSSecurityGroups.md) |
| **Grup parameter** Jika instans DB Anda akan membutuhkan parameter basis data tertentu, buat grup parameter sebelum Anda membuat instans DB. | [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md) |
| **Grup opsi** Jika instans DB Anda membutuhkan opsi basis data tertentu, buat grup opsi sebelum Anda membuat instans DB. | [Menambahkan opsi untuk instans DB Oracle](Appendix.Oracle.Options.md) |
| **Menghubungkan ke instans DB** Setelah membuat grup keamanan dan mengaitkannya ke instans DB, Anda dapat menghubungkan ke instans DB menggunakan aplikasi klien SQL standar seperti Oracle SQL\$1Plus. | [Terhubung ke instans DB Oracle Anda](USER_ConnectToOracleInstance.md) |
| **Pencadangan dan pemulihan** Anda dapat mengonfigurasi instans DB Anda untuk membuat cadangan otomatis, atau membuat snapshot manual, kemudian memulihkan instans dari cadangan atau snapshot. | [Mencadangkan, memulihkan, dan mengekspor data](CHAP_CommonTasks.BackupRestore.md) |
| **Pemantauan** Anda dapat memantau instans Oracle DB dengan menggunakan metrik CloudWatch Amazon RDS, peristiwa, dan pemantauan yang disempurnakan. | [Melihat metrik di konsol Amazon RDS](USER_Monitoring.md) [Melihat RDS acara Amazon](USER_ListEvents.md) |
| **File log** Anda dapat mengakses file log untuk instans DB Oracle Anda. | [Memantau file RDS Amazon](USER_LogAccess.md) |
Setelah itu, Anda dapat menemukan deskripsi untuk implementasi beberapa tugas DBA umum khusus Amazon RDS untuk RDS Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB. Selain itu, RDS membatasi akses ke prosedur dan tabel sistem tertentu yang membutuhkan hak istimewa tingkat lanjut. Dalam banyak tugas, Anda menjalankan paket `rdsadmin`, yang merupakan alat khusus Amazon RDS yang memungkinkan Anda untuk mengelola basis data.
Berikut adalah tugas DBA umum untuk instans DB yang menjalankan Oracle:
+ [Tugas sistem](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tugas basis data](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tugas log](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tugas RMAN](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tugas Scheduler Oracle](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Mendiagnosis masalah](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tugas lainnya](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Anda juga dapat menggunakan prosedur Amazon RDS untuk integrasi Amazon S3 dengan Oracle dan untuk menjalankan tugas basis data OEM Management Agent. Untuk informasi selengkapnya, lihat [Integrasi Amazon S3](oracle-s3-integration.md) dan [Melakukan tugas basis data dengan Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Melakukan tugas sistem umum untuk instans DB Oracle
Setelah itu, Anda dapat menemukan cara melakukan tugas DBA umum tertentu yang terkait dengan sistem di instans DB Amazon RDS yang menjalankan Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB, dan membatasi akses ke sejumlah prosedur dan tabel sistem tertentu yang memerlukan hak istimewa tingkat lanjut.
**Topics**
+ [
# Memutus koneksi sesi
](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [
# Mengakhiri sesi
](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [
# Membatalkan pernyataan SQL dalam sesi
](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [
# Mengaktifkan dan menonaktifkan sesi terbatas
](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [
# Menghapus kolam bersama
](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [
# Memberikan hak istimewa SELECT atau EXECUTE pada objek SYS
](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [
# Mencabut hak istimewa SELECT atau EXECUTE pada objek SYS
](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [
# Mengelola tampilan RDS\$1X\$1 untuk instans DB Oracle
](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [
# Memberikan hak istimewa kepada pengguna non-master
](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [
# Membuat fungsi kustom untuk memverifikasi kata sandi
](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [
## Menyiapkan server DNS kustom
](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [
# Mengatur dan membatalkan pengaturan peristiwa diagnostik sistem
](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Memutus koneksi sesi
Untuk memutus koneksi sesi saat ini dengan mengakhiri proses server khusus, gunakan prosedur `rdsadmin.rdsadmin_util.disconnect` Amazon RDS. Prosedur `disconnect` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `sid` | number | — | Ya | Pengidentifikasi sesi. |
| `serial` | number | — | Ya | Nomor seri sesi. |
| `method` | varchar | 'IMMEDIATE' | Tidak | Nilai yang valid adalah `'IMMEDIATE'` atau `'POST_TRANSACTION'`. |
Berikut ini adalah contoh cara memutus koneksi sesi.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Untuk mendapatkan pengidentifikasi sesi dan nomor sesi, buka tampilan `V$SESSION` . Contoh berikut mendapatkan semua sesi untuk pengguna `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Basis data harus terbuka untuk menggunakan metode ini. Untuk informasi selengkapnya tentang cara memutuskan koneksi sesi, lihat [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) di dokumentasi Oracle.
# Mengakhiri sesi
Untuk mengakhiri sesi, gunakan prosedur `rdsadmin.rdsadmin_util.kill` Amazon RDS. Prosedur `kill` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `sid` | number | — | Ya | Pengidentifikasi sesi. |
| `serial` | number | — | Ya | Nomor seri sesi. |
| `method` | varchar | null | Tidak | Nilai yang valid adalah `'IMMEDIATE'` atau `'PROCESS'`. Jika Anda menentukan `IMMEDIATE`, efeknya akan sama seperti menjalankan pernyataan berikut: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Jika Anda menentukan `PROCESS`, Anda akan mengakhiri proses yang terkait dengan sesi. Hanya tentukan `PROCESS` jika mengakhiri sesi menggunakan `IMMEDIATE` tidak berhasil. |
Untuk mendapatkan pengidentifikasi sesi dan nomor seri sesi, buat kueri tampilan `V$SESSION`. Contoh berikut mendapatkan semua sesi untuk pengguna *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Berikut ini adalah contoh cara mengakhiri sesi.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
Contoh berikut akan mengakhiri proses yang terkait dengan sesi.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Membatalkan pernyataan SQL dalam sesi
Untuk membatalkan pernyataan SQL dalam sesi, gunakan prosedur `rdsadmin.rdsadmin_util.cancel` Amazon RDS.
**catatan**
Prosedur ini mendukung Oracle Database 19c (19.0.0) dan semua versi utama dan minor yang lebih tinggi dari RDS for Oracle.
Prosedur `cancel` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `sid` | number | — | Ya | Pengidentifikasi sesi. |
| `serial` | number | — | Ya | Nomor seri sesi. |
| `sql_id` | varchar2 | null | Tidak | Pengidentifikasi SQL dari pernyataan SQL. |
Contoh berikut membatalkan pernyataan SQL dalam sesi.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Untuk mendapatkan pengidentifikasi sesi, nomor seri sesi, dan pengidentifikasi SQL dari pernyataan SQL, buat kueri tampilan `V$SESSION`. Contoh berikut mendapatkan semua sesi untuk pengidentifikasi SQL untuk pengguna `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Mengaktifkan dan menonaktifkan sesi terbatas
Untuk mengaktifkan dan menonaktifkan sesi terbatas, gunakan prosedur `rdsadmin.rdsadmin_util.restricted_session` Amazon RDS. Prosedur `restricted_session` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Ya | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_enable` | boolean | true | Tidak | Tetapkan ke `true` untuk memungkinkan sesi terbatas, `false` untuk menonaktifkan sesi terbatas. |
Contoh berikut menunjukkan cara mengaktifkan dan menonaktifkan sesi terbatas.
```
/* 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
```
# Menghapus kolam bersama
Untuk menghapus kolam bersama, terapkan prosedur `rdsadmin.rdsadmin_util.flush_shared_pool` Amazon RDS. Prosedur `flush_shared_pool` tidak memiliki parameter.
Contoh berikut menghapus kolam bersama.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Menghapus cache buffer
Untuk menghapus cache buffer, terapkan prosedur `rdsadmin.rdsadmin_util.flush_buffer_cache` Amazon RDS. Prosedur `flush_buffer_cache` tidak memiliki parameter.
Contoh berikut akan menghapus cache buffer.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Menghapus cache flash smart flash basis data
Untuk menghapus cache smart flash basis data, terapkan prosedur `rdsadmin.rdsadmin_util.flush_flash_cache` Amazon RDS. Prosedur `flush_flash_cache` tidak memiliki parameter. Contoh berikut akan menghapus cache smart flash basis data.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Untuk informasi selengkapnya tentang penggunaan cache smart flash basis data dengan RDS for Oracle, lihat [Menyimpan data sementara di penyimpanan instans RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Memberikan hak istimewa SELECT atau EXECUTE pada objek SYS
Biasanya Anda mentransfer hak istimewa dengan menggunakan peran, yang dapat berisi banyak objek. Untuk memberikan hak istimewa kepada satu objek, gunakan prosedur `rdsadmin.rdsadmin_util.grant_sys_object` Amazon RDS. Prosedur ini memberikan hanya hak istimewa yang telah diberikan kepada pengguna master melalui peran atau pemberian langsung.
Prosedur `grant_sys_object` memiliki parameter berikut.
**penting**
Untuk semua nilai parameter, gunakan huruf besar kecuali jika Anda membuat pengguna dengan pengidentifikasi yang peka huruf besar. Misalnya, jika Anda menjalankan `CREATE USER myuser` atau `CREATE USER MYUSER`, kamus data menyimpan `MYUSER`. Namun, jika Anda menggunakan tanda kutip ganda di `CREATE USER "MyUser"`, kamus data menyimpan `MyUser`.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ya | Nama objek untuk menerima pemberian hak istimewa. Objek dapat berupa direktori, fungsi, paket, prosedur, urutan, tabel, atau tampilan. Nama objek harus dieja persis seperti yang muncul di `DBA_OBJECTS`. Sebagian besar objek sistem didefinisikan dalam huruf besar, jadi kami menyarankan Anda untuk mencobanya terlebih dahulu. |
| `p_grantee` | varchar2 | — | Ya | Nama objek untuk menerima pemberian hak istimewa. Objek dapat berupa skema atau peran. |
| `p_privilege` | varchar2 | null | Ya | — |
| `p_grant_option` | boolean | false | Tidak | Tetapkan ke `true` untuk menggunakan opsi pemberian. |
Contoh berikut memberikan hak istimewa tertentu pada objek yang diberi nama `V_$SESSION` ke pengguna bernama `USER1`.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
Contoh berikut memberikan hak istimewa tertentu pada objek yang diberi nama `V_$SESSION` ke pengguna bernama `USER1` dengan opsi pemberian.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Agar dapat memberikan hak istimewa kepada suatu objek, akun Anda harus memiliki hak istimewa yang diberikan kepadanya secara langsung dengan opsi pemberian, atau melalui peran yang diberikan menggunakan `with admin option`. Dalam kasus yang paling umum, Anda mungkin ingin memberikan `SELECT` pada tampilan DBA yang telah diberikan kepada peran `SELECT_CATALOG_ROLE`. Jika peran tersebut belum diberikan secara langsung kepada pengguna Anda menggunakan `with admin option`, Anda tidak dapat mentransfer hak istimewa tersebut. Jika Anda memiliki hak istimewa DBA, Anda dapat memberikan peran tersebut secara langsung ke pengguna lain.
Contoh berikut memberikan `SELECT_CATALOG_ROLE` dan `EXECUTE_CATALOG_ROLE` kepada `USER1`. Sejak `with admin option` digunakan, `USER1` sekarang dapat memberikan akses ke objek SYS yang telah diberikan kepada `SELECT_CATALOG_ROLE`.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Objek yang telah diberikan kepada `PUBLIC` tidak perlu diberikan ulang. Jika Anda menggunakan prosedur `grant_sys_object` untuk memberikan ulang akses, pemanggilan prosedur berhasil.
# Mencabut hak istimewa SELECT atau EXECUTE pada objek SYS
Untuk mencabut hak pada satu objek, gunakan prosedur `rdsadmin.rdsadmin_util.revoke_sys_object` Amazon RDS. Prosedur ini membatalkan hanya hak istimewa yang telah diberikan kepada pengguna master melalui peran atau pemberian langsung.
Prosedur `revoke_sys_object` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ya | Nama objek yang akan dicabut hak istimewanya. Objek dapat berupa direktori, fungsi, paket, prosedur, urutan, tabel, atau tampilan. Nama objek harus dieja persis seperti yang muncul di `DBA_OBJECTS`. Sebagian besar objek sistem didefinisikan dalam huruf besar, jadi kami menyarankan Anda untuk mencobanya terlebih dahulu. |
| `p_revokee` | varchar2 | — | Ya | Nama objek yang akan dicabut hak istimewanya. Objek dapat berupa skema atau peran. |
| `p_privilege` | varchar2 | null | Ya | — |
Contoh berikut mencabut hak istimewa tertentu pada objek yang diberi nama `V_$SESSION` ke pengguna bernama `USER1`.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Mengelola tampilan RDS\$1X\$1 untuk instans DB Oracle
Anda mungkin perlu mengakses tabel tetap `SYS.X$`, yang hanya dapat diakses oleh `SYS`. Untuk membuat tampilan `SYS.RDS_X$` pada tabel `X$` yang memenuhi syarat, gunakan prosedur dalam paket `rdsadmin.rdsadmin_util`. Pengguna master Anda secara otomatis diberikan hak istimewa `SELECT … WITH GRANT OPTION` pada tampilan `RDS_X$`.
`rdsadmin.rdsadmin_util`Prosedur tersedia dalam kasus-kasus berikut:
+ Instans DB yang ada yang belum pernah ditingkatkan dan menggunakan rilis berikut:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1`dan rilis 21c yang lebih tinggi
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1`dan rilis 19c yang lebih tinggi
+ Instans DB baru apa pun yang Anda buat
+ Instans DB yang ada yang telah Anda tingkatkan
**penting**
Secara internal, paket `rdsadmin.rdsadmin_util` membuat tampilan pada tabel `X$`. Tabel `X$` adalah objek sistem internal yang tidak dijelaskan dalam dokumentasi Oracle Database. Sebaiknya uji tampilan spesifik dalam basis data non-produksi dan hanya membuat tampilan di basis data produksi Anda berdasarkan panduan Dukungan Oracle.
## Mencantumkan tabel tetap X\$1 yang memenuhi syarat untuk digunakan dalam tampilan RDS\$1X\$1
Untuk mencantumkan tabel X\$1 yang memenuhi syarat untuk digunakan dalam tampilan `RDS_X$`, gunakan prosedur `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` RDS. Prosedur ini tidak menerima parameter. Pernyataan berikut mencantumkan semua tabel `X$` yang memenuhi syarat (sampel output disertakan).
```
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'
```
Daftar tabel `X$` yang memenuhi syarat dapat berubah seiring waktu. Untuk memastikan bahwa daftar tabel tetap `X$` yang memenuhi syarat Anda selalu terbaru, jalankan kembali `list_allowed_sys_x$_views` secara berkala.
## Membuat tampilan SYS.RDS\$1X\$1
Untuk membuat tampilan `RDS_X$` pada tabel `X$` yang memenuhi syarat, gunakan prosedur `rdsadmin.rdsadmin_util.create_sys_x$_view` RDS. Anda hanya dapat membuat tampilan untuk tabel yang tercantum dalam output `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. Prosedur `create_sys_x$_view` menerima parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ya | Nama tabel `X$` yang valid. Nilai harus menjadi salah satu tabel `X$` yang dilaporkan oleh`list_allowed_sys_x$_views`. |
| `p_force_creation` | Boolean | FALSE | Tidak | Nilai yang menunjukkan apakah akan memaksa pembuatan tampilan `RDS_X$` yang sudah ada untuk tabel `X$`. Secara default, RDS tidak akan membuat tampilan jika sudah ada. Untuk memaksa pembuatan, tetapkan parameter ini ke `TRUE`. |
Contoh berikut membuat tampilan `SYS.RDS_X$KGLOB` di tabel `X$KGLOB`. Format untuk nama tampilan adalah `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
Kueri kamus data berikut mencantumkan tampilan `SYS.RDS_X$KGLOB` dan menunjukkan statusnya. Pengguna master Anda secara otomatis diberikan hak istimewa `SELECT ... WITH GRANT OPTION` pada tampilan ini.
```
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
```
**penting**
Tabel `X$` tidak dijamin untuk tetap sama sebelum dan sesudah pemutakhiran. RDS for Oracle menghapus dan membuat ulang tampilan `RDS_X$` pada tabel `X$` selama pemutakhiran mesin. Kemudian, hak istimewa `SELECT ... WITH GRANT OPTION` diberikan kepada pengguna master. Setelah pemutakhiran, berikan hak istimewa kepada pengguna basis data sesuai kebutuhan pada tampilan `RDS_X$` yang sesuai.
## Mencantumkan tampilan SYS.RDS\$1X\$1
Untuk mencantumkan tampilan `RDS_X$` yang ada, gunakan prosedur `rdsadmin.rdsadmin_util.list_created_sys_x$_views` RDS. Prosedur hanya mencantumkan tampilan yang dibuat oleh prosedur `create_sys_x$_view`. Contoh berikut mencantumkan tabel `X$` yang memiliki tampilan `RDS_X$` yang sesuai (sampel output disertakan).
```
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.
```
## Menghapus tampilan RDS\$1X\$1
Untuk menghapus tampilan `SYS.RDS_X$`, gunakan prosedur `rdsadmin.rdsadmin_util.drop_sys_x$_view` RDS. Anda hanya dapat menghapus tampilan yang tercantum dalam output `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. Prosedur `drop_sys_x$_view` menerima parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ya | Nama tabel tetap `X$` yang valid. Nilai harus menjadi salah satu tabel tetap `X$` yang dilaporkan oleh `list_created_sys_x$_views`. |
Contoh berikut menghapus tampilan `RDS_X$KGLOB`, yang dibuat di tabel `X$KGLOB`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
Contoh berikut menunjukkan bahwa tampilan `SYS.RDS_X$KGLOB` telah dihapus (sampel output disertakan).
```
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
```
# Memberikan hak istimewa kepada pengguna non-master
Anda dapat memberikan hak istimewa pilihan untuk banyak objek dalam skema `SYS` dengan menggunakan peran `SELECT_CATALOG_ROLE`. Peran `SELECT_CATALOG_ROLE` memberi pengguna hak istimewa `SELECT` pada tampilan kamus data. Contoh berikut memberikan peran `SELECT_CATALOG_ROLE` kepada pengguna dengan nama `user1`.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
Anda dapat memberikan hak istimewa `EXECUTE` untuk banyak objek dalam skema `SYS` menggunakan peran `EXECUTE_CATALOG_ROLE`. Peran `EXECUTE_CATALOG_ROLE` memberi pengguna hak istimewa `EXECUTE` untuk paket dan prosedur dalam kamus data. Contoh berikut memberikan peran `EXECUTE_CATALOG_ROLE` kepada pengguna dengan nama *user1*.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
Contoh berikut mendapatkan izin yang peran `SELECT_CATALOG_ROLE` dan `EXECUTE_CATALOG_ROLE` izinkan.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
Contoh berikut membuat pengguna non-master bernama `user1`, memberikan hak istimewa `CREATE SESSION`, dan memberikan hak istimewa `SELECT` pada basis data yang diberi nama *sh.sales*.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Membuat fungsi kustom untuk memverifikasi kata sandi
Anda dapat membuat fungsi verifikasi kata sandi kustom dengan cara berikut:
+ Untuk menggunakan logika verifikasi standar dan untuk menyimpan fungsi Anda di skema `SYS`, gunakan prosedur `create_verify_function`.
+ Untuk menggunakan logika verifikasi kustom atau untuk menghindari menyimpan fungsi Anda dalam skema `SYS`, gunakan prosedur `create_passthrough_verify_fcn`.
# Prosedur create\$1verify\$1function
Anda dapat membuat fungsi kustom untuk memverifikasi kata sandi dengan menerapkan prosedur `rdsadmin.rdsadmin_password_verify.create_verify_function` Amazon RDS. `create_verify_function`Prosedur ini didukung untuk semua versi RDS untuk Oracle.
Prosedur `create_verify_function` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ya | Nama untuk fungsi kustom Anda. Fungsi ini dibuat untuk Anda dalam skema SYS. Anda menetapkan fungsi ini ke profil pengguna. |
| `p_min_length` | number | 8 | Tidak | Jumlah karakter minimum wajib diisi. |
| `p_max_length` | number | 256 | Tidak | Jumlah maksimum karakter diperbolehkan. |
| `p_min_letters` | number | 1 | Tidak | Jumlah huruf minimum wajib diisi. |
| `p_min_uppercase` | number | 0 | Tidak | Jumlah huruf besar minimum wajib diisi. |
| `p_min_lowercase` | number | 0 | Tidak | Jumlah huruf kecil minimum wajib diisi. |
| `p_min_digits` | number | 1 | Tidak | Jumlah digit minimum wajib diisi. |
| `p_min_special` | number | 0 | Tidak | Jumlah karakter khusus minimum wajib diisi. |
| `p_min_different_chars` | number | 3 | Tidak | Jumlah minimum karakter berbeda wajib diisi antara kata sandi lama dan baru. |
| `p_disallow_username` | boolean | true | Tidak | Tetapkan ke `true` untuk tidak mengizinkan nama pengguna dalam kata sandi. |
| `p_disallow_reverse` | boolean | true | Tidak | Tetapkan ke `true` untuk tidak mengizinkan pembalikan nama pengguna dalam kata sandi. |
| `p_disallow_db_name` | boolean | true | Tidak | Tetapkan ke `true` agar tidak mengizinkan nama basis data atau server ke dalam kata sandi. |
| `p_disallow_simple_strings` | boolean | true | Tidak | Tetapkan ke `true` untuk tidak mengizinkan string simpel ke dalam kata sandi. |
| `p_disallow_whitespace` | boolean | false | Tidak | Tetapkan ke `true` untuk tidak mengizinkan karakter dengan spasi dalam kata sandi. |
| `p_disallow_at_sign` | boolean | false | Tidak | Tetapkan ke `true` untuk tidak mengizinkan karakter @ dalam kata sandi. |
Anda dapat membuat beberapa fungsi verifikasi kata sandi.
Ada pembatasan pada nama fungsi kustom Anda. Fungsi kustom Anda tidak dapat memiliki nama yang sama dengan objek sistem yang sudah ada. Panjang nama tidak boleh lebih dari 30 karakter. Selain itu, nama harus menyertakan salah satu dari string berikut: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE`, atau `STRENGTH`.
Contoh berikut membuat fungsi dengan nama `CUSTOM_PASSWORD_FUNCTION`. Fungsi tersebut mengharuskan agar kata sandi memiliki setidaknya 12 karakter, 2 karakter huruf besar, 1 digit, dan 1 karakter khusus, dan kata sandi tidak boleh berisi karakter @.
```
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;
/
```
Untuk melihat teks fungsi verifikasi Anda, kueri `DBA_SOURCE`. Contoh berikut mendapatkan teks fungsi kata sandi kustom bernama `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Untuk mengaitkan fungsi verifikasi Anda dengan profil pengguna, gunakan `ALTER PROFILE`. Contoh berikut mengaitkan PL/SQL fungsi verifikasi bernama `CUSTOM_PASSWORD_FUNCTION` dengan profil `DEFAULT` pengguna. `PASSWORD_VERIFY_FUNCTION`adalah nama sumber daya profil Oracle.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Untuk melihat profil pengguna mana yang terkait dengan fungsi verifikasi mana, kueri`DBA_PROFILES`. Contoh berikut mendapatkan profil yang terkait dengan fungsi verifikasi kustom bernama `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
```
Contoh berikut mendapatkan semua profil dan fungsi verifikasi kata sandi yang terkait dengan profil.
```
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
```
# Prosedur create\$1passthrough\$1verify\$1fcn
`create_passthrough_verify_fcn`Prosedur ini didukung untuk semua versi RDS untuk Oracle.
Anda dapat membuat fungsi kustom untuk memverifikasi kata sandi dengan menerapkan prosedur `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn` Amazon RDS. Prosedur `create_passthrough_verify_fcn` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ya | Nama untuk fungsi verifikasi kustom Anda. Ini adalah fungsi pembungkus yang dibuat untuk Anda dalam skema SYS, dan tidak berisi logika verifikasi apa pun. Anda menetapkan fungsi ini ke profil pengguna. |
| `p_target_owner` | varchar2 | — | Ya | Pemilik skema untuk fungsi verifikasi kustom Anda. |
| `p_target_function_name` | varchar2 | — | Ya | Nama fungsi kustom Anda saat ini yang berisi logika verifikasi. Fungsi kustom Anda harus menampilkan boolean. Fungsi Anda harus menampilkan `true` jika kata sandi valid dan `false` jika kata sandi tidak valid. |
Contoh berikut membuat fungsi verifikasi kata sandi yang menggunakan logika dari fungsi yang disebut `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;
/
```
Untuk mengaitkan fungsi verifikasi dengan profil pengguna, gunakan `alter profile`. Contoh berikut mengaitkan fungsi verifikasi dengan profil pengguna `DEFAULT`.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Menyiapkan server DNS kustom
Amazon RDS mendukung akses jaringan keluar di instans DB Anda yang menjalankan Oracle. Untuk informasi selengkapnya tentang akses jaringan keluar, termasuk prasyarat, lihat [Mengonfigurasi akses UTL\$1HTTP menggunakan sertifikat dan dompet Oracle](Oracle.Concepts.ONA.md).
Amazon RDS Oracle memungkinkan resolusi Layanan Nama Domain (DNS) dari server DNS kustom yang dimiliki oleh pelanggan. Anda hanya dapat menyelesaikan nama domain yang benar-benar memenuhi syarat dari instans DB Amazon RDS Anda melalui server DNS kustom.
Setelah Anda mengatur nama server DNS Anda, perlu waktu hingga 30 menit untuk menyebarkan perubahan ke instans DB Anda. Setelah perubahan diterapkan ke instans DB Anda, semua lalu lintas jaringan keluar mengharuskan pencarian DNS mengueri server DNS melalui port 53.
Untuk membuat server DNS kustom untuk instans DB Amazon RDS for Oracle, lakukan hal berikut:
+ Dari set opsi DHCP yang terlampir pada cloud privat virtual (VPC) Anda, tetapkan opsi `domain-name-servers` ke alamat IP server nama DNS Anda. Untuk informasi selengkapnya, lihat [Set opsi DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**catatan**
Opsi `domain-name-servers` menerima hingga empat nilai, tetapi instans DB Amazon RDS Anda hanya menggunakan nilai pertama.
+ Pastikan bahwa server DNS Anda dapat menyelesaikan semua kueri pencarian, termasuk nama DNS publik, nama DNS privat Amazon EC2, dan nama DNS khusus pelanggan. Jika lalu lintas jaringan keluar memuat setiap pencarian DNS yang tidak dapat ditangani server DNS Anda, server DNS Anda harus dikonfigurasikan oleh penyedia DNS hulu yang sesuai.
+ Konfigurasikan server DNS Anda untuk menghasilkan respons Protokol Datagram Pengguna (UDP) sebesar 512 byte atau kurang.
+ Konfigurasikan server DNS Anda untuk menghasilkan respons Protokol Kontrol Transmisi (TCP) sebesar 1024 byte atau kurang.
+ Konfigurasikan server DNS Anda untuk mengizinkan lalu lintas masuk dari instans DB Amazon RDS Anda melalui port 53. Jika server DNS Anda berada di Amazon VPC, maka VPC harus memiliki grup keamanan yang berisi aturan masuk yang mengizinkan lalu lintas UDP dan TCP di port 53. Jika server DNS Anda tidak berada di dalam VPC Amazon, server harus memiliki daftar izin firewall yang sesuai untuk mengizinkan lalu lintas masuk UDP dan TCP di port 53.
Untuk informasi lebih lanjut, lihat [Grup keamanan untuk VPC Anda](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) dan [Menambahkan dan menghapus aturan](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Konfigurasikan VPC dari instans DB Amazon RDS agar lalu lintas keluar dapat melalui port 53. VPC Anda harus memiliki grup keamanan yang berisi aturan keluar yang mengizinkan lalu lintas UDP dan TCP di port 53.
Untuk informasi lebih lanjut, lihat [Grup keamanan untuk VPC Anda](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) serta [Menambahkan dan menghapus aturan](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Jalur perutean antara instans DB Amazon RDS dan server DNS harus dikonfigurasi dengan benar untuk memungkinkan lalu lintas DNS.
+ Jika instans DB Amazon RDS dan server DNS tidak berada dalam VPC yang sama, koneksi peering harus diatur di antara keduanya. Untuk informasi selengkapnya, lihat [Apa yang dimaksud peering VPC?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Mengatur dan membatalkan pengaturan peristiwa diagnostik sistem
Untuk mengatur dan membatalkan pengaturan peristiwa diagnostik pada tingkat sesi, Anda dapat menggunakan pernyataan `ALTER SESSION SET EVENTS` Oracle SQL. Namun, untuk menyetel peristiwa di tingkat sistem, Anda tidak dapat menggunakan Oracle SQL. Sebaliknya, gunakan prosedur peristiwa sistem dalam paket `rdsadmin.rdsadmin_util`. Prosedur peristiwa sistem tersedia dalam versi mesin berikut:
+ Semua versi Oracle Database 21c
+ Versi 19.0.0.ru-2020-10.rur-2020-10.rur-2020-10.r1 dan Oracle Database 19c yang lebih baru
*Untuk informasi selengkapnya, lihat [Versi 19.0.0.0.ru-2020-10.rur-2020-10.r1 di Catatan Rilis Amazon RDS](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) for Oracle*
**penting**
Secara internal, paket `rdsadmin.rdsadmin_util` menetapkan peristiwa menggunakan pernyataan `ALTER SYSTEM SET EVENTS`. Pernyataan `ALTER SYSTEM` tidak didokumentasikan di dokumentasi Oracle Database. Beberapa peristiwa diagnostik sistem dapat menghasilkan informasi pelacakan dalam jumlah besar, menyebabkan pertentangan, atau memengaruhi ketersediaan basis data. Sebaiknya uji peristiwa diagnostik tertentu dalam basis data nonproduksi, dan hanya tetapkan peristiwa dalam basis data produksi Anda berdasarkan panduan Dukungan Oracle.
## Mencantumkan peristiwa diagnostik sistem yang diizinkan
Untuk mencantumkan peristiwa sistem yang dapat Anda tetapkan, gunakan prosedur `rdsadmin.rdsadmin_util.list_allowed_system_events` Amazon RDS. Prosedur ini tidak menerima parameter.
Contoh berikut mencantumkan semua peristiwa sistem yang dapat Anda tetapkan.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
Output sampel berikut mencantumkan nomor peristiwa dan deskripsinya. Gunakan prosedur `set_system_event` Amazon RDS untuk mengatur peristiwa dan `unset_system_event` untuk membatalkan pengaturannya.
```
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:
```
**catatan**
Daftar peristiwa sistem yang diizinkan dapat berubah seiring waktu. Untuk memastikan bahwa Anda memiliki daftar terbaru peristiwa yang memenuhi syarat, gunakan `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Menyetel peristiwa diagnostik sistem
Untuk menyetel peristiwa sistem, gunakan prosedur `rdsadmin.rdsadmin_util.set_system_event` Amazon RDS. Anda hanya dapat menyetel peristiwa yang tercantum dalam output dari `rdsadmin.rdsadmin_util.list_allowed_system_events`. Prosedur `set_system_event` menerima parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_event` | number | — | Ya | Nomor peristiwa sistem. Nilai harus salah satu nomor event yang dilaporkan oleh `list_allowed_system_events`. |
| `p_level` | number | — | Ya | Level peristiwa. Lihat dokumentasi Oracle Database atau Dukungan Oracle untuk deskripsi berbagai nilai level. |
Prosedur `set_system_event` membangun dan menjalankan pernyataan wajib `ALTER SYSTEM SET EVENTS` yang sesuai dengan prinsip berikut:
+ Tipe peristiwa (`context` atau `errorstack`) ditentukan secara otomatis.
+ Pernyataan dalam formulir `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` menetapkan peristiwa konteks. Notasi ini setara dengan `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Pernyataan dalam formulir `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` mengatur peristiwa tumpukan kesalahan. Notasi ini setara dengan `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
Contoh berikut menetapkan peristiwa 942 di level 3, dan peristiwa 10442 di level 10. Contoh output disertakan.
```
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.
```
## Mencantumkan peristiwa diagnostik sistem yang ditetapkan
Untuk mencantumkan peristiwa sistem yang sudah ditetapkan saat ini, gunakan prosedur `rdsadmin.rdsadmin_util.list_set_system_events` Amazon RDS. Prosedur ini melaporkan hanya peristiwa yang ditetapkan pada tingkat sistem oleh `set_system_event`.
Contoh berikut mencantumkan peristiwa sistem aktif.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
Output sampel berikut menunjukkan daftar peristiwa, tipe peristiwa, level peristiwa yang saat ini ditetapkan, dan waktu saat peristiwa ditetapkan.
```
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.
```
## Membatalkan pengaturan peristiwa diagnostik sistem
Untuk membatalkan pengaturan peristiwa sistem, gunakan prosedur `rdsadmin.rdsadmin_util.unset_system_event` Amazon RDS. Anda hanya dapat membatalkan pengaturan peristiwa yang tercantum dalam output dari `rdsadmin.rdsadmin_util.list_allowed_system_events`. Prosedur `unset_system_event` menerima parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_event` | number | — | Ya | Nomor peristiwa sistem. Nilai harus salah satu nomor peristiwa yang dilaporkan oleh `list_allowed_system_events`. |
Contoh berikut akan membatalkan pengaturan peristiwa 942 dan 10442. Contoh output disertakan.
```
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.
```
# Melakukan tugas basis data umum untuk instans DB Oracle
Pada bagian berikut, Anda dapat menemukan cara melakukan tugas DBA umum tertentu terkait basis data di instans DB Amazon RDS Anda yang menjalankan Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB. Amazon RDS juga membatasi akses ke prosedur dan tabel sistem tertentu yang memerlukan hak istimewa tingkat lanjut.
**Topics**
+ [
# Mengubah nama global basis data
](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [
# Bekerja dengan tablespaces di RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [
# Bekerja dengan tempfiles di RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [
# Mengubah ukuran ruang tabel, file data, dan tempfile di RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [
# Memindahkan data antara volume penyimpanan di RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [
# Bekerja dengan tabel eksternal di RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Mengubah nama global basis data
Untuk mengubah nama global basis data, gunakan prosedur `rdsadmin.rdsadmin_util.rename_global_name` Amazon RDS. Prosedur `rename_global_name` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Ya | Nama global baru untuk basis data. |
Basis data harus terbuka agar namanya dapat diubah. Untuk informasi selengkapnya tentang cara mengubah nama global basis data, lihat [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) di dokumentasi Oracle.
Contoh berikut mengubah nama global basis data menjadi `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Bekerja dengan tablespaces di RDS untuk Oracle
Anda dapat menggunakan tablespace dengan RDS untuk Oracle, yang merupakan unit penyimpanan logis yang menyimpan data database.
**penting**
Jika instans DB Anda memiliki replika, sebaiknya gunakan pengaturan grup parameter alih-alih perubahan tingkat sesi untuk mengelola lokasi file default. Perubahan tingkat sesi ke lokasi file default di instance utama tidak secara otomatis tercermin dalam replika. Menggunakan pengaturan grup parameter memastikan lokasi file yang konsisten di seluruh instance primer dan replika Anda.
**Topics**
+ [
## Menentukan lokasi file database di RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [
## Membuat dan mengukur ruang meja di RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [
## Membuat tablespace pada volume penyimpanan tambahan di RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [
## Mengatur tablespace default di RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [
## Mengatur tablespace sementara default di RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [
## Membuat tablespace sementara di penyimpanan instans
](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Menentukan lokasi file database di RDS untuk Oracle
RDS untuk Oracle menggunakan Oracle Managed Files (OMF) untuk memberi nama file database. Ketika Anda membuat file database database memperoleh pengaturan berdasarkan pengaturan saat ini dari parameter `DB_CREATE_FILE_DEST` inisialisasi.
Nilai default dari parameter `DB_CREATE_FILE_DEST` inisialisasi adalah `/rdsdbdata/db` untuk database mandiri dan `/rdsdbdata/db/pdb` untuk arsitektur containerized (CDB/MT). Jika instans DB Anda memiliki volume penyimpanan tambahan, maka Anda dapat mengatur `DB_CREATE_FILE_DEST` ke lokasi volume Anda. Misalnya, jika instance Anda memiliki volume yang terpasang`/rdsdbdata/db`, Anda dapat mengatur `DB_CREATE_FILE_DEST` ke nilai ini.
Anda dapat memodifikasi `DB_CREATE_FILE_DEST` parameter di tingkat sesi atau tingkat instance database Oracle.
### Memodifikasi DB\$1CREATE\$1FILE\$1SET pada tingkat instance
Untuk memodifikasi parameter pada tingkat instans, perbarui parameter dalam grup parameter yang ditetapkan ke instans DB Anda dan terapkan. Untuk informasi selengkapnya, lihat [RDS untuk parameter inisialisasi Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) dan [](USER_WorkingWithParamGroups.Modifying.md).
### Memodifikasi DB\$1CREATE\$1FILE\$1DEST di tingkat sesi
Anda dapat memodifikasi parameter di tingkat sesi dengan mengeksekusi `ALTER SESSION` pernyataan. Pendekatan ini berguna ketika Anda ingin membuat file database di lokasi tertentu untuk sesi tertentu tanpa mempengaruhi seluruh instance.
Contoh berikut menunjukkan cara memeriksa nilai parameter saat ini dan memodifikasinya untuk sesi:
```
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata/db
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata2/db
```
## Membuat dan mengukur ruang meja di RDS untuk Oracle
Saat Anda membuat tablespaces, database membuat file data dalam volume penyimpanan yang ditentukan oleh parameter `DB_CREATE_FILE_DEST` inisialisasi pada saat pembuatan. Jika Anda tidak menentukan ukuran file data, tablespace dibuat dengan pengaturan default `AUTOEXTEND ON`, dan ukuran maksimum tidak ditentukan. Dalam contoh berikut, tablespace *users1* bersifat autoextensible.
```
CREATE TABLESPACE users1;
```
Karena pengaturan default ini, ukuran tablespace dapat bertambah untuk menggunakan semua penyimpanan yang dialokasikan. Kami sarankan Anda menentukan ukuran maksimum yang sesuai pada ruang tabel permanen dan sementara, dan bahwa Anda dengan cermat menggunakan ruang monitor.
Contoh berikut membuat tablespace bernama *users2* dengan ukuran awal 1 gigabyte. Karena ukuran file data ditentukan, tetapi `AUTOEXTEND ON` tidak ditentukan, tablespace tidak dapat diperluas secara otomatis.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
Contoh berikut membuat tablespace bernama *users3* dengan ukuran awal 1 gigabyte, autoextend dihidupkan, dan ukuran maksimum 10 gigabyte.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
Contoh berikut menciptakan tablespace sementara bernama*temp01*.
```
CREATE TEMPORARY TABLESPACE temp01;
```
Anda dapat mengubah ukuran tablespace bigfile dengan menggunakan `ALTER TABLESPACE`. Anda dapat menentukan ukuran dalam kilobyte (K), megabyte (M), atau gigabyte (G). Contoh berikut mengubah ukuran ruang tabel file besar dengan nama *users\$1bf* hingga 200 MB.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
Contoh berikut menambahkan file data tambahan ke tablespace smallfile bernama. *users\$1sf*
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Membuat tablespace pada volume penyimpanan tambahan di RDS untuk Oracle
Untuk membuat tablespace pada volume penyimpanan tambahan, ubah `DB_CREATE_FILE_DEST` parameter ke lokasi volume. Contoh berikut menetapkan lokasi file ke`/rdsdbdata2/db`.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
Dalam contoh berikut, Anda membuat tablespace pada volume `/rdsdbdata2/db` tambahan.
```
CREATE TABLESPACE new_tablespace DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'NEW_TABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
NEW_TABLESPACE 7 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_newtable_a123b4c5_.dbf
```
Untuk membuat tablespace smallfile dan menyebarkan file datanya di berbagai volume penyimpanan, tambahkan file data ke tablespace setelah Anda membuatnya. Dalam contoh berikut, Anda membuat tablespace dengan file data di lokasi default. `/rdsdbdata/db` Kemudian Anda mengatur tujuan default ke`/rdsdbdata/db2`. Saat Anda menambahkan file data ke tablespace yang baru dibuat, database menyimpan file tersebut. `/rdsdbdata/db2`
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata/db';
Session altered.
CREATE SMALLFILE TABLESPACE smalltbs DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
ALTER TABLESPACE smalltbs ADD DATAFILE SIZE 10G;
Tablespace altered.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
SMALLTBS 9 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_smalltbs_n564004g_.dbf
```
## Mengatur tablespace default di RDS untuk Oracle
Untuk menetapkan tablespace default, gunakan prosedur `rdsadmin.rdsadmin_util.alter_default_tablespace` Amazon RDS. Prosedur `alter_default_tablespace` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Ya | Nama tablespace default. |
Contoh berikut menetapkan tablespace default ke*users2*:
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Mengatur tablespace sementara default di RDS untuk Oracle
Untuk menetapkan tablespace sementara default, gunakan prosedur `rdsadmin.rdsadmin_util.alter_default_temp_tablespace` Amazon RDS. Prosedur `alter_default_temp_tablespace` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Ya | Nama tablespace sementara default. |
Contoh berikut menetapkan tablespace sementara default ke*temp01*.
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Membuat tablespace sementara di penyimpanan instans
Untuk membuat tablespace sementara di penyimpanan instans, gunakan prosedur `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace` Amazon RDS. Prosedur `create_inst_store_tmp_tblspace` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ya | Nama tablespace sementara. |
Contoh berikut menciptakan tablespace sementara *temp01* di toko instance.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**penting**
Saat Anda menjalankan `rdsadmin_util.create_inst_store_tmp_tblspace`, tablespace sementara yang baru dibuat tidak akan otomatis ditetapkan sebagai tablespace sementara default. Untuk menetapkannya sebagai default, lihat [Mengatur tablespace sementara default di RDS untuk Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Lihat informasi yang lebih lengkap di [Menyimpan data sementara di penyimpanan instans RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Bekerja dengan tempfiles di RDS untuk Oracle
## Menambahkan tempfile ke penyimpanan instans di replika baca
Saat Anda membuat tablespace sementara di instans DB utama, replika baca tidak membuat file tempfile. Misalkan tablespace sementara kosong ada di replika baca Anda karena salah satu alasan berikut:
+ Anda meletakkan tempfile dari tablespace di replika baca Anda. Untuk informasi selengkapnya, lihat [Meletakkan tempfile di replika baca](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Anda membuat tablespace sementara baru di instans DB utama. Dalam kasus ini, RDS for Oracle menyinkronkan metadata ke replika baca.
Anda dapat menambahkan tempfile ke tablespace sementara yang kosong dan menyimpan tempfile di penyimpanan instans. Untuk membuat tempfile di penyimpanan instans, gunakan prosedur `rdsadmin.rdsadmin_util.add_inst_store_tempfile` Amazon RDS. Anda dapat menggunakan prosedur ini hanya di replika baca. Prosedur ini memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ya | Nama tablespace sementara di replika baca Anda. |
Dalam contoh berikut, tablespace sementara kosong *temp01* ada di replika baca Anda. Jalankan perintah berikut guna membuat tempfile untuk tablespace ini dan menyimpannya di penyimpanan instans.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Lihat informasi yang lebih lengkap di [Menyimpan data sementara di penyimpanan instans RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Meletakkan tempfile di replika baca
Anda tidak dapat meletakkan tablespace sementara yang ada di replika baca. Anda dapat mengubah penyimpanan tempfile di replika baca dari Amazon EBS ke penyimpanan instans atau dari penyimpanan instans ke Amazon EBS. Untuk mencapai tujuan ini, lakukan hal berikut:
1. Letakkan tempfile saat ini di tablespace sementara di replika baca.
1. Buat tempfile baru di penyimpanan yang berbeda.
Untuk meletakkan tempfile, gunakan prosedur `rdsadmin.rdsadmin_util. drop_replica_tempfiles` Amazon RDS. Anda dapat menggunakan prosedur ini hanya di replika baca. Prosedur `drop_replica_tempfiles` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ya | Nama tablespace sementara di replika baca Anda. |
Asumsikan bahwa tablespace sementara bernama *temp01* berada di penyimpanan instance pada replika baca Anda. Letakkan semua tempfile di tablespace ini dengan menjalankan perintah berikut.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Lihat informasi yang lebih lengkap di [Menyimpan data sementara di penyimpanan instans RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Mengubah ukuran ruang tabel, file data, dan tempfile di RDS untuk Oracle
Secara default, tablespace Oracle dibuat dengan mengaktifkan ekstensi otomatis dan tidak ada ukuran maksimum. Karena pengaturan default ini, tablespace terkadang dapat bertambah terlalu besar. Sebaiknya tentukan ukuran maksimum yang sesuai pada tablespace permanen dan sementara, serta pantau penggunaan ruang dengan cermat.
## Mengubah ukuran tablespace permanen
Untuk mengubah ukuran tablespace permanen dalam instans DB RDS for Oracle, gunakan salah satu prosedur Amazon RDS berikut:
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
Prosedur `resize_datafile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | number | — | Ya | Pengidentifikasi file data yang ukurannya akan diubah. |
| `p_size` | varchar2 | — | Ya | Ukuran file data. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). |
Prosedur `autoextend_datafile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | number | — | Ya | Pengidentifikasi file data yang ukurannya akan diubah. |
| `p_autoextend_state` | varchar2 | — | Ya | Status fitur ekstensi otomatis. Tentukan `ON` untuk memperluas file data secara otomatis dan `OFF` untuk menonaktifkan ekstensi otomatis. |
| `p_next` | varchar2 | — | Tidak | Ukuran penambahan file data berikutnya. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). |
| `p_maxsize` | varchar2 | — | Tidak | Ruang disk maksimum yang diizinkan untuk ekstensi otomatis. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). Anda dapat menentukan `UNLIMITED` untuk menghapus batas ukuran file. |
Contoh berikut mengubah ukuran file data 4 hingga 500 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
Contoh berikut menonaktifkan ekstensi otomatis untuk file data 4. Hal ini juga mengaktifkan ekstensi otomatis untuk file data 5, dengan penambahan 128 MB dan tidak ada ukuran maksimum.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Mengubah ukuran tablespace sementara
Untuk mengubah ukuran tablespace sementara dalam instans DB RDS for Oracle, termasuk replika baca, gunakan salah satu prosedur Amazon RDS berikut:
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
Prosedur `resize_temp_tablespace` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Ya | Nama tablespace sementara yang ukurannya akan diubah. |
| `p_size` | varchar2 | — | Ya | Ukuran tablespace. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). |
Prosedur `resize_tempfile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | number | — | Ya | Pengidentifikasi file temp yang ukurannya akan diubah. |
| `p_size` | varchar2 | — | Ya | Ukuran file temp. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). |
Prosedur `autoextend_tempfile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | number | — | Ya | Pengidentifikasi file temp yang ukurannya akan diubah. |
| `p_autoextend_state` | varchar2 | — | Ya | Status fitur ekstensi otomatis. Tentukan `ON` untuk memperluas file temp secara otomatis dan `OFF` untuk menonaktifkan ekstensi otomatis. |
| `p_next` | varchar2 | — | Tidak | Ukuran penambahan file temp berikutnya. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). |
| `p_maxsize` | varchar2 | — | Tidak | Ruang disk maksimum yang diizinkan untuk ekstensi otomatis. Tentukan ukuran dalam byte (default), kilobyte (K), megabyte (M), atau gigabyte (G). Anda dapat menentukan `UNLIMITED` untuk menghapus batas ukuran file. |
Contoh berikut mengubah ukuran tablespace sementara bernama `TEMP` menjadi 4 GB.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
Contoh berikut mengubah ukuran tablespace sementara berdasarkan file temp dengan pengidentifikasi file `1` menjadi 2 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
Contoh berikut menonaktifkan ekstensi otomatis untuk file temp 1. Contoh ini juga menetapkan ukuran ekstensi otomatis maksimum file temp 2 hingga 10 GB, dengan penambahan 100 MB.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Untuk informasi selengkapnya tentang replika baca untuk instans DB Oracle, lihat [Menggunakan replika baca untuk Amazon RDS for Oracle](oracle-read-replicas.md).
# Memindahkan data antara volume penyimpanan di RDS untuk Oracle
Anda dapat memindahkan file data dan objek database antara volume penyimpanan primer dan tambahan Anda. Sebelum Anda memindahkan data, pertimbangkan hal-hal berikut:
+ Sumber dan volume target harus memiliki ruang kosong yang cukup.
+ Operasi pergerakan data dikonsumsi I/O pada kedua volume.
+ Pergerakan data yang besar dapat memengaruhi kinerja database.
+ Jika Anda memulihkan snapshot, memindahkan data antar volume penyimpanan mungkin lambat jika dipengaruhi oleh pemuatan lambat EBS.
**Topics**
+ [
## Memindahkan file data antar volume dalam RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [
## Memindahkan data tabel dan indeks antar volume dalam RDS untuk Oracle
](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [
## Mengelola penyimpanan LOB menggunakan volume tambahan
](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Memindahkan file data antar volume dalam RDS untuk Oracle
Untuk memindahkan file data antar volume penyimpanan, gunakan prosedur `rdsadmin.rdsadmin_util.move_datafile` Amazon RDS. Perhatikan persyaratan berikut:
+ Anda harus menggunakan Oracle Enterprise Edition untuk menjalankan `move_datafile` prosedur.
+ Anda tidak dapat memindahkan tablespace `SYSTEM` dan`RDSADMIN`.
Prosedur `move_datafile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Diperlukan | Deskripsi |
| --- | --- | --- | --- |
| `p_data_file_id` | number | Ya | ID file data yang akan dipindahkan. |
| `p_location` | varchar2 | Ya | Volume penyimpanan tempat Anda ingin memindahkan file data. |
Contoh berikut memindahkan tablespace dari volume default `rdsdbdata` ke volume `rdsdbdata2` tambahan.
```
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata/db/ORCL_A/datafile/o1_mf_mynewtab_n123abcd_.dbf
EXECUTE rdsadmin.rdsadmin_util.move_datafile( 6, 'rdsdbdata2');
PL/SQL procedure successfully completed.
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_mynewtab_n356efgh_.dbf
```
## Memindahkan data tabel dan indeks antar volume dalam RDS untuk Oracle
Anda dapat mengoptimalkan penyimpanan database dengan membuat tablespace pada volume penyimpanan tambahan. Kemudian Anda dapat memindahkan objek seperti tabel, indeks, dan partisi ke tablespace ini menggunakan Oracle SQL standar. Pendekatan ini berharga untuk penyetelan kinerja ketika database Anda berisi data dengan pola akses yang berbeda. Misalnya, Anda dapat menyimpan data operasional yang sering diakses pada volume penyimpanan berkinerja tinggi sambil memindahkan data historis yang jarang diakses ke volume penyimpanan berbiaya lebih rendah.
Dalam contoh berikut, Anda membuat tablespace baru pada volume kinerja tinggi. `rdsdbdata2` Kemudian Anda memindahkan tabel ke volume penyimpanan tambahan Anda saat tabel sedang online. Anda juga memindahkan indeks ke volume yang sama. Memindahkan tabel dan membangun kembali indeks saat online memerlukan Oracle Enterprise Edition.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
CREATE TABLESPACE perf_tbs DATAFILE SIZE 10G;
ALTER TABLE employees
MOVE TABLESPACE perf_tbs ONLINE;
ALTER INDEX employees_idx
REBUILD ONLINE TABLESPACE perf_tbs;
```
Dalam contoh berikut, Anda membuat tablespace pada volume berbiaya rendah. Kemudian Anda memindahkan partisi tabel ke volume penyimpanan berbiaya rendah Anda menggunakan operasi online.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE hist_tbs DATAFILE SIZE 10G;
ALTER TABLE orders
MOVE PARTITION orders_2022
TABLESPACE hist_tbs ONLINE;
```
Dalam contoh berikut, Anda melakukan kueri operasi panjang sesi aktif.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
Anda dapat memeriksa penggunaan tablespaces Anda dengan kueri berikut.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Mengelola penyimpanan LOB menggunakan volume tambahan
Database Anda mungkin berisi tabel dengan objek BLOB atau CLOB yang menggunakan penyimpanan besar tetapi jarang diakses. Untuk mengoptimalkan penyimpanan, Anda dapat memindahkan segmen LOB ini ke ruang meja pada volume penyimpanan tambahan.
Dalam contoh berikut, Anda membuat tablespace untuk data LOB pada volume berbiaya rendah yang ditujukan untuk data akses rendah. Kemudian Anda membuat tabel yang menyimpan data pada volume ini.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE lob_data DATAFILE SIZE 5G AUTOEXTEND ON NEXT 1G;
CREATE TABLE documents (
doc_id NUMBER PRIMARY KEY,
doc_date DATE,
doc_content CLOB
) TABLESPACE user_data
LOB(doc_content) STORE AS (TABLESPACE lob_data);
```
# Bekerja dengan tabel eksternal di RDS untuk Oracle
*Tabel eksternal Oracle *adalah tabel dengan data yang tidak ada di basis data. Sebagai gantinya, data tersebut ada di file eksternal yang dapat diakses basis data. Dengan menggunakan tabel eksternal, Anda dapat mengakses data dengan memuatnya ke dalam basis data. Untuk informasi selengkapnya tentang tabel eksternal, lihat [Managing external tables](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) di dokumentasi Oracle.
Dengan Amazon RDS, Anda dapat menyimpan file tabel eksternal di objek direktori. Anda dapat membuat objek direktori atau menggunakan yang sudah ditentukan sebelumnya di basis data Oracle, seperti direktori DATA\$1PUMP\$1DIR. Untuk informasi tentang cara membuat objek direktori, lihat [Membuat dan menghapus direktori di ruang penyimpanan data utama](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Anda dapat mengueri tampilan ALL\$1DIRECTORIES guna menampilkan daftar objek direktori untuk instans basis data Amazon RDS Oracle Anda.
**catatan**
Direktori objek mengarah ke ruang penyimpanan data utama (volume EBS Amazon) yang digunakan oleh instans Anda. Ruang yang digunakan, beserta dengan file data, log pengulangan, audit, jejak, dan file lainnya, diperhitungkan terhadap penyimpanan yang dialokasikan.
Anda dapat memindahkan file data eksternal dari satu basis data Oracle ke basis data lainnya dengan menggunakan paket [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) atau paket [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069). File data eksternal dipindahkan dari direktori di basis data sumber ke direktori tertentu di basis data tujuan. Untuk informasi tentang penggunaan`DBMS_FILE_TRANSFER`, lihat[Mengimpor menggunakan Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Setelah memindahkan file data eksternal, Anda dapat membuat tabel eksternal dengannya. Contoh berikut membuat tabel eksternal yang menggunakan `emp_xt_file1.txt` file dalam DIR1 direktori USER\$1.
```
CREATE TABLE emp_xt (
emp_id NUMBER,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
user_name VARCHAR2(20)
)
ORGANIZATION EXTERNAL (
TYPE ORACLE_LOADER
DEFAULT DIRECTORY USER_DIR1
ACCESS PARAMETERS (
RECORDS DELIMITED BY NEWLINE
FIELDS TERMINATED BY ','
MISSING FIELD VALUES ARE NULL
(emp_id,first_name,last_name,user_name)
)
LOCATION ('emp_xt_file1.txt')
)
PARALLEL
REJECT LIMIT UNLIMITED;
```
Misalkan Anda ingin memindahkan data yang ada di instans basis data Amazon RDS Oracle ke file data eksternal. Dalam kasus ini, Anda dapat mengisi file data eksternal dengan membuat tabel eksternal dan memilih data dari tabel di basis data. Misalnya, pernyataan SQL berikut membuat tabel eksternal `orders_xt` dengan mengueri tabel `orders` di basis data.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
Dalam contoh ini, data diisi dalam file `orders_xt.dmp` di direktori DATA\$1PUMP\$1DIR.
# Mengecek database
Untuk membuat checkpoint basis data, gunakan prosedur `rdsadmin.rdsadmin_util.checkpoint` Amazon RDS. Prosedur `checkpoint` tidak memiliki parameter.
Contoh berikut membuat checkpoint basis data.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Mengatur pemulihan terdistribusi
Untuk mengatur pemulihan terdistribusi, gunakan prosedur `rdsadmin.rdsadmin_util.enable_distr_recovery` dan `disable_distr_recovery` Amazon RDS. Prosedur tersebut tidak memiliki parameter.
Contoh berikut mengaktifkan pemulihan terdistribusi.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
Contoh berikut menonaktifkan pemulihan terdistribusi.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Mengatur zona waktu basis data
Anda dapat mengatur zona waktu basis data Amazon RDS Oracle Anda dengan cara berikut:
+ Opsi `Timezone`
Opsi `Timezone` mengubah zona waktu di tingkat host dan memengaruhi semua kolom tanggal dan nilai seperti `SYSDATE`. Untuk informasi selengkapnya, lihat [Zona waktu Oracle](Appendix.Oracle.Options.Timezone.md).
+ Prosedur `rdsadmin.rdsadmin_util.alter_db_time_zone` Amazon RDS
Prosedur `alter_db_time_zone` mengubah zona waktu hanya untuk tipe data tertentu dan tidak mengubah `SYSDATE`. Ada batas tambahan pada pengaturan zona waktu yang tercantum dalam [dokumentasi Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705).
**catatan**
Anda juga dapat mengatur zona waktu default untuk Oracle Scheduler. Untuk informasi selengkapnya, lihat [Mengatur zona waktu untuk pekerjaan Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
Prosedur `alter_db_time_zone` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Ya | Zona waktu baru sebagai wilayah yang disebutkan atau selisih waktu mutlak dari Waktu Universal Terkoordinasi (UTC). Rentang selisih waktu yang valid berkisar dari -12.00 hingga \$114.00. |
Contoh berikut mengubah zona waktu menjadi UTC\$13.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
Contoh berikut mengubah zona waktu ke zona Africa/Algiers waktu.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Setelah Anda mengubah zona waktu dengan menggunakan prosedur `alter_db_time_zone`, boot ulang instans DB Anda agar perubahan dapat diterapkan. Untuk informasi selengkapnya, lihat [Mem-boot ulang instans DB DB](USER_RebootInstance.md). Untuk informasi selengkapnya tentang peningkatan zona waktu, lihat [Pertimbangan zona waktu](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
# Membuat laporan performa dengan Automatic Workload Repository (AWR)
Untuk mengumpulkan data performa dan membuat laporan, Oracle merekomendasikan Automatic Workload Repository (AWR). AWR memerlukan Oracle Database Enterprise Edition dan lisensi untuk paket Diagnostics and Tuning. Untuk mengaktifkan AWR, atur parameter inisiasi `CONTROL_MANAGEMENT_PACK_ACCESS` ke `DIAGNOSTIC` atau `DIAGNOSTIC+TUNING`.
## Bekerja dengan laporan AWR di RDS
Untuk membuat laporan AWR, Anda dapat menjalankan skrip seperti `awrrpt.sql`. Skrip ini diinstal di server host basis data. Di Amazon RDS, Anda tidak memiliki akses langsung ke host. Namun, Anda bisa mendapatkan salinan skrip SQL dari penginstalan Oracle Database lain.
Anda juga dapat menggunakan AWR dengan menjalankan prosedur dalam `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL paket. Anda dapat menggunakan paket ini untuk mengelola baseline dan snapshot, dan juga untuk menampilkan laporan ASH dan AWR. Misalnya, untuk membuat laporan AWR dalam format teks, jalankan prosedur `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`. Namun, Anda tidak dapat mengakses laporan AWR ini dari Konsol Manajemen AWS.
Saat bekerja dengan AWR, sebaiknya gunakan prosedur `rdsadmin.rdsadmin_diagnostic_util`. Anda dapat menggunakan prosedur ini untuk membuat:
+ Laporan AWR
+ Laporan Active Session History (ASH)
+ Laporan Database Diagnostic Monitor (ADDM)
+ File dump Oracle Data Pump Export dari data AWR
Prosedur `rdsadmin_diagnostic_util` menyimpan laporan ke sistem file instans DB. Anda dapat mengakses laporan ini dari konsol. Anda juga dapat mengakses laporan menggunakan prosedur `rdsadmin.rds_file_util` dan Anda dapat mengakses laporan yang disalin ke Amazon S3 menggunakan opsi Integrasi S3. Untuk informasi lebih lanjut, lihat [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) dan [Integrasi Amazon S3](oracle-s3-integration.md).
Anda dapat menggunakan prosedur `rdsadmin_diagnostic_util` di versi mesin DB Amazon RDS for Oracle berikut:
+ Semua versi Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 dan versi Oracle Database 19c yang lebih baru
Untuk blog yang menjelaskan cara bekerja dengan laporan diagnostik dalam skenario replikasi, lihat [Membuat laporan AWR untuk replika baca Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/).
## Parameter umum untuk paket utilitas diagnostik
Biasanya, Anda dapat menggunakan parameter berikut saat mengelola AWR dan ADDM dengan paket `rdsadmin_diagnostic_util`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
Anda dapat menggunakan parameter berikut saat mengelola ASH dengan paket rdsadmin\$1diagnostic\$1util.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Membuat laporan AWR
Untuk membuat laporan AWR, gunakan prosedur `rdsadmin.rdsadmin_diagnostic_util.awr_report`.
Contoh berikut membuat laporan AWR untuk rentang snapshot 101–106. File teks output diberi nama `awrrpt_101_106.txt`. Anda dapat mengakses laporan ini dari Konsol Manajemen AWS.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
Contoh berikut membuat laporan HTML untuk rentang snapshot 63-65. File HTML output diberi nama `awrrpt_63_65.html`. Prosedur menulis laporan ke direktori basis data nondefault bernama `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Mengekstrak data AWR ke dalam file dump
Untuk mengekstrak data AWR ke file dump, gunakan prosedur `rdsadmin.rdsadmin_diagnostic_util.awr_extract`. Anda dapat menggunakan fungsi ini hanya di tingkat PDB.
Contoh berikut mengekstrak rentang snapshot 101–106. File dump output diberi nama `awrextract_101_106.dmp`. Anda dapat mengakses file ini melalui konsol.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
Contoh berikut mengekstrak rentang snapshot 63-65. File dump output diberi nama `awrextract_63_65.dmp`. File disimpan dalam direktori basis data nondefault bernama `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Membuat laporan ADDM
Untuk membuat laporan ADDM, gunakan prosedur `rdsadmin.rdsadmin_diagnostic_util.addm_report`.
Contoh berikut membuat laporan ADDM untuk rentang snapshot 101-106. File teks output diberi nama `addmrpt_101_106.txt`. Anda dapat mengakses laporan ini melalui konsol.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
Contoh berikut membuat laporan ADDM untuk rentang snapshot 63-65. File teks output diberi nama `addmrpt_63_65.txt`. File disimpan dalam direktori basis data nondefault bernama `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Membuat laporan ASH
Untuk membuat laporan ASH, gunakan prosedur `rdsadmin.rdsadmin_diagnostic_util.ash_report`.
Contoh berikut membuat laporan ASH yang mencakup data dari 14 menit yang lalu hingga saat ini. Nama file output menggunakan format `ashrptbegin_timeend_time.txt`, dengan `begin_time` dan `end_time` menggunakan format `YYYYMMDDHH24MISS`. Anda dapat mengakses file ini melalui konsol.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
Contoh berikut membuat laporan ASH yang mencakup data dari 18 November 2019, mulai pukul 18.07 hingga 18.15. Nama laporan output HTML adalah `ashrpt_20190918180700_20190918181500.html`. Laporan disimpan dalam direktori basis data nondefault bernama `AWR_RPT_DUMP`.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => TO_DATE('2019-09-18 18:07:00', 'YYYY-MM-DD HH24:MI:SS'),
end_time => TO_DATE('2019-09-18 18:15:00', 'YYYY-MM-DD HH24:MI:SS'),
report_type => 'html',
dump_directory => 'AWR_RPT_DUMP');
END;
/
```
## Mengakses laporan AWR dari konsol atau CLI
Untuk mengakses laporan AWR atau mengekspor file dump, Anda dapat menggunakan atau. Konsol Manajemen AWS AWS CLI Lihat informasi yang lebih lengkap di [Mengunduh file log basis data](USER_LogAccess.Procedural.Downloading.md).
# Menyesuaikan tautan basis data untuk penggunaan instans DB di VPC
Untuk menggunakan tautan database Oracle dengan instans Amazon RDS DB di dalam virtual private cloud (VPC) atau peered yang sama VPCs, kedua instans DB harus memiliki rute yang valid di antara keduanya. Pastikan rute yang valid antara instans DB dengan menggunakan tabel perutean VPC Anda dan Daftar Kontrol Akses (ACL).
Grup keamanan dari setiap instans DB harus mengizinkan ingress dan egress dari instans DB lainnya. Aturan masuk dan keluar dapat merujuk ke grup keamanan dari VPC yang sama atau VPC yang di-peering. Untuk informasi selengkapnya, lihat [Memperbarui grup keamanan untuk mereferensikan grup keamanan VPC yang di-peering](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Jika Anda telah mengonfigurasi server DNS kustom menggunakan Set Opsi DHCP di VPC Anda, server DNS kustom Anda harus dapat menyelesaikan nama target tautan basis data. Untuk informasi selengkapnya, lihat [Menyiapkan server DNS kustom](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Untuk informasi selengkapnya tentang cara menggunakan tautan basis data dengan Oracle Data Pump, lihat [Mengimpor menggunakan Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Mengatur edisi default untuk instans DB
Anda dapat mendefinisikan ulang objek basis data dalam lingkungan privat yang disebut edisi. Anda dapat menggunakan redefenisi berbasis edisi untuk meningkatkan objek basis data aplikasi dengan waktu henti minimal.
Anda dapat mengatur edisi default instans DB Amazon RDS Oracle menggunakan prosedur `rdsadmin.rdsadmin_util.alter_default_edition` Amazon RDS.
Contoh berikut menetapkan edisi default untuk instans DB Amazon RDS Oracle menjadi `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
Contoh berikut menetapkan edisi default untuk laporan instans DB Amazon RDS Oracle kembali ke default Oracle.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Untuk informasi lebih lanjut tentang redefinisi berbasis edisi Oracle, lihat [About editions and edition-based redefinition](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) di dokumentasi Oracle.
# Mengaktifkan audit untuk tabel SYS.AUD\$1
Untuk mengaktifkan audit di tabel jejak audit basis data `SYS.AUD$`, gunakan prosedur `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table` Amazon RDS. Properti audit yang didukung hanya `ALL`. Anda tidak dapat melakukan audit atau tidak dapat mengaudit pernyataan atau operasi individual.
Pengaktifan audit didukung untuk instans DB Oracle yang menjalankan versi berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Prosedur `audit_all_sys_aud_table` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_by_access` | boolean | true | Tidak | Atur ke `true` untuk mengaudit `BY ACCESS`. Atur ke `false` untuk mengaudit `BY SESSION`. |
Kueri berikut mengembalikan konfigurasi audit `SYS.AUD$` saat ini untuk basis data.
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Perintah berikut mengaktifkan audit `ALL` di `SYS.AUD$` `BY ACCESS`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table;
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => true);
```
Perintah berikut mengaktifkan audit `ALL` di `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Untuk informasi selengkapnya, lihat [AUDIT (traditional auditing)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/AUDIT-Traditional-Auditing.html#GUID-ADF45B07-547A-4096-8144-50241FA2D8DD) di dokumentasi Oracle.
# Menonaktifkan pengauditan untuk tabel SYS.AUD\$1
Untuk menonaktifkan pengauditan di tabel jejak audit basis data `SYS.AUD$`, gunakan prosedur `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table` Amazon RDS. Prosedur ini tidak menggunakan parameter.
Kueri berikut mengembalikan konfigurasi audit `SYS.AUD$` saat ini untuk basis data:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Perintah berikut menonaktifkan audit `ALL` di `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Untuk informasi selengkapnya, lihat [NOAUDIT (traditional auditing)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/NOAUDIT-Traditional-Auditing.html#GUID-9D8EAF18-4AB3-4C04-8BF7-37BD0E15434D) di dokumentasi Oracle.
# Membersihkan pembuatan indeks online yang terganggu
Untuk membersihkan pembuatan indeks online yang gagal, gunakan prosedur `rdsadmin.rdsadmin_dbms_repair.online_index_clean` Amazon RDS.
Prosedur `online_index_clean` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | Tidak | ID objek indeks. Biasanya, Anda dapat menggunakan ID objek dari teks kesalahan ORA-08104. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | Tidak | Tentukan `rdsadmin.rdsadmin_dbms_repair.lock_wait` default, untuk mencoba mendapatkan kunci pada objek yang mendasari dan mencoba lagi hingga batas internal tercapai jika penguncian gagal. Tentukan `rdsadmin.rdsadmin_dbms_repair.lock_nowait` untuk mencoba mendapatkan penguncian di objek yang mendasari tetapi tidak mencoba lagi jika penguncian gagal. |
Contoh berikut membersihkan pembuatan indeks online yang gagal:
```
declare
is_clean boolean;
begin
is_clean := rdsadmin.rdsadmin_dbms_repair.online_index_clean(
object_id => 1234567890,
wait_for_lock => rdsadmin.rdsadmin_dbms_repair.lock_nowait
);
end;
/
```
Untuk informasi selengkapnya, lihat [ONLINE\$1INDEX\$1CLEAN function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) di dokumentasi Oracle.
# Melewatkan blok yang rusak
Untuk melewati blok yang rusak selama pemindaian indeks dan tabel, gunakan paket `rdsadmin.rdsadmin_dbms_repair`.
Prosedur berikut mencakup fungsionalitas prosedur `sys.dbms_repair.admin_table` dan tidak menggunakan parameter:
+ `rdsadmin.rdsadmin_dbms_repair.create_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table`
Prosedur berikut menggunakan parameter yang sama seperti parameter dalam paket `DBMS_REPAIR` untuk basis data Oracle:
+ `rdsadmin.rdsadmin_dbms_repair.check_object`
+ `rdsadmin.rdsadmin_dbms_repair.dump_orphan_keys`
+ `rdsadmin.rdsadmin_dbms_repair.fix_corrupt_blocks`
+ `rdsadmin.rdsadmin_dbms_repair.rebuild_freelists`
+ `rdsadmin.rdsadmin_dbms_repair.segment_fix_status`
+ `rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks`
Untuk informasi selengkapnya tentang cara menangani kerusakan basis data, lihat [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) di dokumentasi Oracle.
**Example Merespons blok yang rusak**
Contoh ini menunjukkan alur kerja dasar untuk merespons blok yang rusak. Langkah-langkah yang diperlukan bergantung pada lokasi dan sifat kerusakan blok Anda.
Sebelum mencoba memperbaiki blok yang rusak, tinjau dokumentasi [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) dengan cermat.
**Untuk melewati blok yang rusak selama pemindaian indeks dan tabel**
1. Jalankan prosedur berikut untuk membuat tabel perbaikan jika belum ada.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Jalankan prosedur berikut untuk memeriksa catatan yang ada dan menghapusnya jika sesuai.
```
SELECT COUNT(*) FROM SYS.REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.ORPHAN_KEY_TABLE;
SELECT COUNT(*) FROM SYS.DBA_REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.DBA_ORPHAN_KEY_TABLE;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table;
```
1. Jalankan prosedur berikut untuk memeriksa adanya blok yang rusak.
```
SET SERVEROUTPUT ON
DECLARE v_num_corrupt INT;
BEGIN
v_num_corrupt := 0;
rdsadmin.rdsadmin_dbms_repair.check_object (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
corrupt_count => v_num_corrupt
);
dbms_output.put_line('number corrupt: '||to_char(v_num_corrupt));
END;
/
COL CORRUPT_DESCRIPTION FORMAT a30
COL REPAIR_DESCRIPTION FORMAT a30
SELECT OBJECT_NAME, BLOCK_ID, CORRUPT_TYPE, MARKED_CORRUPT,
CORRUPT_DESCRIPTION, REPAIR_DESCRIPTION
FROM SYS.REPAIR_TABLE;
SELECT SKIP_CORRUPT
FROM DBA_TABLES
WHERE OWNER = '&corruptionOwner'
AND TABLE_NAME = '&corruptionTable';
```
1. Gunakan prosedur `skip_corrupt_blocks` untuk mengaktifkan atau menonaktifkan pelompatan kerusakan untuk tabel yang terkena dampak. Bergantung pada situasi, Anda mungkin juga perlu mengekstrak data ke tabel baru, lalu meletakkan tabel yang berisi blok yang rusak.
Gunakan prosedur berikut untuk mengaktifkan pelompatan kerusakan untuk tabel yang terkena dampak.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.skip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
Gunakan prosedur berikut untuk menonaktifkan pelompatan kerusakan.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.noskip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
1. Setelah menyelesaikan semua pekerjaan perbaikan, jalankan prosedur berikut untuk melakukan tabel perbaikan.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Membersihkan keranjang sampah
Ketika Anda menghapus tabel, Oracle Database Anda tidak langsung menghapus ruang penyimpanan. Basis data mengubah nama tabel dan menempatkannya dan objek terkait apa pun di keranjang sampah. Membersihkan keranjang sampah akan menghapus item ini dan membersihkan ruang penyimpanannya.
Untuk membersihkan keranjang sampah sepenuhnya, gunakan prosedur `rdsadmin.rdsadmin_util.purge_dba_recyclebin` Amazon RDS. Namun, prosedur ini tidak dapat membersihkan keranjang sampah objek `SYS` dan `RDSADMIN`. Jika Anda perlu membersihkan objek ini, hubungi Dukungan AWS .
Contoh berikut membersihkan keranjang sampah sepenuhnya.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Mengatur nilai default yang ditampilkan untuk redaksi penuh
Untuk mengubah nilai default yang ditampilkan untuk redaksi penuh di instans Amazon RDS Oracle Anda, gunakan prosedur `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val` Amazon RDS. Perhatikan bahwa Anda membuat kebijakan redaksi dengan `DBMS_REDACT` PL/SQL paket, seperti yang dijelaskan dalam dokumentasi Oracle Database. Prosedur `dbms_redact_upd_full_rdct_val` menentukan karakter yang akan ditampilkan untuk berbagai tipe data yang dipengaruhi oleh kebijakan yang ada.
Prosedur `dbms_redact_upd_full_rdct_val` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_number_val` | number | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `CHAR`. |
| `p_varchar_val` | varchar2 | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `NVARCHAR2`. |
| `p_date_val` | date | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `DATE`. |
| `p_ts_val` | timestamp | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `BLOB`. |
| `p_clob_val` | clob | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `CLOB`. |
| `p_nclob_val` | nclob | Null | Tidak | Memodifikasi nilai default untuk kolom tipe data `NCLOB`. |
Contoh berikut mengubah nilai default yang disunting menjadi \$1 untuk tipe data `CHAR`:
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
Contoh berikut mengubah nilai default yang disunting untuk `NUMBER`, `DATE`, dan tipe data `CHAR`:
```
BEGIN
rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(
p_number_val=>1,
p_date_val=>to_date('1900-01-01','YYYY-MM-DD'),
p_varchar_val=>'X');
END;
/
```
Setelah Anda mengubah nilai default untuk redaksi penuh dengan prosedur `dbms_redact_upd_full_rdct_val`, boot ulang instans DB Anda agar perubahan dapat diterapkan. Lihat informasi yang lebih lengkap di [Mem-boot ulang instans DB DB](USER_RebootInstance.md).
# Melakukan tugas umum terkait log untuk instans DB Oracle
Setelah itu, Anda dapat menemukan cara melakukan tugas DBA umum tertentu terkait proses pencatatan log di instans DB Amazon RDS Anda yang menjalankan Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB, dan membatasi akses ke sejumlah prosedur dan tabel sistem tertentu yang memerlukan hak istimewa tingkat lanjut.
Untuk informasi selengkapnya, lihat [File log database Amazon RDS for Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [
## Mengatur pencatatan log paksa
](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [
## Mengatur pencatatan log tambahan
](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [
## Mengganti file log online
](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [
## Menambahkan log pengulangan online
](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [
## Menghapus log pengulangan online
](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [
# Mengubah ukuran log pengulangan online
](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [
# Mempertahankan log pengulangan yang diarsipkan
](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [
# Mengakses log pengulangan online dan yang diarsipkan
](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [
# Mengunduh log pengulangan yang diarsipkan dari Amazon S3
](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Mengatur pencatatan log paksa
Dalam mode pencatatan log paksa, Oracle mencata log semua perubahan pada basis data kecuali perubahan dalam ruang tabel sementara dan segmen sementara (`NOLOGGING` klausul diabaikan). Untuk informasi selengkapnya, lihat [Menentukan mode LOGGING PAKSA](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) di dokumentasi Oracle.
Untuk mengatur pencatatan log paksa, gunakan prosedur `rdsadmin.rdsadmin_util.force_logging` Amazon RDS. Prosedur `force_logging` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Ya | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_enable` | boolean | true | Tidak | Atur ke `true` untuk menempatkan basis data dalam mode pencatatan log paksa, `false` untuk menghapus basis data dari mode pencatatan log paksa. |
Contoh berikut menempatkan basis data dalam mode pencatatan log paksa.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Mengatur pencatatan log tambahan
Jika Anda mengaktifkan pencatatan tambahan, LogMiner memiliki informasi yang diperlukan untuk mendukung baris berantai dan tabel berkerumun. Untuk informasi selengkapnya, lihat [Supplemental logging](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) di dokumentasi Oracle.
Oracle Database tidak mengaktifkan pencatatan log tambahan secara default. Untuk mengaktifkan dan menonaktifkan pencatatan log tambahan, gunakan prosedur `rdsadmin.rdsadmin_util.alter_supplemental_logging` Amazon RDS. Untuk informasi selengkapnya tentang cara Amazon RDS mengelola retensi log pengulangan yang diarsipkan untuk instans DB Oracle, lihat [Mempertahankan log pengulangan yang diarsipkan](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
Prosedur `alter_supplemental_logging` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Ya | `'ADD'` untuk menambahkan pencatatan log tambahan, `'DROP'` untuk menghapus pencatatan log tambahan. |
| `p_type` | varchar2 | null | Tidak | Tipe pencatatan log tambahan. Nilai yang valid adalah `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'`, atau `PROCEDURAL`. |
Contoh berikut mengaktifkan pencatatan log tambahan.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
Contoh berikut mengaktifkan pencatatan log tambahan untuk semua kolom ukuran maksimum dengan panjang tetap.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
Contoh berikut memungkinkan pencatatan log tambahan untuk kolom kunci primer.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Mengganti file log online
Untuk beralih file log, gunakan prosedur `rdsadmin.rdsadmin_util.switch_logfile` Amazon RDS. Prosedur `switch_logfile` tidak memiliki parameter.
Contoh berikut mengganti file log.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Menambahkan log pengulangan online
Instans DB Amazon RDS yang menjalankan Oracle dimulai dengan empat log pengulangan online, yang masing-masing berukuran 128 MB. Untuk menambahkan log pengulangan tambahan, gunakan prosedur `rdsadmin.rdsadmin_util.add_logfile` Amazon RDS.
Prosedur `add_logfile` memiliki parameter berikut.
**catatan**
Parameter ini tidak bisa ada pada saat yang sama.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `bytes` | positif | null | Tidak | Ukuran file log dalam byte. Gunakan parameter ini hanya jika ukuran log di bawah 2147483648 byte (2 GiB). Jika tidak, RDS mengeluarkan kesalahan. Untuk ukuran log di atas nilai byte ini, gunakan `p_size` parameter sebagai gantinya. |
| `p_size` | varchar2 | — | Ya | Ukuran file log dalam kilobyte (K), megabyte (M), atau gigabyte (G). |
Perintah berikut menambahkan file log 100 MB.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Menghapus log pengulangan online
Untuk menghapus log pengulangan, gunakan prosedur `rdsadmin.rdsadmin_util.drop_logfile` Amazon RDS. Prosedur `drop_logfile` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `grp` | positif | — | Ya | Nomor grup log. |
Contoh berikut menghapus log dengan grup nomor 3.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Anda hanya dapat menghapus log yang memiliki status tidak digunakan atau tidak aktif. Contoh berikut mendapatkan status log.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Mengubah ukuran log pengulangan online
Instans DB Amazon RDS yang menjalankan Oracle dimulai dengan empat log pengulangan online, yang masing-masing berukuran 128 MB. Contoh berikut menunjukkan cara menggunakan prosedur Amazon RDS untuk mengubah ukuran log Anda dari 128 MB menjadi 512 MB untuk masing-masing.
```
/* 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
```
# Mempertahankan log pengulangan yang diarsipkan
Anda dapat menyimpan log redo yang diarsipkan secara lokal pada instans DB Anda untuk digunakan dengan produk seperti LogMiner Oracle (). `DBMS_LOGMNR` Setelah Anda mempertahankan redo log, Anda dapat menggunakan LogMiner untuk menganalisis log. Untuk informasi selengkapnya, lihat [Menggunakan LogMiner untuk menganalisis file log ulang](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm) dalam dokumentasi Oracle.
Untuk mempertahankan log pengulangan yang diarsipkan, terapkan prosedur `rdsadmin.rdsadmin_util.set_configuration` Amazon RDS. Jika Anda menggunakan prosedur ini pada instance utama di Oracle Data Guard, RDS mengubah pengaturan penyimpanan log arsip pada instance utama dan membuka replika baca, tetapi tidak pada replika yang dipasang. RDS mempertahankan log pengulangan arsip terbaru pada replika yang dipasang untuk waktu yang singkat. RDS secara otomatis menghapus log lama yang diunduh ke replika yang dipasang.
Prosedur `set_configuration` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Ya | Nama konfigurasi yang akan diperbarui. Untuk mengubah jam retensi log ulang yang diarsipkan, setel nama ke. `archivelog retention hours` |
| `value` | varchar | — | Ya | Nilai untuk konfigurasi. Tetapkan nilai jumlah jam untuk mempertahankan log. |
Contoh berikut mempertahankan log pengulangan 24 jam.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**catatan**
Commit tersebut diperlukan agar perubahan dapat berlaku.
Untuk melihat berapa lama log pengulangan yang diarsipkan dipertahankan untuk instans DB Anda, gunakan prosedur `rdsadmin.rdsadmin_util.show_configuration` Amazon RDS.
Contoh berikut menunjukkan waktu retensi log.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
Output menunjukkan pengaturan saat ini untuk `archivelog retention hours`. Output berikut menunjukkan bahwa log pengulangan yang diarsipkan dipertahankan selama 48 jam.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Karena log pengulangan yang diarsipkan dipertahankan dalam instans DB Anda, pastikan bahwa instans DB Anda memiliki penyimpanan yang cukup untuk log yang dipertahankan. Untuk menentukan seberapa besar ruang yang digunakan oleh instans DB Anda dalam X jam terakhir, Anda dapat menjalankan kueri berikut, mengganti X dengan jumlah jam.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
RDS for Oracle hanya menghasilkan log pengulangan yang diarsipkan jika periode retensi cadangan instans DB Anda lebih besar dari nol. Secara default periode retensi cadangan lebih besar dari nol.
Ketika periode retensi log yang diarsipkan berakhir, RDS for Oracle akan menghapus log pengulangan yang diarsipkan dari instans DB Anda. Untuk mendukung pemulihan instans DB Anda ke titik waktu tertentu, Amazon RDS menyimpan log pengulangan yang diarsipkan di luar instans DB Anda berdasarkan periode retensi cadangan. Untuk mengubah periode retensi cadangan, lihat [Memodifikasi instans DB Amazon RDS](Overview.DBInstance.Modifying.md).
**catatan**
Dalam beberapa kasus, Anda mungkin menggunakan JDBC di Linux untuk mengunduh log pengulangan yang diarsipkan dan mengalami waktu latensi panjang dan pengaturan ulang koneksi. Dalam kasus seperti itu, masalah mungkin disebabkan oleh pengaturan generator nomor acak default pada klien Java Anda. Sebaiknya setel driver JDBC Anda untuk menggunakan generator nomor acak yang tidak blokir.
# Mengakses log pengulangan online dan yang diarsipkan
Anda mungkin ingin mengakses file log redo online dan diarsipkan untuk pertambangan dengan alat eksternal seperti GoldenGate, Attunity, Informatica, dan lainnya. Untuk mengakses file ini, lakukan hal berikut:
1. Buat objek direktori yang memberikan akses hanya baca ke jalur file fisik.
Gunakan `rdsadmin.rdsadmin_master_util.create_archivelog_dir` dan `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Baca file menggunakan PL/SQL.
Anda dapat membaca file menggunakan PL/SQL. Untuk informasi selengkapnya tentang cara membaca file dari objek direktori, lihat [Membuat daftar file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) dan [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Mengakses log transaksi didukung untuk rilis berikut ini:
+ Oracle Database 21c
+ Oracle Database 19c
Kode berikut membuat direktori yang memberikan akses baca saja ke file log pengulangan online dan yang diarsipkan.
**penting**
Kode ini juga mencabut hak istimewa `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
Kode berikut menghapus direktori untuk file log pengulangan online dan yang diarsipkan.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
Kode berikut memberikan dan mencabut hak istimewa `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Mengunduh log pengulangan yang diarsipkan dari Amazon S3
Anda dapat mengunduh log pengulangan yang diarsipkan pada instans DB Anda menggunakan paket `rdsadmin.rdsadmin_archive_log_download`. Jika log pengulangan yang diarsipkan tidak lagi tersedia di instans DB, Anda dapat mengunduhnya lagi dari Amazon S3. Kemudian Anda dapat menambang log atau menggunakannya untuk memulihkan atau mereplikasi basis data Anda.
**catatan**
Anda tidak dapat mengunduh log pengulangan yang diarsipkan pada instans replika baca.
## Mengunduh log pengulangan yang diarsipkan: langkah-langkah dasar
Ketersediaan log pengulangan yang diarsipkan bergantung pada kebijakan retensi berikut:
+ Kebijakan retensi cadangan - Log dalam kebijakan ini tersedia di Amazon S3. Log di luar kebijakan ini akan dihapus.
+ Kebijakan penyimpanan log yang diarsipkan - Log dalam kebijakan ini tersedia pada instans DB Anda. Log di luar kebijakan ini akan dihapus.
Jika log tidak tersedia di instans Anda tetapi dilindungi oleh periode retensi cadangan, gunakan `rdsadmin.rdsadmin_archive_log_download` untuk mengunduhnya lagi. RDS for Oracle menyimpan log ke direktori `/rdsdbdata/log/arch` pada instans DB Anda.
**Untuk mengunduh log pengulangan yang diarsipkan dari Amazon S3**
1. Konfigurasikan periode retensi Anda untuk memastikan unduhan log pengulangan yang diarsipkan dipertahankan selama yang Anda butuhkan. Pastikan untuk `COMMIT` perubahan Anda.
RDS mempertahankan log yang Anda unduh sesuai dengan kebijakan retensi log yang diarsipkan, mulai dari saat log diunduh. Untuk mempelajari cara menetapkan kebijakan retensi, lihat [Mempertahankan log pengulangan yang diarsipkan](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Tunggu hingga 5 menit agar perubahan kebijakan retensi log yang diarsipkan diterapkan.
1. Unduh log pengulangan yang diarsipkan dari Amazon S3 menggunakan `rdsadmin.rdsadmin_archive_log_download`.
Untuk informasi lebih lanjut, lihat [Mengunduh satu log pengulangan yang diarsipkan](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) dan [Mengunduh serangkaian log pengulangan yang diarsipkan](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**catatan**
RDS secara otomatis memeriksa penyimpanan yang tersedia sebelum mengunduh. Jika log yang diminta memakan ruang dengan persentase tinggi, Anda akan menerima peringatan.
1. Konfirmasi bahwa log berhasil diunduh dari Amazon S3.
Anda dapat melihat status tugas unduhan Anda di file bdump. File bdump memiliki nama jalur `/rdsdbdata/log/trace/dbtask-task-id.log`. Pada langkah unduhan sebelumnya, Anda menjalankan pernyataan `SELECT` yang menampilkan ID tugas dalam tipe data `VARCHAR2`. Untuk informasi selengkapnya, lihat contoh serupa di [Memantau status transfer file](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Mengunduh satu log pengulangan yang diarsipkan
Untuk mengunduh satu log pengulangan yang diarsipkan ke direktori `/rdsdbdata/log/arch`, gunakan `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Prosedur ini memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `seqnum` | number | — | Ya | Nomor urut log pengulangan yang diarsipkan. |
Contoh berikut mengunduh log dengan nomor urut 20.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Mengunduh serangkaian log pengulangan yang diarsipkan
Untuk mengunduh serangkaian log pengulangan yang diarsipkan ke direktori `/rdsdbdata/log/arch`, gunakan `download_logs_in_seqnum_range`. Unduhan Anda dibatasi hingga 300 log per permintaan. Prosedur `download_logs_in_seqnum_range` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `start_seq` | number | — | Ya | Nomor urut awal untuk rangkaian. |
| `end_seq` | number | — | Ya | Nomor urut akhir untuk rangkaian. |
Contoh berikut mengunduh log dengan nomor urut 50 sampai 100.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Melakukan tugas RMAN umum untuk instans DB Oracle
Di bagian berikut ini, Anda dapat menemukan cara melakukan tugas DBA Oracle Recovery Manager (RMAN) di instans DB Amazon RDS yang menjalankan Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB. Layanan ini juga membatasi akses ke prosedur dan tabel sistem tertentu yang memerlukan hak istimewa tingkat lanjut.
Gunakan paket Amazon RDS `rdsadmin.rdsadmin_rman_util` untuk melakukan pencadangan RMAN untuk basis data Amazon RDS for Oracle ke disk. Paket `rdsadmin.rdsadmin_rman_util` mendukung pencadangan file basis data secara penuh dan bertahap, pencadangan ruang tabel, dan pencadangan log pengulangan yang diarsipkan.
Setelah pencadangan RMAN selesai, Anda dapat menyalin file cadangan dari host instans DB Amazon RDS for Oracle. Anda dapat melakukan tindakan ini dengan tujuan melakukan pemulihan ke host non-RDS atau untuk penyimpanan cadangan jangka panjang. Misalnya, Anda dapat menyalin file cadangan ke bucket Amazon S3. Untuk informasi selengkapnya, lihat cara menggunakan [Integrasi Amazon S3](oracle-s3-integration.md).
File cadangan untuk pencadangan RMAN tetap berada di host instans DB Amazon RDS hingga Anda menghapusnya secara manual. Anda dapat menggunakan prosedur Oracle `UTL_FILE.FREMOVE` untuk menghapus file dari direktori. Untuk informasi selengkapnya, lihat [FREMOVE procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) di dokumentasi Oracle Database.
Anda tidak dapat menggunakan RMAN untuk memulihkan instans DB RDS for Oracle. Namun, Anda dapat menggunakan RMAN untuk memulihkan cadangan ke instans EC2 Amazon atau on-premise. Untuk informasi selengkapnya, lihat artikel blog [Memulihkan instans Amazon RDS for Oracle ke instans yang dikelola sendiri](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/).
**catatan**
Untuk membuat cadangan dan memulihkan ke instans DB Amazon RDS for Oracle, Anda dapat terus menggunakan fitur pencadangan dan pemulihan Amazon RDS. Lihat informasi yang lebih lengkap di [Mencadangkan, memulihkan, dan mengekspor data](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [
# Prasyarat untuk pencadangan RMAN
](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [
# Parameter umum untuk prosedur RMAN
](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [
# Memvalidasi file database dalam RDS untuk Oracle
](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [
# Mengaktifkan dan menonaktifkan pelacakan perubahan blok
](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [
# Memeriksa ulang log pengulangan yang diarsipkan
](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [
# Mencadangkan file log redo yang diarsipkan
](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [
# Melakukan pencadangan basis data penuh
](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [
# Melakukan pencadangan penuh untuk basis data penghuni
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [
# Melakukan pencadangan basis data inkremental
](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [
# Melakukan pencadangan inkremental untuk basis data penghuni
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [
# Mencadangkan ruang tabel
](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [
# Mencadangkan file kontrol
](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [
# Melakukan pemulihan media blok
](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Prasyarat untuk pencadangan RMAN
Sebelum membuat cadangan basis data menggunakan paket `rdsadmin.rdsadmin_rman_util`, pastikan Anda memenuhi prasyarat berikut:
+ Pastikan bahwa basis data RDS for Oracle Anda berada dalam mode `ARCHIVELOG`. Untuk mengaktifkan mode ini, atur periode retensi pencadangan ke nilai bukan nol.
+ Saat membuat cadangan log pengulangan yang diarsipkan atau menjalankan pencadangan penuh atau bertahap yang mencakup log pengulangan yang diarsipkan, dan saat membuat cadangan basis data, pastikan retensi log pengulangan diatur ke nilai bukan nol. Log pengulangan yang diarsipkan diperlukan untuk membuat file basis data konsisten selama pemulihan. Untuk informasi selengkapnya, lihat [Mempertahankan log pengulangan yang diarsipkan](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Pastikan instans DB Anda memiliki ruang kosong yang cukup untuk menyimpan cadangan. Saat membuat cadangan basis data, Anda menentukan objek direktori Oracle sebagai parameter dalam panggilan prosedur. RMAN menempatkan file di direktori yang ditentukan. Anda dapat menggunakan direktori default, seperti `DATA_PUMP_DIR`, atau membuat direktori baru. Untuk informasi selengkapnya, lihat [Membuat dan menghapus direktori di ruang penyimpanan data utama](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
Anda dapat memantau ruang kosong saat ini dalam RDS untuk instance Oracle menggunakan metrik. CloudWatch `FreeStorageSpace` Sebaiknya siapkan ruang kosong yang melebihi ukuran basis data saat ini, meskipun RMAN hanya mencadangkan blok yang diformat dan mendukung kompresi.
# Parameter umum untuk prosedur RMAN
Anda dapat menggunakan prosedur di paket `rdsadmin.rdsadmin_rman_util` Amazon RDS untuk melakukan tugas dengan RMAN. Beberapa parameter umum untuk prosedur dalam paket. Paket memiliki parameter umum berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Nama direktori basis data yang valid. | — | Ya | Nama direktori yang memuat file cadangan. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | Tidak | String unik yang disertakan dalam nama file cadangan. Batasnya adalah 30 karakter. |
| `p_owner` | varchar2 | Pemilik sah direktori yang ditetapkan di `p_directory_name`. | — | Ya | Pemilik direktori yang memuat file cadangan. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | Tidak | String yang dapat digunakan untuk membedakan antara cadangan untuk menunjukkan tujuan atau penggunaan cadangan, seperti pencadangan harian, mingguan, atau inkremental sesuai tingkat tertentu. Batasnya adalah 30 karakter. Tanda tidak peka huruf besar/kecil. Tanda selalu disimpan dalam huruf besar, terlepas dari huruf yang digunakan saat memasukkan tanda. Tanda tidak harus unik. Jadi, beberapa cadangan dapat memiliki tanda yang sama. Jika Anda tidak menentukan tag, maka RMAN menetapkan tag default secara otomatis menggunakan format`TAGYYYYMMDDTHHMMSS`, di mana *YYYY* tahun, *MM* adalah bulan, *DD* adalah hari, *HH* adalah jam (dalam format 24 jam), *MM* adalah menit, dan *SS* detik. Tanggal dan waktu mengacu pada kapan RMAN memulai pencadangan. Misalnya, cadangan mungkin menerima tanda `TAG20190927T214517` untuk pencadangan yang dimulai pada 2019-09-27 pukul 21:45:17. Parameter `p_tag` didukung untuk versi mesin DB Amazon RDS for Oracle berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | boolean | `TRUE`, `FALSE` | `FALSE` | Tidak | Tentukan `TRUE` untuk mengaktifkan kompresi pencadangan BASIC. Tentukan `FALSE` untuk menonaktifkan kompresi pencadangan BASIC. |
| `p_include_archive_logs` | boolean | `TRUE`, `FALSE` | `FALSE` | Tidak | Tentukan `TRUE` untuk menyertakan log pengulangan yang diarsipkan dalam pencadangan. Tentukan `FALSE` untuk tidak menyertakan log pengulangan yang diarsipkan dari pencadangan. Jika Anda menyertakan log pengulangan yang diarsipkan dalam pencadangan, atur retensi ke satu jam atau lebih menggunakan prosedur `rdsadmin.rdsadmin_util.set_configuration`. Selain itu, panggil prosedur `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` sebelum menjalankan pencadangan. Jika tidak, pencadangan dapat gagal karena file log pengulangan yang diarsipkan tidak ada. File ini telah dihapus oleh prosedur pengelolaan Amazon RDS. |
| `p_include_controlfile` | boolean | `TRUE`, `FALSE` | `FALSE` | Tidak | Tentukan `TRUE` untuk menyertakan file kontrol di pencadangan. Tentukan `FALSE` untuk tidak menyertakan file kontrol dari pencadangan. |
| `p_optimize` | boolean | `TRUE`, `FALSE` | `TRUE` | Tidak | Tentukan `TRUE` untuk mengaktifkan pengoptimalan pencadangan, jika log pengulangan yang diarsipkan disertakan, untuk mengurangi ukuran cadangan. Tentukan `FALSE` untuk menonaktifkan pengoptimalan pencadangan. |
| `p_parallel` | number | Suatu bilangan bulat yang valid antara `1` dan `254` untuk Oracle Database Enterprise Edition (EE) `1` untuk Oracle Database edisi lain | `1` | Tidak | Jumlah saluran. |
| `p_rman_to_dbms_output` | boolean | `TRUE`, `FALSE` | `FALSE` | Tidak | Jika `TRUE`, artinya output RMAN dikirimkan ke paket `DBMS_OUTPUT` dengan tambahan ke file di direktori `BDUMP`. Di SQL\$1Plus, gunakan `SET SERVEROUTPUT ON` untuk melihat output-nya. Jika `FALSE`, artinya output RMAN hanya dikirimkan ke file di direktori `BDUMP`. |
| `p_section_size_mb` | number | Bilangan bulat yang valid | `NULL` | Tidak | Ukuran bagian dalam megabyte (MB). Memvalidasi secara paralel dengan membagi setiap file ke dalam ukuran bagian yang ditentukan. Jika `NULL`, artinya parameter akan diabaikan. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | Tidak | Level deteksi kerusakan. Tentukan `'PHYSICAL'` untuk memeriksa kerusakan fisik. Contoh kerusakan fisik adalah kerusakan blok yang tidak sesuai pada header dan footer. Tentukan `'PHYSICAL+LOGICAL'` untuk memeriksa inkonsistensi logis selain kerusakan fisik. Contoh kerusakan logis adalah blok yang rusak. |
# Memvalidasi file database dalam RDS untuk Oracle
Anda dapat menggunakan paket Amazon RDS `rdsadmin.rdsadmin_rman_util` untuk memvalidasi file database Amazon RDS for Oracle, seperti file data, tablespaces, file kontrol, dan file parameter server (). SPFILEs
Untuk informasi selengkapnya tentang validasi RMAN, lihat [ Validating database files and backups](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) dan [VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) di dokumentasi Oracle.
**Topics**
+ [
## Memvalidasi database
](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [
## Memvalidasi basis data penghuni
](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [
## Memvalidasi ruang tabel
](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [
## Memvalidasi file kontrol
](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [
## Memvalidasi SPFILE
](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [
## Memvalidasi file data Oracle
](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Memvalidasi database
Untuk memvalidasi semua file yang relevan yang digunakan oleh database Oracle di RDS untuk Oracle, gunakan prosedur Amazon RDS. `rdsadmin.rdsadmin_rman_util.validate_database`
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Contoh berikut memvalidasi database menggunakan nilai default untuk parameter.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
Contoh berikut memvalidasi database menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_database(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Saat parameter `p_rman_to_dbms_output` ditetapkan ke `FALSE`, output RMAN ditulis ke file di direktori `BDUMP`.
Untuk melihat file di direktori `BDUMP`, jalankan pernyataan `SELECT` berikut.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Untuk melihat konten file di direktori `BDUMP`, jalankan pernyataan `SELECT` berikut.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Ganti nama file dengan nama file yang ingin Anda lihat.
## Memvalidasi basis data penghuni
Untuk memvalidasi file data basis data penghuni dalam basis data kontainer (CDB), gunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_tenant` Amazon RDS.
Prosedur ini hanya berlaku untuk basis data penghuni saat ini dan menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Prosedur ini didukung untuk versi mesin DB berikut:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Contoh berikut memvalidasi basis data penghuni saat ini menggunakan nilai default untuk parameter.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
Contoh berikut memvalidasi basis data penghuni saat ini menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tenant(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Saat parameter `p_rman_to_dbms_output` ditetapkan ke `FALSE`, output RMAN ditulis ke file di direktori `BDUMP`.
Untuk melihat file di direktori `BDUMP`, jalankan pernyataan `SELECT` berikut.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Untuk melihat konten file di direktori `BDUMP`, jalankan pernyataan `SELECT` berikut.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Ganti nama file dengan nama file yang ingin Anda lihat.
## Memvalidasi ruang tabel
Untuk memvalidasi file terkait dengan ruang tabel, gunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_tablespace` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Nama ruang tabel yang valid | — | Ya | Nama ruang tabel. |
## Memvalidasi file kontrol
Untuk memvalidasi hanya file kontrol yang digunakan instans DB Amazon RDS Oracle, gunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_current_controlfile` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Memvalidasi SPFILE
Untuk memvalidasi hanya file parameter server (SPFILE) yang digunakan instans DB Amazon RDS Oracle, gunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_spfile` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Memvalidasi file data Oracle
Untuk memvalidasi file data, gunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_datafile` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Nomor ID file data yang valid atau nama file data yang valid termasuk jalur lengkap | — | Ya | Nomor ID file data (dari `v$datafile.file#`) atau nama file data lengkap termasuk jalur (dari `v$datafile.name`). |
| `p_from_block` | number | Bilangan bulat yang valid | `NULL` | Tidak | Jumlah blok tempat validasi mulai dalam file data. Jika ditetapkan ke `NULL`, `1` akan digunakan. |
| `p_to_block` | number | Bilangan bulat yang valid | `NULL` | Tidak | Jumlah blok tempat validasi berakhir dalam file data. Jika ditetapkan ke `NULL`, blok maksimum dalam file data digunakan. |
# Mengaktifkan dan menonaktifkan pelacakan perubahan blok
Pelacakan perubahan blok mencatat blok yang berubah dalam file pelacakan. Teknik ini dapat meningkatkan performa pencadangan inkremental RMAN. Untuk informasi selengkapnya, lihat [Using Block Change Tracking to Improve Incremental Backup Performance](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) dalam dokumentasi Oracle Database.
Fitur RMAN tidak didukung dalam replika baca. Namun, sebagai bagian dari strategi ketersediaan tinggi, Anda dapat memilih untuk mengaktifkan pelacakan blok dalam replika hanya-baca menggunakan prosedur `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Jika Anda mempromosikan replika hanya-baca ini ke instans DB sumber, pelacakan perubahan blok akan diaktifkan untuk instans sumber baru. Dengan demikian, instans Anda dapat memperoleh manfaat dari pencadangan inkremental yang cepat.
Prosedur pelacakan perubahan blok didukung di Edisi Perusahaan hanya untuk versi mesin DB berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**catatan**
Di CDB penghuni tunggal, operasi berikut dapat dijalankan, tetapi tidak ada mekanisme yang dapat dilihat pelanggan yang dapat mendeteksi status operasi saat ini. Lihat juga [Keterbatasan RDS untuk Oracle CDBs](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Untuk mengaktifkan pelacakan perubahan blok untuk instans DB, gunakan prosedur `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking` Amazon RDS. Untuk menonaktifkan pelacakan perubahan blok, gunakan `disable_block_change_tracking`. Prosedur ini tidak menggunakan parameter.
Untuk menentukan apakah pelacakan perubahan blok diaktifkan untuk instans DB Anda, jalankan kueri berikut.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
Contoh berikut memungkinkan pelacakan perubahan blok untuk instans DB.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
Contoh berikut menonaktifkan pelacakan perubahan blok untuk instans DB.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Memeriksa ulang log pengulangan yang diarsipkan
Anda dapat memeriksa ulang log pengulangan yang diarsipkan menggunakan prosedur `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` Amazon RDS.
Anda dapat menggunakan prosedur ini untuk memeriksa ulang log pengulangan yang diarsipkan yang terdaftar dalam file kontrol. Anda juga dapat menghapus catatan log yang sudah tidak berlaku. Saat RMAN membuat cadangan, RMAN akan membuat catatan di file kontrol. Seiring berjalannya waktu, catatan ini meningkatkan ukuran file kontrol. Sebaiknya hapus catatan yang sudah tidak berlaku secara berkala.
**catatan**
Pencadangan Amazon RDS standar tidak menggunakan RMAN sehingga tidak membuat catatan di file kontrol.
Prosedur ini menggunakan parameter `p_rman_to_dbms_output` umum untuk tugas RMAN.
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | boolean | `TRUE`, `FALSE` | `TRUE` | Tidak | Saat ditetapkan ke `TRUE`, hapus riwayat log pengulangan yang diarsipkan dari file kontrol. Saat ditetapkan ke `FALSE`, simpan riwayat log pengulangan yang diarsipkan di file kontrol. |
Prosedur ini didukung untuk versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Contoh berikut menandai catatan log pengulangan yang diarsipkan di file kontrol sebagai kedaluwarsa, tetapi tidak menghapus catatan tersebut.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
Contoh berikut menghapus catatan log pengulangan yang diarsipkan yang telah kedaluwarsa dari file kontrol.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Mencadangkan file log redo yang diarsipkan
Anda dapat menggunakan paket `rdsadmin.rdsadmin_rman_util` Amazon RDS untuk mencadangkan log pengulangan yang diarsipkan untuk instans DB Amazon RDS Oracle.
Prosedur untuk mencadangkan log pengulangan yang diarsipkan mendukung versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [
## Mencadangkan semua log pengulangan yang diarsipkan
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [
## Mencadangkan log pengulangan yang diarsipkan dari rentang tanggal
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [
## Mencadangkan log pengulangan yang diarsipkan dari rentang SCN
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [
## Mencadangkan log pengulangan yang diarsipkan dari rentang nomor urut
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Mencadangkan semua log pengulangan yang diarsipkan
Untuk mencadangkan semua log pengulangan yang diarsipkan untuk instans DB Amazon RDS Oracle, gunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_all` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Contoh berikut mencadangkan semua log pengulangan yang diarsipkan untuk instans DB.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_all(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Mencadangkan log pengulangan yang diarsipkan dari rentang tanggal
Untuk mencadangkan log pengulangan tertentu yang diarsipkan untuk instans DB Amazon RDS Oracle dengan menentukan rentang tanggal, gunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_date` Amazon RDS. Rentang tanggal menentukan log pengulangan yang diarsipkan mana yang akan dicadangkan.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | Tanggal antara `start_date` dan `next_date` dari log pengulangan yang diarsipkan yang ada di disk. Nilai harus kurang dari atau sama dengan nilai yang ditentukan untuk `p_to_date`. | — | Ya | Tanggal mulai untuk pencadangan log yang diarsipkan. |
| `p_to_date` | date | Tanggal antara `start_date` dan `next_date` dari log pengulangan yang diarsipkan yang ada di disk. Nilai harus lebih besar dari atau sama dengan nilai yang ditentukan untuk `p_from_date`. | — | Ya | Tanggal akhir untuk pencadangan log yang diarsipkan. |
Contoh berikut mencadangkan log pengulangan yang diarsipkan dalam rentang tanggal tertentu untuk instans DB.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_date(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_date => '03/01/2019 00:00:00',
p_to_date => '03/02/2019 00:00:00',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Mencadangkan log pengulangan yang diarsipkan dari rentang SCN
Untuk mencadangkan log pengulangan tertentu yang diarsipkan untuk instans DB Amazon RDS Oracle dengan menentukan rentang nomor perubahan sistem (SCN), gunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn` Amazon RDS. Rentang SCN menentukan log pengulangan yang diarsipkan mana yang akan dicadangkan.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | number | SCN dari log pengulangan yang diarsipkan yang ada di disk. Nilai harus kurang dari atau sama dengan nilai yang ditentukan untuk `p_to_scn`. | — | Ya | SCN awal untuk pencadangan log yang diarsipkan. |
| `p_to_scn` | number | SCN dari log pengulangan yang diarsipkan yang ada di disk. Nilai harus lebih besar dari atau sama dengan nilai yang ditentukan untuk `p_from_scn`. | — | Ya | SCN akhir untuk pencadangan log yang diarsipkan. |
Contoh berikut membuat pencadangan log pengulangan yang diarsipkan dalam rentang SCN untuk instans DB.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_scn(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_scn => 1533835,
p_to_scn => 1892447,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Mencadangkan log pengulangan yang diarsipkan dari rentang nomor urut
Untuk mencadangkan log pengulangan tertentu yang diarsipkan untuk instans DB Amazon RDS Oracle dengan menentukan rentang nomor urut, gunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence` Amazon RDS. Rentang nomor urut menentukan log pengulangan yang diarsipkan mana yang akan dicadangkan.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | number | Nomor urut log pengulangan yang diarsipkan yang ada di disk. Nilai harus kurang dari atau sama dengan nilai yang ditentukan untuk `p_to_sequence`. | — | Ya | Nomor urut awal untuk pencadangan log yang diarsipkan. |
| `p_to_sequence` | number | Nomor urut log pengulangan yang diarsipkan yang ada di disk. Nilai harus lebih besar dari atau sama dengan nilai yang ditentukan untuk `p_from_sequence`. | — | Ya | Nomor urut akhir untuk pencadangan log yang diarsipkan. |
Contoh berikut mencadangkan log pengulangan yang diarsipkan dalam rentang nomor urut untuk instans DB.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_sequence => 11160,
p_to_sequence => 11160,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Melakukan pencadangan basis data penuh
Anda dapat melakukan pencadangan pada semua blok file data yang disertakan dalam pencadangan menggunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_database_full` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini didukung untuk versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Contoh berikut melakukan pencadangan penuh instans DB menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Melakukan pencadangan penuh untuk basis data penghuni
Anda dapat melakukan pencadangan untuk semua blok data termasuk basis data penghuni dalam basis data kontainer (CDB). Gunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_tenant_full` Amazon RDS. Prosedur ini hanya berlaku untuk pencadangan basis data saat ini dan menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur `rdsadmin_rman_util.backup_tenant_full` didukung untuk versi mesin DB RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Contoh berikut melakukan pencadangan penuh untuk basis data penghuni saat ini menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_TENANT_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Melakukan pencadangan basis data inkremental
Anda dapat melakukan pencadangan inkremental instans DB Anda menggunakan RDS prosedur `rdsadmin.rdsadmin_rman_util.backup_database_incremental` Amazon.
Untuk informasi selengkapnya tentang pencadangan inkremental, lihat [Incremental backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) di dokumentasi Oracle.
Prosedur ini menggunakan parameter umum berikut untuk RMAN tugas:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini didukung untuk Amazon RDS berikut untuk versi mesin Oracle DB:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_level` | number | `0`, `1` | `0` | Tidak | Tentukan `0` untuk mengaktifkan pencadangan inkremental. Tentukan `1` untuk mengaktifkan pencadangan inkremental non-kumulatif. |
Contoh berikut melakukan pencadangan inkremental instans DB menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Melakukan pencadangan inkremental untuk basis data penghuni
Anda dapat melakukan pencadangan tambahan dari database penyewa saat ini di Anda. CDB Gunakan RDS prosedur Amazon`rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Untuk informasi selengkapnya tentang pencadangan inkremental, lihat [Incremental backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) di dokumentasi Oracle Database.
Prosedur ini hanya berlaku untuk database penyewa saat ini dan menggunakan parameter umum berikut untuk RMAN tugas:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini didukung untuk Amazon RDS berikut untuk versi mesin Oracle DB:
+ Database Oracle 21c (21.0.0) CDB
+ Database Oracle 19c (19.0.0) CDB
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_level` | number | `0`, `1` | `0` | Tidak | Tentukan `0` untuk mengaktifkan pencadangan inkremental. Tentukan `1` untuk mengaktifkan pencadangan inkremental non-kumulatif. |
Contoh berikut melakukan pencadangan inkremental untuk basis data penghuni saat ini menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Mencadangkan ruang tabel
Anda dapat mencadangkan ruang tabel menggunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_tablespace` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini juga menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Nama ruang tabel yang valid. | — | Ya | Nama ruang tabel untuk dicadangkan. |
Prosedur ini didukung untuk versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Contoh berikut menjalankan pencadangan ruang tabel menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tablespace(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tablespace_name => 'MYTABLESPACE',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MYTABLESPACE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Mencadangkan file kontrol
Anda dapat mencadangkan file kontrol menggunakan prosedur `rdsadmin.rdsadmin_rman_util.backup_current_controlfile` Amazon RDS.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini didukung untuk versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Contoh berikut mencadangkan file kontrol menggunakan nilai yang ditentukan untuk parameter.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_current_controlfile(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tag => 'CONTROL_FILE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Melakukan pemulihan media blok
Anda dapat memulihkan blok data individual, yang dikenal sebagai pemulihan media blok, menggunakan prosedur `rdsadmin.rdsadmin_rman_util.recover_datafile_block` Amazon RDS. Anda dapat menggunakan prosedur kelebihan beban ini untuk memulihkan baik blok data individu atau berbagai blok data.
Prosedur ini menggunakan parameter umum berikut untuk tugas RMAN:
+ `p_rman_to_dbms_output`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Prosedur ini menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Nomor ID file data yang valid. | — | Ya | File data yang berisi blok korup. Tentukan file data dengan salah satu cara berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Sebuah integer yang valid. | — | Ya | Jumlah blok individu yang akan dipulihkan. Parameter berikut saling eksklusif: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Sebuah integer yang valid. | — | Ya | Nomor blok pertama dalam berbagai blok yang akan dipulihkan. Parameter berikut saling eksklusif: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Sebuah integer yang valid. | — | Ya | Nomor blok terakhir dalam berbagai blok yang akan dipulihkan. Parameter berikut saling eksklusif: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Prosedur ini didukung untuk versi mesin DB Amazon RDS for Oracle berikut:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Contoh berikut memulihkan blok 100 dalam file data 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
Contoh berikut memulihkan blok 100 hingga 150 dalam file data 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_from_block => 100,
p_to_block => 150,
p_rman_to_dbms_output => TRUE);
END;
/
```
# Melakukan tugas penjadwalan umum untuk instans DB Oracle
Beberapa pekerjaan penjadwal yang dimiliki `SYS` dapat mengganggu operasi basis data normal. Dalam kasus seperti itu, Oracle Support merekomendasikan agar Anda mengubah jadwal. Jika Anda perlu mengaktifkan atau menonaktifkan `SYS` pekerjaan, uji operasi pada pekerjaan terjadwal di lingkungan pengujian sebelum menerapkannya di lingkungan produksi. Untuk melakukan tugas untuk pekerjaan Oracle Scheduler yang dimiliki oleh `SYS`, gunakan paket `rdsadmin.rdsadmin_dbms_scheduler` Amazon RDS.
`rdsadmin.rdsadmin_dbms_scheduler`Prosedur ini didukung untuk versi mesin Amazon RDS for Oracle DB yang ditunjukkan pada tabel berikut. Saat menggunakan paket ini, Anda dapat menentukan `SYS` pekerjaan yang tercantum dalam tabel.
| Rilis basis data | Pekerjaan diaktifkan secara default | Pekerjaan dinonaktifkan secara default |
| --- | --- | --- |
| Oracle Database 19c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
RSE$CLEAN_RECOVERABLE_SCRIPT
SM$CLEAN_AUTO_SPLIT_MERGE
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
XMLDB_NFS_CLEANUP_JOB
|
| Oracle Database 21c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
ORA$_ATSK_AUTOSTS
XMLDB_NFS_CLEANUP_JOB
|
## Parameter umum untuk prosedur Oracle Scheduler
Untuk melakukan tugas dengan Oracle Scheduler, gunakan prosedur di paket `rdsadmin.rdsadmin_dbms_scheduler` Amazon RDS. Beberapa parameter umum untuk prosedur dalam paket. Paket memiliki parameter umum berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Prosedur yang tercantum dalam tabel di [Melakukan tugas penjadwalan umum untuk instans DB Oracle](#Appendix.Oracle.CommonDBATasks.Scheduler) | — | Ya | Nama pekerjaan yang akan dimodifikasi. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Ya | Atribut untuk diubah. Untuk memodifikasi interval pengulangan untuk pekerjaan, tentukan `'REPEAT_INTERVAL'`. Untuk memodifikasi nama jadwal untuk pekerjaan, tentukan `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Interval jadwal atau nama jadwal yang valid, tergantung atribut yang digunakan. | – | Ya | Nilai baru dari atribut. |
## Memodifikasi pekerjaan DBMS\$1SCHEDULER
Untuk memodifikasi komponen tertentu dari Oracle Scheduler, gunakan prosedur `dbms_scheduler.set_attribute` Oracle. Untuk informasi selengkapnya, lihat [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) dan [SET\$1ATTRIBUTE procedure](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) di dokumentasi Oracle.
Saat bekerja dengan instans DB Amazon RDS, siapkan nama skema `SYS` ke nama objek. Contoh berikut mengatur atribut rencana sumber daya untuk objek periode hari Senin.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## Memodifikasi AutoTask jendela pemeliharaan
Instans Amazon RDS for Oracle dibuat dengan pengaturan default untuk masa pemeliharaan. Tugas pemeliharaan otomatis seperti pengumpulan statistik pengoptimal berjalan selama periode ini. Secara default, masa pemeliharaan mengaktifkan Oracle Database Resource Manager.
Untuk memodifikasi periode, gunakan paket `DBMS_SCHEDULER`. Anda mungkin perlu memodifikasi pengaturan masa pemeliharaan karena alasan berikut ini:
+ Anda ingin pekerjaan pemeliharaan berjalan pada waktu yang berbeda, dengan pengaturan yang berbeda, atau tidak sama sekali. Misalnya, Anda mungkin ingin mengubah durasi periode atau mengubah waktu dan interval pengulangan.
+ Anda ingin menghindari dampak performa dari mengaktifkan Resource Manager selama pemeliharaan. Misalnya, jika rencana pemeliharaan default ditentukan dan jika masa pemeliharaan terbuka saat basis data sedang dimuat, Anda mungkin melihat peristiwa tunggu seperti `resmgr:cpu quantum`. Peristiwa tunggu ini terkait dengan Database Resource Manager. Anda memiliki opsi berikut:
+ Pastikan masa pemeliharaan aktif selama waktu tidak sibuk untuk instans DB Anda.
+ Nonaktifkan rencana pemeliharaan default dengan mengatur atribut `resource_plan` ke string kosong.
+ Tetapkan parameter `resource_manager_plan` ke `FORCE:` dalam grup parameter Anda. Jika instans Anda menggunakan Enterprise Edition, pengaturan ini mencegah paket Database Resource Manager diaktifkan.
**Untuk memodifikasi pengaturan masa pemeliharaan**
1. Terhubung ke basis data Anda menggunakan klien Oracle SQL.
1. Kueri konfigurasi saat ini untuk periode penjadwal.
Contoh berikut mengueri konfigurasi untuk `MONDAY_WINDOW`.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
Output berikut menunjukkan bahwa periode menggunakan nilai default.
```
ENABLED RESOURCE_PLAN DURATION REPEAT_INTERVAL
--------------- ------------------------------ ---------------- ------------------------------
TRUE DEFAULT_MAINTENANCE_PLAN +000 04:00:00 freq=daily;byday=MON;byhour=22
;byminute=0; bysecond=0
```
1. Modifikasi periode menggunakan paket `DBMS_SCHEDULER`.
Contoh berikut menetapkan rencana sumber daya ke null sehingga Resource Manager tidak akan berjalan selama masa pemeliharaan.
```
BEGIN
-- disable the window to make changes
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
-- specify the empty string to use no plan
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'RESOURCE_PLAN', value=>'');
-- re-enable the window
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
Contoh berikut mengatur durasi maksimum periode menjadi 2 jam.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'DURATION', value=>'0 2:00:00');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
Contoh berikut menetapkan interval pengulangan untuk setiap hari Senin pukul 10 pagi.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'REPEAT_INTERVAL', value=>'freq=daily;byday=MON;byhour=10;byminute=0;bysecond=0');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
## Mengatur zona waktu untuk pekerjaan Oracle Scheduler
Untuk memodifikasi zona waktu Oracle Scheduler, Anda dapat menggunakan prosedur `dbms_scheduler.set_scheduler_attribute` Oracle. Untuk informasi selengkapnya tentang paket `dbms_scheduler`, lihat [DBMS\$1SCHEDULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) dan [SET\$1SCHEDULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) dalam dokumentasi Oracle.
**Untuk memodifikasi pengaturan zona waktu saat ini**
1. Terhubung ke basis data menggunakan klien seperti SQL Developer. Untuk informasi selengkapnya, lihat [Menghubungkan ke instans DB menggunakan developer Oracle SQL](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Atur zona waktu default sebagai berikut, menggantikan zona waktu untuk `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
Dalam contoh berikut, Anda mengubah zona waktu ke Asia/Shanghai.
Mulai dengan melakukan kueri zona waktu saat ini, seperti yang ditunjukkan berikut.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
Output menunjukkan bahwa zona waktu saat ini adalah ETC/UTC.
```
VALUE
-------
Etc/UTC
```
Kemudian Anda mengubah zona waktu ke Asia/Shanghai.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Untuk informasi selengkapnya tentang perubahan zona waktu sistem, lihat [Zona waktu Oracle](Appendix.Oracle.Options.Timezone.md).
## Menonaktifkan pekerjaan Oracle Scheduler yang dimiliki oleh SYS
Untuk menonaktifkan pekerjaan Oracle Scheduler yang dimiliki oleh pengguna SYS, gunakan prosedur `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Prosedur ini menggunakan parameter umum `name` untuk tugas Oracle Scheduler. Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Contoh berikut menonaktifkan pekerjaan `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Mengaktifkan pekerjaan Oracle Scheduler yang dimiliki oleh SYS
Untuk mengaktifkan pekerjaan Oracle Scheduler yang dimiliki oleh SYS, gunakan prosedur `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Prosedur ini menggunakan parameter umum `name` untuk tugas Oracle Scheduler. Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Contoh berikut memungkinkan pekerjaan `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Memodifikasi interval pengulangan Oracle Scheduler untuk pekerjaan tipe CALENDAR
Untuk memodifikasi interval pengulangan untuk memodifikasi pekerjaan Oracle Scheduler yang dimiliki SYS dari tipe `CALENDAR`, gunakan prosedur `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Prosedur ini menggunakan parameter umum berikut untuk tugas Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Contoh berikut memodifikasi interval pengulangan dari pekerjaan `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute(
name => 'SYS.CLEANUP_ONLINE_IND_BUILD',
attribute => 'repeat_interval',
value => 'freq=daily;byday=FRI,SAT;byhour=20;byminute=0;bysecond=0');
END;
/
```
## Memodifikasi interval pengulangan Oracle Scheduler untuk pekerjaan tipe NAMED
Beberapa pekerjaan Oracle Scheduler menggunakan nama jadwal, bukan interval. Untuk jenis pekerjaan ini, Anda harus membuat jadwal baru yang sudah dinamai di skema pengguna master. Gunakan standar prosedur `sys.dbms_scheduler.create_schedule` Oracle untuk melakukan tindakan ini. Selain itu, gunakan `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` untuk menetapkan jadwal baru yang dinamai pada pekerjaan.
Prosedur ini menggunakan parameter umum berikut untuk tugas Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Contoh berikut memodifikasi interval pengulangan dari pekerjaan `SYS.BSLN_MAINTAIN_STATS_JOB` Oracle Scheduler.
```
BEGIN
DBMS_SCHEDULER.CREATE_SCHEDULE (
schedule_name => 'rds_master_user.new_schedule',
start_date => SYSTIMESTAMP,
repeat_interval => 'freq=daily;byday=MON,TUE,WED,THU,FRI;byhour=0;byminute=0;bysecond=0',
end_date => NULL,
comments => 'Repeats daily forever');
END;
/
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute (
name => 'SYS.BSLN_MAINTAIN_STATS_JOB',
attribute => 'schedule_name',
value => 'rds_master_user.new_schedule');
END;
/
```
## Menonaktifkan autocommit untuk pembuatan pekerjaan Oracle Scheduler
Ketika `DBMS_SCHEDULER.CREATE_JOB` membuat pekerjaan Oracle Scheduler, tindakan ini langsung menciptakan pekerjaan dan melakukan perubahan. Anda mungkin perlu memasukkan pembuatan pekerjaan Oracle Scheduler dalam transaksi pengguna untuk melakukan hal berikut:
+ Lakukan roll-back pada pekerjaan Oracle Schedule saat roll-back diterapkan pada transaksi pengguna.
+ Buat pekerjaan Oracle Scheduler saat transaksi pengguna utama dilakukan.
Anda dapat menggunakan prosedur `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` untuk mengaktifkan perilaku ini. Prosedur ini tidak menggunakan parameter. Anda dapat menggunakan prosedur ini dalam rilis RDS for Oracle berikut:
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 dan yang lebih baru
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 dan yang lebih baru
Contoh berikut menonaktifkan autocommit untuk Oracle Scheduler, membuat pekerjaan Oracle Scheduler, dan kemudian melakukan roll-back pada transaksi. Karena autocommit dinonaktifkan, basis data juga melakukan roll-back pada pembuatan pekerjaan Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag;
DBMS_SCHEDULER.CREATE_JOB(job_name => 'EMPTY_JOB',
job_type => 'PLSQL_BLOCK',
job_action => 'begin null; end;',
auto_drop => false);
ROLLBACK;
END;
/
PL/SQL procedure successfully completed.
SELECT * FROM DBA_SCHEDULER_JOBS WHERE JOB_NAME='EMPTY_JOB';
no rows selected
```
# Mendiagnosis masalah dengan RDS untuk instans Oracle DB
Oracle Database mencakup infrastruktur kemampuan diagnosis kesalahan yang dapat Anda gunakan untuk mengatasi masalah basis data. Dalam terminologi Oracle, *masalah* adalah kesalahan kritis seperti bug kode atau kerusakan data. *Insiden* adalah kondisi saat terjadi masalah. Jika kesalahan yang sama terjadi tiga kali, infrastruktur akan menunjukkan tiga insiden masalah ini. Untuk informasi selengkapnya, lihat [Diagnosing and resolving problems](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) di dokumentasi Oracle Database.
Utilitas Automatic Diagnostic Repository Command Interpreter (ADRCI) merupakan alat baris perintah Oracle yang Anda gunakan untuk mengelola data diagnostik. Misalnya, Anda dapat menggunakan alat ini untuk menyelidiki masalah dan memaketkan data diagnostik. *Paket insiden* mencakup data diagnostik insiden atau semua insiden yang mengacu pada masalah tertentu. Anda dapat mengunggah paket insiden, yang diimplementasikan sebagai file .zip, ke Oracle Support.
Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak menyediakan akses shell ADRCI. Untuk melakukan tugas diagnostik untuk instans RDS untuk Oracle DB, gunakan paket Amazon RDS. `rdsadmin.rdsadmin_adrci_util`
Dengan menggunakan fungsi di `rdsadmin_adrci_util`, Anda dapat membuat daftar serta mengemas masalah dan insiden, serta menunjukkan file jejak. Semua fungsi mengembalikan ID tugas. ID ini merupakan bagian dari nama file log yang berisi output ADRCI, seperti di `dbtask-task_id.log`. File log terletak di direktori BDUMP. Anda dapat mengunduh file log dengan mengikuti prosedur yang dijelaskan di [Mengunduh file log basis data](USER_LogAccess.Procedural.Downloading.md).
## Parameter umum untuk prosedur diagnostik
Untuk melakukan tugas diagnostik, gunakan fungsi dalam paket `rdsadmin.rdsadmin_adrci_util` Amazon RDS. Paket memiliki parameter umum berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | number | ID insiden yang valid atau null | Null | Tidak | Jika nilainya null, fungsi akan menunjukkan semua insiden. Jika nilainya tidak null dan mewakili ID insiden yang valid, fungsi akan menampilkan insiden yang ditentukan. |
| `problem_id` | number | ID masalah yang valid atau null | Null | Tidak | Jika nilainya null, fungsinya akan menunjukkan semua masalah. Jika nilainya tidak null dan mewakili ID masalah yang valid, fungsi akan menampilkan masalah yang ditentukan. |
| `last` | number | Bilangan bulat valid yang lebih besar dari 0 atau null | Null | Tidak | Jika nilainya null, fungsi akan menampilkan maksimal 50 item. Jika nilainya tidak null, fungsi akan menampilkan jumlah yang ditentukan. |
## Daftar insiden
Untuk membuat daftar masalah diagnostik bagi Oracle, gunakan fungsi `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` Amazon RDS. Anda dapat membuat daftar insiden dalam mode dasar atau terperinci. Secara default, fungsi ini mencantumkan 50 insiden terbaru.
Fungsi ini menggunakan parameter umum berikut:
+ `incident_id`
+ `problem_id`
+ `last`
Jika Anda menentukan `incident_id` dan`problem_id`, `incident_id` akan mengganti `problem_id`. Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur diagnostik](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Fungsi ini menggunakan parameter tambahan berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `detail` | boolean | TRUE atau FALSE | `FALSE` | Tidak | Jika `TRUE`, fungsi ini mencantumkan insiden dalam mode terperinci. Jika `FALSE`, fungsi ini mencantumkan daftar insiden dalam mode dasar. |
Untuk mencantumkan semua insiden, kueri fungsi `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` tanpa argumen apa pun. Kueri akan mengembalikan ID tugas.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Anda juga dapat memanggil fungsi `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` tanpa argumen dan menyimpan output di variabel klien SQL. Anda dapat menggunakan variabel di pernyataan lainnya.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Untuk membaca file log, panggil prosedur `rdsadmin.rds_file_util.read_text_file` Amazon RDS. Berikan ID tugas sebagai bagian dari nama file. Output berikut menunjukkan tiga insiden: 53523, 53522, dan 53521.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:11:46.193 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:11:46.256 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
----------- ----------------------------------------------------------- ----------------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
53522 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 2020-05-29 20:15:15.247000 +00:00
53521 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:11:46.256 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:11:46.256 UTC [INFO ] The task finished successfully.
14 rows selected.
```
Untuk membuat daftar insiden tertentu, tentukan ID menggunakan parameter `incident_id`. Dalam contoh berikut, Anda mengueri file log untuk insiden 53523 saja.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents(incident_id=>53523);
PL/SQL procedure successfully completed.
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------
2020-05-29 21:15:25.358 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:15:25.426 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
-------------------- ----------------------------------------------------------- ---------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
1 rows fetched
2020-05-29 21:15:25.427 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:15:25.427 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Mencantumkan masalah
Untuk mencantumkan masalah diagnostik bagi Oracle, gunakan fungsi `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` Amazon RDS.
Secara default, fungsi ini akan mencantumkan 50 masalah terbaru.
Fungsi ini menggunakan parameter umum `problem_id` dan `last`. Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur diagnostik](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Guna mendapatkan ID tugas untuk semua masalah, panggil fungsi `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` tanpa argumen apa pun, dan simpan hasilnya dalam variabel klien SQL.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Untuk membaca file log, panggil fungsi `rdsadmin.rds_file_util.read_text_file`, berikan ID tugas sebagai bagian dari nama file. Di output berikut, file log menampilkan tiga masalah: 1, 2, dan 3.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
----------------------------------------------------------------------------------------------------------------------
2020-05-29 21:18:50.764 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:18:50.829 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
2 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 53523 2020-05-29 20:15:20.928000 +00:00
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 53521 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:18:50.829 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:18:50.829 UTC [INFO ] The task finished successfully.
14 rows selected.
```
Dalam contoh berikut, Anda hanya mencantumkan masalah nomor 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Untuk membaca file log masalah 3, panggil `rdsadmin.rds_file_util.read_text_file`. Berikan ID tugas sebagai bagian dari nama file.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------
2020-05-29 21:19:42.533 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:19:42.599 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 rows fetched
2020-05-29 21:19:42.599 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:19:42.599 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Membuat paket insiden
Anda dapat membuat paket insiden menggunakan fungsi `rdsadmin.rdsadmin_adrci_util.create_adrci_package` Amazon RDS. Output adalah file .zip yang dapat Anda berikan ke Oracle Support.
Fungsi ini menggunakan parameter umum berikut:
+ `problem_id`
+ `incident_id`
Pastikan untuk menentukan salah satu parameter sebelumnya. Jika Anda menentukan kedua parameter, `incident_id` akan menimpa `problem_id`. Untuk informasi selengkapnya, lihat [Parameter umum untuk prosedur diagnostik](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Untuk membuat paket insiden tertentu, panggil fungsi Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package` dengan parameter `incident_id`. Contoh berikut membuat paket untuk insiden 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Untuk membaca file log, panggil `rdsadmin.rds_file_util.read_text_file`. Anda dapat memberikan ID tugas sebagai bagian dari nama file. Output menunjukkan bahwa Anda menghasilkan paket insiden `ORA700EVE_20200529212043_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
--------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:20:43.031 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:20:47.641 UTC [INFO ] Generated package 1 in file /rdsdbdata/log/trace/ORA700EVE_20200529212043_COM_1.zip, mode complete
2020-05-29 21:20:47.642 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:20:47.642 UTC [INFO ] The task finished successfully.
```
Untuk membuat paket data diagnostik masalah tertentu, tentukan ID menggunakan parameter `problem_id`. Dalam contoh berikut, Anda hanya memaketkan data untuk masalah nomor 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Untuk membaca output tugas, panggil `rdsadmin.rds_file_util.read_text_file`, berikan ID tugas sebagai bagian dari nama file. Output menunjukkan bahwa Anda menghasilkan paket insiden `ORA700EVE_20200529212111_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:21:11.050 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:21:15.646 UTC [INFO ] Generated package 2 in file /rdsdbdata/log/trace/ORA700EVE_20200529212111_COM_1.zip, mode complete
2020-05-29 21:21:15.646 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:21:15.646 UTC [INFO ] The task finished successfully.
```
Anda juga dapat mengunduh file log. Untuk informasi selengkapnya, lihat [Mengunduh file log basis data](USER_LogAccess.Procedural.Downloading.md).
## Menampilkan file jejak
Anda dapat menggunakan fungsi Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` untuk membuat daftar file jejak di bagian direktori jejak dan semua direktori insiden di beranda ADR saat ini. Anda juga dapat menampilkan konten file jejak dan file jejak insiden.
Fungsi ini menggunakan parameter berikut.
****
| Nama parameter | Tipe data | Nilai valid | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Nama file jejak yang valid | Null | Tidak | Jika nilainya null, fungsi akan menunjukkan semua file jejak. Jika nilainya tidak null, fungsi akan menampilkan file yang ditentukan. |
Untuk menampilkan file jejak, panggil fungsi `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` Amazon RDS.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
Untuk mencantumkan nama file jejak, panggil prosedur `rdsadmin.rds_file_util.read_text_file` Amazon RDS, dengan memberikan ID tugas sebagai bagian dari nama file.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE TEXT LIKE '%/alert_%';
TEXT
---------------------------------------------------------------
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-28
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-27
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-26
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-25
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-24
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-23
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-22
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-21
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log
9 rows selected.
```
Dalam contoh berikut, Anda membuat output untuk `alert_ORCL.log`.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile('diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log');
PL/SQL procedure successfully completed.
```
Untuk membaca file log, panggil `rdsadmin.rds_file_util.read_text_file`. Berikan ID tugas sebagai bagian dari nama file. Output menampilkan 10 baris pertama alert\$1ORCL.log.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE ROWNUM <= 10;
TEXT
-----------------------------------------------------------------------------------------
2020-05-29 21:24:02.083 UTC [INFO ] The trace files are being displayed.
2020-05-29 21:24:02.128 UTC [INFO ] Thu May 28 23:59:10 2020
Thread 1 advanced to log sequence 2048 (LGWR switch)
Current log# 3 seq# 2048 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_3_hbl2p8xs_.log
Thu May 28 23:59:10 2020
Archived Log entry 2037 added for thread 1 sequence 2047 ID 0x5d62ce43 dest 1:
Fri May 29 00:04:10 2020
Thread 1 advanced to log sequence 2049 (LGWR switch)
Current log# 4 seq# 2049 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_4_hbl2qgmh_.log
Fri May 29 00:04:10 2020
10 rows selected.
```
Anda juga dapat mengunduh file log. Lihat informasi yang lebih lengkap di [Mengunduh file log basis data](USER_LogAccess.Procedural.Downloading.md).
# Melakukan berbagai tugas untuk instans DB Oracle
Setelah itu, Anda dapat menemukan cara melakukan berbagai tugas DBA di instans DB Amazon RDS Anda yang menjalankan Oracle. Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak memberikan akses shell ke instans DB, dan membatasi akses ke sejumlah prosedur dan tabel sistem tertentu yang memerlukan hak istimewa tingkat lanjut.
**Topics**
+ [
## Membuat dan menghapus direktori di ruang penyimpanan data utama
](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [
## Membuat daftar file di direktori instans DB
](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [
## Membaca file di direktori instans DB
](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [
## Mengakses file Opatch
](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [
## Mengelola tugas penasihat
](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [
# Mengangkut tablespace
](rdsadmin_transport_util.md)
## Membuat dan menghapus direktori di ruang penyimpanan data utama
Untuk membuat direktori, gunakan prosedur `rdsadmin.rdsadmin_util.create_directory` Amazon RDS. Anda dapat membuat hingga 10.000 direktori, semuanya berada di ruang penyimpanan data utama Anda. Untuk menghapus direktori gunakan prosedur `rdsadmin.rdsadmin_util.drop_directory` Amazon RDS.
Prosedur `create_directory` dan `drop_directory` memiliki parameter yang diperlukan berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Ya | Nama direktori. |
Contoh berikut membuat direktori baru dengan nama `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Direktori data menyimpan nama direktori dengan huruf besar. Anda dapat membuat daftar direktori dengan membuat kueri `DBA_DIRECTORIES`. Sistem memilih nama jalur host aktual secara otomatis. Contoh berikut memperoleh jalur direktori untuk direktori dengan nama `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Nama pengguna master untuk instans DB memiliki hak istimewa baca dan tulis di direktori baru, dan dapat memberikan akses ke pengguna lain. Hak istimewa `EXECUTE` tidak tersedia untuk direktori pada instans DB. Direktori dibuat di ruang penyimpanan data utama Anda dan akan menghabiskan ruang dan I/O bandwidth.
Contoh berikut menghapus direktori dengan nama `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**catatan**
Anda juga dapat menghapus direktori menggunakan perintah `DROP DIRECTORY` Oracle SQL.
Menghapus direktori tidak menghapus kontennya. Karena prosedur `rdsadmin.rdsadmin_util.create_directory` dapat menggunakan ulang nama jalur, file di direktori yang dihapus dapat muncul di direktori yang baru dibuat. Sebelum menghapus direktori, sebaiknya Anda menggunakan `UTL_FILE.FREMOVE` untuk menghapus file dari direktori. Untuk informasi lebih lanjut, lihat [FREMOVE procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) di dokumentasi Oracle.
## Membuat daftar file di direktori instans DB
Untuk membuat daftar file di direktori, gunakan prosedur `rdsadmin.rds_file_util.listdir` Amazon RDS. Prosedur ini tidak didukung pada replika Oracle. Prosedur `listdir` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ya | Nama direktori yang dibuat daftarnya. |
Contoh berikut memberikan hak read/write istimewa pada direktori `PRODUCT_DESCRIPTIONS` kepada pengguna`rdsadmin`, dan kemudian daftar file dalam direktori ini.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Membaca file di direktori instans DB
Untuk membaca file teks, gunakan prosedur `rdsadmin.rds_file_util.read_text_file` Amazon RDS. Prosedur `read_text_file` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ya | Nama direktori yang memuat file. |
| `p_filename` | varchar2 | — | Ya | Nama file yang akan dibaca. |
Contoh berikut membuat file `rice.txt` di direktori `PRODUCT_DESCRIPTIONS`.
```
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;
/
```
Contoh berikut membaca file `rice.txt` dari direktori `PRODUCT_DESCRIPTIONS`.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Mengakses file Opatch
Opatch adalah utilitas Oracle yang mendukung aplikasi dan rollback patch untuk perangkat lunak Oracle. Mekanisme Oracle untuk menentukan patch mana yang telah diterapkan ke basis data adalah perintah `opatch lsinventory`. Untuk membuka permintaan layanan bagi pelanggan Bring Your Own Licence (BYOL), Oracle mendukung permintaan `lsinventory` dan terkadang file `lsinventory_detail` yang dihasilkan oleh Opatch.
Untuk memberikan pengalaman layanan terkelola, Amazon RDS tidak menyediakan akses shell ke Opatch. Sebagai gantinya, `lsinventory-dbv.txt` di direktori BDUMP berisi informasi patch yang terkait dengan versi mesin Anda saat ini. Saat Anda melakukan peningkatan kecil atau besar, Amazon RDS memperbarui `lsinventory-dbv.txt` dalam waktu satu jam setelah patch diterapkan. Untuk memverifikasi patch yang diterapkan, baca `lsinventory-dbv.txt`. Tindakan ini mirip dengan menjalankan perintah `opatch lsinventory`.
**catatan**
Contoh di bagian ini mengasumsikan bahwa direktori BDUMP diberi nama `BDUMP`. Pada replika baca, nama direktori BDUMP berbeda. Untuk mempelajari cara mendapatkan nama BDUMP dengan mengueri `V$DATABASE.DB_UNIQUE_NAME` pada replika baca, lihat [Membuat daftar file](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
File inventaris menggunakan konvensi penamaan Amazon RDS `lsinventory-dbv.txt` dan`lsinventory_detail-dbv.txt`, di *dbv* mana nama lengkap versi DB Anda. File `lsinventory-dbv.txt` tersedia di semua versi DB. Yang sesuai `lsinventory_detail-dbv.txt` tersedia di 19.0.0.0, ru-2020-01.rur-2020-01.r1 atau yang lebih baru.
Misalnya, jika versi DB Anda adalah 19.0.0.0.ru-2021-07.rur-2021-07.r1, inventaris file Anda memiliki nama berikut.
```
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
```
Pastikan Anda mengunduh file yang sesuai dengan versi mesin DB terkini milik Anda.
### Konsol
**Untuk mengunduh file inventaris menggunakan konsol**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis data**.
1. Pilih nama instans DB yang memiliki file log yang ingin dilihat.
1. Pilih tab **Log & peristiwa**.
1. Gulir ke bawah hingga bagian **Log**.
1. Di bagian **Log**, cari `lsinventory`.
1. Pilih file yang ingin Anda akses, lalu pilih **Unduh**.
### SQL
Untuk membaca `lsinventory-dbv.txt` di klien SQL, Anda dapat menggunakan pernyataan `SELECT`. Untuk teknik ini, gunakan fungsi `rdsadmin` berikut: `rdsadmin.rds_file_util.read_text_file` atau `rdsadmin.tracefile_listing`.
Dalam contoh query berikut, ganti *dbv* dengan versi Oracle DB Anda. Misalnya, DB version Anda mungkin 19.0.0.0.ru-2020-04.rur-2020-04.r1.
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
Untuk membaca `lsinventory-dbv.txt` di klien SQL, Anda dapat menulis PL/SQL program. Program ini menggunakan `utl_file` untuk membaca file, dan `dbms_output` untuk mencetaknya. Ini adalah paket yang diberikan oleh Oracle.
Dalam contoh program berikut, ganti *dbv* dengan versi Oracle DB Anda. Misalnya, versi DB Anda mungkin 19.0.0.0.ru-2020-04.rur-2020-04.r1.
```
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;
/
```
Atau kueri `rdsadmin.tracefile_listing`, dan gulung output ke file. Contoh berikut menggulung output ke `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Mengelola tugas penasihat
Oracle Database mencakup sejumlah penasihat. Setiap penasihat mendukung tugas otomatis dan manual. Anda dapat menggunakan prosedur di paket `rdsadmin.rdsadmin_util` untuk mengelola beberapa tugas penasihat.
Prosedur tugas penasihat tersedia dalam versi mesin berikut:
+ Oracle Database 21c (21.0.0)
+ Versi 19.0.0.0.ru-2021-01.rur-2021-01.r1 dan Oracle Database versi 19c yang lebih baru
Untuk informasi selengkapnya, lihat [Versi 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) di *Catatan Rilis Amazon RDS for Oracle.*
**Topics**
+ [
### Mengatur parameter untuk tugas penasihat
](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [
### Menonaktifkan AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [
### Mengaktifkan kembali AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Mengatur parameter untuk tugas penasihat
Untuk mengatur parameter untuk beberapa tugas penasihat, gunakan prosedur `rdsadmin.rdsadmin_util.advisor_task_set_parameter` Amazon RDS. Prosedur `advisor_task_set_parameter` memiliki parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ya | Nama tugas penasihat yang parameternya ingin Anda ubah. Nilai berikut ini valid: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Ya | Nama parameter tugas. Untuk menemukan parameter yang valid untuk tugas penasihat, jalankan kueri berikut. Ganti *p\$1task\$1name* dengan nilai yang valid untuk`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 | — | Ya | Nilai untuk parameter tugas. Untuk menemukan nilai yang valid untuk parameter tugas, jalankan kueri berikut. Ganti *p\$1task\$1name* dengan nilai yang valid untuk`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;
|
PL/SQL Program berikut ditetapkan `ACCEPT_PLANS` `FALSE` untuk`SYS_AUTO_SPM_EVOLVE_TASK`. Tugas otomatis SQL Plan Management memverifikasi rencana dan membuat laporan temuan, tetapi tidak mengembangkan rencana secara otomatis. Anda dapat menggunakan laporan untuk mengidentifikasi garis dasar rencana SQL baru dan menerimanya secara manual.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
PL/SQL Program berikut ditetapkan `EXECUTION_DAYS_TO_EXPIRE` `10` untuk`AUTO_STATS_ADVISOR_TASK`. Tugas `AUTO_STATS_ADVISOR_TASK` yang telah ditetapkan berjalan secara otomatis pada masa pemeliharaan sekali per hari. Contoh yang ada menetapkan periode retensi untuk eksekusi tugas sampai 10 hari.
```
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;
```
### Menonaktifkan AUTO\$1STATS\$1ADVISOR\$1TASK
Untuk menonaktifkan `AUTO_STATS_ADVISOR_TASK`, gunakan prosedur `rdsadmin.rdsadmin_util.advisor_task_drop` Amazon RDS. Prosedur `advisor_task_drop` menerima parameter berikut.
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ya | Nama tugas penasihat yang akan dinonaktifkan. Satu-satunya nilai yang valid adalah `AUTO_STATS_ADVISOR_TASK`. |
Perintah berikut menghapus `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Anda dapat mengaktifkan kembali `AUTO_STATS_ADVISOR_TASK` menggunakan `rdsadmin.rdsadmin_util.dbms_stats_init`.
### Mengaktifkan kembali AUTO\$1STATS\$1ADVISOR\$1TASK
Untuk mengaktifkan kembali `AUTO_STATS_ADVISOR_TASK`, gunakan prosedur `rdsadmin.rdsadmin_util.dbms_stats_init` Amazon RDS. Prosedur `dbms_stats_init` tidak menggunakan parameter.
Perintah berikut mengaktifkan kembali `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Mengangkut tablespace
Gunakan RDS paket Amazon `rdsadmin.rdsadmin_transport_util` untuk menyalin satu set tablespace dari database Oracle lokal ke instans untuk Oracle RDS DB. Pada tingkat fisik, fitur tablespace yang dapat diangkut secara bertahap menyalin file data sumber dan file metadata ke instans target Anda. Anda dapat mentransfer file menggunakan Amazon EFS atau Amazon S3. Untuk informasi selengkapnya, lihat [Bermigrasi menggunakan tablespace yang dapat dipindahkan Oracle](oracle-migrating-tts.md).
**Topics**
+ [
# Mengimpor tablespace yang diangkut ke instans DB Anda
](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [
# Mengimpor metadata tablespace yang dapat diangkut ke instans DB Anda
](rdsadmin_transport_util_import_xtts_metadata.md)
+ [
# Mencantumkan file tanpa induk setelah impor tablespace
](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [
# Menghapus file data tanpa induk setelah impor tablespace
](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Mengimpor tablespace yang diangkut ke instans DB Anda
Gunakan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` untuk memulihkan tablespace yang sebelumnya telah Anda ekspor dari instans DB sumber. Pada fase pengangkutan, Anda mencadangkan tablespace hanya baca, mengekspor metadata Data Pump, mentransfer file-file ini ke instans DB target Anda, kemudian mengimpor tablespace. Untuk informasi selengkapnya, lihat [Tahap 4: Pindahkan tablespace](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Sintaks
```
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;
```
## Parameter
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Ya | Daftar tablespace yang akan diimpor. |
| `p_directory_name` | `VARCHAR2` | — | Ya | Direktori yang berisi cadangan tablespace. |
| `p_platform_id` | `NUMBER` | `13` | Tidak | Berikan ID platform yang cocok dengan yang ditentukan selama fase pencadangan. Untuk menemukan daftar platform, lakukan kueri `V$TRANSPORTABLE_PLATFORM`. Platform default adalah Linux x86 64-bit, yang sedikit endian. |
| `p_parallel` | `INTEGER` | `0` | Tidak | Tingkat paralelisme. Secara default, paralelisme dinonaktifkan. |
## Contoh
Contoh berikut mengimpor tablespaces*TBS1*,*TBS2*, dan *TBS3* dari direktori. *DATA\$1PUMP\$1DIR* Platform sumbernya adalah Sistem berbasis AIX (64-bit), yang memiliki ID platform. `6` Anda dapat menemukan platform IDs dengan menanyakan`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
```
# Mengimpor metadata tablespace yang dapat diangkut ke instans DB Anda
Gunakan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` untuk mengimpor metadata tablespace yang dapat diangkut ke RDS Anda untuk instans DB Oracle. Selama operasi, status impor metadata ditunjukkan pada tabel `rdsadmin.rds_xtts_operation_info`. Untuk informasi selengkapnya, lihat [Langkah 5: Impor metadata tablespace pada instans DB target Anda](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Sintaks
```
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);
```
## Parameter
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Ya | Nama file Oracle Data Pump yang berisi metadata untuk tablespace yang dapat diangkut. |
| `p_directory_name` | `VARCHAR2` | — | Ya | Direktori yang berisi file Data Pump. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | Tidak | Bendera yang menunjukkan apakah akan mengecualikan statistik. |
| `p_remap_tablespace_list` | `CLOB` | NULL | Tidak | Daftar tablespace yang akan dipetakan ulang selama impor metadata. Gunakan format `from_tbs:to_tbs`. Sebagai contoh, tentukan `users:user_data`. |
| `p_remap_user_list` | `CLOB` | NULL | Tidak | Daftar skema pengguna yang akan dipetakan ulang selama impor metadata. Gunakan format `from_schema_name:to_schema_name`. Sebagai contoh, tentukan `hr:human_resources`. |
## Contoh
Contoh mengimpor metadata tablespace dari file*xttdump.dmp*, yang terletak di direktori. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Mencantumkan file tanpa induk setelah impor tablespace
Gunakan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` untuk mencantumkan file data tanpa induk setelah impor tablespace. Setelah Anda mengidentifikasi file data, Anda dapat menghapusnya dengan memanggil `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
## Sintaks
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Contoh
Contoh berikut menjalankan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`. Output menunjukkan dua file data tanpa induk.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Menghapus file data tanpa induk setelah impor tablespace
Gunakan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` untuk menghapus file data tanpa induk setelah impor tablespace. Menjalankan perintah ini akan menghasilkan file log yang menggunakan format nama `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` dalam direktori `BDUMP`. Gunakan prosedur `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` untuk menemukan file tanpa induk. Anda dapat membaca file log dengan memanggil prosedur `rdsadmin.rds_file_util.read_text_file`. Untuk informasi selengkapnya, lihat [Tahap 6: Bersihkan file sisa](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Sintaks
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameter
****
| Nama parameter | Jenis data | Default | Wajib | Deskripsi |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Ya | Direktori yang berisi file data tanpa induk. |
## Contoh
Contoh berikut menghapus file data yatim piatu di. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
Contoh berikut membaca file log yang dihasilkan oleh perintah sebelumnya.
```
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.
```