Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Amministrazione dell'istanza database RDS per Oracle
Di seguito sono riportate le attività di gestione comuni che si eseguono con una istanza database RDS per Oracle. Alcune attività sono uguali per tutte le istanze database RDS. Altri invece sono specifiche di RDS for Oracle.
Le attività riportate di seguito sono comuni a tutti i database RDS, ma per Oracle Database è necessario effettuare considerazioni particolari. Ad esempio, per connetterti a un database Oracle si utilizzano i client Oracle SQL\$1Plus e SQL Developer.
****
| Area attività | Documentazione di riferimento |
| --- | --- |
| **Classi delle istanze, storage e PIOPS** Se si sta creando un'istanza di produzione, occorre conoscere il funzionamento di classi di istanza, tipi di storage e IOPS con provisioning in Amazon RDS. | [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md) [Tipi di storage Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Implementazioni Multi-AZ** Un'istanza database in produzione deve utilizzare implementazioni Multi-AZ. Le implementazioni Multi-AZ forniscono alle istanze database maggior disponibilità, longevità dei dati e tolleranza ai guasti. | [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Se il tuo AWS account ha un cloud privato virtuale (VPC) predefinito, l'istanza DB viene creata automaticamente all'interno del VPC predefinito. Se l'account non dispone di un VPC predefinito e desideri che l'istanza database sia in un VPC, è necessario creare il VPC e i gruppi di sottoreti prima di creare l'istanza. | [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Gruppi di sicurezza** Per impostazione predefinita, le istanze database utilizzano un firewall che impedisce l'accesso. Per accedere all'istanza database, assicurati di aver creato un gruppo di sicurezza con gli indirizzi IP e la configurazione di rete corretti. | [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md) |
| **Gruppi di parametri** Se l'istanza database richiede parametri database specifici, crea un gruppo di parametri prima di creare l'istanza database. | [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Gruppi di opzioni** Se l'istanza database richiede opzioni database specifiche, crea un gruppo di opzioni prima di creare l'istanza database. | [Aggiunta di opzioni alle istanze database Oracle](Appendix.Oracle.Options.md) |
| **Connessione all'istanza database** Dopo aver creato un gruppo di sicurezza e averlo associato a un'istanza database, è possibile effettuare la connessione all'istanza database mediante un'applicazione cliente SQL standard, come Oracle SQL Plus. | [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md) |
| **Backup e ripristino** È possibile configurare l'istanza database affinché effettui backup automatici o acquisisca snapshot manuali e poi esegua il ripristino istanze da backup o snapshot. | [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md) |
| **Monitoraggio** Puoi monitorare un'istanza DB Oracle utilizzando i parametri, gli eventi e il monitoraggio avanzato di CloudWatch Amazon RDS. | [Visualizzazione dei parametri nella console Amazon RDS](USER_Monitoring.md) [Visualizzazione di eventi Amazon RDS](USER_ListEvents.md) |
| **File di log** È possibile accedere ai file di log per le istanze database Oracle. | [Monitoraggio dei file di log di Amazon RDS](USER_LogAccess.md) |
Di seguito, è riportata una descrizione per implementazioni specifiche di Amazon RDS di attività DBA comuni per RDS Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. RDS limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati. In molte delle attività, è possibile eseguire il pacchetto `rdsadmin`, che è uno strumento specifico di Amazon RDS che consente di amministrare il database.
Seguono alcune attività DBA comuni per le istanze database che eseguono Oracle:
+ [Attività di sistema](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività di database](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività di log](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività RMAN](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Diagnosi dei problemi](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Altre attività](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Puoi anche utilizzare le procedure di Amazon RDS per l'integrazione di Amazon S3 con Oracle e per l'esecuzione delle attività di database di OEM Management Agent. Per ulteriori informazioni, consultare [Integrazione Amazon S3](oracle-s3-integration.md) e [Esecuzione delle attività di database con Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Esecuzione di attività di sistema comuni per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative al sistema nelle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
**Topics**
+ [
# Disconnessione di una sessione
](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [
# Terminazione di una sessione
](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [
# Annullamento di una istruzione SQL in una sessione
](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [
# Abilitazione e disabilitazione delle sessioni limitate
](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [
# Scaricamento del pool condiviso
](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [
# Concedere privilegi SELECT o EXECUTE agli oggetti SYS
](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [
# Revoca del privilegio SELECT o EXECUTE in oggetti SYS
](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [
# Gestione delle viste RDS\$1X\$1 per le istanze database Oracle
](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [
# Concessione di privilegi a utenti non-master
](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [
# Creazione delle funzionalità personalizzate per verificare le password
](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [
## Impostazione di un server DNS personalizzato
](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [
# Impostazione e annullamento dell'impostazione degli eventi diagnostici di sistema
](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Disconnessione di una sessione
Puoi usare la procedura in Amazon RDS per disconnettere la sessione corrente terminando il processo server dedicato `rdsadmin.rdsadmin_util.disconnect`. La procedura `disconnect` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `method` | varchar | “IMMEDIATO” | No | I valori validi sono `'IMMEDIATE'` e `'POST_TRANSACTION'`. |
L'esempio seguente disconnette una sessione.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Per ottenere l'identificatore di sessione e il numero di serie di sessione, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni per l'utente `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Il database deve essere aperto per utilizzare questo metodo. Per ulteriori informazioni sulla disconnessione di una sessione, consulta [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) nella documentazione di Oracle.
# Terminazione di una sessione
Per terminare una sessione, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_util.kill`. La procedura `kill` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `method` | varchar | null | No | I valori validi sono `'IMMEDIATE'` e `'PROCESS'`. Se specifichi `IMMEDIATE`, ottieni lo stesso effetto dell'istruzione riportata di seguito: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Se specifichi `PROCESS`, vengono terminati i processi associati a una sessione. Specifica `PROCESS` solo se la terminazione della sessione con `IMMEDIATE` non riesce. |
Per ottenere l'identificatore di sessione e il numero di serie di sessione, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni per l'utente *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Nell'esempio seguente viene terminata una sessione.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
Nell'esempio seguente vengono terminati i processi associati a una sessione.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Annullamento di una istruzione SQL in una sessione
Per annullare un'istruzione SQL in una sessione, puoi utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_util.cancel`.
**Nota**
Questa procedura è supportata per Oracle Database 19c (19.0.0) e per tutte le versioni principali e secondarie di RDS for Oracle.
La procedura `cancel` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `sql_id` | varchar2 | null | No | L'identificatore SQL nell'istruzione SQL. |
L'esempio seguente annulla un'istruzione SQL in una sessione.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Per ottenere l'identificatore di sessione, il numero di serie di sessione e l'identificativo SQL di un'istruzione SQL, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni e gli identificativi SQL per l'utente `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Abilitazione e disabilitazione delle sessioni limitate
Puoi usare la procedura in Amazon RDS per abilitare e disabilitare sessioni limitate `rdsadmin.rdsadmin_util.restricted_session`. La procedura `restricted_session` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Sì | Descrizione |
| --- | --- | --- | --- | --- |
| `p_enable` | booleano | true | No | Impostato su `true` per abilitare le sessioni limitate, su `false` per disabilitare le sessioni limitate. |
L'esempio seguente mostra come abilitare e disabilitare le sessioni limitate.
```
/* 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
```
# Scaricamento del pool condiviso
Puoi usare la procedura in Amazon RDS per scaricare il pool condiviso `rdsadmin.rdsadmin_util.flush_shared_pool`. La procedura `flush_shared_pool` non ha parametri.
L'esempio seguente scarica il pool condiviso.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Scaricamento della cache del buffer
Puoi usare la procedura in Amazon RDS per scaricare la cache del buffe `rdsadmin.rdsadmin_util.flush_buffer_cache`. La procedura `flush_buffer_cache` non ha parametri.
L'esempio seguente scarica la cache del buffer.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Scaricamento della cache smart flash del database
Per scaricare la cache smart flash del database, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.flush_flash_cache`. La procedura `flush_flash_cache` non ha parametri. Nell'esempio seguente viene scaricata la cache smart flash del database.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Per ulteriori informazioni sull'utilizzo della cache smart flash del database con RDS per Oracle, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Concedere privilegi SELECT o EXECUTE agli oggetti SYS
Solitamente si trasferiscono i privilegi utilizzando ruoli che possono contenere molti oggetti. Puoi concedere privilegi a un singolo oggetto utilizzando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.grant_sys_object`. La procedura concede solo i privilegi già concessi all'utente master tramite un ruolo o una concessione diretta.
La procedura `grant_sys_object` include i seguenti parametri.
**Importante**
Per tutti i valori dei parametri, utilizzare maiuscole a meno che non sia stato creato l'utente con un identificatore con distinzione tra maiuscole e minuscole. Ad esempio, se esegui `CREATE USER myuser` o `CREATE USER MYUSER`, il dizionario dati memorizza `MYUSER`. Tuttavia, se si utilizzano virgolette doppie in `CREATE USER "MyUser"`, il dizionario dati memorizza `MyUser`.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sì | Il nome dell'oggetto per il quale concedere privilegi. L'oggetto può essere una directory, funzione, pacchetto, procedura, sequenza, tabella o visualizzazione. I nomi degli oggetti devono essere scritti allo stesso modo in cui appaiono in `DBA_OBJECTS`. La maggior parte degli oggetti di sistema è scritta in maiuscolo, quindi consigliamo di provare prima il maiuscolo. |
| `p_grantee` | varchar2 | — | Sì | Il nome dell'oggetto al quale concedere privilegi. L'oggetto può essere uno schema o un ruolo. |
| `p_privilege` | varchar2 | null | Sì | — |
| `p_grant_option` | booleano | false | No | Impostato su `true` per utilizzare l'opzione concessione. |
L'esempio seguente concede certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1`.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
L'esempio seguente concede certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1` con l'opzione concessione.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Per poter concedere privilegi per un oggetto, quei privilegi devono essere concessi all'account direttamente con l'opzione concessione o tramite un ruolo concesso utilizzando `with admin option`. Nel caso più comune, potresti voler concedere `SELECT` a una visualizzazione DBA concessa al ruolo `SELECT_CATALOG_ROLE`. Se quel ruolo non è già concesso direttamente all'utente utilizzando `with admin option`, non sarai in grado di trasferire il privilegio. Se disponi del privilegio DBA, puoi concedere il ruolo direttamente a un altro utente.
L'esempio seguente concede `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE` a `USER1`. Siccome `with admin option` viene utilizzato, `USER1` può ora garantire l'accesso agli oggetti SYS che sono stati concessi a `SELECT_CATALOG_ROLE`.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Gli oggetti già concessi a `PUBLIC` non devono essere concessi nuovamente. Se utilizzi la procedura `grant_sys_object` per concedere nuovamente l'accesso, la chiamata di procedura va a buon fine.
# Revoca del privilegio SELECT o EXECUTE in oggetti SYS
Puoi revocare privilegi in un singolo oggetto usando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.revoke_sys_object`. La procedura revoca solo i privilegi che l'account master è già stato concesso tramite un ruolo o una concessione diretta.
La procedura `revoke_sys_object` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sì | Il nome dell'oggetto per il quale revocare privilegi. L'oggetto può essere una directory, funzione, pacchetto, procedura, sequenza, tabella o visualizzazione. I nomi degli oggetti devono essere scritti allo stesso modo in cui appaiono in `DBA_OBJECTS`. LA maggior parte degli oggetti di sistema sono scritti in maiuscolo, quindi consigliamo di provare prima il maiuscolo. |
| `p_revokee` | varchar2 | — | Sì | Il nome dell'oggetto per il quale revocare privilegi. L'oggetto può essere uno schema o un ruolo. |
| `p_privilege` | varchar2 | null | Sì | — |
L'esempio seguente revoca certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1`.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Gestione delle viste RDS\$1X\$1 per le istanze database Oracle
Potrebbe essere necessario accedere alle tabelle fisse `SYS.X$`, accessibili solo da `SYS`. Per creare viste `SYS.RDS_X$` sulle tabelle `X$` idonee, utilizza le procedure incluse nel pacchetto `rdsadmin.rdsadmin_util`. All’utente master viene automaticamente concesso il privilegio `SELECT … WITH GRANT OPTION` sulle viste `RDS_X$`.
Le procedure `rdsadmin.rdsadmin_util` sono disponibili nei seguenti casi:
+ Istanze database esistenti che non sono mai state aggiornate e utilizzano le seguenti release:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` e versioni successive alla 21c
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` e versioni successive alla 19c
+ Qualsiasi nuova istanza database che crei
+ Qualsiasi istanza database esistente che hai aggiornato
**Importante**
Internamente, il pacchetto `rdsadmin.rdsadmin_util` crea viste sulle tabelle `X$`. Le tabelle `X$` sono oggetti di sistema interni che non sono descritti nella documentazione di Oracle Database. Si consiglia di testare viste specifici nel database non di produzione e creare viste nel database di produzione solo sotto la guida del supporto Oracle.
## Elenca le tabelle fisse X\$1 idonee per l’uso nelle viste RDS\$1X\$1
Per elencare le tabelle X\$1 idonee all’uso nelle viste `RDS_X$`, utilizza la procedura RDS `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. Questa procedura non accetta parametri. Le seguenti istruzioni elencano tutte le tabelle `X$` idonee (output di esempio incluso).
```
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'
```
L’elenco delle tabelle `X$` idonee può cambiare nel corso del tempo. Per assicurarti che l’elenco delle tabelle fisse `X$` idonee sia aggiornato, esegui di nuovo `list_allowed_sys_x$_views` periodicamente.
## Creazione di viste SYS.RDS\$1X\$1
Per creare una vista `RDS_X$` su una tabella `X$` idonea, utilizza la procedura RDS `rdsadmin.rdsadmin_util.create_sys_x$_view`. Puoi creare viste solo per le tabelle elencate nell’output di `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procedura `create_sys_x$_view` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sì | Un nome tabella `X$` valido. Il valore deve essere una delle tabelle `X$` segnalati da `list_allowed_sys_x$_views`. |
| `p_force_creation` | Boolean | FALSE | No | Un valore che indica se forzare la creazione di una vista `RDS_X$` già esistente per una tabella `X$`. Per impostazione predefinita, RDS non crea una vista se questa esiste già. Per forzare la creazione, imposta questo parametro su `TRUE`. |
Il seguente esempio crea una vista `SYS.RDS_X$KGLOB` sulla tabella `X$KGLOB`. Il formato per il nome della vista è `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
La seguente query sul dizionario di dati elenca la vista `SYS.RDS_X$KGLOB` e ne mostra lo stato. All’utente master viene automaticamente concesso il privilegio `SELECT ... WITH GRANT OPTION` su questa vista.
```
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
```
**Importante**
Non è garantito che le tabelle `X$` restino invariate prima e dopo l’esecuzione di un aggiornamento. RDS per Oracle elimina e ricrea le viste `RDS_X$` sulle tabelle `X$` durante un aggiornamento del motore. Quindi concede il privilegio `SELECT ... WITH GRANT OPTION` all’utente master. Dopo un aggiornamento, concedi i privilegi agli utenti del database secondo necessità sulle viste `RDS_X$` corrispondenti.
## Elenco delle viste SYS.RDS\$1X\$1
Per elencare le viste `RDS_X$` esistenti, utilizza la procedura RDS `rdsadmin.rdsadmin_util.list_created_sys_x$_views`. La procedura elenca solo le viste create dalla procedura `create_sys_x$_view`. L’esempio seguente elenca le tabelle `X$` con le viste `RDS_X$` corrispondenti (output di esempio incluso).
```
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.
```
## Eliminazione delle viste RDS\$1X\$1
Per eliminare una vista `SYS.RDS_X$`, utilizza la procedura RDS `rdsadmin.rdsadmin_util.drop_sys_x$_view`. Puoi impostare solo le viste elencate nell’output di `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procedura `drop_sys_x$_view` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sì | Un nome della tabella fissa `X$` valido. Il valore deve essere una delle tabelle fisse `X$` riportate da `list_created_sys_x$_views`. |
L’esempio seguente elimina la vista `RDS_X$KGLOB` creata nella tabella `X$KGLOB`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
L’esempio seguente mostra che la vista `SYS.RDS_X$KGLOB` è stata eliminata (incluso l’output di esempio).
```
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
```
# Concessione di privilegi a utenti non-master
È possibile concedere privilegi per molti oggetti nello schema `SYS` utilizzando il ruolo `SELECT_CATALOG_ROLE`. Il ruolo `SELECT_CATALOG_ROLE` offre agli utenti privilegi `SELECT` per visualizzazioni del dizionario dati. L'esempio seguente concede il ruolo `SELECT_CATALOG_ROLE` a un utente denominato `user1`.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
È possibile concedere privilegi `EXECUTE` per molti oggetti nello schema `SYS` utilizzando il ruolo `EXECUTE_CATALOG_ROLE`. Il ruolo `EXECUTE_CATALOG_ROLE` offre agli utenti privilegi `EXECUTE` per pacchetti e procedure nel dizionario dati. L'esempio seguente concede il ruolo `EXECUTE_CATALOG_ROLE` a un utente denominato *user1*.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
L'esempio seguente ottiene le autorizzazioni che permettono i ruoli `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE`.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
L'esempio seguente crea un utente non-master denominato `user1`, concede il privilegio `CREATE SESSION` e il privilegio `SELECT` in un database denominato *sh.sales*.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Creazione delle funzionalità personalizzate per verificare le password
Puoi creare una funzionalità di verifica della password personalizzata in due modi:
+ Se desideri utilizzare la verifica standard e archiviare la funzione nello schema `SYS`, utilizza la procedura `create_verify_function`.
+ Se desideri utilizzare la verifica personalizzata p desideri archiviare la funzione nello schema `SYS`, utilizza la procedura `create_passthrough_verify_fcn`.
# La procedura create\$1verify\$1function
Puoi creare una funzione personalizzata per verificare le password usando la procedura in Amazon RDS `rdsadmin.rdsadmin_password_verify.create_verify_function`. La procedura `create_verify_function` è supportata per tutte le versioni di RDS per Oracle.
La procedura `create_verify_function` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sì | Il nome per la funzionalità personalizzata. La funzionalità viene creata per te nello schema SYS. Assegni questa funzione a profili di utente. |
| `p_min_length` | numero | 8 | No | Il numero minimo di caratteri necessari. |
| `p_max_length` | numero | 256 | No | Il numero massimo di caratteri permessi. |
| `p_min_letters` | numero | 1 | No | Il numero minimo di lettere necessarie. |
| `p_min_uppercase` | numero | 0 | No | Il numero minimo di lettere maiuscole necessarie. |
| `p_min_lowercase` | numero | 0 | No | Il numero minimo di lettere minuscole necessarie. |
| `p_min_digits` | numero | 1 | No | Il numero minimo di cifre necessarie. |
| `p_min_special` | numero | 0 | No | Il numero minimo di caratteri speciali necessari. |
| `p_min_different_chars` | numero | 3 | No | Il numero minimo di caratteri diversi necessari tra la password vecchia e quella nuova. |
| `p_disallow_username` | booleano | true | No | Impostato su `true` per non consentire il nome utente nella password. |
| `p_disallow_reverse` | booleano | true | No | Impostato su `true` per non consentire l'inversione del nome utente nella password. |
| `p_disallow_db_name` | booleano | true | No | Impostato su `true` per non consentire il database o il nome del server nella password. |
| `p_disallow_simple_strings` | booleano | true | No | Impostato su `true` per non consentire stringhe semplici come password. |
| `p_disallow_whitespace` | booleano | false | No | Impostato su `true` per non consentire gli spazi vuoti nella password. |
| `p_disallow_at_sign` | booleano | false | No | Impostare su `true` per non consentire il carattere @ nella password. |
Puoi creare funzionalità multiple di verifica della password.
Ci sono limitazioni riguardo al nome della funzionalità personalizzata. La funzione personalizzata non può avere lo stesso nome di un oggetto di sistema esistente. La lunghezza del nome non può superare i 30 caratteri. Inoltre, il nome deve includere una delle seguenti stringhe: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` o `STRENGTH`.
L'esempio seguente crea una funzionalità denominata `CUSTOM_PASSWORD_FUNCTION`. La funzionalità richiede una password che includa almeno 12 caratteri, 2 caratteri maiuscoli, 1 cifra, 1 carattere speciale e che non consenta il carattere @.
```
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;
/
```
Per vedere il testo della funzionalità di verifica, eseguire una query a `DBA_SOURCE`. L'esempio seguente ottiene il testo da una funzionalità di password personalizzata denominata `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Per associare la funzionalità di verifica con un profilo utente, utilizza `ALTER PROFILE`. L'esempio seguente associa una PL/SQL funzione di verifica `CUSTOM_PASSWORD_FUNCTION` denominata al profilo `DEFAULT` utente. `PASSWORD_VERIFY_FUNCTION`è il nome della risorsa del profilo Oracle.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Per vedere quali profili utente sono associati a quali funzioni di verifica, interroga`DBA_PROFILES`. L'esempio seguente ottiene i profili che sono associati alla funzionalità di verifica personalizzata denominata `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
```
L'esempio seguente ottiene tutti i profili e la funzionalità di verifica della password alla quale sono associati.
```
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
```
# La procedura create\$1passthrough\$1verify\$1fcn
La procedura `create_passthrough_verify_fcn` è supportata per tutte le versioni di RDS per Oracle.
Puoi creare una funzione personalizzata per verificare le password usando la procedura in Amazon RDS `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn`. La procedura `create_passthrough_verify_fcn` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sì | Il nome per la funzionalità di verifica personalizzata. Questa è una funzionalità wrapper creata per te nello schema SYS e non contiene nessuna logica di verifica. Assegni questa funzione a profili di utente. |
| `p_target_owner` | varchar2 | — | Sì | Il proprietario dello schema per la funzionalità di verifica personalizzata. |
| `p_target_function_name` | varchar2 | — | Sì | Il nome della funzionalità personalizzata esistente che contiene una logica di verifica. La funzionalità personalizzata deve restituire un booleano. La funzionalità deve restituire `true` se la password è valida e `false` se la password non è valida. |
L'esempio seguente crea una funzionalità di verifica della password che utilizza la logica dalla funzionalità denominata `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;
/
```
Per associare la funzionalità di verifica con un profilo utente, utilizza `alter profile`. L'esempio seguente associa la funzionalità di verifica con un profilo utente `DEFAULT`.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Impostazione di un server DNS personalizzato
Amazon RDS supporta l'accesso di rete in uscita sull'istanza database che esegue Oracle. Per ulteriori informazioni sull'accesso di rete in uscita, inclusi i prerequisiti, consulta [Configurazione dell'accesso UTL\$1HTTP utilizzando certificati e un portafoglio Oracle](Oracle.Concepts.ONA.md).
Amazon RDS Oracle permette la risoluzione Domain Name Service (DNS) da un server DNS personalizzato di proprietà del cliente. È possibile risolvere solo nomi di dominio completamente qualificati dall'istanza database Amazon RDS tramite il server DNS personalizzato.
Dopo aver impostato il server dei nomi DNS personalizzato, ci vogliono circa 30 minuti per propagare le modifiche all'istanza database. Dopo che le modifiche vengono propagate all'istanza database, tutto il traffico di rete in uscita che richiede una ricerca DNS esegue una query al server DNS tramite la porta 53.
Per impostare un server DNS personalizzato per l'istanza database Amazon RDS for Oracle, procedi come segue:
+ Dal set di opzioni DHCP collegate al Virtual Private Cloud (VPC), imposta l'opzione `domain-name-servers` sull'indirizzo IP del server dei nomi DNS. Per ulteriori informazioni, consulta la pagina relativa ai [Set di opzioni DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**Nota**
L'opzione `domain-name-servers` accetta fino a quattro valori, ma l'istanza database Amazon RDS usa solo il primo valore.
+ Assicurati che il server DNS possa risolvere tutte le query di ricerca, compresi i nomi DNS pubblici, i nomi DNS privati Amazon EC2 e i nomi DNS specifici per i clienti. Se il traffico di rete in uscita contiene ricerche DNS che il server DNS non può gestire, il server DNS deve avere fornitori DNS upstream appropriati configurati.
+ Configura il server DNS per produrre risposte UDP (User Datagram Protocol) di 512 byte o meno.
+ Configura il server DNS per produrre risposte TCP (Transmission Control Protocol) di 1024 byte o meno.
+ Configura il server DNS per consentire il traffico in entrata dalle istanze database Amazon RDS tramite la porta 53. Se il server DNS si trova in un Amazon VPC, il VPC deve avere un gruppo di sicurezza che contiene regole in entrata che permettono traffico UDP e TCP tramite la porta 53. Se il server DNS non si trova in un Amazon VPC, deve avere una whitelist firewall appropriata per permettere traffico in entrata UDP e TCP tramite la porta 53.
Per ulteriori informazioni, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Aggiunta e rimozione di regole](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Configura il VPC dell'istanza database Amazon RDS per permettere traffico in uscita tramite la porta 53. Il VPC deve avere un gruppo di sicurezza che contiene regole in uscita che permettono traffico UDP e TCP tramite la porta 53.
Per ulteriori informazioni, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Aggiunta e rimozione di regole](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Il percorso di routing tra l'istanza database Amazon RDS e il server DNS deve essere configurata correttamente per consentire traffico DNS.
+ Se l'istanza database Amazon RDS e il server DNS non si trovano nello stesso VPC, una connessione peer deve essere configurata tra loro. Per ulteriori informazioni, consulta [Che cos'è il VPC in peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Impostazione e annullamento dell'impostazione degli eventi diagnostici di sistema
Per impostare e annullare l'impostazione degli eventi diagnostici a livello di sessione, è possibile utilizzare l'istruzione Oracle SQL `ALTER SESSION SET EVENTS`. Tuttavia, per impostare gli eventi a livello di sistema non è possibile utilizzare Oracle SQL. Utilizzare invece le procedure evento di sistema nel pacchetto `rdsadmin.rdsadmin_util`. Le procedure evento di sistema sono disponibili nelle seguenti versioni del motore:
+ Tutte le versioni di Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 e versioni successive di Oracle Database 19c
Per ulteriori informazioni, consulta [Versione 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) nelle *Note di rilascio di Amazon RDS per Oracle*.
**Importante**
Internamente, il pacchetto `rdsadmin.rdsadmin_util` imposta gli eventi utilizzando l'istruzione `ALTER SYSTEM SET EVENTS`. Questa istruzione `ALTER SYSTEM` non è documentata nella documentazione di Oracle Database. Alcuni eventi di diagnostica del sistema possono generare grandi quantità di informazioni di traccia, causare contese o influire sulla disponibilità del database. Si consiglia di testare eventi diagnostici specifici nel database non di produzione e impostare gli eventi nel database di produzione solo sotto la guida del supporto Oracle.
## Elenco degli eventi diagnostici di sistema consentiti
Per elencare gli eventi di sistema che è possibile impostare, attenersi alla Amazon RDS procedura `rdsadmin.rdsadmin_util.list_allowed_system_events`. Questa procedura non accetta parametri.
Nell'esempio seguente sono elencati tutti gli eventi di sistema che è possibile impostare.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
Nell'output di esempio seguente sono elencati i numeri degli eventi e le relative descrizioni. Utilizzare le Amazon RDS procedure `set_system_event` per impostare questi eventi e `unset_system_event` per disimpostarli.
```
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:
```
**Nota**
L'elenco degli eventi di sistema consentiti può cambiare nel tempo. Per assicurarti di avere l'elenco degli eventi idonei più recente, usa `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Impostazione degli eventi di diagnostica del sistema
Per impostare un evento di sistema, usa la Amazon RDS procedura `rdsadmin.rdsadmin_util.set_system_event`. È possibile impostare solo gli eventi elencati nell'output di `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procedura `set_system_event` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_event` | numero | — | Sì | Il numero dell'evento di sistema. Il valore deve essere uno dei numeri degli eventi segnalati da `list_allowed_system_events`. |
| `p_level` | numero | — | Sì | Il livello dell'evento. Per le descrizioni dei valori di livello diversi, consulta la documentazione di Oracle Database o Oracle Support. |
La procedura `set_system_event` costruisce ed esegue le istruzioni `ALTER SYSTEM SET EVENTS` richieste secondo i seguenti principi:
+ Il tipo di evento (`context` o `errorstack`) viene determinato automaticamente.
+ Un'istruzione nel modulo `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` imposta gli eventi di contesto. Questa notazione è equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Un'istruzione nel modulo `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` imposta gli eventi stack di errore. Questa notazione è equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
Nell'esempio seguente viene impostato l'evento 942 al livello 3 e l'evento 10442 al livello 10. L'output di esempio è incluso.
```
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.
```
## Elenco degli eventi diagnostici di sistema impostati
Per elencare gli eventi di sistema correntemente impostati, utilizza la Amazon RDS procedura `rdsadmin.rdsadmin_util.list_set_system_events`. Questa procedura segnala solo gli eventi impostati a livello di sistema da `set_system_event`.
Nell'esempio seguente vengono elencati gli eventi di sistema attivi.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
Nell'output di esempio seguente viene illustrato l'elenco degli eventi, il tipo di evento, il livello in cui gli eventi sono attualmente impostati e l'ora in cui è stato impostato l'evento.
```
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.
```
## Annullamento dell'impostazione degli eventi diagnostici del sistema
Per annullare l'impostazione di un evento di sistema, attenersi alla Amazon RDS procedura `rdsadmin.rdsadmin_util.unset_system_event`. È possibile annullare solo gli eventi elencati nell'output di `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procedura `unset_system_event` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_event` | numero | — | Sì | Il numero dell'evento di sistema. Il valore deve essere uno dei numeri degli eventi segnalati da `list_allowed_system_events`. |
Nell'esempio seguente vengono disimpostati gli eventi 942 e 10442. L'output di esempio è incluso.
```
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.
```
# Esecuzione di attività di database comuni per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative ai database nelle istanze database Amazon RDS che eseguono Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Amazon RDS limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati.
**Topics**
+ [
# Modifica del nome globale di un database
](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [
# Utilizzo delle tablespace in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [
# Utilizzo dei file temporanei in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [
# Ridimensionamento di tablespace, file di dati e file temporanei in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [
# Spostamento di dati tra volumi di storage in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [
# Utilizzo di tabelle esterne in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Modifica del nome globale di un database
Puoi usare la procedura in Amazon RDS per modificare il nome globale di un database `rdsadmin.rdsadmin_util.rename_global_name`. La procedura `rename_global_name` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Sì | Il nuovo nome globale per il database. |
Il database deve essere aperto affinché la modifica del nome abbia luogo. Per ulteriori informazioni sulla modifica del nome globale di un database, consulta [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) nella documentazione di Oracle.
L'esempio seguente modifica il nome globale del database in `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Utilizzo delle tablespace in RDS per Oracle
È possibile utilizzare i tablespace con RDS for Oracle, un'unità di archiviazione logica che archivia i dati del database.
**Importante**
Se l'istanza DB dispone di repliche, si consiglia di utilizzare le impostazioni dei gruppi di parametri anziché le modifiche a livello di sessione per gestire le posizioni dei file predefinite. Le modifiche a livello di sessione alle posizioni dei file predefinite nell'istanza principale non si riflettono automaticamente nelle repliche. L'utilizzo delle impostazioni dei gruppi di parametri garantisce la coerenza delle posizioni dei file tra le istanze primarie e di replica.
**Topics**
+ [
## Specificazione delle posizioni dei file di database in RDS for Oracle
](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [
## Creazione e dimensionamento di tablespace in RDS for Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [
## Creazione di tablespace su volumi di archiviazione aggiuntivi in RDS per Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [
## Impostazione del tablespace predefinito in RDS per Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [
## Impostazione del tablespace temporaneo predefinito in RDS per Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [
## Creazione di un tablespace temporaneo nell’archivio dell’istanza
](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Specificazione delle posizioni dei file di database in RDS for Oracle
RDS per Oracle utilizza Oracle Managed Files (OMF) per denominare i file di database. Quando si creano file di database, il database ricava l'impostazione in base all'impostazione corrente del parametro di inizializzazione. `DB_CREATE_FILE_DEST`
Il valore predefinito del parametro di `DB_CREATE_FILE_DEST` inizializzazione è `/rdsdbdata/db` per i database autonomi e `/rdsdbdata/db/pdb` per l'architettura containerizzata (CDB/MT). Se l'istanza DB dispone di volumi di storage aggiuntivi, è possibile impostare le posizioni dei volumi. `DB_CREATE_FILE_DEST` Ad esempio, se la tua istanza ha un volume montato`/rdsdbdata/db`, puoi `DB_CREATE_FILE_DEST` impostarlo su questo valore.
È possibile modificare il `DB_CREATE_FILE_DEST` parametro a livello di sessione o a livello di istanza del database Oracle.
### Modifica di DB\$1CREATE\$1FILE\$1SET a livello di istanza
Per modificare il parametro a livello di istanza, aggiorna il parametro nel gruppo di parametri assegnato all'istanza DB e applicalo. Per ulteriori informazioni, consultare [Parametri di inizializzazione di RDS per Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) e [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Modifica di DB\$1CREATE\$1FILE\$1DEST a livello di sessione
È possibile modificare il parametro a livello di sessione eseguendo un'`ALTER SESSION`istruzione. Questo approccio è utile quando si desidera creare file di database in una posizione specifica per una sessione particolare senza influire sull'intera istanza.
L'esempio seguente mostra come controllare il valore corrente del parametro e modificarlo per la sessione:
```
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
```
## Creazione e dimensionamento di tablespace in RDS for Oracle
Quando si creano tablespace, il database crea i file di dati nel volume di archiviazione specificato dal parametro di inizializzazione al momento della `DB_CREATE_FILE_DEST` creazione. Per impostazione predefinita, se non si specifica una dimensione del file di dati, gli spazi di tabella vengono creati con il valore predefinito di `AUTOEXTEND ON` e nessuna dimensione massima. Nell'esempio seguente, il tablespace è estensibile automaticamente. *users1*
```
CREATE TABLESPACE users1;
```
A causa di queste impostazioni predefinite, i tablespace possono aumentare e occupare tutto lo spazio di archiviazione allocato. Consigliamo di specificare una dimensione massima appropriata per tablespace permanenti e temporanei e che monitori attentamente l’utilizzo di spazio.
L'esempio seguente crea un tablespace denominato *users2* con una dimensione iniziale di 1 gigabyte. Poiché la dimensione di un file di dati è specificata, ma `AUTOEXTEND ON` non è specificato, lo spazio di tabella non è estensibile automaticamente.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
L'esempio seguente crea una tablespace denominata *users3* con una dimensione iniziale di 1 gigabyte, estensione automatica attivata e una dimensione massima di 10 gigabyte.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
L'esempio seguente crea un tablespace temporaneo denominato. *temp01*
```
CREATE TEMPORARY TABLESPACE temp01;
```
Puoi ridimensionare un tablespace di file di grandi dimensioni utilizzando `ALTER TABLESPACE`. Puoi specificare le dimensioni in kilobyte (K), megabyte (M), gigabyte (G), o terabyte (T). L'esempio seguente ridimensiona uno spazio tabella di un file di grandi dimensioni denominato *users\$1bf* a 200 MB.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
L'esempio seguente aggiunge un file di dati aggiuntivo a una tablespace di file di piccole dimensioni denominata. *users\$1sf*
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Creazione di tablespace su volumi di archiviazione aggiuntivi in RDS per Oracle
Per creare un tablespace su un volume di archiviazione aggiuntivo, modificate il `DB_CREATE_FILE_DEST` parametro impostando la posizione del volume. L'esempio seguente imposta la posizione del file su. `/rdsdbdata2/db`
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
Nell'esempio seguente, create una tablespace sul volume aggiuntivo. `/rdsdbdata2/db`
```
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
```
Per creare una tablespace di file di piccole dimensioni e distribuirne i file di dati su diversi volumi di archiviazione, aggiungi i file di dati alla tablespace dopo averla creata. Nell'esempio seguente, crei una tablespace con i file di dati nella posizione predefinita di. `/rdsdbdata/db` Quindi impostate la destinazione predefinita su. `/rdsdbdata/db2` Quando aggiungete un file di dati alla tablespace appena creata, il database memorizza il file in. `/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
```
## Impostazione del tablespace predefinito in RDS per Oracle
Puoi usare la procedura in Amazon RDS per impostare lo spazio di tabella predefinito `rdsadmin.rdsadmin_util.alter_default_tablespace`. La procedura `alter_default_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sì | Il nome dello spazio tabella predefinito. |
L'esempio seguente imposta il tablespace predefinito su: *users2*
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Impostazione del tablespace temporaneo predefinito in RDS per Oracle
Puoi usare la procedura in Amazon RDS per impostare lo spazio di tabella temporaneo predefinito `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`. La procedura `alter_default_temp_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sì | Il nome dello spazio tabella predefinito temporaneo. |
L'esempio seguente imposta il tablespace temporaneo predefinito su. *temp01*
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Creazione di un tablespace temporaneo nell’archivio dell’istanza
Per creare un tablespace temporaneo nell’archivio dell’istanza, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace`. La procedura `create_inst_store_tmp_tblspace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo. |
L'esempio seguente crea il tablespace temporaneo *temp01* nell'instance store.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**Importante**
Durante l'esecuzione di `rdsadmin_util.create_inst_store_tmp_tblspace`, lo spazio di tabella temporaneo appena creato non viene impostato automaticamente come spazio di tabella temporaneo predefinito. Per impostarlo come predefinito, consulta [Impostazione del tablespace temporaneo predefinito in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Utilizzo dei file temporanei in RDS per Oracle
## Aggiunta di un file temporaneo all'archivio dell'istanza in una replica di lettura
Quando si crea uno spazio di tabella temporaneo in un'istanza database primaria, la replica di lettura non crea i file temporanei. Supponi che nella replica di lettura esista uno spazio di tabella temporaneo vuoto per uno dei seguenti motivi:
+ Hai eliminato un file temporaneo dallo spazio di tabella temporaneo nella replica di lettura. Per ulteriori informazioni, consulta [Rilascio di file temporanei in una replica di lettura](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Hai creato un nuovo spazio di tabella temporaneo nell'istanza database primaria. In questo caso, RDS per Oracle sincronizza i metadati con la replica di lettura.
Puoi aggiungere un file temporaneo allo spazio di tabella temporaneo vuoto e archiviare il file temporaneo nell'archivio dell'istanza. Per creare un file temporaneo nell'archivio dell'istanza, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.add_inst_store_tempfile`. Puoi utilizzare questa procedura solo in una replica di lettura. La procedura include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo nella replica di lettura. |
Nell'esempio seguente, il tablespace temporaneo vuoto *temp01* esiste nella replica di lettura. Esegui il comando seguente per creare un file temporaneo per la tabella e archiviarlo nell'archivio dell'istanza.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Rilascio di file temporanei in una replica di lettura
Non è possibile rilasciare uno spazio di tabella temporaneo esistente in una replica di lettura. Puoi modificare l'archivio dei file temporanei in una replica di lettura da Amazon EBS nell'archivio dell'istanza o dall'archivio dell'istanza ad Amazon EBS. Per raggiungere questi obiettivi, effettua le seguenti operazioni:
1. Rilascia i file temporanei correnti nello spazio di tabella temporaneo nella replica di lettura.
1. Crea nuovi file temporanei in un altro archivio.
Per rilasciare i file temporanei, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util. drop_replica_tempfiles`. Puoi utilizzare questa procedura solo nelle repliche di lettura. La procedura `drop_replica_tempfiles` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo nella replica di lettura. |
Supponiamo che un tablespace temporaneo denominato *temp01* risieda nell'instance store della replica di lettura. Rilascia tutti i file temporanei in questo spazio di tabella eseguendo il comando seguente.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Ridimensionamento di tablespace, file di dati e file temporanei in RDS per Oracle
Come impostazione predefinita, gli spazi tabelle Oracle sono creati con l'estensione automatica attivata e nessuna dimensione massima. A causa delle impostazioni predefinite, gli spazi tabella possono a volte diventare troppo grandi. Consigliamo di specificare una dimensione massima appropriata per tablespace permanenti e temporanei e che monitori attentamente l’utilizzo di spazio.
## Ridimensionamento degli spazi di tabella permanenti
Per ridimensionare uno spazio di tabella permanente in un'istanza database RDS per Oracle, utilizza una delle seguenti procedure Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
La procedura `resize_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | numero | — | Sì | L'identificatore del file di dati da ridimensionare. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file di dati. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `autoextend_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | numero | — | Sì | L'identificatore del file di dati da ridimensionare. |
| `p_autoextend_state` | varchar2 | — | Sì | Lo stato della funzionalità di estensione automatica. Specifica `ON` per estendere automaticamente il file di dati e `OFF` per disattivare l'estensione automatica. |
| `p_next` | varchar2 | — | No | Le dimensioni del successivo incremento del file di dati. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
| `p_maxsize` | varchar2 | — | No | Lo spazio massimo su disco consentito per l'estensione automatica. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). È possibile specificare `UNLIMITED` per rimuovere il limite di dimensione del file. |
L'esempio seguente ridimensiona il file di dati da 4 a 500 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
L'esempio seguente disattiva l'estensione automatica per il file di dati 4. Attiva l'estensione automatica per il file di dati 5, con un incremento di 128 MB e nessuna dimensione massima.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Ridimensionamento degli spazi di tabella temporanei
Per ridimensionare uno spazio di tabella temporaneo in un'istanza database RDS per Oracle, inclusa una replica di lettura, utilizza una delle seguenti procedure Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
La procedura `resize_temp_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Sì | Il nome dello spazio tabella temporaneo da ridimensionare. |
| `p_size` | varchar2 | — | Sì | La dimensione dello spazio di tabella. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `resize_tempfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | numero | — | Sì | L'identificatore del file temporaneo da ridimensionare. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file temporaneo. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `autoextend_tempfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | numero | — | Sì | L'identificatore del file temporaneo da ridimensionare. |
| `p_autoextend_state` | varchar2 | — | Sì | Lo stato della funzionalità di estensione automatica. Specifica `ON` per estendere automaticamente il file temporaneo e `OFF` per disattivare l'estensione automatica. |
| `p_next` | varchar2 | — | No | Le dimensioni del successivo incremento del file temporaneo. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
| `p_maxsize` | varchar2 | — | No | Lo spazio massimo su disco consentito per l'estensione automatica. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). È possibile specificare `UNLIMITED` per rimuovere il limite di dimensione del file. |
I seguenti esempi ridimensionano uno spazio di tabella temporaneo denominato `TEMP` alla dimensione di 4 GB.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
Il seguente esempio ridimensiona uno spazio tabella temporaneo basato sul file temporaneo con l'identificatore file `1` alla dimensione di 2 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
L'esempio seguente disattiva l'estensione automatica per il file temporaneo 1. Imposta la dimensione massima dell'estensione automatica del file temporaneo da 2 a 10 GB, con un incremento di 100 MB.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Per maggiori informazioni sulle repliche di lettura per le istanze database Oracle, consulta [Utilizzo di repliche di lettura per Amazon RDS per Oracle](oracle-read-replicas.md).
# Spostamento di dati tra volumi di storage in RDS per Oracle
È possibile spostare file di dati e oggetti di database tra i volumi di storage primari e aggiuntivi. Prima di spostare i dati, considera i seguenti punti:
+ I volumi di origine e di destinazione devono disporre di spazio libero sufficiente.
+ Le operazioni di spostamento dei dati I/O occupano entrambi i volumi.
+ I movimenti di dati di grandi dimensioni possono influire sulle prestazioni del database.
+ Se ripristini un'istantanea, lo spostamento dei dati tra i volumi di storage potrebbe essere lento se è influenzato dal lazy loading di EBS.
**Topics**
+ [
## Spostamento di file di dati tra volumi in RDS per Oracle
](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [
## Spostamento dei dati e degli indici delle tabelle tra i volumi in RDS for Oracle
](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [
## Gestione dello storage LOB utilizzando volumi aggiuntivi
](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Spostamento di file di dati tra volumi in RDS per Oracle
Per spostare file di dati tra volumi di storage, utilizza la procedura `rdsadmin.rdsadmin_util.move_datafile` Amazon RDS. Si notino i requisiti seguenti:
+ È necessario utilizzare Oracle Enterprise Edition per eseguire la `move_datafile` procedura.
+ Non è possibile spostare tablespace e`SYSTEM`. `RDSADMIN`
La procedura `move_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Richiesto | Descrizione |
| --- | --- | --- | --- |
| `p_data_file_id` | numero | Sì | L'ID del file di dati da spostare. |
| `p_location` | varchar2 | Sì | Il volume di archiviazione in cui si desidera spostare il file di dati. |
L'esempio seguente sposta una tablespace dal volume predefinito `rdsdbdata` al volume aggiuntivo. `rdsdbdata2`
```
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
```
## Spostamento dei dati e degli indici delle tabelle tra i volumi in RDS for Oracle
È possibile ottimizzare l'archiviazione del database creando tablespace su volumi di archiviazione aggiuntivi. È quindi possibile spostare oggetti come tabelle, indici e partizioni in questi tablespace utilizzando lo standard Oracle SQL. Questo approccio è utile per ottimizzare le prestazioni quando il database contiene dati con modelli di accesso diversi. Ad esempio, è possibile archiviare i dati operativi a cui si accede di frequente su volumi di storage ad alte prestazioni spostando al contempo i dati storici a cui si accede raramente in volumi di storage a basso costo.
Nell'esempio seguente, si crea una nuova tablespace su un volume ad alte prestazioni. `rdsdbdata2` Quindi sposti una tabella nel volume di archiviazione aggiuntivo mentre la tabella è online. Inoltre, sposti l'indice sullo stesso volume. Lo spostamento delle tabelle e la ricostruzione degli indici online richiedono 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;
```
Nell'esempio seguente, si crea una tablespace su un volume a basso costo. Quindi si sposta una partizione di tabella nel volume di archiviazione a basso costo utilizzando un'operazione 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;
```
Nell'esempio seguente, si interrogano le sessioni attive su operazioni di lunga durata.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
È possibile verificare l'utilizzo dei tablespace con la seguente query.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Gestione dello storage LOB utilizzando volumi aggiuntivi
Il database potrebbe contenere tabelle con oggetti BLOB o CLOB che consumano una notevole quantità di spazio di archiviazione ma a cui si accede raramente. Per ottimizzare l'archiviazione, è possibile riposizionare questi segmenti LOB in un tablespace su un volume di archiviazione aggiuntivo.
Nell'esempio seguente, si crea una tablespace per i dati LOB su un volume a basso costo destinato a dati a basso accesso. Quindi si crea una tabella che memorizza i dati su questo volume.
```
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);
```
# Utilizzo di tabelle esterne in RDS per Oracle
Le *Tabelle esterne Oracle* sono tabelle con dati che non si trovano nel database. Invece, i dati si trovano nei file esterni ai quali il database può accedere. Utilizzando le tabelle esterne, puoi accedere ai dati senza caricarli nel database. Per ulteriori informazioni sulle tabelle esterne, consulta [Gestione delle tabelle esterne](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) nella documentazione Oracle.
Con Amazon RDS, puoi archiviare i file della tabella esterna negli oggetti della directory. Puoi creare un oggetto di directory o puoi utilizzare uno predefinito nel database Oracle, ad esempio la directory DATA\$1PUMP\$1DIR. Per informazioni sulla creazione di oggetti di directory, consulta [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Puoi eseguire query sulla visualizzazione ALL\$1DIRECTORIES per elencare gli oggetti di directory per l'istanza database Amazon RDS Oracle.
**Nota**
Gli oggetti directory puntano allo spazio principale dello storage dei dati (volume Amazon EBS) utilizzato dall'istanza. Lo spazio usato—insieme a file di dati, log delle modifiche, audit, traccia e altri file— fa parte dello storage allocato.
Puoi spostare un file di dati esterno da un database Oracle a un altro utilizzando il pacchetto [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) o [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069). I file dati esterni si spostano da una directory nel database origine a una directory specificata nel database di destinazione. Per ulteriori informazioni sull'uso di `DBMS_FILE_TRANSFER`, consultare [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Dopo aver spostato il file dei dati esterno puoi crearci una tabella esterna. L'esempio seguente crea una tabella esterna che utilizza il `emp_xt_file1.txt` file nella directory USER\$1DIR1 .
```
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;
```
Immaginiamo che desideri spostare i dati che si trovano nell'istanza database Amazon RDS Oracle nel file di dati esterno. In questo caso, puoi popolare il file di dati esterno creando una tabella esterna e selezionando i dati dalla tabella nel database. Ad esempio, la seguente istruzione SQL crea la tabella esterna `orders_xt` eseguendo la query sulla tabella `orders` nel database.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
In questo esempio, i dati sono popolati nel file `orders_xt.dmp` nella directory DATA\$1PUMP\$1DIR.
# Checkpoint di un database
Puoi usare la procedura in Amazon RDS per eseguire il checkpoint del database `rdsadmin.rdsadmin_util.checkpoint`. La procedura `checkpoint` non ha parametri.
L'esempio seguente esegue il checkpoint del database.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Impostazione del ripristino distribuito
Puoi usare le procedure `rdsadmin.rdsadmin_util.enable_distr_recovery` e `disable_distr_recovery` in Amazon RDS per impostare il ripristino distribuito. Le procedure non hanno parametri.
L'esempio seguente abilita il ripristino distribuito.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
L'esempio seguente disabilita il ripristino distribuito.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Impostazione del fuso orario del database
È possibile impostare il fuso orario del database Amazon RDS Oracle nei modi seguenti:
+ L'opzione `Timezone`
L'opzione `Timezone` modifica il fuso orario a livello di host e interessa tutte le colonne e valori data come `SYSDATE`. Per ulteriori informazioni, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md).
+ La procedura Amazon RDS `rdsadmin.rdsadmin_util.alter_db_time_zone`
La procedura `alter_db_time_zone` modifica il fuso orario solo per certi tipi di dati e non modifica `SYSDATE`. Ci sono limitazioni aggiuntive per l'impostazione del fuso orario elencato nella [Documentazione di Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705).
**Nota**
È inoltre possibile impostare il fuso orario predefinito per Oracle Scheduler. Per ulteriori informazioni, consulta [Impostazione del fuso orario per i job di Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
La procedura `alter_db_time_zone` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Sì | Il nuovo fuso orario come regione denominata o un offset assoluto da Coordinated Universal Time (UTC). Gli offset validi sono compresi tra -12.00 e \$114.00. |
Il seguente esempio imposta il fuso orario su UTC più tre ore.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
L'esempio seguente modifica il fuso orario in fuso Africa/Algiers orario.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Dopo aver modificato il fuso orario utilizzando la procedura `alter_db_time_zone`, devi riavviare l'istanza database per rendere effettive le modifiche. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md). Per informazioni sull'aggiornamento dei fusi orari, consulta [Considerazioni sul fuso orario](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
# Generazione di report sulle prestazioni con AWR (Automatic Workload Repository)
Per raccogliere i dati sulle prestazioni e generare report, Oracle consiglia AWR (Automatic Workload Repository). AWR richiede Oracle Database Enterprise Edition e una licenza per i pacchetti di diagnostica e ottimizzazione. Per abilitare AWR, impostare il parametro di inizializzazione `CONTROL_MANAGEMENT_PACK_ACCESS` su `DIAGNOSTIC` o `DIAGNOSTIC+TUNING`.
## Utilizzo di report AWR in RDS
Per generare report AWR, puoi eseguire script quali `awrrpt.sql`. Questi script vengono installati nel server host del database. In Amazon RDS non è possibile accedere direttamente all'host. Tuttavia, puoi ottenere copie di script SQL da un'altra installazione di Oracle Database.
È inoltre possibile utilizzare AWR eseguendo le procedure nel `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL pacchetto. Puoi utilizzare questo pacchetto per gestire baseline e snapshot, nonché visualizzare report ASH e AWR. Ad esempio, per generare un report AWR in formato di testo, esegui la procedura `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`. Tuttavia, non puoi raggiungere questi report AWR da Console di gestione AWS.
Quando utilizzi AWR, ti consigliamo di utilizzare le procedure `rdsadmin.rdsadmin_diagnostic_util`. Puoi utilizzare queste procedure per generare quanto segue:
+ Report AWR
+ Report ASH (Active Session History)
+ Report ADDM (Automatic Database Diagnostic Monitor)
+ File di dump di Export di Oracle Data Pump di dati AWR
Le procedure `rdsadmin_diagnostic_util` salvano i report nel file system dell'istanza database. Puoi accedere a questi report dalla console. Puoi inoltre accedere ai report utilizzando le procedure `rdsadmin.rds_file_util` e accedere ai report copiati in Simple Storage Service (Amazon S3) mediante l'opzione Integrazione S3. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) e [Integrazione Amazon S3](oracle-s3-integration.md).
Puoi utilizzare le procedure `rdsadmin_diagnostic_util` nelle seguente per versioni del motore database Amazon RDS for Oracle:
+ Tutte le versioni di Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 e versioni successive di Oracle Database 19c
Per un blog che spiega come utilizzare i report diagnostici in uno scenario di replica, consulta il post relativo alla [generazione di report AWR per le repliche di lettura di Amazon RDS per Oracle](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/).
## Parametri comuni per il pacchetto di utilità di diagnostica
In genere i seguenti parametri vengono utilizzati durante la gestione di AWR e ADDM con il pacchetto `rdsadmin_diagnostic_util`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
In genere i seguenti parametri vengono utilizzati durante la gestione di ASH con il pacchetto rdsadmin\$1diagnostic\$1util.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Generazione di un report AWR
Per generare un report AWR, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.awr_report`.
Nell'esempio seguente viene generato un report AWR per l'intervallo di snapshot da 101 a 106. Il file di testo di output è denominato `awrrpt_101_106.txt`. Puoi accedere a questo report da Console di gestione AWS.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
Nell'esempio seguente viene generato un report HTML per l'intervallo di snapshot da 63 a 65. Il file HTML di output è denominato `awrrpt_63_65.html`. La procedura scrive il report nella directory di database non predefinita denominata `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Estrazione di dati AWR in un file di dump
Per estrarre i dati AWR in un file di dump, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.awr_extract`. È possibile utilizzare questa funzione solo a livello di PDB.
Nell'esempio seguente viene estratto l'intervallo di snapshot da 101 a 106. Il file di dump di output è denominato `awrextract_101_106.dmp`. Puoi accedere a questo file tramite la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
Nell'esempio seguente viene estratto l'intervallo di snapshot da 63 a 65. Il file di dump di output è denominato `awrextract_63_65.dmp`. Il file viene archiviato nella directory di database non predefinita denominata `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Generazione di un report ADDM
Per generare un report ADDM, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.addm_report`.
Nell'esempio seguente viene generato un report ADDM per l'intervallo di snapshot da 101 a 106. Il file di testo di output è denominato `addmrpt_101_106.txt`. È possibile accedere al report tramite la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
Nell'esempio seguente viene generato un report ADDM per l'intervallo di snapshot da 63 a 65. Il file di testo di output è denominato `addmrpt_63_65.txt`. Il file viene archiviato nella directory di database non predefinita denominata `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Generazione di un report ASH
Per generare un report ASH, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.ash_report`.
Nell'esempio seguente viene generato un report ASH che include i dati da 14 minuti fa fino all'ora corrente. Il nome del file di output utilizza il formato `ashrptbegin_timeend_time.txt`, dove `begin_time` e `end_time` utilizzano il formato `YYYYMMDDHH24MISS`. Puoi accedere al file tramite la console.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
Nell'esempio seguente viene generato un report ASH che include i dati dal 18 novembre 2019 alle 18.07 fino al 18 novembre 2019 alle 18.15. Il nome del report HTML di output è `ashrpt_20190918180700_20190918181500.html`. Il file viene archiviato nella directory di database non predefinita denominata `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;
/
```
## Accesso ai report AWR dalla console o da CLI
Per accedere ai report AWR o esportare file di dump, puoi usare o. Console di gestione AWS AWS CLI Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
# Modifica dei collegamenti di database per l'utilizzo con le istanze database in un VPC
Per utilizzare i collegamenti al database Oracle con le istanze DB di Amazon RDS all'interno dello stesso cloud privato virtuale (VPC) o in peering VPCs, le due istanze DB devono avere un percorso valido tra di loro. Verifica l'instradamento valido tra le istanze database utilizzando le tabelle di routing VPC e la lista di controllo accessi della rete (ACL).
Il gruppo di sicurezza di ogni istanza database deve permettere l'ingresso e l'uscita dall'altra istanza database. Le regole in entrata e in uscita possono riferirsi ai gruppi di sicurezza dallo stesso VPC o da un VPC in peering. Per ulteriori informazioni, consulta [Aggiornamento dei gruppi di sicurezza a gruppi di sicurezza VPC in peering di riferimento](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Se hai configurato un server DNS personalizzato utilizzando il set opzioni DHCP nel VPC, il server DNS personalizzato deve essere in grado di risolvere il nome del target del collegamento di database. Per ulteriori informazioni, consulta [Impostazione di un server DNS personalizzato](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Per ulteriori informazioni sull'utilizzo di collegamenti di database con Oracle Data Pump, consulta [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Impostazione dell'edizione predefinita per un'istanza database
Puoi ridefinire gli oggetti di database in un ambiente privato che si chiama edizione. Puoi utilizzare una ridefinizione basata sull'edizione per aggiornare gli oggetti di database dell'applicazione con tempo di inattività minimo.
Puoi impostare l'edizione predefinita di un'istanza database Oracle Amazon RDS usando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.alter_default_edition`.
L'esempio seguente imposta l'edizione predefinita per l'istanza database Oracle Amazon RDS su `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
L'esempio seguente imposta l'edizione predefinita per l'istanza database Amazon RDS Oracle a quella predefinita di Oracle.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Per ulteriori informazioni sulla ridefinizione Oracle basata sull'edizione, consulta le [Informazioni sulla edizione e sulla ridefinizione basata sull'edizione](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) nella documentazione di Oracle.
# Abilitazione dell'audit per la tabella SYS.AUD\$1
Puoi utilizzare la procedura `SYS.AUD$` in Amazon RDS per abilitare l'audit sulla tabella di trail dell'audit del database `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table`. L'unica proprietà dell'audit supportata è `ALL`. Non è possibile sottoporre o non sottoporre ad audit singole istruzioni o operazioni.
L'abilitazione dell'audit è supportata per le istanze database Oracle che eseguono le seguenti versioni:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
La procedura `audit_all_sys_aud_table` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_by_access` | booleano | true | No | Impostato su `true` per l'audit di `BY ACCESS`. Impostato su `false` per l'audit di `BY SESSION`. |
La seguente query restituisce l'attuale configurazione dell'audit di `SYS.AUD$` per un database.
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
I seguenti comandi abilitano l'audit di `ALL` su `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);
```
Il seguente comando abilita l'audit di `ALL` su `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Per ulteriori informazioni, consulta la sezione relativa all'[AUDIT (Audit tradizionale)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/AUDIT-Traditional-Auditing.html#GUID-ADF45B07-547A-4096-8144-50241FA2D8DD) nella documentazione Oracle.
# Disabilitazione dell'audit per la tabella SYS.AUD\$1
Puoi utilizzare la procedura `SYS.AUD$` in Amazon RDS per disabilitare l'audit sulla tabella di trail dell'audit del database `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table`. Questa procedura non richiede parametri.
La seguente query restituisce l'attuale configurazione dell'audit di `SYS.AUD$` per un database:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Il seguente comando disabilita l'audit di `ALL` su `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Per ulteriori informazioni, consulta la sezione relativa a [NOAUDIT (Audit tradizionale)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/NOAUDIT-Traditional-Auditing.html#GUID-9D8EAF18-4AB3-4C04-8BF7-37BD0E15434D) nella documentazione Oracle.
# Pulizia di compilazioni dell'indice online interrotte
Per pulire compilazioni dell'indice online non riuscite, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_dbms_repair.online_index_clean`.
La procedura `online_index_clean` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | No | L'ID oggetto dell'indice. In genere, puoi utilizzare l'ID oggetto dal testo dell'errore ORA-08104. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | No | Specifica `rdsadmin.rdsadmin_dbms_repair.lock_wait`, l'impostazione predefinita, per cercare di ottenere un blocco sull'oggetto sottostante e riprovare finché non viene raggiunto un limite interno se il blocco non va a buon fine. Specifica `rdsadmin.rdsadmin_dbms_repair.lock_nowait` per cercare di ottenere un blocco sull'oggetto sottostante ma non riprovare se il blocco non va a buon fine. |
L'esempio seguente pulisce una compilazione di indice online non riuscita:
```
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;
/
```
Per ulteriori informazioni, consulta [ONLINE\$1INDEX\$1CLEAN Function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) nella documentazione Oracle.
# Ignorare blocchi corrotti
Per ignorare blocchi corrotti durante le scansioni di indici e tabelle, utilizza il pacchetto `rdsadmin.rdsadmin_dbms_repair`.
Le seguenti procedure eseguono il wrapping della funzionalità della procedura `sys.dbms_repair.admin_table` e non accettano parametri:
+ `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`
Le seguenti procedure accettano gli stessi parametri delle loro controparti nel pacchetto `DBMS_REPAIR` per database 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`
Per ulteriori informazioni sulla gestione del danneggiamento del database, vedere [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) nella documentazione Oracle.
**Example Risposta a blocchi danneggiati**
Questo esempio mostra il flusso di lavoro di base per rispondere ai blocchi danneggiati. I passaggi dipenderanno dalla posizione e dalla natura del danneggiamento del blocco.
Prima di tentare di riparare i blocchi danneggiati, esaminare attentamente la documentazione di [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948).
**Per saltare i blocchi danneggiati durante le scansioni di indice e tabella**
1. Esegui le procedure seguenti per creare tabelle di riparazione se non esistono già.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Esegui le procedura seguenti per verificare l'esistenza di record e cancellarli se appropriato.
```
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. Esegui la procedura seguente per verificare la presenza di blocchi corrotti.
```
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. Esegui la procedura `skip_corrupt_blocks` per abilitare o disabilitare l'omissione della corruzione per le tabelle interessate. A seconda della situazione, potrebbe essere necessario estrarre i dati in una nuova tabella e quindi eliminare la tabella contenente il blocco danneggiato.
Esegui la procedura seguente per ignorare la corruzione per le tabelle interessate.
```
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';
```
Esegui la procedura seguente per non ignorare la corruzione.
```
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. Dopo aver completato tutti i lavori di riparazione, eseguire le procedure seguenti per eliminare le tabelle di ripristino.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Eliminazione del cestino riciclaggio
Quando si rilascia una tabella, il database Oracle non rimuove immediatamente lo spazio di storage. Il database rinomina la tabella inserendola insieme agli eventuali oggetti associati in un cestino riciclaggio. L'eliminazione del cestino riciclaggio rimuove questi elementi e rilascia il relativo spazio di storage.
Per rimuovere l'intero cestino riciclaggio, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.purge_dba_recyclebin`. Tuttavia, questa procedura non può eliminare dal cestino riciclaggio gli oggetti `SYS` e `RDSADMIN`. Se è necessario eliminare questi oggetti, contatta AWS Support.
Nell'esempio seguente viene eliminato l'intero cestino riciclaggio.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Impostazione dei valori di default visualizzati per la redazione completa
Per modificare i valori di default visualizzati per la redazione completa sull'istanza Oracle Amazon RDS, utilizza la procedura `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val` di Amazon RDS. Si noti che si crea una politica di redazione con il `DBMS_REDACT` PL/SQL pacchetto, come spiegato nella documentazione di Oracle Database. La procedura `dbms_redact_upd_full_rdct_val` specifica i caratteri da visualizzare per i diversi tipi di dati influenzati da una policy esistente.
La procedura `dbms_redact_upd_full_rdct_val` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_number_val` | numero | Null | No | Modifica il valore di default per le colonne del tipo di dati `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | No | Modifica il valore di default per le colonne del tipo di dati `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | No | Modifica il valore di default per le colonne del tipo di dati `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | No | Modifica il valore di default per le colonne del tipo di dati `CHAR`. |
| `p_varchar_val` | varchar2 | Null | No | Modifica il valore di default per le colonne del tipo di dati `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | No | Modifica il valore di default per le colonne del tipo di dati `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | No | Modifica il valore di default per le colonne del tipo di dati `NVARCHAR2`. |
| `p_date_val` | data | Null | No | Modifica il valore di default per le colonne del tipo di dati `DATE`. |
| `p_ts_val` | timestamp | Null | No | Modifica il valore di default per le colonne del tipo di dati `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | No | Modifica il valore di default per le colonne del tipo di dati `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | No | Modifica il valore di default per le colonne del tipo di dati `BLOB`. |
| `p_clob_val` | clob | Null | No | Modifica il valore di default per le colonne del tipo di dati `CLOB`. |
| `p_nclob_val` | nclob | Null | No | Modifica il valore di default per le colonne del tipo di dati `NCLOB`. |
L'esempio seguente modifica il valore di default redatto in \$1 per il tipo di dati `CHAR`:
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
L'esempio seguente modifica i valori di default redatti per i tipi di dati `NUMBER`, `DATE` e `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;
/
```
Dopo aver modificato i valori di default per la redazione completa con la procedura `dbms_redact_upd_full_rdct_val`, riavvia l'istanza database per rendere effettiva la modifica. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
# Esecuzione di attività comuni relative ai log per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative all'accesso alle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
Per ulteriori informazioni, consulta [File di log del database Amazon RDS per Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [
## Impostazione accesso forzato
](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [
## Impostazione di accesso supplementare
](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [
## Cambio dei file di log online
](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [
## Aggiunta di log redo online
](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [
## Eliminazione di log redo online
](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [
# Ridimensionamento di log redo online
](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [
# Conservazione dei log redo archiviati
](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [
# Accesso ai log di ripristino online e archiviati
](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [
# Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)
](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Impostazione accesso forzato
In modalità accesso forzato, Oracle registra tutte le modifiche nel database ad eccezione delle modifiche in spazi tabella temporanei e segmenti temporanei (le clausole `NOLOGGING` vengono ignorate). Per ulteriori informazioni, consulta [Specificare la modalità FORCE LOGGING (ACCESSO FORZATO)](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) nella documentazione Oracle.
Puoi usare la procedura in Amazon RDS per impostare il logging forzato `rdsadmin.rdsadmin_util.force_logging`. La procedura `force_logging` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Sì | Descrizione |
| --- | --- | --- | --- | --- |
| `p_enable` | booleano | true | No | Imposta su `true` per impostare il database nella modalità accesso forzato, `false` per rimuovere il database dalla modalità accesso forzato. |
L'esempio seguente imposta il database in modalità accesso forzato.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Impostazione di accesso supplementare
Se abiliti la registrazione supplementare, LogMiner dispone delle informazioni necessarie per supportare righe concatenate e tabelle raggruppate. Per ulteriori informazioni, consulta la pagina [Accesso supplementare](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) nella documentazione Oracle.
L'Oracle Database non abilita l'accesso supplementare come impostazione predefinita. Puoi usare la procedura in Amazon RDS per abilitare e disabilitare il logging supplementare `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Per ulteriori informazioni sul modo in cui Amazon RDS gestisce la conservazione dei log delle modifiche archiviati per istanze database Oracle, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
La procedura `alter_supplemental_logging` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Sì | `'ADD'` per aggiungere l'accesso supplementare, `'DROP'` per rilasciare l'accesso supplementare. |
| `p_type` | varchar2 | null | No | Tipo di accesso supplementare. I valori validi sono `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` o `PROCEDURAL`. |
L'esempio seguente abilita l'accesso supplementare.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
L'esempio seguente abilita l'accesso supplementare per tutte le colonne di lunghezza fissa massima.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
L'esempio seguente abilita l'accesso supplementare per le colonne chiave primarie.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Cambio dei file di log online
Puoi usare la procedura in Amazon RDS per cambiare file di lo `rdsadmin.rdsadmin_util.switch_logfile`. La procedura `switch_logfile` non ha parametri.
L'esempio seguente cambia i file di log.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Aggiunta di log redo online
Un'istanza database Amazon RDS che esegue Oracle inizia con quattro log redo online, di 128 MB ciascuno. Puoi usare la procedura in Amazon RDS per aggiungere ulteriori log red `rdsadmin.rdsadmin_util.add_logfile`.
La procedura `add_logfile` include i seguenti parametri.
**Nota**
I parametri sono si escludono a vicenda.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `bytes` | positivo | null | No | Le dimensioni del file di log in byte. Utilizza questo parametro solo se la dimensione del log è inferiore a 2147483648 bytes (2 GiB). In caso contrario, RDS restituisce un errore. Per le dimensioni dei log superiori a questo valore di byte, utilizza invece il parametro `p_size`. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file di log in kilobyte (K), megabyte (M) o gigabyte (G). |
Il seguente comando aggiunge un file di log di 100 MB.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Eliminazione di log redo online
Puoi utilizzare la procedura in Amazon RDS per rilasciare i log red `rdsadmin.rdsadmin_util.drop_logfile`. La procedura `drop_logfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `grp` | positivo | — | Sì | Il numero di gruppo del log. |
L'esempio seguente rilascia il log con il numero di gruppo 3.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Puoi solo rilasciare log che hanno uno stato di inutilizzato o inattivo. L'esempio seguente ottiene gli stati dei log.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Ridimensionamento di log redo online
Un'istanza database Amazon RDS che esegue Oracle inizia con quattro log redo online, di 128 MB ciascuno. L'esempio seguente visualizza come si possono utilizzare le procedure Amazon RDS per ridimensionare i log da 128 MB ciascuno a 512 MB ciascuno.
```
/* 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
```
# Conservazione dei log redo archiviati
È possibile conservare i redo log archiviati localmente sull'istanza DB per utilizzarli con prodotti come Oracle LogMiner (). `DBMS_LOGMNR` Dopo aver conservato i redo log, è possibile utilizzarli per analizzarli. LogMiner Per ulteriori informazioni, vedere [Using LogMiner to analysis redo log file](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm) nella documentazione Oracle.
Puoi usare la procedura in Amazon RDS per mantenere i log redo archiviat `rdsadmin.rdsadmin_util.set_configuration`. Se utilizzi questa procedura su un’istanza primaria in Oracle Data Guard, RDS modifica l’impostazione relativa alla conservazione dei log di archivio sull’istanza primaria e apre le repliche di lettura, ma non sulle repliche montate. RDS mantiene i log di redo di archivio più recenti sulle repliche montate per un breve periodo di tempo. RDS elimina automaticamente i log precedenti scaricati nelle repliche montate.
La procedura `set_configuration` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Sì | Il nome della configurazione da aggiornare. Per modificare gli orari di conservazione dei log di redo archiviati, imposta il nome su `archivelog retention hours`. |
| `value` | varchar | — | Sì | Il valore per la configurazione. Imposta il valore del numero di ore in cui mantenere i log. |
L'esempio seguente conserva 24 ore di log redo.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**Nota**
La conferma è necessaria per rendere effettiva la modifica.
Puoi utilizzare la procedura Amazon RDS per visualizzare quanto a lungo i log redo archiviati vengono conservati per l'istanza databas `rdsadmin.rdsadmin_util.show_configuration`.
L'esempio seguente mostra il tempo di conservazione dei log.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
L'output indica l'impostazione corrente per `archivelog retention hours`. L'output seguente indica che i log redo vengono mantenuti per 48 ore.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Poiché i log redo archiviati vengono conservati nell'istanza database, assicurati che l'istanza database abbia abbastanza storage allocato per i log conservati. Per determinare quanto spazio l'istanza database ha utilizzato nelle ultime X ore, puoi eseguire la query seguente, sostituendo X con il numero di ore.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
I log di ripristino archiviati vengono generati solo se il tempo di conservazione del backup dell'istanza database è superiore a zero. Per impostazione predefinita, il tempo di conservazione del backup è maggiore di zero.
Alla scadenza del periodo di conservazione dei log archiviati, RDS per Oracle rimuove i log di ripristino archiviati dall'istanza database. Per supportare il ripristino dell'istanza del DB a un punto temporale specifico, Amazon RDS conserva i log di ripristino archiviati al di fuori dell'istanza database in base al tempo di conservazione del backup. Per modificare il tempo di conservazione del backup, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
**Nota**
In alcuni casi, si potrebbe utilizzare JDBC su Linux per scaricare i log redo archiviati e riscontrare periodi di latenza e ripristini di connessione lunghi. In questi casi i problemi potrebbero dipendere dall'impostazione predefinita del generatore di numeri casuali nel client Java. Consigliamo di impostare i driver JDBC in modo che utilizzino un generatore di numero casuale senza blocchi.
# Accesso ai log di ripristino online e archiviati
Potresti voler accedere ai tuoi redo log file online e archiviati per il mining con strumenti esterni come Attunity GoldenGate, Informatica e altri. Per accedere a questi file, effettuare le operazioni seguenti:
1. Creare oggetti di directory che forniscono l'accesso di sola lettura ai percorsi fisici dei file.
Uso di `rdsadmin.rdsadmin_master_util.create_archivelog_dir` e `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Leggere i file utilizzando PL/SQL.
È possibile leggere i file utilizzando PL/SQL. Per ulteriori informazioni sulla lettura di file dagli oggetti di directory, consulta [Generazione di un elenco dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) e [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
L'accesso ai log delle transazioni è supportato per le versioni seguenti:
+ Oracle Database 21c
+ Oracle Database 19c
Il seguente codice crea delle directory che forniscono accesso di sola lettura ai file di log redo online e archiviati:
**Importante**
Questo codice revoca anche il privilegio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
Il seguente codice rilascia directory per i file di log redo online e archiviati.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
Il seguente codice concede e revoca il privilegio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)
È possibile scaricare i log di ripristino archiviati nell'istanza database utilizzando il pacchetto `rdsadmin.rdsadmin_archive_log_download`. Se i log di ripristino archiviati non sono più presenti nell'istanza database, sarà possibile scaricarli di nuovo da Simple Storage Service (Amazon S3). Quindi è possibile estrarre i log o utilizzarli per recuperare o replicare il database.
**Nota**
Non è possibile scaricare log redo archiviati sulle istanze di replica di lettura.
## Download dei log di ripristino archiviati: passaggi di base
La disponibilità dei log di ripristino archiviati dipende dalle seguenti policy di conservazione:
+ Policy di conservazione dei backup: i log all'interno di questa politica sono disponibili in Simple Storage Service (Amazon S3). I log esterni a questa policy vengono rimossi.
+ Policy di conservazione dei log archiviati: i log all'interno di questa policy sono disponibili nell'istanza database. I log esterni a questa policy vengono rimossi.
Se i log non sono presenti nell'istanza ma sono protetti dal tempo di conservazione del backup, utilizza `rdsadmin.rdsadmin_archive_log_download` per scaricarli di nuovo. RDS per Oracle salva i log nella directory `/rdsdbdata/log/arch` nell'istanza database.
**Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)**
1. Configura il periodo di conservazione per assicurarti che i log redo archiviati scaricati vengano mantenuti per la durata necessaria. Assicurati di `COMMIT` la modifica.
RDS mantiene i log scaricati in base alla policy di conservazione dei log archiviati, a partire dal momento in cui i log sono stati scaricati. Per informazioni su come impostare la policy di conservazione, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Attendere fino a 5 minuti per rendere effettiva la modifica della policy di conservazione dei log archiviati.
1. Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3) tramite `rdsadmin.rdsadmin_archive_log_download`.
Per ulteriori informazioni, consulta [Download di un singolo log di ripristino archiviato](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) e [Download di una serie di log di ripristino archiviati](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**Nota**
RDS controlla automaticamente lo spazio di archiviazione disponibile prima del download. Se i log richiesti consumano un'alta percentuale di spazio, viene visualizzato un avviso.
1. Conferma che i log siano stati scaricati correttamente da Simple Storage Service (Amazon S3).
È possibile visualizzare lo stato dell'attività di download in un file bdump. I file bdump hanno il percorso `/rdsdbdata/log/trace/dbtask-task-id.log`. Nel passaggio di download precedente, si esegue una istruzione `SELECT` che restituisce l'ID attività in un tipo di dati `VARCHAR2`. Per maggiori informazioni, consulta gli esempi simili in [Monitoraggio dello stato di un file transfer](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Download di un singolo log di ripristino archiviato
Per scaricare un singolo log di ripristino archiviato nella directory `/rdsdbdata/log/arch` utilizza `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Questa procedura include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `seqnum` | numero | — | Sì | Il numero di sequenza del log di ripristino archiviato. |
L'esempio seguente scarica il log con il numero di sequenza 20.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Download di una serie di log di ripristino archiviati
Per scaricare un singolo log di ripristino archiviato nella directory `/rdsdbdata/log/arch` utilizza `download_logs_in_seqnum_range`. Il download è limitato a 300 registri per richiesta. La procedura `download_logs_in_seqnum_range` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `start_seq` | numero | — | Sì | Il numero di sequenza iniziale per la serie. |
| `end_seq` | numero | — | Sì | Il numero di sequenza finale per la serie. |
L'esempio seguente scarica il log dalla sequenza 50 a 100.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Esecuzione di attività RMAN comuni per le istanze database Oracle
Nella seguente sezione viene illustrato come eseguire attività DBA Oracle Recovery Manager (RMAN) sulle istanze database Amazon RDS che eseguono Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati.
Utilizza il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per eseguire backup RMAN del database Amazon RDS per Oracle su disco. Il pacchetto `rdsadmin.rdsadmin_rman_util` supporta backup completi e incrementali dei file di database, backup degli spazi tabella e backup dei log redo archiviati.
Al termine di un backup RMAN, è possibile copiare i file di backup dall'host dell'istanza database Amazon RDS for Oracle. Tale operazione può essere eseguita per il ripristino su un host diverso da RDS o per uno storage a lungo termine dei backup. Ad esempio, i file di backup possono essere copiati in un bucket Simple Storage Service (Amazon S3). Per ulteriori informazioni, consulta l'utilizzo di [Integrazione Amazon S3](oracle-s3-integration.md).
I file di backup dei backup RMAN rimangono nell'host dell'istanza database Amazon RDS fino a quando non vengono rimossi manualmente. Per rimuovere i file da una directory, è possibile utilizzare la procedura Oracle `UTL_FILE.FREMOVE`. Per ulteriori informazioni, consulta la sezione relativa alla [Procedura FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) nella documentazione del database Oracle.
Non puoi utilizzare l'RMAN per ripristinare RDS per le istanze database Oracle. Tuttavia, puoi utilizzare RMAN per ripristinare un backup su un'istanza on-premise o Amazon EC2. Per ulteriori informazioni, consulta l'articolo del blog [Restore an Amazon RDS for Oracle instance to a self-managed instance](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/).
**Nota**
Per il backup e il ripristino su un'altra istanza database Amazon RDS for Oracle, si può continuare a utilizzare le funzionalità di backup e ripristino di Amazon RDS. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [
# Prerequisiti per i backup RMAN
](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [
# Parametri comuni per le procedure RMAN
](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [
# Convalida dei file di database in RDS per Oracle
](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [
# Abilitazione e disabilitazione del monitoraggio delle modifiche dei blocchi.
](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [
# Controllo incrociato dei log redo archiviati
](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [
# Backup dei file di log di redo archiviati
](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [
# Esecuzione di un backup di database completo
](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [
# Esecuzione di un backup completo di un database del tenant
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [
# Esecuzione di un backup di database incrementale
](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [
# Esecuzione di un backup incrementale di un database del tenant
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [
# Backup di uno spazio di tabella
](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [
# Backup di un file di controllo
](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [
# Esecuzione del ripristino dei supporti a blocchi
](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Prerequisiti per i backup RMAN
Prima di eseguire il backup del database utilizzando il pacchetto `rdsadmin.rdsadmin_rman_util`, assicurati di soddisfare i seguenti prerequisiti:
+ Assicurati che il tuo database RDS per Oracle sia in modalità `ARCHIVELOG`. Per abilitare questa modalità, imposta il periodo di conservazione del backup su un valore diverso da zero.
+ Se si esegue il backup di log redo archiviati o un backup completo o incrementale che include log redo archiviati, e quando si esegue il backup del database, accertarsi che la conservazione dei log redo sia impostata su un valore diverso da zero. I log redo archiviati sono necessari per rendere i file del database coerenti durante il ripristino. Per ulteriori informazioni, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Assicurati che l'istanza database disponga di spazio libero sufficiente per contenere i backup. Quando esegui il backup del database, specifica un oggetto della directory Oracle come un parametro nella chiamata di procedura. RMAN inserisce i file nella directory specificata. Si possono utilizzare directory predefinite, come `DATA_PUMP_DIR`, o crearne di nuove. Per ulteriori informazioni, consulta [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
È possibile monitorare lo spazio libero corrente in un'istanza di RDS for Oracle utilizzando la CloudWatch metrica`FreeStorageSpace`. È opportuno che lo spazio libero superi la dimensione corrente del database, sebbene RMAN esegua il backup solo dei blocchi formattati e supporti la compressione.
# Parametri comuni per le procedure RMAN
Per eseguire attività con RMAN, si possono utilizzare le procedure del pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util`. Nelle procedure del pacchetto ci sono diversi parametri comuni. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Un nome valido della directory del database. | — | Sì | Il nome della directory che conterrà i file di backup. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | No | Una stringa univoca, inclusa nei nomi dei file di backup. Ha un limite di 30 caratteri. |
| `p_owner` | varchar2 | Un proprietario valido della directory specificata in `p_directory_name`. | — | Sì | Il proprietario della directory che conterrà i file di backup. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | No | Una stringa che può essere utilizzata per distinguere tra i backup per indicare lo scopo o l'utilizzo dei backup, ad esempio backup a livello giornaliero, settimanale o incrementale. Ha un limite di 30 caratteri. Il tag non rileva la distinzione tra maiuscole e minuscole. I tag sono sempre memorizzati in maiuscolo, indipendentemente dalle maiuscole e minuscole utilizzate durante l'inserimento. I tag non devono essere univoci, quindi più backup possono avere lo stesso tag. Se non si specifica un tag, RMAN assegna automaticamente un tag predefinito utilizzando il formato`TAGYYYYMMDDTHHMMSS`, dove *YYYY* è l'anno, *MM* il mese, *DD* il giorno, *HH* l'ora (nel formato a 24 ore), *MM* i minuti e i *SS* secondi. La data e l'ora si riferiscono a quando RMAN ha avviato il backup. Ad esempio, un backup potrebbe ricevere un tag `TAG20190927T214517` per un backup avviato il 27/09/2019 alle 21:45:17. Il parametro `p_tag` è supportato nelle seguenti versioni del motore database Amazon RDS for Oracle: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per abilitare la compressione BASIC del backup. Specificare `FALSE` per disabilitare la compressione BASIC del backup. |
| `p_include_archive_logs` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per includere i log redo archiviati nel backup. Specificare `FALSE` per escludere i log redo archiviati dal backup. Se si includono log redo archiviati nel backup, la retention va impostata su un valore almeno pari a un'ora tramite la procedura `rdsadmin.rdsadmin_util.set_configuration`. Inoltre, occorre chiamare la procedura `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` subito prima di eseguire il backup. In caso contrario, il backup potrebbe non andare a buon fine perché mancano i file di log redo archiviati che sono stati eliminati dalle procedure di gestione di Amazon RDS. |
| `p_include_controlfile` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per includere il file di controllo nel backup. Specificare `FALSE` per escludere il file di controllo dal backup. |
| `p_optimize` | booleano | `TRUE`, `FALSE` | `TRUE` | No | Specificare `TRUE` per abilitare l'ottimizzazione del backup e ridurne le dimensioni, se sono inclusi log redo archiviati. Specificare `FALSE` per disabilitare l'ottimizzazione del backup. |
| `p_parallel` | numero | Un intero valido tra `1` e `254` per Oracle Database Enterprise Edition (EE) `1` per altre edizioni Oracle Database | `1` | No | Numero di canali. |
| `p_rman_to_dbms_output` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Quando `TRUE`, l'output RMAN viene inviato al pacchetto `DBMS_OUTPUT` oltre a un file nella directory `BDUMP`. In SQL\$1Plus, utilizza `SET SERVEROUTPUT ON` per visualizzare l'output. Quando `FALSE`, l'output RMAN viene solo inviato a un file nella directory `BDUMP`. |
| `p_section_size_mb` | numero | Intero valido | `NULL` | No | Le dimensioni della sezione in megabyte (MB). Convalida in parallelo dividendo ogni file nelle dimensioni specificate della sezione. Quando `NULL`, il parametro è ignorato. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | No | Livello di rilevamento di danneggiamenti. Specifica `'PHYSICAL'` per cercare i danneggiamenti fisici. Un esempio di danneggiamento fisico è un blocco con una mancata corrispondenza nell'intestazione e piè di pagina. Specifica `'PHYSICAL+LOGICAL'` per cercare le incoerenze logiche oltre ai danneggiamenti fisici. Un esempio di danneggiamento logico è un blocco danneggiato. |
# Convalida dei file di database in RDS per Oracle
Puoi utilizzare il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per convalidare i file di database Amazon RDS for Oracle, come file di dati, tablespace, file di controllo e file dei parametri del server (). SPFILEs
Per ulteriori informazioni sulla convalida RMAN, consulta [ Convalida di file di dati e backup di database](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) e [VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) nella documentazione Oracle.
**Topics**
+ [
## Convalida di un database
](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [
## Convalida di un database del tenant
](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [
## Convalida di uno spazio di tabella
](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [
## Convalida di un file di controllo
](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [
## Convalida di un file SPFILE
](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [
## Convalida di un file di dati Oracle
](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Convalida di un database
Per convalidare tutti i file pertinenti utilizzati da un database Oracle in RDS per Oracle, utilizza la procedura `rdsadmin.rdsadmin_rman_util.validate_database` in Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Il seguente esempio convalida il database utilizzando i valori predefiniti per i parametri.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
Il seguente esempio convalida il database utilizzando i valori predefiniti per i parametri.
```
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;
/
```
Quando il parametro `p_rman_to_dbms_output` è impostato su `FALSE`, l'output RMAN viene scritto in un file nella directory `BDUMP`.
Per visualizzare i file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Per visualizzare i contenuti di un file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Sostituisci il nome del file con il nome del file che desideri visualizzare.
## Convalida di un database del tenant
Per convalidare i file di dati del database del tenant in un database container (CDB), utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_tenant`.
La procedura si applica solo al database del tenant corrente e utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Questa procedura è supportata nelle seguenti versioni del motore di database:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Il seguente esempio convalida il database del tenant corrente utilizzando i valori predefiniti per i parametri.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
Il seguente esempio convalida il database del tenant corrente utilizzando i valori predefiniti per i parametri.
```
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;
/
```
Quando il parametro `p_rman_to_dbms_output` è impostato su `FALSE`, l'output RMAN viene scritto in un file nella directory `BDUMP`.
Per visualizzare i file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Per visualizzare i contenuti di un file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Sostituisci il nome del file con il nome del file che desideri visualizzare.
## Convalida di uno spazio di tabella
Puoi usare la procedura in Amazon RDS per convalidare i file associati a uno spazio tabell `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Un nome spazio tabella valido | — | Sì | Il nome dello spazio tabella. |
## Convalida di un file di controllo
Per convalidare solo il file di controllo usato da un'istanza database Oracle Amazon RDS, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Convalida di un file SPFILE
Per convalidare solo il file dei parametri server (SPFILE) usato da un'istanza database Oracle Amazon RDS, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_spfile`.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Convalida di un file di dati Oracle
Puoi usare la procedura in Amazon RDS per convalidare un file di dat `rdsadmin.rdsadmin_rman_util.validate_datafile`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Un numero ID di file di dati valido o un nome di file di dati valido incluso il percorso completo | — | Sì | Il numero ID di file di dati (da `v$datafile.file#`) o il nome completo di file di dati incluso il percorso (da `v$datafile.name`). |
| `p_from_block` | numero | Intero valido | `NULL` | No | Il numero del blocco dove la convalida inizia con i file di dati. Se questo numero è `NULL`, si utilizza `1`. |
| `p_to_block` | numero | Intero valido | `NULL` | No | Il numero del blocco dove la convalida finisce con i file di dati. Se questo numero è `NULL`, viene utilizzato il blocco massimo nel file di dati. |
# Abilitazione e disabilitazione del monitoraggio delle modifiche dei blocchi.
Il rilevamento delle modifiche di blocco registra i blocchi modificati in un file di monitoraggio. Questa tecnica può migliorare le prestazioni dei backup incrementali RMAN. Per ulteriori informazioni, consulta [Utilizzo del rilevamento delle modifiche di blocco per migliorare le prestazioni di backup incrementali](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) nella documentazione di Oracle Database.
Le funzionalità RMAN non sono supportate in una replica di lettura. Tuttavia, come parte della strategia per la disponibilità elevata, puoi scegliere di abilitare il tracciamento dei blocchi in una replica di sola lettura utilizzando la procedura `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Se promuovi questa replica di sola lettura a un'istanza database di origine, il tracciamento delle modifiche dei blocchi viene abilitato per la nuova istanza di origine. Pertanto, la tua istanza può trarre vantaggio da backup incrementali rapidi.
Le procedure di rilevamento delle modifiche di blocco sono supportate in Enterprise Edition solo per le seguenti versioni del motore del database:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Nota**
In un CDB a tenant singolo funzionano le seguenti operazioni, ma nessun meccanismo visibile al cliente può rilevare lo stato corrente delle operazioni. Consulta anche [Limitazioni di RDS per Oracle CDBs](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Per abilitare il rilevamento delle modifiche di blocco per un'istanza database, consulta la Amazon RDS procedura `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Per disattivare il rilevamento delle modifiche di blocco, utilizza `disable_block_change_tracking`. Queste procedure non hanno parametri.
Per determinare se il monitoraggio delle modifiche dei blocchi è abilitato per l'istanza database, eseguire la seguente query.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
Il seguente esempio abilita il monitoraggio delle modifiche dei blocchi per un'istanza database.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
Il seguente esempio disabilita il monitoraggio delle modifiche dei blocchi per un'istanza database.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Controllo incrociato dei log redo archiviati
Si può eseguire il controllo incrociato dei log redo archiviati utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog`.
Questa procedura serve a eseguire il controllo incrociato dei log redo archiviati registrati nel file di controllo e opzionalmente per eliminare i record di log scaduti. Quando RMAN esegue un backup, crea un record nel file di controllo. Col tempo, questi registri aumentano le dimensioni del file di controllo. Si consiglia di rimuovere periodicamente i record scaduti.
**Nota**
I backup Amazon RDS standard non utilizzano RMAN, quindi non creano registri nel file di controllo.
La procedura utilizza il parametro comune `p_rman_to_dbms_output` per le attività RMAN.
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | booleano | `TRUE`, `FALSE` | `TRUE` | No | Se `TRUE`, si eliminano dal file di controllo i record di log redo archiviati scaduti. Se `FALSE`, si conservano nel file di controllo i record di log redo archiviati scaduti. |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Nell'esempio seguente i record di log redo archiviati nel file di controllo file vengono contrassegni come scaduti, ma non vengono eliminati.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
Il seguente esempio elimina i record di log redo archiviati scaduti dal file di controllo.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup dei file di log di redo archiviati
Si può utilizzare il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per eseguire il backup dei log redo archiviati per un'istanza database Amazon RDS Oracle.
Le procedure di backup dei log di redo archiviati sono supportate nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [
## Backup di tutti i log redo archiviati
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [
## Backup di un log redo archiviato in base a un intervallo di date
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [
## Backup di un log redo archiviato in base a un intervallo SCN
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [
## Backup di un log redo archiviato in base a un intervallo di numeri di sequenza
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Backup di tutti i log redo archiviati
Per eseguire il backup di tutti i og redo archiviati per un'istanza database Oracle Amazon RDS, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Il seguente esempio esegue il backup di tutti i log redo archiviati per l'istanza database.
```
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;
/
```
## Backup di un log redo archiviato in base a un intervallo di date
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un intervallo di date, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`. L'intervallo di date specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | Una data compresa tra `start_date` e `next_date` di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_date`. | — | Sì | La data di inizio per i backup dei log archiviati. |
| `p_to_date` | date | Una data compresa tra `start_date` e `next_date` di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_date`. | — | Sì | La data di file per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di date per l'istanza database.
```
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;
/
```
## Backup di un log redo archiviato in base a un intervallo SCN
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un numero di modifica del sistema (SCN), utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`. L'intervallo SCN specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | numero | Un SCN di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_scn`. | — | Sì | L'SCN di inizio per i backup dei log archiviati. |
| `p_to_scn` | numero | Un SCN di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_scn`. | — | Sì | Il SCN di fine per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di SCN per l'istanza database.
```
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;
/
```
## Backup di un log redo archiviato in base a un intervallo di numeri di sequenza
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un intervallo di numeri in sequenza, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`. L'intervallo di numeri di sequenza specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | numero | Un numero di sequenza di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_sequence`. | — | Sì | Il numero di sequenza iniziale per i backup dei log archiviati. |
| `p_to_sequence` | numero | Un numero di sequenza di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_sequence`. | — | Sì | Il numero di sequenza finale per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di numeri di sequenza per l'istanza database.
```
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;
/
```
# Esecuzione di un backup di database completo
Si può eseguire un backup di tutti i blocchi di file di dati inclusi nel backup utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_full`.
La procedura utilizza i seguenti parametri comuni per le attività 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`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup completo dell'istanza database utilizzando i valori specificati per i parametri:
```
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;
/
```
# Esecuzione di un backup completo di un database del tenant
È possibile eseguire un backup di tutti i blocchi di dati inclusi in un database del tenant in un database container (CDB). Usa la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_full`. La procedura si applica solo al backup del database corrente e utilizza i seguenti parametri comuni per le operazioni 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`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
La procedura `rdsadmin_rman_util.backup_tenant_full` è supportata nelle seguenti versioni del motore di database RDS per Oracle:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Il seguente esempio esegue un backup completo del database del tenant corrente utilizzando i valori specificati per i parametri:
```
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;
/
```
# Esecuzione di un backup di database incrementale
Si può eseguire un backup incrementale dell'istanza database utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_incremental`.
Per ulteriori informazioni sui backup incrementali, consulta [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) nella documentazione di Oracle.
La procedura utilizza i seguenti parametri comuni per le attività 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`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS for Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_level` | numero | `0`, `1` | `0` | No | Specificare `0` per abilitare un backup incrementale completo. Specificare `1` per abilitare un backup incrementale non cumulativo. |
Il seguente esempio esegue un backup incrementale dell'istanza database utilizzando i valori specificati per i parametri:
```
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;
/
```
# Esecuzione di un backup incrementale di un database del tenant
È possibile eseguire un backup incrementale del database del tenant corrente nel tuo CDB. Usa la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Per ulteriori informazioni sui backup incrementali, consulta [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) nella documentazione di Oracle Database.
La procedura si applica solo al database del tenant corrente e utilizza i seguenti parametri comuni per le attività 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`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS for Oracle:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_level` | numero | `0`, `1` | `0` | No | Specificare `0` per abilitare un backup incrementale completo. Specificare `1` per abilitare un backup incrementale non cumulativo. |
Il seguente esempio esegue un backup incrementale del database del tenant corrente utilizzando i valori specificati per i parametri.
```
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;
/
```
# Backup di uno spazio di tabella
Si può eseguire il backup di uno spazio di tabella utilizzando la procedura `rdsadmin.rdsadmin_rman_util.backup_tablespace` di Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività 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`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Un nome spazio tabella valido. | — | Sì | Il nome dello spazio tabella di cui eseguire il backup. |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup dello spazio tabella utilizzando i valori specificati per i parametri.
```
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;
/
```
# Backup di un file di controllo
Si può eseguire il backup di un file di controllo utilizzando la procedura `rdsadmin.rdsadmin_rman_util.backup_current_controlfile` di Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup di un file di controllo utilizzando i valori specificati per i parametri.
```
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;
/
```
# Esecuzione del ripristino dei supporti a blocchi
Puoi ripristinare singoli blocchi di dati, operazione nota come ripristino dei supporti a blocchi, utilizzando le procedure `rdsadmin.rdsadmin_rman_util.recover_datafile_block` di Amazon RDS. È possibile utilizzare questa procedura di overload per ripristinare un singolo blocco di dati o una serie di blocchi di dati.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Description |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Un numero ID valido per il file di dati. | — | Sì | Il file di dati contenente i blocchi danneggiati. Specifica il file di dati in uno dei seguenti modi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Intero valido. | — | Sì | Il numero di un singolo blocco da ripristinare. I parametri seguenti si escludono a vicenda: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Intero valido. | — | Sì | Il primo numero di blocco in un intervallo di blocchi da ripristinare. I parametri seguenti si escludono a vicenda: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Intero valido. | — | Sì | L’ultimo numero di blocco in un intervallo di blocchi da ripristinare. I parametri seguenti si escludono a vicenda. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L’esempio seguente ripristina il blocco 100 nel file di dati 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
L’esempio seguente ripristina i blocchi da 100 a 150 nel file di dati 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;
/
```
# Esecuzione di attività di programmazione comuni per le istanze database Oracle
Alcuni processi Scheduler di proprietà di `SYS` possono interferire con le normali operazioni di database. In questi casi, Oracle Support consiglia di modificare la pianificazione. Se è necessario abilitare o disabilitare i processi `SYS`, testa l’operazione sui processi pianificati in un ambiente di test prima di implementarla in un ambiente di produzione. Puoi utilizzare il pacchetto `rdsadmin.rdsadmin_dbms_scheduler` di Amazon RDS per eseguire le attività dai processi Oracle Scheduler di proprietà di `SYS`.
Le procedure `rdsadmin.rdsadmin_dbms_scheduler` sono supportate nelle versioni del motore di database Amazon RDS per Oracle mostrate nella tabella seguente. Quando utilizzi questo pacchetto, puoi specificare i processi `SYS` elencati nella tabella.
| Versione del database | Processi abilitati per impostazione predefinita | Processi disabilitati per impostazione predefinita |
| --- | --- | --- |
| 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
|
## Parametri comuni per procedure Oracle Scheduler
Per eseguire attività con Oracle Scheduler, puoi utilizzare le procedure del pacchetto di Amazon RDS `rdsadmin.rdsadmin_dbms_scheduler`. Nelle procedure del pacchetto ci sono diversi parametri comuni. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Le procedure elencate nella tabella in [Esecuzione di attività di programmazione comuni per le istanze database Oracle](#Appendix.Oracle.CommonDBATasks.Scheduler) | — | Sì | Il nome del processo da modificare. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Sì | Attributo da modificare Per modificare l'intervallo di ripetizione del lavoro, specificare `'REPEAT_INTERVAL'`. Per modificare il nome della pianificazione del lavoro, specificare `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Un intervallo o un nome di pianificazione valido, a seconda dell'attributo utilizzato. | – | Sì | Il nuovo valore dell'attributo. |
## Modifica dei processi di DBMS\$1SCHEDULER
Puoi utilizzare la procedura Oracle `dbms_scheduler.set_attribute` per modificare determinati componenti di Oracle Scheduler. Per ulteriori informazioni, consulta [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) e [Procedura SET\$1ATTRIBUTE](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) nella documentazione di Oracle.
Quando usi istanze database Amazon RDS, aggiungi il nome di schema `SYS` come prefisso al nome dell'oggetto. L'esempio seguente imposta l'attributo del piano delle risorse per l'oggetto finestra Lunedì.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## Modifica delle finestre di AutoTask manutenzione
Le istanze di Amazon RDS for Oracle vengono create con le impostazioni predefinite per le finestre di manutenzione. Le attività di manutenzione automatizzate come la raccolta delle statistiche dell'ottimizzatore vengono eseguite durante queste finestre. Per impostazione predefinita, le finestre di manutenzione attivano Oracle Database Resource Manager.
Per modificare la finestra, utilizzare il pacchetto `DBMS_SCHEDULER`. Potrebbe essere necessario modificare le impostazioni della finestra di manutenzione per i motivi seguenti:
+ Si desidera che i processi di manutenzione vengano eseguiti in un momento diverso, con impostazioni diverse o non del tutto. Ad esempio, è possibile modificare la durata della finestra o modificare il tempo e l'intervallo di ripetizione.
+ Si desidera evitare l'impatto sulle prestazioni dell'abilitazione di Resource Manager durante la manutenzione. Ad esempio, se viene specificato il piano di manutenzione predefinito e se si apre la finestra di manutenzione mentre il database è sotto carico, è possibile che vengano visualizzati eventi di attesa come `resmgr:cpu quantum`. Questo evento di attesa è correlato a Database Resource Manager. Sono disponibili le seguenti opzioni:
+ Assicurarsi che le finestre di manutenzione siano attive durante i periodi non di punta per l'istanza del database.
+ Disabilitare il piano di manutenzione predefinito impostando l'attributo `resource_plan` ad una stringa vuota.
+ Imposta il parametro `resource_manager_plan` su `FORCE:` nel gruppo di parametri. Se l'istanza utilizza Enterprise Edition, questa impostazione impedisce l'attivazione dei piani di Database Resource Manager.
**Per modificare le impostazioni della finestra di manutenzione**
1. Connettersi al database utilizzando un client Oracle SQL.
1. Eseguire una query sulla configurazione corrente per una finestra di scheduler.
Nell'esempio seguente viene eseguita una query sulla configurazione di `MONDAY_WINDOW`.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
Il seguente output mostra che la finestra utilizza i valori di 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. Modificare la finestra utilizzando il pacchetto `DBMS_SCHEDULER`.
Nell'esempio seguente il piano delle risorse viene impostato su null in modo che il Resource Manager non venga eseguito durante la finestra di manutenzione.
```
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;
/
```
L'esempio seguente imposta la durata massima della finestra su 2 ore.
```
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;
/
```
Nell'esempio seguente l'intervallo di ripetizione viene impostato su ogni lunedì alle 10:00.
```
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;
/
```
## Impostazione del fuso orario per i job di Oracle Scheduler
Per modificare il fuso orario per Oracle Scheduler, è possibile utilizzare la procedura Oracle `dbms_scheduler.set_scheduler_attribute`. Per ulteriori informazioni sul pacchetto `dbms_scheduler`, consulta [DBMS\$1SCHEDULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) e [SET\$1SCHEDULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) nella documentazione di Oracle.
**Per modificare l'impostazione del fuso orario corrente**
1. Connettersi al database utilizzando un client come SQL Developer. Per ulteriori informazioni, consulta [Connessione all'istanza database tramite Oracle SQL Developer](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Impostare il fuso orario predefinito come segue, sostituendo il fuso orario per `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
Nell'esempio seguente, si modifica il fuso orario in Asia/Shanghai.
Iniziare interrogando il fuso orario corrente, come illustrato di seguito.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
L'output mostra che il fuso orario corrente è ETC/UTC.
```
VALUE
-------
Etc/UTC
```
Quindi si imposta il fuso orario su Asia/Shanghai.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Per ulteriori informazioni sulla modifica del fuso orario di sistema, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md).
## Disattivazione dei processi Oracle Scheduler di proprietà di SYS
Per disattivare un processo Oracle Scheduler di proprietà dell'utente SYS, utilizza la procedura `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Questa procedura utilizza il parametro comune `name` per le attività Oracle Scheduler. Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente disabilita il lavoro Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Attivazione dei processi Oracle Scheduler di proprietà di SYS
Per attivare un processo Oracle Scheduler di proprietà SYS, utilizza la procedura `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Questa procedura utilizza il parametro comune `name` per le attività Oracle Scheduler. Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente abilita il lavoro Oracle Scheduler per `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Modifica dell'intervallo di ripetizione di Oracle Scheduler dei processi di tipo CALENDAR
Per modificare l'intervallo di ripetizione per modificare un lavoro Oracle Scheduler di proprietà SYS di tipo `CALENDAR`, utilizzare la procedura `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Questa procedura utilizza i parametri comuni seguenti per le attività Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente modifica l'intervallo di ripetizione del lavoro Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
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;
/
```
## Modifica dell'intervallo di ripetizione di Oracle Scheduler dei processi di tipo NAMED
I lavori Oracle Scheduler utilizzano il nome della pianificazione invece dell'intervallo. Per questi tipi di lavori, è necessario creare un nuovo nome di pianificazione nello schema dell'utente principale. Per questo, utilizzare la procedura standard Oracle `sys.dbms_scheduler.create_schedule`. Inoltre, utilizza `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` per assegnare le nuove pianificazioni denominate al processo.
Questa procedura utilizza i parametri comuni seguenti per le attività Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente modifica l'intervallo di ripetizione del lavoro Oracle Scheduler `SYS.BSLN_MAINTAIN_STATS_JOB`.
```
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;
/
```
## Disattivazione del commit automatico per la creazione di processi in Oracle Scheduler
`DBMS_SCHEDULER.CREATE_JOB` crea i processi Oracle Scheduler immediatamente e conferma le modifiche. Potrebbe essere necessario incorporare la creazione di processi Oracle Scheduler nella transazione utente per:
+ Eseguire il rollback del processo Oracle Schedule quando viene eseguito il rollback della transazione dell'utente.
+ Creare il processo Oracle Scheduler quando viene confermata la transazione dell'utente principale.
Puoi utilizzare la procedura `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` per attivare questo comportamento. Questa procedura non richiede parametri. È possibile utilizzare questa procedura nelle seguenti versioni di RDS per Oracle:
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 versioni successive
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 versioni successive
L'esempio seguente disattiva il commit automatico per Oracle Scheduler, crea un processo Oracle Scheduler e quindi esegue il rollback della transazione. Poiché il commit automatico è disattivato, il database esegue il rollback anche del processo 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
```
# Diagnosi dei problemi con le istanze database RDS per Oracle
Oracle Database include un'infrastruttura di diagnosi degli errori che è possibile utilizzare per analizzare i problemi del database. Nella terminologia Oracle, un *problema* è un errore critico, ad esempio un bug di codice o il danneggiamento dei dati. Un *incidente* è il verificarsi di un problema. Se lo stesso errore si verifica tre volte, l'infrastruttura mostra tre incidenti di questo problema. Per ulteriori informazioni, consulta [Diagnostica e risoluzione dei problemi](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) nella documentazione di Oracle Database.
L'utility ADRCI (Automatic Diagnostic Repository Command Interpreter) è uno strumento a riga di comando Oracle utilizzato per gestire i dati di diagnostica. Ad esempio, è possibile utilizzare questo strumento per analizzare i problemi e creare pacchetti di dati diagnostici. Un *pacchetto incidente* include dati diagnostici per un incidente o tutti gli incidenti che fanno riferimento a un problema specifico. È possibile caricare un pacchetto incidente, implementato come file zip, nel supporto Oracle.
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell ad ADRCI. Per eseguire le attività diagnostiche per l’istanza database RDS per Oracle, utilizza il pacchetto `rdsadmin.rdsadmin_adrci_util` Amazon RDS.
Utilizzando le funzioni in `rdsadmin_adrci_util`, è possibile elencare e creare pacchetti di problemi e incidenti, nonché visualizzare i file di traccia. Tutte le funzioni restituiscono un ID attività. Questo ID fa parte del nome del file di registro che contiene l'output ADRCI, come in `dbtask-task_id.log`. Il file di registro si trova nella directory BDUMP. Puoi scaricare il file di log seguendo la procedura descritta in [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
## Parametri comuni per le procedure diagnostiche
Per eseguire attività diagnostiche, utilizzare le funzioni nel pacchetto Amazon RDS `rdsadmin.rdsadmin_adrci_util`. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | numero | Un ID incidente valido o null | Null | No | Se il valore è null, la funzione mostra tutti gli incidenti. Se il valore non è null e rappresenta un ID incidente valido, la funzione mostra l'incidente specificato. |
| `problem_id` | numero | Un ID di problema valido o null | Null | No | Se il valore è null, la funzione mostra tutti i problemi. Se il valore non è null e rappresenta un ID problema valido, la funzione mostra il problema specificato. |
| `last` | numero | Un numero intero valido maggiore di 0 o null | Null | No | Se il valore è null, la funzione visualizza al massimo 50 elementi. Se il valore non è null, la funzione visualizza il numero specificato. |
## Elenco degli incidenti
Per elencare gli incidenti diagnostici per Oracle, utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`. È possibile elencare gli incidenti in modalità base o dettagliata. Per impostazione predefinita, la funzione elenca i 50 incidenti più recenti.
Questa funzione utilizza i seguenti parametri comuni:
+ `incident_id`
+ `problem_id`
+ `last`
Se specifichi `incident_id` e `problem_id`, `incident_id` sostituisce `problem_id`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Questa funzione utilizza il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `detail` | booleano | TRUE o FALSE | `FALSE` | No | Se `TRUE`, la funzione elenca gli incidenti in modalità dettaglio. Se `FALSE`, la funzione elenca gli incidenti in modalità base. |
Per elencare tutti gli incidenti, esegui una query della funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` senza argomenti. La query restituisce l'ID attività.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Oppure chiama la funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` senza argomenti e memorizza l'output in una variabile client SQL. Puoi utilizzare la variabile in altre istruzioni.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare la procedura Amazon RDS `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del file. Il seguente output mostra tre incidenti: 53523, 53522 e 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.
```
Per elencare un particolare incidente, specificarne l'ID utilizzando il parametro `incident_id`. Nell'esempio seguente, è possibile eseguire la query del file di registro solo per incidente 53523.
```
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.
```
## Elenco dei problemi
Per elencare i problemi di diagnostica per Oracle, utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`.
Per impostazione predefinita, la funzione elenca i 50 problemi più recenti.
Questa funzione utilizza i parametri comuni `problem_id` e `last`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Per ottenere l'ID attività per tutti i problemi, chiamare la funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` senza argomenti e memorizzare l'output in una variabile client SQL.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare la funzione `rdsadmin.rds_file_util.read_text_file`, fornendo l'ID attività come parte del nome del file. Nell'output seguente, il file di registro mostra tre problemi: 1, 2 e 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.
```
Nell'esempio seguente, è possibile elencare solo il problema 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Per leggere il file di registro per il problema 3, chiamare `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del 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.
```
## Creazione di pacchetti incidenti
È possibile creare pacchetti incidenti utilizzando la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package`. L'output è un file zip che è possibile fornire al supporto Oracle.
Questa funzione utilizza i seguenti parametri comuni:
+ `problem_id`
+ `incident_id`
Assicurarsi di specificare uno dei parametri precedenti. Se si specificano entrambi i parametri, `incident_id` sovrascrive `problem_id`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Per creare un pacchetto per un incidente specifico, chiamare la funzione `rdsadmin.rdsadmin_adrci_util.create_adrci_package` Amazon RDS con il parametro `incident_id`. Nell'esempio seguente viene creato un pacchetto per l'incidente 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare `rdsadmin.rds_file_util.read_text_file`. È possibile fornire l'ID attività come parte del nome del file. L'output mostra che hai generato il pacchetto incidente `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.
```
Per creare un pacchetto di dati diagnostici per un particolare problema, specificarne l'ID utilizzando il parametro `problem_id`. Nell'esempio seguente, si impacchettano i dati solo per il problema 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Per leggere l'output dell'attività, chiamare `rdsadmin.rds_file_util.read_text_file`, fornendo l'ID attività come parte del nome del file. L'output mostra che hai generato il pacchetto incidente `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.
```
Puoi anche scaricare il file di log. Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
## Visualizzazione di file di traccia
Puoi utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` per elencare i file di traccia nella directory di traccia e tutte le directory degli incidenti nella home page ADR corrente. È inoltre possibile visualizzare il contenuto dei file di traccia e dei file di traccia degli incidenti.
Questa funzione utilizza il seguente parametro.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Un nome di file di traccia valido | Null | No | Se il valore è null, la funzione visualizza tutti i file di traccia. Se non è null, la funzione mostra il file specificato. |
Per visualizzare il file di traccia, chiama la funzione `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.
```
Per elencare i nomi dei file di traccia, chiamare la procedura `rdsadmin.rds_file_util.read_text_file` Amazon RDS fornendo l'ID attività come parte del nome 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.
```
Nell’esempio seguente viene generato l’output per `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.
```
Per leggere il file di registro, chiamare `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del file. L'output mostra le prime 10 righe di 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.
```
Puoi anche scaricare il file di log. Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
# Esecuzione di varie attività per istanze database Oracle
Di seguito viene descritto come eseguire attività DBA varie sulle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
**Topics**
+ [
## Creazione ed eliminazione di directory nello spazio di archiviazione dati principale
](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [
## Generazione di un elenco dei file in una directory di istanze database
](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [
## Lettura dei file in una directory di istanze database
](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [
## Accesso ai file Opatch
](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [
## Gestione delle attività degli advisor
](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [
# Trasporto di tablespace
](rdsadmin_transport_util.md)
## Creazione ed eliminazione di directory nello spazio di archiviazione dati principale
Puoi usare la procedura in Amazon RDS per creare director `rdsadmin.rdsadmin_util.create_directory`. Puoi creare fino a 10000 directory, tutte posizionate nello spazio principale di storage dei dati. Puoi usare la procedura Amazon RDS in per eliminare le director `rdsadmin.rdsadmin_util.drop_directory`.
Le procedure `create_directory` e `drop_directory` hanno il seguente parametro obbligatorio.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Sì | Il nome della directory. |
L'esempio seguente crea una nuova directory denominata `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Il dizionario dati memorizza il nome della directory in maiuscolo. Puoi elencare le directory eseguendo query su `DBA_DIRECTORIES`. Il sistema seleziona il percorso host effettivo automaticamente. L'esempio seguente mostra ottiene il percorso di directory per la directory denominata `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Il nome utente master per l'istanza database ha privilegi di lettura e scrittura nella nuova directory e può concedere l'accesso ad altri utenti. I privilegi `EXECUTE` non sono disponibili per le directory su una istanza database. Le directory vengono create nello spazio di archiviazione dati principale e consumano spazio e larghezza di I/O banda.
L'esempio seguente elimina la directory denominata `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**Nota**
È inoltre possibile eliminare una directory utilizzando il comando Oracle SQL `DROP DIRECTORY`.
Il rilascio di una directory non rimuove i suoi contenuti. Poiché il metodo `rdsadmin.rdsadmin_util.create_directory` può riutilizzare percorsi, i file nelle directory eliminate possono apparire in una directory appena creata. Prima di eliminare una directory, si consiglia di utilizzare `UTL_FILE.FREMOVE` per rimuovere i file dalla directory. Per ulteriori informazioni, consulta la sezione relativa alla [Procedura FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) nella documentazione di Oracle.
## Generazione di un elenco dei file in una directory di istanze database
Puoi usare la procedura in Amazon RDS per elencare i file in una director `rdsadmin.rds_file_util.listdir`. Questa procedura non è supportata in una replica Oracle. La procedura `listdir` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sì | Il nome della directory da elencare. |
L'esempio seguente concede all'utente read/write i privilegi sulla directory `PRODUCT_DESCRIPTIONS``rdsadmin`, quindi elenca i file in questa directory.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Lettura dei file in una directory di istanze database
Puoi usare la procedura in Amazon RDS per leggere un file di test `rdsadmin.rds_file_util.read_text_file`. La procedura `read_text_file` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sì | Il nome della directory che contiene il file . |
| `p_filename` | varchar2 | — | Sì | Nome del file da leggere. |
Nell'esempio seguente viene creato il file `rice.txt` nella directory `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;
/
```
L'esempio seguente legge il file `rice.txt` dalla directory `PRODUCT_DESCRIPTIONS`.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Accesso ai file Opatch
Opatch è una utility Oracle che consente l'applicazione e il rollback delle patch al software Oracle. Il meccanismo Oracle per determinare quali patch sono state applicate a un database è il comando `opatch lsinventory`. Per aprire le richieste di assistenza per i clienti BYOL (Bring Your Own Licence), il supporto Oracle richiede il file `lsinventory` e talvolta il file `lsinventory_detail` generato da Opatch.
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell a Opatch. Invece, l'`lsinventory-dbv.txt` nella directory BDUMP contiene le informazioni sulla patch relative alla versione corrente del motore. Quando esegui un aggiornamento minore o importante, Amazon RDS aggiorna `lsinventory-dbv.txt` entro un'ora dall'applicazione della patch. Per verificare le patch applicate, leggere `lsinventory-dbv.txt`. Questa operazione è simile all'esecuzione del comando `opatch lsinventory`.
**Nota**
Gli esempi riportati in questa sezione presuppongono che la directory BDUMP sia denominata `BDUMP`. In una replica di lettura il nome della directory BDUMP è diverso. Per informazioni su come ottenere il nome BDUMP eseguendo una query `V$DATABASE.DB_UNIQUE_NAME` su una replica di lettura, consulta [Elenco di file](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
I file di inventario utilizzano la convenzione di denominazione di Amazon RDS `lsinventory-dbv.txt` e`lsinventory_detail-dbv.txt`, dove si *dbv* trova il nome completo della versione del database. Il file `lsinventory-dbv.txt` è disponibile in tutte le versioni DB. Il `lsinventory_detail-dbv.txt` corrispondente è disponibile nelle versioni 19.0.0.0, ru-2020-01.rur-2020-01.r1 o nelle versioni successive.
Ad esempio, se la versione del database è 19.0.0.0.ru-2021-07.rur-2021-07.r1, i file di inventario hanno i seguenti nomi.
```
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
```
Assicurarsi di scaricare i file corrispondenti alla versione corrente del motore DB.
### Console
**Per scaricare un modello di inventario utilizzando la console**
1. Aprire la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Databases (Database)**.
1. Scegliere il nome dell'istanza di database che ha il file di log che si desidera visualizzare.
1. Scegliere la scheda **Logs & events (Log ed eventi)**.
1. Scorrere fino alla sezione **Logs (Log)**.
1. Nella sezione **Log** cercare `lsinventory`.
1. Selezionare il file a cui si desidera accedere, quindi scegliere **Scarica**.
### SQL
Per leggere `lsinventory-dbv.txt` in un client SQL, è possibile utilizzare un'istruzione `SELECT`. Per questa tecnica, utilizzare una delle seguenti funzioni `rdsadmin`: `rdsadmin.rds_file_util.read_text_file` o `rdsadmin.tracefile_listing`.
Nella seguente query di esempio, sostituiscila *dbv* con la tua versione di Oracle DB. Ad esempio, la versione del DB potrebbe essere 19.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
Per leggerla `lsinventory-dbv.txt` in un client SQL, puoi scrivere un PL/SQL programma. Questo programma utilizza `utl_file` per leggere il file e `dbms_output` per stamparlo. Questi sono pacchetti forniti da Oracle.
Nel seguente programma di esempio, sostituiscilo *dbv* con la tua versione di Oracle DB. Ad esempio, la versione del DB potrebbe essere 19.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;
/
```
Oppure interrogare `rdsadmin.tracefile_listing` ed eseguire lo spooling dell'output in un file. Nell'esempio seguente viene eseguito lo spooling dell'output in `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Gestione delle attività degli advisor
Oracle Database include un certo numero di advisor. Ogni advisor supporta attività automatizzate e manuali. Puoi utilizzare le procedure nel pacchetto `rdsadmin.rdsadmin_util` per gestire alcune attività di advisor.
Le procedure delle attività di advisor sono disponibili nelle seguenti versioni del motore:
+ Oracle Database 21c (21.0.0)
+ Versione 19.0.0.0.ru-2021-01.rur-2021-01.r1 e versioni successive di Oracle Database 19c
Per ulteriori informazioni, consultare [Versione 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) nelle *Note di rilascio di Amazon RDS for Oracle*.
**Topics**
+ [
### Impostazione dei parametri per le attività di advisor
](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [
### Disattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [
### Riattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Impostazione dei parametri per le attività di advisor
Per impostare i parametri per alcune attività di advisor, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. La procedura `advisor_task_set_parameter` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sì | Il nome dell'attività di advisor di cui si desidera modificare i parametri. I valori seguenti sono validi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Sì | Il nome del parametro dell'attività. Per trovare parametri validi per un'attività di advisor, esegui la query riportata. Sostituisci *p\$1task\$1name* con un valore valido`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 | — | Sì | Il valore di un parametro di attività. Per trovare valori validi per i parametri delle attività, esegui la query riportata. Sostituire *p\$1task\$1name* con un valore valido: `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;
|
Il seguente PL/SQL programma è impostato `ACCEPT_PLANS` su `FALSE` for`SYS_AUTO_SPM_EVOLVE_TASK`. L'attività automatizzata Gestione piano SQL verifica i piani e genera un report dei risultati, ma non evolve automaticamente i piani. Puoi utilizzare un report per identificare le nuove baseline del piano SQL e accettarle manualmente.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Il seguente PL/SQL programma è `EXECUTION_DAYS_TO_EXPIRE` impostato su `10` for`AUTO_STATS_ADVISOR_TASK`. L'attività predefinita `AUTO_STATS_ADVISOR_TASK` viene eseguita automaticamente nella finestra di manutenzione una volta al giorno. Nell'esempio viene impostato il periodo di conservazione per l'esecuzione dell'attività su 10 giorni.
```
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;
```
### Disattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
Per disabilitare `AUTO_STATS_ADVISOR_TASK`, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_drop`. La procedura `advisor_task_drop` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sì | Il nome dell'attività di advisor da disabilitare. L'unico valore valido è `AUTO_STATS_ADVISOR_TASK`. |
Il seguente comando elimina `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Puoi riabilitare `AUTO_STATS_ADVISOR_TASK` utilizzando `rdsadmin.rdsadmin_util.dbms_stats_init`.
### Riattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
Per riattivare `AUTO_STATS_ADVISOR_TASK`, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_util.dbms_stats_init` . La procedura `dbms_stats_init` non richiede parametri.
Il seguente comando abilita nuovamente `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Trasporto di tablespace
Usa il pacchetto Amazon RDS `rdsadmin.rdsadmin_transport_util` per copiare un set di tablespace da un database Oracle on-premise a un'istanza database RDS per Oracle. A livello fisico, questa funzionalità tablespace trasportabile copia in modo incrementale i file di dati e metadati nell'istanza di destinazione. È possibile trasferire i file mediante Amazon EFS o Amazon S3. Per ulteriori informazioni, consulta [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md).
**Topics**
+ [
# Importazione di tablespace trasportate nell'istanza database
](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [
# Importazione dei metadati delle tablespace trasportabili nell'istanza database
](rdsadmin_transport_util_import_xtts_metadata.md)
+ [
# Elenco dei file orfani dopo un'importazione della tablespace
](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [
# Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace
](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importazione di tablespace trasportate nell'istanza database
Usa la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` per ripristinare le tablespace esportate in precedenza da un'istanza database di origine. In questa fase di trasporto, viene eseguito il backup delle tablespace di sola lettura, vengono esportati i metadati di Data Pump, vengono trasferiti questi file nell'istanza database di destinazione e quindi vengono importate le tablespace. Per ulteriori informazioni, consulta [Fase 4: trasporto delle tablespace](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Sintassi
```
FUNCTION import_xtts_tablespaces(
p_tablespace_list IN CLOB,
p_directory_name IN VARCHAR2,
p_platform_id IN NUMBER DEFAULT 13,
p_parallel IN INTEGER DEFAULT 0) RETURN VARCHAR2;
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Sì | L'elenco delle tablespace da importare. |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene i backup del tablespace. |
| `p_platform_id` | `NUMBER` | `13` | No | Fornire un ID piattaforma che corrisponde a quello specificato durante la fase di backup. Per trovare un elenco di piattaforme, esegui una query su `V$TRANSPORTABLE_PLATFORM`. La piattaforma predefinita è Linux x86 a 64 bit, che è in formato little-endian. |
| `p_parallel` | `INTEGER` | `0` | No | Il grado di parallelismo. Il parallelismo è disabilitato per impostazione predefinita. |
## Esempi
L'esempio seguente importa i tablespace *TBS1* e *TBS3* dalla directory. *TBS2* *DATA\$1PUMP\$1DIR* La piattaforma di origine è AIX-Based Systems (64 bit), identificata dall’ID `6`. È possibile trovare la piattaforma IDs eseguendo una query. `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
```
# Importazione dei metadati delle tablespace trasportabili nell'istanza database
Utilizza la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` per importare i metadati delle tablespace trasportabili nell'istanza database RDS per Oracle. Durante l'operazione, lo stato dell'importazione dei metadati viene visualizzato nella tabella `rdsadmin.rds_xtts_operation_info`. Per ulteriori informazioni, consulta [Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Sintassi
```
PROCEDURE import_xtts_metadata(
p_datapump_metadata_file IN SYS.DBA_DATA_FILES.FILE_NAME%TYPE,
p_directory_name IN VARCHAR2,
p_exclude_stats IN BOOLEAN DEFAULT FALSE,
p_remap_tablespace_list IN CLOB DEFAULT NULL,
p_remap_user_list IN CLOB DEFAULT NULL);
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Sì | Il nome del file Oracle Data Pump che contiene i metadati per le tablespace trasportabili. |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene il file Data Pump. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | No | Flag che indica se escludere le statistiche. |
| `p_remap_tablespace_list` | `CLOB` | NULL | No | Un elenco delle tablespace che devono essere rimappate durante l'importazione dei metadati. Utilizzare il formato `from_tbs:to_tbs`. Ad esempio, specifica `users:user_data`. |
| `p_remap_user_list` | `CLOB` | NULL | No | Un elenco di schemi utente che devono essere rimappati durante l'importazione dei metadati. Utilizzare il formato `from_schema_name:to_schema_name`. Ad esempio, specifica `hr:human_resources`. |
## Esempi
L'esempio importa i metadati del tablespace dal file*xttdump.dmp*, che si trova nella directory. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Elenco dei file orfani dopo un'importazione della tablespace
Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per elencare i file di dati che sono rimasti orfani dopo un'importazione della tablespace. Dopo aver identificato i file di dati, puoi eliminarli chiamando `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
## Sintassi
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Esempi
L'esempio seguente esegue la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`. L'output mostra due file di dati che sono rimasti orfani.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace
Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per eliminare i file di dati che sono rimasti orfani dopo un'importazione della tablespace. L'esecuzione di questo comando genera un file di log che utilizza il formato del nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` nella directory `BDUMP`. Usa la procedura `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` per trovare i file rimasti orfani. Puoi leggere il file di log chiamando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Fase 6: rimozione dei file residui](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Sintassi
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene i file di dati rimasti orfani. |
## Esempi
L'esempio seguente elimina i file di dati orfani in. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'esempio seguente legge il file di log generato dal comando precedente.
```
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.
```