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à.
# Informazioni di riferimento sulle stored procedure di Amazon RDS per Db2
È possibile gestire le istanze database Amazon RDS per Db2 che eseguono il motore Db2 chiamando le stored procedure integrate.
| Stored procedure | Categoria | Description |
| --- | --- | --- |
| [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database) | Database | La stored procedure `rdsadmin.activate_database` consente di attivare un database su un’istanza database RDS per Db2 autonoma. |
| [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.add_groups` consente di aggiungere uno o più gruppi a un utente per un database su un’istanza database RDS per Db2. |
| [rdsadmin.add\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-add-user) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.add_user` consente di aggiungere un utente a un elenco di autorizzazioni per un database su un’istanza database RDS per Db2. |
| [rdsadmin.alter\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-alter-buffer-pool) | Pool di buffer | La stored procedure `rdsadmin.alter_bufferpool` consente di modificare un pool di buffer per un database su un’istanza database RDS per Db2. |
| [rdsadmin.alter\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-alter-tablespace) | Tablespace | La stored procedure `rdsadmin.alter_tablespace` consente di modificare un tablespace per un database su un’istanza database RDS per Db2. |
| [rdsadmin.backup\$1database](db2-sp-managing-databases.md#db2-sp-backup-database) | Database | Utilizza la `rdsadmin.backup_database` stored procedure per eseguire il backup di un database su un'istanza DB RDS for Db2 su un bucket Amazon S3. Quindi puoi ripristinare il backup da Amazon S3 su un'istanza DB RDS for Db2 o in un'altra posizione, ad esempio un server locale. |
| [rdsadmin.catalog\$1storage\$1access](db2-sp-managing-storage-access.md#db2-sp-catalog-storage-access) | Accesso all’archiviazione | La stored procedure `rdsadmin.catalog_storage_access` consente di catalogare un alias di archiviazione per l’accesso a un bucket Amazon S3 con file di dati Db2 per un database su un’istanza database RDS per Db2. |
| [rdsadmin.change\$1password](db2-sp-granting-revoking-privileges.md#db2-sp-change-password) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.change_password` consente di modificare la password di un utente per un database su un’istanza database RDS per Db2. |
| [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward) | Database | La stored procedure `rdsadmin.complete_rollforward` consente di portare online un database su un’istanza database RDS per Db2 da uno stato `ROLL-FORWARD PENDING`. Lo stato `ROLL-FORWARD PENDING` si verifica quando si chiama [rdsadmin.rollforward\$1database](db2-sp-managing-databases.md#db2-sp-rollforward-database) ma il parametro `complete_rollforward` è impostato su `FALSE`. |
| [rdsadmin.configure\$1db\$1audit](db2-sp-managing-audit-policies.md#db2-sp-configure-db-audit) | Policy di audit | La stored procedure `rdsadmin.configure_db_audit` consente di modificare una policy di audit per un database su un’istanza database RDS per Db2. Se non esiste alcuna policy di audit, l’esecuzione di questa stored procedure ha l’effetto di crearne una. |
| [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool) | Pool di buffer | La stored procedure `rdsadmin.create_bufferpool` consente di creare un pool di buffer per un database su un’istanza database RDS per Db2. |
| [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database) | Database | La stored procedure `rdsadmin.create_database` consente di creare un database su un’istanza database RDS per Db2. |
| [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.create_role` consente di creare un ruolo da collegare a un database su un’istanza database RDS per Db2. |
| [rdsadmin.create\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-create-tablespace) | Tablespace | La stored procedure `rdsadmin.create_tablespace` consente di creare un tablespace per un database su un’istanza database RDS per Db2. |
| [rdsadmin.db2pd\$1command](db2-sp-managing-databases.md#db2-sp-db2pd-command) | Database | La stored procedure `rdsadmin.db2pd_command` consente di raccogliere informazioni su un database su un’istanza database RDS per Db2. Queste informazioni possono aiutare a monitorare e risolvere i problemi relativi ai database in RDS per Db2. |
| [rdsadmin.db2support\$1command](db2-sp-managing-databases.md#db2-sp-db2support-command) | Database | Utilizza la procedura `rdsadmin.db2support_command` memorizzata per raccogliere informazioni diagnostiche su un database su un'istanza DB RDS for Db2 e caricarle in un bucket Amazon S3. |
| [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.dbadm_grant` consente di concedere uno o più tipi di autorizzazione (`DBADM`, `ACCESSCTRL` o `DATAACCESS`) a uno o più ruoli, utenti o gruppi per un database su un’istanza database RDS per Db2. |
| [rdsadmin.dbadm\$1revoke](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-revoke) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.dbadm_revoke` consente di revocare uno o più tipi di autorizzazione (`DBADM`, `ACCESSCTRL` o `DATAACCESS`) a uno o più ruoli, utenti o gruppi per un database su un’istanza database RDS per Db2. |
| [rdsadmin.deactivate\$1database](db2-sp-managing-databases.md#db2-sp-deactivate-database) | Database | La stored procedure `rdsadmin.deactivate_database` consente di disattivare un database su un’istanza database RDS per Db2. È possibile disattivare i database per risparmiare risorse di memoria. |
| [rdsadmin.disable\$1db\$1audit](db2-sp-managing-audit-policies.md#db2-sp-disable-db-audit) | Policy di audit | La stored procedure `rdsadmin.disable_db_audit` consente di arrestare la registrazione di log di audit e rimuovere una policy di audit da un database su un’istanza database RDS per Db2. |
| [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool) | Pool di buffer | La stored procedure `rdsadmin.drop_bufferpool` consente di rimuovere un pool di buffer da un database su un’istanza database RDS per Db2. |
| [rdsadmin.drop\$1database](db2-sp-managing-databases.md#db2-sp-drop-database) | Database | La stored procedure `rdsadmin.drop_database` consente di rimuovere un database da un’istanza database RDS per Db2. |
| [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.drop_role` consente di eliminare un ruolo da un database su un’istanza database RDS per Db2. |
| [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace) | Tablespace | La stored procedure `rdsadmin.drop_tablespace` consente di rimuovere un tablespace da un database su un’istanza database RDS per Db2. |
| [rdsadmin.fgac\$1command](db2-sp-managing-databases.md#db2-sp-fgac-command) | Database | Utilizza la `rdsadmin.fgac_command` stored procedure per controllare l'accesso a livello di riga o colonna ai dati di tabella nel tuo database su un'istanza DB RDS for Db2. |
| [rdsadmin.force\$1application](db2-sp-managing-databases.md#db2-sp-force-application) | Database | La stored procedure `rdsadmin.force_application` consente di forzare la disconnessione delle applicazioni da un database su un’istanza database RDS per Db2 al fine di eseguire attività di manutenzione. |
| [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.grant_role` consente di assegnare un ruolo a un ruolo, a un utente o a un gruppo in un database su un’istanza database RDS per Db2. È possibile utilizzare questa stored procedure anche per concedere a un ruolo l’autorizzazione `DBADM` per assegnare ruoli. |
| [rdsadmin.list\$1archive\$1log\$1information](db2-sp-managing-databases.md#db2-sp-list-archive-log-information) | Database | La stored procedure `rdsadmin.list_archive_log_information` consente di restituire informazioni sui log di archivio per un database su un’istanza database RDS per Db2. Le informazioni restituite includono dettagli quali la dimensione e la data di creazione di singoli file di log e l’archiviazione totale utilizzata dai file di log di archivio. |
| [rdsadmin.list\$1sid\$1group\$1mapping](db2-sp-granting-revoking-privileges.md#db2-sp-list-sid-group-mapping) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.list_sid_group_mapping` consente di restituire un elenco di tutte le mappature di ID di sicurezza (SID) e gruppi di Active Directory configurate su un’istanza database RDS per Db2. |
| [rdsadmin.list\$1users](db2-sp-granting-revoking-privileges.md#db2-sp-list-users) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.list_users` consente di restituire un elenco di utenti su un elenco di autorizzazioni per un database su un’istanza database RDS per Db2. |
| [rdsadmin.reactivate\$1database](db2-sp-managing-databases.md#db2-sp-reactivate-database) | Database | La stored procedure `rdsadmin.reactivate_database` consente di riattivare un database su un’istanza database RDS per Db2 dopo aver apportato modifiche alla configurazione del database. Per un database su un’istanza database autonoma, è possibile utilizzare questa stored procedure o la stored procedure [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database). Per un database su un’istanza database di origine replica, è necessario utilizzare la stored procedure `rdsadmin.reactivate_database`. |
| [rdsadmin.remove\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-remove-groups) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.remove_groups` consente di rimuovere uno o più gruppi da un utente per un database su un’istanza database RDS per Db2. |
| [rdsadmin.remove\$1sid\$1group\$1mapping](db2-sp-granting-revoking-privileges.md#db2-sp-remove-sid-group-mapping) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.remove_sid_group_mapping` consente di rimuovere una mappatura di ID di sicurezza (SID) e gruppo di Active Directory corrispondente da un’istanza database RDS per Db2. |
| [rdsadmin.remove\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-remove-user) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.remove_user` consente di rimuovere un utente da un elenco di autorizzazioni per un database su un’istanza database RDS per Db2. |
| [rdsadmin.rename\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-rename-tablespace) | Tablespace | La stored procedure `rdsadmin.rename_tablespace` consente di rinominare un tablespace per un database su un’istanza database RDS per Db2. |
| [rdsadmin.restore\$1database](db2-sp-managing-databases.md#db2-sp-restore-database) | Database | La stored procedure `rdsadmin.restore_database` consente di ripristinare un database su un’istanza database RDS per Db2 da un bucket Amazon S3. |
| [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.revoke_role` consente di revocare un ruolo a un ruolo, a un utente o a un gruppo assegnatario in un database su un’istanza database RDS per Db2. |
| [rdsadmin.rollforward\$1database](db2-sp-managing-databases.md#db2-sp-rollforward-database) | Database | La stored procedure `rdsadmin.rollforward_database` consente di portare online un database su un’istanza database RDS per Db2 e di applicare i log delle transazioni dopo aver ripristinato un database su un’istanza database RDS per Db2 tramite una chiamata a [rdsadmin.restore\$1database](db2-sp-managing-databases.md#db2-sp-restore-database). |
| [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status) | Database | La stored procedure `rdsadmin.rollforward_status` consente di interrogare lo stato di rollforward della chiamata alla stored procedure [rdsadmin.rollforward\$1database](db2-sp-managing-databases.md#db2-sp-rollforward-database) o [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward) su un’istanza database RDS per Db2. |
| [rdsadmin.set\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-set-archive-log-retention) | Database | La stored procedure `rdsadmin.set_archive_log_retention` consente di configurare il periodo di tempo di conservazione dei file di log di archivio per un database su un’istanza database RDS per Db2. È possibile utilizzare questa stored procedure anche per disabilitare la conservazione dei log di archivio. |
| [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration) | Database | La stored procedure `rdsadmin.set_configuration` consente di configurare determinate impostazioni per un database su un’istanza database RDS per Db2. |
| [rdsadmin.set\$1sid\$1group\$1mapping](db2-sp-granting-revoking-privileges.md#db2-sp-set-sid-group-mapping) | Concessione e revoca dei privilegi | La stored procedure `rdsadmin.set_sid_group_mapping` consente di creare una mappatura di ID di sicurezza (SID) e gruppo di Active Directory corrispondente su un’istanza database RDS per Db2. |
| [rdsadmin.show\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-show-archive-log-retention) | Database | La stored procedure rdsadmin.show\$1archive\$1log\$1retention consente di restituire l’impostazione corrente relativa alla conservazione dei file di log di archivio per un database su un’istanza database RDS per Db2. |
| [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration) | Database | La stored procedure rdsadmin.show\$1configuration consente di restituire una o più impostazioni modificabili per un database su un’istanza database RDS per Db2. |
| [rdsadmin.uncatalog\$1storage\$1access](db2-sp-managing-storage-access.md#db2-sp-uncatalog-storage-access) | Accesso all’archiviazione | La stored procedure `rdsadmin.uncatalog_storage_access` consente di rimuovere un alias di archiviazione per l’accesso a un bucket Amazon S3 con file di dati Db2. |
| [rdsadmin.update\$1db\$1param](db2-sp-managing-databases.md#db2-sp-update-db-param) | Database | La stored procedure rdsadmin.update\$1db\$1param consente di aggiornare i parametri per un database su un’istanza database RDS per Db2. |
| [rdsadmin.enable\$1archive\$1log\$1copy](db2-sp-managing-databases.md#db2-sp-enable_archive_log_copy) | Database | Utilizza la rdsadmin.enable\$1archive\$1log\$1copy stored procedure per abilitare la copia del log di archivio del database RDS Db2 su Amazon S3. |
| [rdsadmin.disable\$1archive\$1log\$1copy](db2-sp-managing-databases.md#db2-sp-disable_archive_log_copy) | Database | Utilizza la rdsadmin.disable\$1archive\$1log\$1copy stored procedure per disabilitare la copia del log di archivio del database RDS Db2 su Amazon S3. |
**Topics**
+ [Considerazioni per le stored procedure di Amazon RDS per Db2](db2-stored-procedures-considerations.md)
+ [Stored procedure per la concessione e la revoca dei privilegi per RDS per Db2](db2-sp-granting-revoking-privileges.md)
+ [Stored procedure relative alle policy di audit per RDS per Db2](db2-sp-managing-audit-policies.md)
+ [Stored procedure relative a pool di buffer per RDS per Db2](db2-sp-managing-buffer-pools.md)
+ [Stored procedure relative ai database per RDS per Db2](db2-sp-managing-databases.md)
+ [Stored procedure per l’accesso all’archiviazione per RDS per Db2](db2-sp-managing-storage-access.md)
+ [Stored procedure relative ai tablespace per RDS per Db2](db2-sp-managing-tablespaces.md)
# Considerazioni per le stored procedure di Amazon RDS per Db2
Prima di utilizzare le stored procedure di sistema di Amazon RDS per le istanze database RDS per Db2 che eseguono il motore Db2, esamina le seguenti informazioni:
+ Prima di eseguire le stored procedure, devi prima connetterti al database `rdsadmin` come utente master per l’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
+ Le stored procedure restituiscono il parametro `ERR_MESSAGE`, che indica se la stored procedure ha avuto esito positivo o negativo e il motivo dell’eventuale esito negativo.
**Esempi**
L’esempio seguente indica che la stored procedure ha avuto esito positivo.
```
Parameter Name : ERR_MESSAGE
Parameter Value : -
Return Status = 0
```
L’esempio seguente indica che la stored procedure ha avuto esito negativo perché il nome del bucket Amazon S3 utilizzato nella stored procedure non era valido.
```
Parameter Name : ERR_MESSAGE
Parameter Value : Invalid S3 bucket name
Return Status = -1006
```
Per i messaggi di errore restituiti durante le chiamate alle stored procedure, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
Per informazioni su come verificare lo stato di una stored procedure, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
# Stored procedure per la concessione e la revoca dei privilegi per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono utenti, ruoli, gruppi e autorizzazioni per i database Amazon RDS per Db2. Per eseguire queste procedure, l’utente master deve prima connettersi al database `rdsadmin`.
Per le attività che utilizzano queste stored procedure, consulta [Concessione e revoca dei privilegi](db2-granting-revoking-privileges.md) e [Configurazione dell’autenticazione Kerberos](db2-kerberos-setting-up.md).
Fai riferimento alle seguenti stored procedure integrate per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi.
**Topics**
+ [rdsadmin.create\$1role](#db2-sp-create-role)
+ [rdsadmin.grant\$1role](#db2-sp-grant-role)
+ [rdsadmin.revoke\$1role](#db2-sp-revoke-role)
+ [rdsadmin.drop\$1role](#db2-sp-drop-role)
+ [rdsadmin.add\$1user](#db2-sp-add-user)
+ [rdsadmin.change\$1password](#db2-sp-change-password)
+ [rdsadmin.list\$1users](#db2-sp-list-users)
+ [rdsadmin.remove\$1user](#db2-sp-remove-user)
+ [rdsadmin.add\$1groups](#db2-sp-add-groups)
+ [rdsadmin.remove\$1groups](#db2-sp-remove-groups)
+ [rdsadmin.dbadm\$1grant](#db2-sp-dbadm-grant)
+ [rdsadmin.dbadm\$1revoke](#db2-sp-dbadm-revoke)
+ [rdsadmin.set\$1sid\$1group\$1mapping](#db2-sp-set-sid-group-mapping)
+ [rdsadmin.list\$1sid\$1group\$1mapping](#db2-sp-list-sid-group-mapping)
+ [rdsadmin.remove\$1sid\$1group\$1mapping](#db2-sp-remove-sid-group-mapping)
## rdsadmin.create\$1role
Crea un ruolo.
### Sintassi
```
db2 "call rdsadmin.create_role(
'database_name',
'role_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*role\$1name*
Il nome del ruolo da creare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della creazione di un ruolo, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente crea un ruolo denominato `MY_ROLE` per il database `DB2DB`.
```
db2 "call rdsadmin.create_role(
'DB2DB',
'MY_ROLE')"
```
## rdsadmin.grant\$1role
Assegna un ruolo a un ruolo, a un utente o a un gruppo.
### Sintassi
```
db2 "call rdsadmin.grant_role(
?,
'database_name',
'role_name',
'grantee',
'admin_option')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che restituisce l’identificatore univoco dell’attività. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*role\$1name*
Il nome del ruolo da creare. Il tipo di dati è `varchar`.
*grantee*
Il ruolo, l’utente o il gruppo che riceverà l’autorizzazione. Il tipo di dati è `varchar`. Valori validi: `ROLE`, `USER`, `GROUP`, `PUBLIC`.
Il formato deve essere un valore seguito dal nome. Per separare più valori e nomi, utilizza le virgole. Esempio: '`USER user1, user2, GROUP group1, group2`'. Sostituisci i nomi con le tue informazioni.
Il parametro di input seguente è facoltativo:
*admin\$1option*
Specifica se l’assegnatario `ROLE` dispone dell’autorizzazione `DBADM` per assegnare ruoli. Il tipo di dati è `char`. Il valore predefinito è `N`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’assegnazione di un ruolo, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: assegnazione di un ruolo a un ruolo, a un utente e a un gruppo e concessione dell’autorizzazione**
L’esempio seguente assegna un ruolo denominato `ROLE_TEST` per il database `TESTDB` al ruolo `role1`, all’utente `user1` e al gruppo `group1`. `ROLE_TEST` riceve l’autorizzazione di amministratore per l’assegnazione di ruoli.
```
db2 "call rdsadmin.grant_role(
?,
'TESTDB',
'ROLE_TEST',
'ROLE role1, USER user1, GROUP group1',
'Y')"
```
**Esempio 2: assegnazione di un ruolo a `PUBLIC` senza concessione dell’autorizzazione**
L’esempio seguente assegna un ruolo denominato `ROLE_TEST` per il database `TESTDB` a `PUBLIC`. `ROLE_TEST` non riceve l’autorizzazione di amministratore per l’assegnazione di ruoli.
```
db2 "call rdsadmin.grant_role(
?,
'TESTDB',
'ROLE_TEST',
'PUBLIC')"
```
## rdsadmin.revoke\$1role
Revoca un ruolo a un ruolo, a un utente o a un gruppo.
### Sintassi
```
db2 "call rdsadmin.revoke_role(
?,
'database_name',
'role_name',
'grantee')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che restituisce l’identificatore univoco dell’attività. Questo parametro accetta solo ?.
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*role\$1name*
Il nome del ruolo da revocare. Il tipo di dati è `varchar`.
*grantee*
Il ruolo, l’utente o il gruppo che perderà l’autorizzazione. Il tipo di dati è `varchar`. Valori validi: `ROLE`, `USER`, `GROUP`, `PUBLIC`.
Il formato deve essere un valore seguito dal nome. Per separare più valori e nomi, utilizza le virgole. Esempio: '`USER user1, user2, GROUP group1, group2`'. Sostituisci i nomi con le tue informazioni.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della revoca di un ruolo, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: revoca di un ruolo a un ruolo, a un utente e a un gruppo**
L’esempio seguente revoca un ruolo denominato `ROLE_TEST` per il database `TESTDB` al ruolo `role1`, all’utente `user1` e al gruppo `group1`.
```
db2 "call rdsadmin.revoke_role(
?,
'TESTDB',
'ROLE_TEST',
'ROLE role1, USER user1, GROUP group1')"
```
**Esempio 2: revoca del ruolo a `PUBLIC`**
L’esempio seguente revoca un ruolo denominato `ROLE_TEST` per il database `TESTDB` a `PUBLIC`.
```
db2 "call rdsadmin.revoke_role(
?,
'TESTDB',
'ROLE_TEST',
'PUBLIC')"
```
## rdsadmin.drop\$1role
Elimina un ruolo.
### Sintassi
```
db2 "call rdsadmin.drop_role(
?,
'database_name',
'role_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che restituisce l’identificatore univoco dell’attività. Questo parametro accetta solo ?.
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*role\$1name*
Il nome del ruolo da eliminare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’eliminazione di un ruolo, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente elimina un ruolo denominato `ROLE_TEST` per il database `TESTDB`.
```
db2 "call rdsadmin.drop_role(
?,
'TESTDB',
'ROLE_TEST')"
```
## rdsadmin.add\$1user
Aggiunge un utente a un elenco di autorizzazioni.
### Sintassi
```
db2 "call rdsadmin.add_user(
'username',
'password',
'group_name,group_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
*username*
Il nome utente dell’utente. Il tipo di dati è `varchar`.
*password*
La password dell’utente. Il tipo di dati è `varchar`.
Il parametro seguente è facoltativo:
*group\$1name*
Il nome di un gruppo a cui aggiungere l’utente. Il tipo di dati è `varchar`. L’impostazione predefinita è una stringa vuota o null.
### Note per l’utilizzo
Per aggiungere un utente a uno o più gruppi, separa i nomi dei gruppi con virgole.
Puoi creare un gruppo quando crei un nuovo utente o quando [aggiungi un gruppo a un utente esistente](db2-granting-revoking-privileges.md#add-group-to-user). Non puoi creare un gruppo da solo.
**Nota**
Il numero massimo di utenti che puoi aggiungere chiamando `rdsadmin.add_user` è 5.000.
Per informazioni su come verificare lo stato dell’aggiunta di un utente, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente crea un utente denominato `jorge_souza` e assegna l’utente ai gruppi `sales` e `inside_sales`.
```
db2 "call rdsadmin.add_user(
'jorge_souza',
'*******',
'sales,inside_sales')"
```
## rdsadmin.change\$1password
Modifica la password di un utente.
### Sintassi
```
db2 "call rdsadmin.change_password(
'username',
'new_password')"
```
### Parameters
I parametri seguenti sono obbligatori:
*username*
Il nome utente dell’utente. Il tipo di dati è `varchar`.
*new\$1password*
La nuova password per l’utente. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della modifica di una password, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente modifica la password per `jorge_souza`.
```
db2 "call rdsadmin.change_password(
'jorge_souza',
'*******')"
```
## rdsadmin.list\$1users
Inserisce gli utenti in un elenco di autorizzazioni.
### Sintassi
```
db2 "call rdsadmin.list_users()"
```
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’inserimento di utenti in un elenco, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
## rdsadmin.remove\$1user
Rimuove un utente dall’elenco di autorizzazioni.
### Sintassi
```
db2 "call rdsadmin.remove_user('username')"
```
### Parameters
Il parametro seguente è obbligatorio:
*username*
Il nome utente dell’utente. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della rimozione di un utente, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente impedisce a `jorge_souza` di accedere ai database nelle istanze database RDS per Db2.
```
db2 "call rdsadmin.remove_user('jorge_souza')"
```
## rdsadmin.add\$1groups
Aggiunge gruppi a un utente.
### Sintassi
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
*username*
Il nome utente dell’utente. Il tipo di dati è `varchar`.
*group\$1name*
Il nome di un gruppo a cui aggiungere l’utente. Il tipo di dati è `varchar`. L'impostazione predefinita è una stringa vuota.
### Note per l’utilizzo
Per aggiungere uno o più gruppi a un utente, separa i nomi dei gruppi con virgole. Per informazioni su come verificare lo stato dell’aggiunta di gruppi, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente aggiunge i gruppi `direct_sales` e `b2b_sales` all’utente `jorge_souza`.
```
db2 "call rdsadmin.add_groups(
'jorge_souza',
'direct_sales,b2b_sales')"
```
## rdsadmin.remove\$1groups
Rimuove gruppi da un utente.
### Sintassi
```
db2 "call rdsadmin.remove_groups(
'username',
'group_name,group_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
*username*
Il nome utente dell’utente. Il tipo di dati è `varchar`.
*group\$1name*
Il nome di un gruppo da cui rimuovere l’utente. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per rimuovere uno o più gruppi da un utente, separa i nomi dei gruppi con virgole.
Per informazioni su come verificare lo stato della rimozione di gruppi, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente rimuove i gruppi `direct_sales` e `b2b_sales` dall’utente `jorge_souza`.
```
db2 "call rdsadmin.remove_groups(
'jorge_souza',
'direct_sales,b2b_sales')"
```
## rdsadmin.dbadm\$1grant
Concede l’autorizzazione `DBADM`, `ACCESSCTRL` o `DATAACCESS` a un ruolo, a un utente o a un gruppo.
### Sintassi
```
db2 "call rdsadmin.dbadm_grant(
?,
'database_name',
'authorization',
'grantee')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che restituisce l’identificatore univoco dell’attività. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*authorization*
Il tipo di autorizzazione da concedere. Il tipo di dati è `varchar`. Valori validi: `DBADM`, `ACCESSCTRL`, `DATAACCESS`.
Per separare più tipi, utilizza le virgole.
*grantee*
Il ruolo, l’utente o il gruppo che riceverà l’autorizzazione. Il tipo di dati è `varchar`. Valori validi: `ROLE`, `USER`, `GROUP`.
Il formato deve essere un valore seguito dal nome. Per separare più valori e nomi, utilizza le virgole. Esempio: '`USER user1, user2, GROUP group1, group2`'. Sostituisci i nomi con le tue informazioni.
### Note per l’utilizzo
Il ruolo che riceverà l’autorizzazione di accesso deve essere già presente.
Per informazioni su come verificare lo stato della concessione dell’autorizzazione di accesso come amministratore del database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: concessione dell’autorizzazione di accesso come amministratore del database a un ruolo**
L’esempio seguente concede l’autorizzazione di accesso come amministratore del database `TESTDB` al ruolo `ROLE_DBA`.
```
db2 "call rdsadmin.dbadm_grant(
?,
'TESTDB',
'DBADM',
'ROLE ROLE_DBA')"
```
**Esempio 2: concessione dell’autorizzazione di accesso come amministratore del database a un utente e a un gruppo**
L’esempio seguente concede l’autorizzazione di accesso come amministratore del database `TESTDB` a `user1` e `group1`.
```
db2 "call rdsadmin.dbadm_grant(
?,
'TESTDB',
'DBADM',
'USER user1, GROUP group1')"
```
**Esempio 3: concessione dell’autorizzazione di accesso come amministratore del database a più utenti e gruppi**
L’esempio seguente concede l’autorizzazione di accesso come amministratore del database `TESTDB` a `user1`, `user2`, `group1` e `group2`.
```
db2 "call rdsadmin.dbadm_grant(
?,
'TESTDB',
'DBADM',
'USER user1, user2, GROUP group1, group2')"
```
## rdsadmin.dbadm\$1revoke
Revoca l’autorizzazione `DBADM`, `ACCESSCTRL` o `DATAACCESS` a un ruolo, a un utente o a un gruppo.
### Sintassi
```
db2 "call rdsadmin.dbadm_revoke(
?,
'database_name',
'authorization',
'grantee')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Identificatore univoco dell'attività. Questo parametro accetta solo `?`.
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui verrà eseguito il comando. Il tipo di dati è `varchar`.
*authorization*
Il tipo di autorizzazione da revocare. Il tipo di dati è `varchar`. Valori validi: `DBADM`, `ACCESSCTRL`, `DATAACCESS`.
Per separare più tipi, utilizza le virgole.
*grantee*
Il ruolo, l’utente o il gruppo a cui revocare l’autorizzazione. Il tipo di dati è `varchar`. Valori validi: `ROLE`, `USER`, `GROUP`.
Il formato deve essere un valore seguito dal nome. Per separare più valori e nomi, utilizza le virgole. Esempio: '`USER user1, user2, GROUP group1, group2`'. Sostituisci i nomi con le tue informazioni.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della revoca dell’autorizzazione di accesso come amministratore del database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: revoca dell’autorizzazione di accesso come amministratore del database a un ruolo**
L’esempio seguente revoca l’autorizzazione di accesso come amministratore del database `TESTDB` al ruolo `ROLE_DBA`.
```
db2 "call rdsadmin.dbadm_revoke(
?,
'TESTDB',
'DBADM',
'ROLE ROLE_DBA')"
```
**Esempio 2: revoca dell’autorizzazione di accesso come amministratore del database a un utente e a un gruppo**
L’esempio seguente revoca l’autorizzazione di accesso come amministratore del database `TESTDB` a `user1` e `group1`.
```
db2 "call rdsadmin.dbadm_revoke(
?,
'TESTDB',
'DBADM',
'USER user1, GROUP group1')"
```
**Esempio 3: revoca dell’autorizzazione di accesso come amministratore del database a più utenti e gruppi**
L’esempio seguente revoca l’autorizzazione di accesso come amministratore del database `TESTDB` a `user1`, `user2`, `group1` e `group2`.
```
db2 "call rdsadmin.dbadm_revoke(
?,
'TESTDB',
'DBADM',
'USER user1, user2, GROUP group1, group2')"
```
## rdsadmin.set\$1sid\$1group\$1mapping
Crea una mappatura tra un ID di sicurezza (SID) e il gruppo Active Directory corrispondente.
### Sintassi
```
db2 "call rdsadmin.set_sid_group_mapping(
?,
'SID',
'group_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*SID*
L’ID di sicurezza. Il tipo di dati è `varchar`.
*group\$1name*
Il nome del gruppo Active Directory da mappare al SID. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Utilizza questa stored procedure per abilitare l’autenticazione Kerberos con i gruppi Active Directory. Se il valore di `SID` o `group_name` è già presente nella mappatura, questa stored procedure ha esito negativo.
Per informazioni su come trovare il SID per un gruppo, consulta [Fase 8: Recuperare il SID del gruppo Active Directory in PowerShellPassaggio 8: Recuperare il SID del gruppo Active Directory in PowerShell](db2-kerberos-setting-up.md#db2-kerberos-setting-up-retrieve-ad-group-sid).
Per informazioni su come verificare lo stato della creazione di una mappatura, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente mappa un SID a un gruppo denominato `my_group`.
```
db2 "call rdsadmin.set_sid_group_mapping(
?,
'S-1-5-21-9146495592-531070549-834388463-513',
'my_group')"
```
## rdsadmin.list\$1sid\$1group\$1mapping
Elenca tutte le mappature di SID e gruppi Active Directory configurate sull’istanza database.
### Sintassi
```
db2 "call rdsadmin.list_sid_group_mapping()"
```
### Note per l’utilizzo
Per informazioni su come verificare lo stato della creazione di un elenco di mappature, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
## rdsadmin.remove\$1sid\$1group\$1mapping
Rimuove una mappatura tra un SID e il gruppo Active Directory corrispondente da un’istanza database.
### Sintassi
```
db2 "call rdsadmin.remove_sid_group_mapping(
?,
'SID')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*SID*
L’ID di sicurezza. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come trovare il SID per un gruppo, consulta [Fase 8: Recuperare il SID del gruppo Active Directory in PowerShellPassaggio 8: Recuperare il SID del gruppo Active Directory in PowerShell](db2-kerberos-setting-up.md#db2-kerberos-setting-up-retrieve-ad-group-sid).
Per informazioni su come verificare lo stato della rimozione di mappature, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente rimuove la mappatura di un SID dal gruppo per cui è stata creata.
```
db2 "call rdsadmin.remove_sid_group_mapping(
?,
'S-1-5-21-9146495592-531070549-834388463-513')"
```
# Stored procedure relative alle policy di audit per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono le policy di audit per i database Amazon RDS per Db2. Per ulteriori informazioni, consulta [Registrazione di log di audit Db2](Db2.Options.Audit.md). Per eseguire queste procedure, l’utente master deve prima connettersi al database `rdsadmin`.
Fai riferimento alle seguenti stored procedure integrate per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi.
**Topics**
+ [rdsadmin.configure\$1db\$1audit](#db2-sp-configure-db-audit)
+ [rdsadmin.disable\$1db\$1audit](#db2-sp-disable-db-audit)
## rdsadmin.configure\$1db\$1audit
Configura la politica di controllo per il database RDS for Db2 specificato da. *db\$1name* Se la policy da configurare non esiste, viene creata automaticamente al momento della chiamata a questa stored procedure. Se invece la policy esiste, la chiamata a questa stored procedure ne determina la modifica in base ai valori dei parametri specificati.
### Sintassi
```
db2 "call rdsadmin.configure_db_audit(
'db_name',
'category',
'category_setting',
'?')"
```
### Parameters
I parametri seguenti sono obbligatori.
*db\$1name*
Il nome del database RDS per Db2 per cui configurare la policy di audit. Il tipo di dati è `varchar`.
*category*
Il nome della categoria per cui configurare la policy di audit. Il tipo di dati è `varchar`. Di seguito sono elencati i valori validi per questo parametro:
+ `ALL`: con `ALL`, Amazon RDS non include le categorie `CONTEXT`, `EXECUTE` e `ERROR`.
+ `AUDIT`
+ `CHECKING`
+ `CONTEXT`
+ `ERROR`
+ `EXECUTE`: è possibile configurare questa categoria con o senza dati. La configurazione con dati significa che vengono registrati anche i valori dei dati di input del log specificati per qualsiasi variabile host e indicatore di parametro. Per impostazione predefinita, viene eseguita la configurazione senza dati. Per ulteriori informazioni, vedere la descrizione del *category\$1setting* parametro e il. [Esempi](#db2-sp-configure-db-audit-examples)
+ `OBJMAINT`
+ `SECMAINT`
+ `SYSADMIN`
+ `VALIDATE`
Per ulteriori informazioni su queste categorie, consulta la [documentazione di IBM Db2](https://www.ibm.com/docs/en/db2/11.1?topic=statements-create-audit-policy).
*category\$1setting*
L’impostazione relativa alla categoria di audit specificata. Il tipo di dati è `varchar`.
Nella tabella seguente sono illustrati i valori validi delle impostazioni per ogni categoria.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/db2-sp-managing-audit-policies.html)
### Note per l’utilizzo
Prima di chiamare `rdsadmin.configure_db_audit`, assicurati che l’istanza database RDS per Db2 con il database per cui stai configurando la policy di audit sia associata a un gruppo di opzioni che include l’opzione `DB2_AUDIT`. Per ulteriori informazioni, consulta [Configurazione della registrazione di log di audit Db2](Db2.Options.Audit.md#db2-audit-setting-up).
Dopo aver configurato la policy di audit, puoi verificare lo stato della configurazione di audit per il database seguendo le istruzioni riportate in [Verifica della configurazione di audit](Db2.Options.Audit.md#db2-audit-check-config-status).
L’impostazione di `ALL` per il parametro `category` non include le categorie `CONTEXT`, `EXECUTE` e `ERROR`. Per aggiungere queste categorie alla policy di audit, chiama `rdsadmin.configure_db_audit` separatamente per ogni categoria da aggiungere. Per ulteriori informazioni, consulta [Esempi](#db2-sp-configure-db-audit-examples).
### Esempi
I seguenti esempi creano o modificano la policy di audit per un database denominato `TESTDB`. Negli esempi da 1 a 5, se la categoria `ERROR` non è stata configurata in precedenza, viene impostata su `NORMAL` (impostazione predefinita). Per modificare questa impostazione in `AUDIT`, segui le istruzioni riportate in [Example 6: Specifying the ERROR category](#example-6).
**Esempio 1: specifica della categoria `ALL`**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'ALL', 'BOTH', ?)"
```
In questo esempio, la chiamata configura le categorie `AUDIT`, `CHECKING`, `OBJMAINT`, `SECMAINT`, `SYSADMIN` e `VALIDATE` nella policy di audit. La specifica di `BOTH` significa che gli eventi con esito sia positivo che negativo verranno sottoposti a audit per ciascuna di queste categorie.
**Esempio 2: specifica della categoria `EXECUTE` con dati**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'EXECUTE', 'SUCCESS,WITH', ?)"
```
In questo esempio, la chiamata configura la categoria `EXECUTE` nella policy di audit. La specifica di `SUCCESS,WITH` significa che i log relativi a questa categoria includeranno solo gli eventi con esito positivo insieme ai valori dei dati di input specificati per le variabili host e gli indicatori dei parametri.
**Esempio 3: specifica della categoria `EXECUTE` senza dati**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'EXECUTE', 'FAILURE,WITHOUT', ?)"
```
In questo esempio, la chiamata configura la categoria `EXECUTE` nella policy di audit. La specifica di `FAILURE,WITHOUT` significa che i log relativi a questa categoria includeranno solo gli eventi con esito negativo senza i valori dei dati di input specificati per le variabili host e gli indicatori dei parametri.
**Esempio 4: specifica della categoria `EXECUTE` senza eventi di stato**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'EXECUTE', 'NONE', ?)"
```
In questo esempio, la chiamata configura la categoria `EXECUTE` nella policy di audit. La specifica di `NONE` significa che nessun evento in questa categoria verrà sottoposto a audit.
**Esempio 5: specifica della categoria `OBJMAINT`**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'OBJMAINT', 'NONE', ?)"
```
In questo esempio, la chiamata configura la categoria `OBJMAINT` nella policy di audit. La specifica di `NONE` significa che nessun evento in questa categoria verrà sottoposto a audit.
**Esempio 6: specifica della categoria `ERROR`**
```
db2 "call rdsadmin.configure_db_audit('TESTDB', 'ERROR', 'AUDIT', ?)"
```
In questo esempio, la chiamata configura la categoria `ERROR` nella policy di audit. La specifica di `AUDIT` significa che tutti gli errori, inclusi quelli che si verificano nell’ambito della registrazione di log di audit, vengono registrati nei log. Il tipo di errore predefinito è `NORMAL`. Con `NORMAL`, vengono ignorati gli errori generati dall’audit e vengono acquisiti soltanto i codici `SQLCODE` per gli errori associati all’operazione eseguita.
## rdsadmin.disable\$1db\$1audit
Interrompe la registrazione di controllo per il database RDS for Db2 specificato da *db\$1name* e rimuove la politica di controllo configurata per tale database.
**Nota**
Questa stored procedure rimuove solo le policy di audit configurate tramite una chiamata a [rdsadmin.configure\$1db\$1audit](#db2-sp-configure-db-audit).
### Sintassi
```
db2 "call rdsadmin.disable_db_audit('db_name', ?)"
```
### Parameters
I parametri seguenti sono obbligatori.
*db\$1name*
Il nome del database RDS per Db2 per cui disabilitare la registrazione di log di audit. Il tipo di dati è `varchar`.
### Note per l’utilizzo
La chiamata a `rdsadmin.disable_db_audit` non disabilita la registrazione di log di audit per l’istanza database RDS per Db2. Per disabilitare la registrazione di log di audit a livello di istanza database, rimuovi il gruppo di opzioni dall’istanza database. Per ulteriori informazioni, consulta [Disabilitazione della registrazione di log di audit Db2](Db2.Options.Audit.md#db2-audit-disabling).
### Esempi
L’esempio seguente disabilita la registrazione di log di audit per un database denominato `TESTDB`.
```
db2 "call rdsadmin.disable_db_audit('TESTDB', ?)"
```
# Stored procedure relative a pool di buffer per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono i pool di buffer per i database Amazon RDS per Db2. Per eseguire queste procedure, l’utente master deve prima connettersi al database `rdsadmin`.
Queste stored procedure vengono utilizzate in diverse attività. L'elenco non è completo.
+ [Attività comuni per i pool di buffer](db2-managing-buffer-pools.md)
+ [Generazione di report sulle prestazioni](db2-managing-databases.md#db2-generating-performance-reports)
+ [Copia dei metadati del database con db2look](db2-native-db2-tools-db2look.md)
+ [Creazione di un database di repository per IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md#db2-creating-repo-db-monitoring-dmc)
Fai riferimento alle seguenti stored procedure integrate per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi.
**Topics**
+ [rdsadmin.create\$1bufferpool](#db2-sp-create-buffer-pool)
+ [rdsadmin.alter\$1bufferpool](#db2-sp-alter-buffer-pool)
+ [rdsadmin.drop\$1bufferpool](#db2-sp-drop-buffer-pool)
## rdsadmin.create\$1bufferpool
Crea un pool di buffer.
### Sintassi
```
db2 "call rdsadmin.create_bufferpool(
'database_name',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
page_size,
number_block_pages,
block_size)"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui eseguire il comando. Il tipo di dati è `varchar`.
*buffer\$1pool\$1name*
Il nome del pool di buffer da creare. Il tipo di dati è `varchar`.
I parametri seguenti sono facoltativi:
*buffer\$1pool\$1size*
La dimensione del pool di buffer espressa in numero di pagine. Il tipo di dati è `integer`. Il valore predefinito è `-1`.
*immediate*
Specifica se il comando viene eseguito immediatamente. Il tipo di dati è `char`. Il valore predefinito è `Y`.
*automatic*
Specifica se impostare il pool di buffer in modalità automatica. Il tipo di dati è `char`. Il valore predefinito è `Y`.
*page\$1size*
Aumenta la dimensione di pagina del pool di buffer. Il tipo di dati è `integer`. Valori validi: `4096`, `8192`, `16384`, `32768`. Il valore predefinito è `8192`.
*number\$1block\$1pages*
Il numero di pagine di blocco nei pool di buffer. Il tipo di dati è `integer`. Il valore predefinito è `0`.
*block\$1size*
La dimensione di blocco per le pagine di blocco. Il tipo di dati è `integer`. Valori validi: da `2` a `256`. Il valore predefinito è `32`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della creazione di un pool di buffer, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: creazione di un pool di buffer con parametri predefiniti**
L’esempio seguente crea un pool di buffer denominato `BP8` per il database `TESTDB` con parametri predefiniti, pertanto il pool di buffer utilizza una dimensione di pagina pari a 8 KB.
```
db2 "call rdsadmin.create_bufferpool(
'TESTDB',
'BP8')"
```
**Esempio 2: creazione di un pool di buffer da eseguire immediatamente con allocazione automatica**
L’esempio seguente crea un pool di buffer denominato `BP16` per il database `TESTDB` che utilizza una dimensione di pagina di 16 KB con un numero iniziale di pagine pari a 1.000 ed è impostato in modalità automatica. Db2 esegue il comando immediatamente. Se il numero iniziale di pagine è pari a -1, Db2 utilizzerà l’allocazione automatica delle pagine.
```
db2 "call rdsadmin.create_bufferpool(
'TESTDB',
'BP16',
1000,
'Y',
'Y',
16384)"
```
**Esempio 3: creazione di un pool di buffer da eseguire immediatamente utilizzando pagine di blocco**
L’esempio seguente crea un pool di buffer denominato `BP16` per il database `TESTDB`. Questo pool di buffer ha una dimensione di pagina di 16 KB con un numero iniziale di pagine pari a 10.000. Db2 esegue immediatamente il comando utilizzando 500 pagine di blocco con una dimensione di blocco pari a 512.
```
db2 "call rdsadmin.create_bufferpool(
'TESTDB',
'BP16',
10000,
'Y',
'Y',
16384,
500,
512)"
```
## rdsadmin.alter\$1bufferpool
Modifica un pool di buffer.
### Sintassi
```
db2 "call rdsadmin.alter_bufferpool(
'database_name',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
change_number_blocks,
number_block_pages,
block_size)"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui eseguire il comando. Il tipo di dati è `varchar`.
*buffer\$1pool\$1name*
Il nome del pool di buffer da modificare. Il tipo di dati è `varchar`.
*buffer\$1pool\$1size*
La dimensione del pool di buffer espressa in numero di pagine. Il tipo di dati è `integer`.
I parametri seguenti sono facoltativi:
*immediate*
Specifica se il comando viene eseguito immediatamente. Il tipo di dati è `char`. Il valore predefinito è `Y`.
*automatic*
Specifica se impostare il pool di buffer in modalità automatica. Il tipo di dati è `char`. Il valore predefinito è `N`.
*change\$1number\$1blocks*
Specifica se è stata apportata una modifica al numero di pagine di blocco nel pool di buffer. Il tipo di dati è `char`. Il valore predefinito è `N`.
*number\$1block\$1pages*
Il numero di pagine di blocco nei pool di buffer. Il tipo di dati è `integer`. Il valore predefinito è `0`.
*block\$1size*
La dimensione di blocco per le pagine di blocco. Il tipo di dati è `integer`. Valori validi: da `2` a `256`. Il valore predefinito è `32`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della modifica di un pool di buffer, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente modifica un pool di buffer denominato `BP16` per il database `TESTDB` impostando la modalità automatica e la dimensione pari a 10.000 pagine. Db2 esegue il comando immediatamente.
```
db2 "call rdsadmin.alter_bufferpool(
'TESTDB',
'BP16',
10000,
'Y',
'N')"
```
## rdsadmin.drop\$1bufferpool
Elimina un pool di buffer.
### Sintassi
```
db2 "call rdsadmin.drop_bufferpool(
'database_name',
'buffer_pool_name'"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database a cui appartiene il pool di buffer. Il tipo di dati è `varchar`.
*buffer\$1pool\$1name*
Il nome del pool di buffer da eliminare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’eliminazione di un pool di buffer, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente elimina un pool di buffer denominato `BP16` per il database `TESTDB`.
```
db2 "call rdsadmin.drop_bufferpool(
'TESTDB',
'BP16')"
```
# Stored procedure relative ai database per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono i database per Amazon RDS per Db2. Per eseguire queste procedure, l’utente master deve prima connettersi al database `rdsadmin`.
Queste stored procedure vengono utilizzate in diverse attività. L'elenco non è completo.
+ [Attività comuni per i database](db2-managing-databases.md)
+ [Creazione di database con regole di confronto EBCDIC](db2-ebcdic.md)
+ [Raccolta di informazioni sui database](db2-supported-parameters.md#db2-modifying-parameters-db2-commands)
+ [Modifica dei parametri di configurazione del database](db2-supported-parameters.md#db2-modifying-parameters-db2-commands)
+ [Migrazione da Linux a Linux](db2-one-time-migration-linux.md)
+ [Migrazione da Linux a Linux con tempo di inattività quasi nullo](db2-near-zero-downtime-migration.md)
Per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi, fai riferimento alle seguenti stored procedure integrate.
**Topics**
+ [rdsadmin.create\$1database](#db2-sp-create-database)
+ [rdsadmin.deactivate\$1database](#db2-sp-deactivate-database)
+ [rdsadmin.activate\$1database](#db2-sp-activate-database)
+ [rdsadmin.reactivate\$1database](#db2-sp-reactivate-database)
+ [rdsadmin.drop\$1database](#db2-sp-drop-database)
+ [rdsadmin.update\$1db\$1param](#db2-sp-update-db-param)
+ [rdsadmin.set\$1configuration](#db2-sp-set-configuration)
+ [rdsadmin.show\$1configuration](#db2-sp-show-configuration)
+ [rdsadmin.backup\$1database](#db2-sp-backup-database)
+ [rdsadmin.restore\$1database](#db2-sp-restore-database)
+ [rdsadmin.rollforward\$1database](#db2-sp-rollforward-database)
+ [rdsadmin.rollforward\$1status](#db2-sp-rollforward-status)
+ [rdsadmin.complete\$1rollforward](#db2-sp-complete-rollforward)
+ [rdsadmin.db2pd\$1command](#db2-sp-db2pd-command)
+ [rdsadmin.force\$1application](#db2-sp-force-application)
+ [rdsadmin.set\$1archive\$1log\$1retention](#db2-sp-set-archive-log-retention)
+ [rdsadmin.show\$1archive\$1log\$1retention](#db2-sp-show-archive-log-retention)
+ [rdsadmin.list\$1archive\$1log\$1information](#db2-sp-list-archive-log-information)
+ [rdsadmin.enable\$1archive\$1log\$1copy](#db2-sp-enable_archive_log_copy)
+ [rdsadmin.disable\$1archive\$1log\$1copy](#db2-sp-disable_archive_log_copy)
+ [rdsadmin.fgac\$1command](#db2-sp-fgac-command)
+ [rdsadmin.db2support\$1command](#db2-sp-db2support-command)
## rdsadmin.create\$1database
Crea un database.
### Sintassi
```
db2 "call rdsadmin.create_database(
'database_name',
'database_page_size',
'database_code_set',
'database_territory',
'database_collation',
'database_autoconfigure_str',
'database_non-restrictive')"
```
### Parameters
**Nota**
Questa stored procedure non convalida la combinazione dei parametri richiesti. Quando si chiama [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status), la funzione definita dall’utente potrebbe restituire un errore a causa di una combinazione di `database_codeset`, `database_territory` e `database_collation` non valida. Per ulteriori informazioni, consulta [Choosing the code page, territory, and collation for your database](https://www.ibm.com/docs/en/db2/11.5?topic=support-choosing-code-page-territory-collation-your-database) nella documentazione di IBM Db2.
Il parametro seguente è obbligatorio:
*database\$1name*
Il nome del database da creare. Il tipo di dati è `varchar`.
I parametri seguenti sono facoltativi:
*database\$1page\$1size*
La dimensione predefinita della pagina del database. Valori validi: `4096`, `8192`, `16384`, `32768`. Il tipo di dati è `integer`. Il valore predefinito è `8192`.
Amazon RDS supporta l’atomicità di scrittura per pagine da 4, 8 e 16 KiB. Al contrario, le pagine da 32 KB rischiano *scritture strappate* o la scrittura di dati parziali sul disco. Se utilizzi pagine da 32 KiB, ti consigliamo di abilitare il point-in-time ripristino e i backup automatici. Altrimenti, corri il rischio di non riuscire a recuperare le pagine danneggiate. Per ulteriori informazioni, consultare [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md) e [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
*database\$1code\$1set*
Il set di codici per il database. Il tipo di dati è `varchar`. Il valore predefinito è `UTF-8`.
*database\$1territory*
Il codice di due lettere del paese per il database. Il tipo di dati è `varchar`. Il valore predefinito è `US`.
*database\$1collation*
La sequenza di regole di confronto che determina il modo in cui le stringhe di caratteri archiviate nel database vengono ordinate e confrontate. Il tipo di dati è `varchar`.
Valori validi:
+ `COMPATIBILITY`: una sequenza di regole di confronto IBM Db2 versione 2.
+ `EBCDIC_819_037`: tabella codici ISO alfabeto latino, regole di confronto; CCSID 037 (EBCDIC inglese statunitense).
+ `EBCDIC_819_500`: tabella codici ISO alfabeto latino, regole di confronto; CCSID 500 (EBCDIC internazionale).
+ `EBCDIC_850_037`: tabella codici ASCII alfabeto latino, regole di confronto; CCSID 037 (EBCDIC inglese statunitense).
+ `EBCDIC_850_500`: tabella codici ASCII alfabeto latino, regole di confronto; CCSID 500 (EBCDIC internazionale).
+ `EBCDIC_932_5026`: tabella codici ASCII alfabeto giapponese, regole di confronto; CCSID 5026 (EBCDIC inglese statunitense).
+ `EBCDIC_932_5035`: tabella codici ASCII alfabeto giapponese, regole di confronto; CCSID 5035 (EBCDIC internazionale).
+ `EBCDIC_1252_037`: tabella codici Windows alfabeto latino, regole di confronto; CCSID 037 (EBCDIC inglese statunitense).
+ `EBCDIC_1252_500`: tabella codici Windows alfabeto latino, regole di confronto; CCSID 500 (EBCDIC internazionale).
+ `IDENTITY`: regole di confronto predefinite. Le stringhe vengono confrontate byte per byte.
+ `IDENTITY_16BIT`: lo schema di codifica di compatibilità per UTF-16: sequenza di regole di confronto a 8 bit (CESU-8). Per ulteriori informazioni, consulta l’[Unicode Technical Report \$126](https://www.unicode.org/reports/tr26/tr26-4.html) sul sito web Unicode Consortium.
+ `NLSCHAR`— Da utilizzare solo con la tabella codici thailandese (CP874).
+ `SYSTEM`: se utilizzi `SYSTEM`, il database applica automaticamente la sequenza di regole di confronto per `database_codeset` e `database_territory`.
Il valore predefinito è `IDENTITY`.
Inoltre, RDS per Db2 supporta i seguenti gruppi di regole di confronto: `language-aware-collation` e `locale-sensitive-collation`. Per ulteriori informazioni, consulta [Choosing a collation for a Unicode database](https://www.ibm.com/docs/en/db2/11.5?topic=collation-choosing-unicode-database) nella documentazione di IBM Db2.
*database\$1autoconfigure\$1str*
La sintassi del comando `AUTOCONFIGURE`, ad esempio `'AUTOCONFIGURE APPLY DB'`. Il tipo di dati è `varchar`. L’impostazione predefinita è una stringa vuota o null.
Per ulteriori informazioni, consulta [AUTOCONFIGURE command](https://www.ibm.com/docs/en/db2/11.5?topic=cc-autoconfigure) nella documentazione di IBM Db2.
*database\$1non-restrictive*
La concessione di autorità e privilegi predefiniti all'interno del database. Il tipo di dati è `varchar`. Il valore predefinito è `N`.
Valori validi:
+ `N`— Il database creato è restrittivo e non concede autorità o privilegi.
+ `Y`— Il database creato non è restrittivo e concede una serie di autorizzazioni al gruppo speciale. `PUBLIC` Per ulteriori informazioni, consulta [Privilegi predefiniti concessi per la creazione di un database](https://www.ibm.com/docs/en/db2/11.5.x?topic=ownership-default-privileges-granted-creating-database) nella documentazione. IBM Db2
### Note per l’utilizzo
Se intendi modificare il parametro `db2_compatibility_vector`, modificalo prima di creare un database. Per ulteriori informazioni, consulta [Impostazione del parametro db2\$1compatibility\$1vector](db2-known-issues-limitations.md#db2-known-issues-limitations-db2-compatibility-vector).
Considerazioni speciali:
+ Il comando `CREATE DATABASE` inviato all’istanza Db2 utilizza l’opzione `RESTRICTIVE`.
+ RDS per Db2 utilizza solo tablespace `AUTOMATIC STORAGE`.
+ RDS per Db2 utilizza i valori predefiniti per `NUMSEGS` e `DFT_EXTENT_SZ`.
+ RDS per Db2 utilizza la crittografia dell’archiviazione e non supporta la crittografia del database.
Per ulteriori informazioni su queste considerazioni, consulta [CREATE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-create-database#:~:text=in%20the%20database.-,RESTRICTIVE,-If%20the%20RESTRICTIVE) nella documentazione di IBM Db2.
Prima di chiamare `rdsadmin.create_database`, è necessario connettersi al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le informazioni sull'istanza DB RDS for Db2:
```
db2 connect to rdsadmin user master_username using master_password
```
Per informazioni su come verificare lo stato della creazione di un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.create_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
L'esempio seguente crea un database chiamato `TESTJP` con una combinazione corretta di *database\$1code\$1set**database\$1territory*, e *database\$1collation* parametri per il Giappone:
```
db2 "call rdsadmin.create_database('TESTJP', 4096, 'IBM-437', 'JP', 'SYSTEM')"
```
## rdsadmin.deactivate\$1database
Disattiva un database.
### Sintassi
```
db2 "call rdsadmin.deactivate_database(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database da disattivare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
È possibile disattivare i database per risparmiare risorse di memoria o per apportare altre modifiche alla configurazione del database. Per riportare online i database disattivati, chiama la stored procedure [rdsadmin.activate\$1database](#db2-sp-activate-database).
Non è possibile disattivare un database su un’istanza database di origine durante la replica chiamando la stored procedure `rdsadmin.deactivate_database`.
Per informazioni su come verificare lo stato della disattivazione di un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.deactivate_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
Nell’esempio seguente viene disattivato un database denominato `TESTDB`.
```
db2 "call rdsadmin.deactivate_database(?, 'TESTDB')"
```
## rdsadmin.activate\$1database
Attiva un database.
Per ulteriori informazioni sulla differenza tra [rdsadmin.reactivate\$1database](#db2-sp-reactivate-database) e `rdsadmin.activate_database`, consulta [Note per l’utilizzo](#db2-sp-activate-database-usage-notes).
### Sintassi
```
db2 "call rdsadmin.activate_database(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database da attivare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Tutti i database vengono attivati per impostazione predefinita al momento della creazione. Se per risparmiare risorse di memoria o apportare altre modifiche alla configurazione del database si [disattiva]() un database su un’istanza database autonoma, chiama la stored procedure `rdsadmin.activate_database` per riattivarlo.
Questa stored procedure attiva solo un database che si trova su un’istanza database autonoma e che è stato disattivato chiamando la stored procedure [rdsadmin.deactivate\$1database](#db2-sp-deactivate-database). Per attivare un database su un’istanza database di origine di replica, è necessario chiamare la stored procedure [rdsadmin.reactivate\$1database](#db2-sp-reactivate-database).
Per informazioni su come verificare lo stato dell’attivazione di un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.activate_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
Nell’esempio seguente viene attivato un database denominato `TESTDB`.
```
db2 "call rdsadmin.activate_database(?, 'TESTDB')"
```
## rdsadmin.reactivate\$1database
Riattiva un database.
Per informazioni sulle differenze tra [rdsadmin.activate\$1database](#db2-sp-activate-database) e `rdsadmin.reactivate_database`, consulta [Note per l’utilizzo](#db2-sp-reactivate-database-usage-notes).
### Sintassi
```
db2 "call rdsadmin.reactivate_database(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database da riattivare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Quando si chiama la stored procedure `rdsadmin.reactivate_database`, questa prima disattiva il database chiamando la stored procedure [rdsadmin.deactivate\$1database](#db2-sp-deactivate-database), quindi lo attiva chiamando la stored procedure [rdsadmin.activate\$1database](#db2-sp-activate-database).
Dopo aver apportato modifiche alle configurazioni dei database, potrebbe essere necessario riattivare un database su un’istanza database RDS per Db2. Per stabilire se è necessario riattivare un database, connettiti al database ed esegui `db2 get db cfg show detail`.
Per un database su un’istanza database autonoma, per la riattivazione è possibile utilizzare la stored procedure `rdsadmin.reactivate_database`. Oppure, se hai già chiamato la stored procedure [rdsadmin.deactivate\$1database](#db2-sp-deactivate-database), puoi invece chiamare la stored procedure [rdsadmin.activate\$1database](#db2-sp-activate-database).
Per un database su un’istanza database di origine di replica, per la riattivazione è necessario utilizzare la stored procedure `rdsadmin.reactivate_database`.
Per informazioni su come verificare lo stato della riattivazione di un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.reactivate_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
Nell’esempio seguente viene riattivato un database denominato `TESTDB`.
```
db2 "call rdsadmin.reactivate_database(?, 'TESTDB')"
```
## rdsadmin.drop\$1database
Rimuovi un database.
### Sintassi
```
db2 "call rdsadmin.drop_database('database_name')"
```
### Parameters
Il parametro seguente è obbligatorio:
*database\$1name*
Nome del database da rimuovere. Il tipo di dati è `varchar`.
### Note per l’utilizzo
È possibile eliminare un database chiamando `rdsadmin.drop_database` solo se sono soddisfatte le seguenti condizioni:
+ Non hai specificato il nome del database quando hai creato l’istanza database RDS per Db2 utilizzando la console Amazon RDS o la AWS CLI. Per ulteriori informazioni, consulta [Creazione di un'istanza database](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
+ Hai creato il database chiamando la stored procedure [rdsadmin.create\$1database](#db2-sp-create-database).
+ Hai ripristinato il database da un’immagine offline o di cui è stato eseguito il backup chiamando la stored procedure [rdsadmin.restore\$1database](#db2-sp-restore-database).
Prima di chiamare `rdsadmin.drop_database`, è necessario connettersi al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le informazioni sull'istanza DB RDS for Db2:
```
db2 connect to rdsadmin user master_username using master_password
```
Per informazioni su come verificare lo stato dell’eliminazione di un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.drop_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
Nell’esempio seguente viene rimosso un database denominato `TESTDB`.
```
db2 "call rdsadmin.drop_database('TESTDB')"
```
## rdsadmin.update\$1db\$1param
Aggiorna i parametri del database.
### Sintassi
```
db2 "call rdsadmin.update_db_param(
'database_name',
'parameter_to_modify',
'changed_value',
'restart_database')"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database per cui eseguire l’attività. Il tipo di dati è `varchar`.
*parameter\$1to\$1modify*
Il nome del parametro da modificare. Il tipo di dati è `varchar`. Per ulteriori informazioni, consulta [Parametri di Amazon RDS per Db2](db2-supported-parameters.md).
*changed\$1value*
Il valore in cui modificare il valore del parametro. Il tipo di dati è `varchar`.
Il parametro seguente è facoltativo:
*restart\$1database*
Specifica se RDS riavvia il database in caso fosse necessario un riavvio. Il tipo di dati è `varchar`. Per modificare `logprimary` e `logfilsiz`, imposta questo parametro su `'YES'`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’aggiornamento dei parametri del database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.update_db_param`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
**Esempio 1: aggiornamento di un parametro**
Nell’esempio seguente il parametro `archretrydelay` viene aggiornato a `100` per un database chiamato `TESTDB`:
```
db2 "call rdsadmin.update_db_param(
'TESTDB',
'archretrydelay',
'100')"
```
**Esempio 2: rinvio della convalida degli oggetti**
Nell’esempio seguente viene posticipata la convalida degli oggetti creati su un database denominato `TESTDB` per evitare il controllo delle dipendenze:
```
db2 "call rdsadmin.update_db_param(
'TESTDB',
'auto_reval',
'deferred_force')"
```
## rdsadmin.set\$1configuration
Configura impostazioni specifiche per il database.
### Sintassi
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
### Parameters
I parametri seguenti sono obbligatori:
*name*
Il nome dell’impostazione di configurazione. Il tipo di dati è `varchar`.
*value*
Il valore dell’impostazione di configurazione. Il tipo di dati è `varchar`.
### Note per l’utilizzo
La tabella riportata di seguito mostra le impostazioni di configurazione che è possibile controllare con `rdsadmin.set_configuration`.
| Nome | Description |
| --- | --- |
| `RESTORE_DATABASE_NUM_BUFFERS` | Il numero di buffer da creare durante un’operazione di ripristino. Questo valore deve essere inferiore alla dimensione totale della memoria della classe dell’istanza database. Se questa impostazione non è configurata, Db2 determina il valore da utilizzare durante l’operazione di ripristino. Per ulteriori informazioni, vedete il [comando RESTORE DATABASE](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database) nella IBM Db2 documentazione. |
| `RESTORE_DATABASE_PARALLELISM` | Il numero di manipolatori di buffer da creare durante un’operazione di ripristino. Questo valore deve essere inferiore al doppio del numero di v CPUs per l'istanza DB. Se questa impostazione non è configurata, Db2 determina il valore da utilizzare durante l’operazione di ripristino. Per ulteriori informazioni, vedete [il comando RESTORE DATABASE](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database) nella IBM Db2 documentazione. |
| `RESTORE_DATABASE_NUM_MULTI_PATHS` | Il numero di percorsi (o I/O stream) da utilizzare durante un ripristino da un'operazione di Amazon S3. Per utilizzare questa impostazione di configurazione, è necessario disporre di più file di backup. Questo valore può migliorare le prestazioni durante il ripristino di database con grandi volumi di dati perché ripristina più file di backup del database in parallelo. Si consiglia di impostare questo valore in modo che corrisponda al numero dei file di backup del database. Per ulteriori informazioni, vedere il [comando BACKUP DATABASE](https://www.ibm.com/docs/en/db2/11.5?topic=commands-backup-database) nella IBM Db2 documentazione. |
| `USE_STREAMING_RESTORE` | Speciifica se eseguire lo streaming dei dati di backup direttamente durante il ripristino anziché scaricare prima l'intero backup sull'istanza DB RDS for Db2 e poi estrarlo. L'impostazione `USE_STREAMING_RESTORE` su riduce `TRUE` in modo significativo i requisiti di archiviazione e può migliorare le prestazioni di ripristino. Questa impostazione richiede la versione 11.5.9.0.sb00063198.r1 o successiva del motore IBM Db2 e la connettività Amazon S3 tramite l'elastic network interface (ENI) del database. Per ulteriori [informazioni](https://www.ibm.com/docs/en/db2/11.5.x?topic=databases-remote-storage), consulta IBM Db2 Storage remoto nella documentazione. |
### Esempi
**Esempio 1: Specificazione del numero di buffer da creare**
Nell’esempio seguente, la configurazione `RESTORE_DATABASE_NUM_BUFFERS` viene impostata su `150`.
```
db2 "call rdsadmin.set_configuration(
'RESTORE_DATABASE_NUM_BUFFERS',
'150')"
```
**Esempio 2: Specificazione del numero di manipolatori di buffer da creare**
Nell’esempio seguente, la configurazione `RESTORE_DATABASE_PARALLELISM` viene impostata su `8`.
```
db2 "call rdsadmin.set_configuration(
'RESTORE_DATABASE_PARALLELISM',
'8')"
```
**Esempio 3: Specificazione del numero di percorsi o I/O stream da utilizzare durante il ripristino**
Nell’esempio seguente, la configurazione `RESTORE_DATABASE_NUM_MULTI_PATHS` viene impostata su `5`.
```
db2 "call rdsadmin.set_configuration(
'RESTORE_DATABASE_NUM_MULTI_PATHS',
'5')"
```
**Esempio 4: impostazione del ripristino per lo streaming dei dati di backup**
Nell’esempio seguente, la configurazione `USE_STREAMING_RESTORE` viene impostata su `TRUE`.
```
db2 "call rdsadmin.set_configuration(
'USE_STREAMING_RESTORE',
'TRUE')"
```
## rdsadmin.show\$1configuration
Restituisce le impostazioni correnti che è possibile definire utilizzando la stored procedure `rdsadmin.set_configuration`.
### Sintassi
```
db2 "call rdsadmin.show_configuration(
'name')"
```
### Parameters
Il parametro seguente è facoltativo:
*name*
Il nome dell’impostazione di configurazione per cui restituire informazioni. Il tipo di dati è `varchar`.
Le opzioni di configurazione valide sono:
+ `RESTORE_DATABASE_NUM_BUFFERS`— Il numero di buffer da creare durante un'operazione di ripristino.
+ `RESTORE_DATABASE_PARALLELISM`— Il numero di manipolatori di buffer da creare durante un'operazione di ripristino.
+ `RESTORE_DATABASE_NUM_MULTI_PATHS`— Il numero di percorsi (o I/O stream) da utilizzare durante un ripristino da un'operazione di ripristino da Amazon S3.
+ `USE_STREAMING_RESTORE`— Speciifica se eseguire lo streaming dei dati di backup direttamente durante il ripristino anziché scaricare prima tutti i dati di backup sull'istanza DB RDS for Db2 e poi estrarli.
### Note per l’utilizzo
Se non si specifica il nome di un’impostazione di configurazione, `rdsadmin.show_configuration` restituisce informazioni per tutte le impostazioni di configurazione che è possibile definire utilizzando la stored procedure `rdsadmin.set_configuration`.
### Esempi
Nell’esempio seguente vengono restituite informazioni sulla configurazione `RESTORE_DATABASE_PARALLELISM` corrente.
```
db2 "call rdsadmin.show_configuration(
'RESTORE_DATABASE_PARALLELISM')"
```
## rdsadmin.backup\$1database
Esegue il backup di un database da un'istanza DB RDS for Db2 su un bucket Amazon S3.
### Sintassi
```
db2 "call rdsadmin.backup_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
'backup_type',
'compression_option',
'util_impact_priority',
'num_files',
'parallelism',
'num_buffers')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database di destinazione su un'istanza DB RDS for Db2 di cui eseguire il backup. Il tipo di dati è `varchar`.
Il database deve esistere nell'istanza DB. Non è possibile eseguire il backup del `rdsadmin` database.
*s3\$1bucket\$1name*
Il nome del bucket Amazon S3 in cui desideri che risieda il backup. Il tipo di dati è `varchar`.
Il bucket S3 deve esistere prima della chiamata`rdsadmin.backup_database`, trovarsi nello stesso database di destinazione nell'istanza DB RDS for Db2 di cui desideri eseguire il backup ed essere accessibile tramite il Regione AWS ruolo IAM collegato all'istanza DB.
*s3\$1prefix*
Il prefisso del percorso verso Amazon S3 in cui RDS per Db2 carica i file di backup. Il tipo di dati è `varchar`.
Il prefisso è limitato a 1024 caratteri. Non deve includere una barra iniziale o finale (/). A causa di una limitazione IBM dello streaming su Amazon S3, consigliamo che il prefisso includa le sottodirectory.
Per una migliore gestione dei file, RDS for Db2 crea directory aggiuntive in seguito. *s3\$1prefix* RDS for Db2 carica tutti i file di backup su. *s3\$1prefix/dbi\$1resource\$1id/db\$1name* Se si imposta un *num\$1files* valore superiore a`1`, la *db\$1name* directory conterrà più di un file di backup.
Di seguito è riportato un esempio di posizione Amazon S3 per i file di backup. Nell'esempio, `backups/daily` è il valore impostato per il *s3\$1prefix* parametro.
```
backups/daily/db-5N7FXOY4GDP7RG2NSH2ZTAI2W4/SAMPLEDB
```
*backup\$1type*
Il tipo di backup che determina se il database rimane disponibile durante il backup. Il tipo di dati è `varchar`.
Valori validi:
+ `OFFLINE`— Il database non è disponibile durante il backup. Questo tipo è più veloce, ma causa tempi di inattività.
+ `ONLINE`— Il database rimane disponibile durante il backup. Per impostazione predefinita, `ONLINE` è impostato su `INCLUDE LOGS`.
I parametri seguenti sono facoltativi:
*compression\$1option*
Il tipo di algoritmo di compressione utilizzato che influisce sui tempi di backup, sull'utilizzo della CPU e sui costi di archiviazione. Il tipo di dati è `varchar`. Il valore predefinito è `NONE`.
Valori validi:
+ `NONE`— La dimensione del file più grande, il minor utilizzo della CPU e i costi di archiviazione più bassi.
+ `STANDARD`— Compressione Db2 standard. Usi`libdb2compr.so`.
+ `ZLIB`— Compressione Db2 migliorata. Utilizza`libdb2zcompr.so`, ma richiede un uso più intensivo della CPU e il costo di archiviazione più costoso.
*util\$1impact\$1priority*
L'impostazione che controlla l'impatto del backup sulle risorse di sistema. Il tipo di dati è `integer`. Valori validi: `1` — `100` (dal più basso al più alto). Il valore predefinito è `50`.
Valori inferiori riducono l'impatto del backup sulle risorse di sistema, ma possono aumentare il tempo necessario per eseguire il backup del database. Valori più elevati potrebbero completare il backup del database più rapidamente, ma potrebbero influire su altre operazioni. L'impatto effettivo dipende dall'utilizzo complessivo del sistema e dall'`util_impact_lim`impostazione. È possibile visualizzare e modificare l'`util_impact_lim`impostazione in gruppi di parametri. Per ulteriori informazioni, consulta [Parametri di Amazon RDS per Db2](db2-supported-parameters.md).
*num\$1files*
Il numero di flussi di caricamento paralleli su Amazon S3. Il tipo di dati è `integer`. Valori validi: `1`-`256`.
Ti consigliamo di impostare questo parametro solo dopo aver osservato le prestazioni di backup predefinite calcolate automaticamente da Amazon RDS. Valori più alti potrebbero migliorare le prestazioni per i backup di grandi dimensioni, in particolare con connessioni a larghezza di banda elevata, ma a un certo punto, valori più alti peggiorano le prestazioni. Inoltre, assicurati di tenere conto delle risorse di sistema disponibili e della capacità di rete.
*parallelism*
Il numero di tablespace che l'utilità di backup può leggere in parallelo. Il tipo di dati è `integer`. Valori validi: `1`-`256`.
Si consiglia di impostare questo parametro solo dopo aver osservato le prestazioni di backup al valore predefinito che il motore Db2 calcola automaticamente come valore ottimale. Se imposti questo parametro, Amazon RDS esegue la convalida rispetto ai processori disponibili e non eseguirà la richiesta di backup se la potenza di elaborazione è insufficiente.
*num\$1buffers*
Il numero di buffer da utilizzare. Il tipo di dati è `integer`. Valori validi: `1`-`268435456`.
Ti consigliamo di impostare questo parametro solo dopo aver osservato le prestazioni di backup predefinite che Amazon RDS calcola automaticamente in base alla memoria. Se imposti questo parametro, Amazon RDS esegue la convalida in base alla memoria disponibile e non eseguirà la richiesta di backup se la memoria disponibile è insufficiente. Se esegui il backup su più posizioni (`num_files`è impostato su più di`1`), un numero maggiore di buffer potrebbe migliorare le prestazioni. Se non lo `compression_option` imposti`NONE`, puoi migliorare le prestazioni aumentando `num_buffers` e. `parallelism`
### Note per l’utilizzo
Questa procedura memorizzata crea attività di backup asincrone che trasmettono il backup del database direttamente al bucket Amazon S3 utilizzando l'integrazione Amazon S3. Puoi eseguire backup sia dal tuo server locale che da un'istanza DB RDS per Db2, trasmetterli in streaming su Amazon S3 e ripristinarli dove vuoi. Per informazioni sul ripristino di un database su un'istanza DB RDS for Db2, consulta. [rdsadmin.restore\$1database](#db2-sp-restore-database)
Prima di chiamare la stored procedure, esamina le seguenti considerazioni:
+ È possibile eseguire il backup di un solo database alla volta.
+ Non è possibile eseguire un backup e un ripristino contemporaneamente su un'istanza DB.
+ La crittografia lato server di Amazon S3 con AWS KMS (SSE-KMS) non è supportata. Anche se il bucket S3 è impostato su SSE-KMS, i file caricati nel bucket S3 non utilizzeranno la crittografia SSE-KMS.
+ Per eseguire lo streaming dei file di backup su Amazon S3, devi aver già configurato l'integrazione. Per ulteriori informazioni, consulta [Integrazione di un’istanza database Amazon RDS per Db2 con Amazon S3](db2-s3-integration.md).
+ Affinché un'istanza DB RDS for Db2 sia in grado di interagire con Amazon S3, è necessario disporre di un VPC e di un endpoint gateway Amazon S3 per l'utilizzo di sottoreti private. Per ulteriori informazioni, consultare [Fase 1: creare un endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-creating-endpoint) e [Fase 2: verificare l’esistenza dell’endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-confirming-endpoint).
Prima di chiamare `rdsadmin.backup_database`, è necessario connettersi al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le informazioni sull'istanza DB RDS for Db2:
```
db2 connect to rdsadmin user master_username using master_password
```
Dopo aver eseguito il backup del database, assicuratevi di terminare la connessione.
```
terminate
```
Per informazioni sulla verifica dello stato del backup di un database, consulta. [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status)
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.backup_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
Tutti gli esempi eseguono il backup di un database chiamato `MYDB` nel bucket Amazon S3 chiamato `amzn-s3-demo-bucket` e impostato su. *s3\$1prefix* `backups/daily`
**Esempio \$11: Specificazione del database offline e non disponibile con utilizzo medio e un singolo flusso di caricamento**
Nell'esempio seguente, il database è offline, il che è più veloce ma significa che il database non è disponibile durante il backup. L'esempio non esegue alcuna compressione dei file, ha un impatto mediano sulle risorse di sistema e utilizza un singolo flusso di caricamento su Amazon S3.
```
db2 call "rdsadmin.backup_database(
?,
'MYDB',
'amzn-s3-demo-bucket',
'backups/daily',
'OFFLINE',
'NONE',
50,
1)"
```
**Esempio \$12: Specificazione del database online e disponibile con compressione avanzata, utilizzo mediano e pochi flussi di caricamento paralleli**
Nell'esempio seguente, il database è online e disponibile durante il backup. L'esempio esegue una compressione avanzata, che si traduce in file di dimensioni ridotte, ma richiede un uso intensivo della CPU. Ha un impatto leggermente superiore alla media sulle risorse di sistema e utilizza cinque flussi di caricamento su Amazon S3.
```
db2 call "rdsadmin.backup_database(
?,
'MYDB',
'amzn-s3-demo-bucket',
'backups/daily',
'ONLINE',
'ZLIB',
60,
5)"
```
**Esempio \$13: Specificazione del database offline e non disponibile con impostazioni predefinite e calcoli di sistema**
Nell'esempio seguente, il database è offline, il che è più veloce ma significa che il database non è disponibile durante il backup. L'esempio utilizza la compressione predefinita dei file e l'impatto sulle risorse di sistema. Consente inoltre a RDS for Db2 di calcolare il numero di flussi di caricamento paralleli su Amazon S3, i tablespace da leggere in parallelo e i buffer da utilizzare.
```
db2 "call rdsadmin.backup_database(
?,
'MYDB',
'amzn-s3-demo-bucket',
'backups/daily',
'OFFLINE')"
```
**Esempio \$14: Specificazione del database offline e non disponibile senza compressione, utilizzo elevato e calcoli personalizzati**
Nell'esempio seguente, il database è offline, il che è più veloce ma significa che il database non è disponibile durante il backup. L'esempio non esegue alcuna compressione dei file, ha un impatto elevato sulle risorse di sistema e utilizza 20 flussi di caricamento su Amazon S3. Imposta il numero massimo di tablespace da leggere in parallelo, il che può causare il fallimento della richiesta di backup se la potenza di elaborazione è insufficiente. Imposta inoltre il numero massimo di buffer da utilizzare, il che può causare il fallimento della richiesta di backup se la memoria è insufficiente.
```
db2 "call rdsadmin.backup_database(
?,
'MYDB',
'amzn-s3-demo-bucket',
'backups/daily',
'OFFLINE',
'NONE',
90,
20,
256,
268435456)"
```
## rdsadmin.restore\$1database
Ripristina un database da un bucket Amazon S3 su un’istanza database RDS per Db2.
### Sintassi
```
db2 "call rdsadmin.restore_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
restore_timestamp,
'backup_type')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database di destinazione da ripristinare in RDS per Db2. Il tipo di dati è `varchar`.
Ad esempio, se il nome del database di origine era `TESTDB` impostato *database\$1name* su`NEWDB`, Amazon RDS esegue il ripristino `NEWDB` come database di origine.
*s3\$1bucket\$1name*
Il nome del bucket Amazon S3 in cui risiede il backup. Il tipo di dati è `varchar`.
*s3\$1prefix*
Il prefisso da utilizzare per la corrispondenza dei file durante il download. Il tipo di dati è `varchar`.
Se questo parametro è vuoto, verranno elaborati tutti i file nel bucket Amazon S3. Di seguito è riportato un prefisso di esempio.
```
backupfolder/SAMPLE.0.rdsdb.DBPART000.20230615010101
```
*restore\$1timestamp*
Il timestamp dell’immagine di backup del database. Il tipo di dati è `varchar`.
Il timestamp è incluso nel nome del file di backup. Ad esempio, `20230615010101` è il timestamp del nome file `SAMPLE.0.rdsdb.DBPART000.20230615010101.001`.
*backup\$1type*
Il tipo di backup. Il tipo di dati è `varchar`. Valori validi: `OFFLINE`, `ONLINE`.
Utilizza `ONLINE` per migrazioni con tempo di inattività prossimo allo zero. Per ulteriori informazioni, consulta [Migrazione da Linux a Linux con tempo di inattività quasi nullo per Amazon RDS per Db2](db2-near-zero-downtime-migration.md).
### Note per l’utilizzo
È possibile utilizzare questa stored procedure per eseguire la migrazione di un’istanza database Db2 a un’istanza database RDS per Db2. Per ulteriori informazioni, consulta [Utilizzo dei servizi AWS per migrare i dati da Db2 ad Amazon RDS per Db2](db2-migration-approaches.md). È inoltre possibile utilizzare questa stored procedure per creare più copie dello stesso database con nomi di database diversi che utilizzano la stessa immagine di ripristino.
Prima di chiamare la stored procedure, esamina le seguenti considerazioni:
+ Prima di ripristinare un database, è necessario fornire uno spazio di archiviazione per l'istanza DB RDS for Db2 superiore a quello del database Db2 originale su disco. Se l'opzione è abilitata`USE_STREAMING_RESTORE`, quando ripristini il backup, Amazon RDS trasmette i file di backup direttamente dal bucket S3 all'istanza DB RDS for Db2. Se non lo abiliti`USE_STREAMING_RESTORE`, devi fornire uno spazio di archiviazione per l'istanza DB RDS for Db2 uguale o superiore alla somma delle dimensioni del backup più il database Db2 originale su disco. Per ulteriori informazioni, consulta [Insufficient disk space](db2-troubleshooting.md#restore-database-sp-insufficient-disk-space).
+ Quando ripristini il backup, Amazon RDS estrae il file di backup sulla tua istanza database RDS per Db2. Ogni file di backup deve avere una dimensione pari o inferiore a 5 TB. Se un file di backup supera i 5 TB, devi dividerlo in file più piccoli.
+ Per ripristinare tutti i file utilizzando la stored procedure `rdsadmin.restore_database`, non includere nei nomi dei file il suffisso numerico del file dopo il timestamp. Ad esempio, *s3\$1prefix* `backupfolder/SAMPLE.0.rdsdb.DBPART000.20230615010101` ripristina i seguenti file:
```
SAMPLE.0.rdsdb.DBPART000.20230615010101.001
SAMPLE.0.rdsdb.DBPART000.20230615010101.002
SAMPLE.0.rdsdb.DBPART000.20230615010101.003
SAMPLE.0.rdsdb.DBPART000.20230615010101.004
SAMPLE.0.rdsdb.DBPART000.20230615010101.005
```
+ RDS per Db2 non supporta l’archiviazione non automatica. Per ulteriori informazioni, consulta [Tablespaces not restored](db2-troubleshooting.md#restore-database-sp-tablespaces-not-restored).
+ RDS per Db2 non supporta routine non recintate. Per ulteriori informazioni, consulta [Non-fenced routines not allowed](db2-troubleshooting.md#restore-database-sp-non-fenced-routines).
+ Per migliorare le prestazioni delle operazioni di ripristino del database, è possibile configurare il numero di buffer, di manipolatori di buffer e il numero di percorsi di backup multipli da utilizzare con RDS. Per ottimizzare l'utilizzo dello storage e migliorare potenzialmente le prestazioni, puoi anche eseguire lo streaming diretto di un backup da Amazon S3. Per controllare la configurazione corrente, utilizza [rdsadmin.show\$1configuration](#db2-sp-show-configuration). Per modificare la configurazione, utilizza [rdsadmin.set\$1configuration](#db2-sp-set-configuration).
Per portare il database online e applicare log delle transazioni aggiuntivi dopo il ripristino del database, consulta [rdsadmin.rollforward\$1database](#db2-sp-rollforward-database).
Per informazioni su come verificare lo stato del ripristino del database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante la chiamata di `rdsadmin.restore_database`, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
L'esempio seguente ripristina un backup offline con un singolo file o più file con: *s3\$1prefix* `backupfolder/SAMPLE.0.rdsdb.DBPART000.20230615010101`
```
db2 "call rdsadmin.restore_database(
?,
'SAMPLE',
'amzn-s3-demo-bucket',
'backupfolder/SAMPLE.0.rdsdb.DBPART000.20230615010101',
20230615010101,
'OFFLINE')"
```
## rdsadmin.rollforward\$1database
Porta il database online e applica log delle transazioni aggiuntivi dopo aver ripristinato un database chiamando [rdsadmin.restore\$1database](#db2-sp-restore-database).
### Sintassi
```
db2 "call rdsadmin.rollforward_database(
?,
'database_name',
's3_bucket_name',
s3_prefix,
'rollforward_to_option',
'complete_rollforward')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui eseguire l’operazione. Il tipo di dati è `varchar`.
*s3\$1bucket\$1name*
Il nome del bucket Amazon S3 in cui risiede il backup. Il tipo di dati è `varchar`.
*s3\$1prefix*
Il prefisso da utilizzare per la corrispondenza dei file durante il download. Il tipo di dati è `varchar`.
Se questo parametro è vuoto, tutti i file verranno scaricati nel bucket S3. Di seguito è riportato un prefisso di esempio.
```
backupfolder/SAMPLE.0.rdsdb.DBPART000.20230615010101
```
I parametri seguenti sono facoltativi:
*rollforward\$1to\$1option*
Il punto verso cui vuoi effettuare il roll forward. Il tipo di dati è `varchar`. Valori validi: `END_OF_LOGS`, `END_OF_BACKUP` con il timestamp nel formato `YYYY-MM-DD-HH.MM.SS`. Il valore predefinito è `END_OF_LOGS`.
*complete\$1rollforward*
Specifica se completare il processo di roll-forward. Il tipo di dati è `varchar`. Il valore predefinito è `TRUE`.
Se `TRUE`, dopo il completamento il database è online e accessibile. Se `FALSE`, allora il database rimane in uno stato `ROLL-FORWARD PENDING`.
### Note per l’utilizzo
È possibile utilizzare `rds.rollforward_database` per un backup online che includa i log prodotti on-premises in molti scenari diversi.
**Scenario 1: ripristino del database, roll forward dei log inclusi e messa online del database**
Al termine di `rdsadmin.restore_database()`, utilizza la sintassi indicata nell’[Esempio 1](#db2-sp-rollforward-database-examples) per portare online il database con i log delle transazioni.
**Scenario 2: messa online del database senza roll forward dei log inclusi.**
Al termine di `rdsadmin.restore_database()`, utilizza la sintassi indicata nell’[Esempio 2](#db2-sp-rollforward-database-examples) per portare online il database senza i log delle transazioni.
**Scenario 3: roll forward dei log inclusi nel backup e applicazione di log delle transazioni aggiuntivi man mano che vengono prodotti on-premises**
Al termine del `rdsadmin.restore_database()`, utilizza la sintassi indicata nell’[Esempio 3 o Esempio 4](#db2-sp-rollforward-database-examples) per effettuare il roll forward dei log senza portare online il database.
Se imposti `complete_rollforward` su `FALSE`, il database è in uno stato `ROLL-FORWARD PENDING` e offline. Per portare il database online, devi chiamare [rdsadmin.complete\$1rollforward](#db2-sp-complete-rollforward).
Per informazioni su come verificare lo stato del roll-forward del database, consulta [rdsadmin.rollforward\$1status](#db2-sp-rollforward-status).
### Esempi
**Esempio 1: messa online del database con i log delle transazioni**
Nell’esempio seguente viene effettuato il roll forward a un backup online del database con i log delle transazioni con successiva messa online del database:
```
db2 "call rdsadmin.rollforward_database(
?,
null,
null,
'END_OF_LOGS',
'TRUE')"
```
**Esempio 2: messa online del database senza i log delle transazioni**
Nell’esempio seguente viene effettuato il roll forward a un backup online del database senza i log delle transazioni con successiva messa online del database:
```
db2 "call rdsadmin.rollforward_database(
?,
'TESTDB',
'amzn-s3-demo-bucket',
'logsfolder/,
'END_OF_BACKUP',
'TRUE')"
```
**Esempio 3: messa online del database con i log delle transazioni non eseguita**
Nell’esempio seguente viene effettuato il roll forward a un backup online del database con i log delle transazioni senza successiva messa online del database:
```
db2 "call rdsadmin.rollforward_database(
?,
'TESTDB',
null,
'onlinebackup/TESTDB',
'END_OF_LOGS',
'FALSE')"
```
**Esempio 4: messa online del database con log delle transazioni aggiuntivi non eseguita**
Nell’esempio seguente viene effettuato il roll forward a un backup online del database con i log delle transazioni aggiuntivi senza successiva messa online del database:
```
db2 "call rdsadmin.rollforward_database(
?,
'TESTDB',
'amzn-s3-demo-bucket',
'logsfolder/S0000155.LOG',
'END_OF_LOGS',
'FALSE')"
```
## rdsadmin.rollforward\$1status
Restituisce l’output di `ROLLFORWARD DATABASE database_name QUERY STATUS`.
### Sintassi
```
db2 "call rdsadmin.rollforward_status(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database su cui eseguire l’operazione. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Dopo aver chiamato [rdsadmin.rollforward\$1database](#db2-sp-rollforward-database), puoi chiamare `rdsadmin.rollforward_status` per verificare lo stato del roll forward nel database.
Per informazioni su come verificare lo stato di questa stored procedure, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
## rdsadmin.complete\$1rollforward
Porta il database online da uno stato `ROLL-FORWARD PENDING`.
### Sintassi
```
db2 "call rdsadmin.complete_rollforward(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database che desideri portare online. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Se hai chiamato [rdsadmin.rollforward\$1database](#db2-sp-rollforward-database) con `complete_rollforward` impostato su `FALSE`, il tuo database è in uno stato `ROLL-FORWARD PENDING` e offline. Per completare il roll forward e portare il database online, chiama `rdsadmin.complete_rollforward`.
Per informazioni su come verificare lo stato del completamento del processo di roll-forward, consulta [rdsadmin.rollforward\$1status](#db2-sp-rollforward-status).
### Esempi
Nell’esempio seguente il database TESTDB viene portato online:
```
db2 "call rdsadmin.complete_rollforward(
?,
'TESTDB')"
```
## rdsadmin.db2pd\$1command
Raccoglie informazioni su un database RDS per Db2.
### Sintassi
```
db2 "call rdsadmin.db2pd_command('db2pd_cmd')"
```
### Parameters
Il parametro di input seguente è obbligatorio:
*db2pd\$1cmd*
Il nome del comando `db2pd` che desideri eseguire. Il tipo di dati è `varchar`.
Il parametro deve iniziare con un trattino. Per un elenco di parametri, consulta [db2pd - Monitor and troubleshoot Db2 database command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-db2pd-monitor-troubleshoot-db2-engine-activities) nella documentazione di IBM Db2.
Le seguenti opzioni non sono supportate:
+ `-addnode`
+ `-alldatabases`
+ `-alldbp`
+ `-alldbs`
+ `-allmembers`
+ `-alm_in_memory`
+ `-cfinfo`
+ `-cfpool`
+ `-command`
+ `-dbpartitionnum`
+ `-debug`
+ `-dump`
+ `-everything`
+ `-file | -o`
+ `-ha`
+ `-interactive`
+ `-member`
+ `-pages`
**Nota**
`-pages summary` è supportato.
+ `-pdcollection`
+ `-repeat`
+ `-stack`
+ `-totalmem`
L’opzione secondaria `file` non è supportata, ad esempio `db2pd -db testdb -tcbstats file=tcbstat.out`.
L’utilizzo dell’opzione `stacks` non è supportato, ad esempio `db2pd -edus interval=5 top=10 stacks`.
### Note per l’utilizzo
Questa stored procedure raccoglie informazioni che possono contribuire al monitoraggio e alla risoluzione dei problemi dei database RDS per Db2.
La stored procedure ricorre all’utility IBM `db2pd` per eseguire vari comandi. L’utility `db2pd` richiede l’autorizzazione `SYSADM`, di cui l’utente master RDS per Db2 non dispone. Tuttavia, con la stored procedure di Amazon RDS, l’utente master è in grado di ricorrere all’utility per eseguire vari comandi. Per ulteriori informazioni sull’utility, consulta [db2pd - Monitor and troubleshoot Db2 database command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-db2pd-monitor-troubleshoot-db2-engine-activities) nella documentazione di IBM Db2.
L’output è limitato a un massimo di 2 GB.
Per informazioni su come verificare lo stato della raccolta delle informazioni sul database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: restituzione del tempo di attività dell’istanza database**
Nell’esempio seguente viene restituito il tempo di attività di un’istanza database RDS per Db2:
```
db2 "call rdsadmin.db2pd_command('-')"
```
**Esempio 2: restituzione del tempo di attività del database**
Nell’esempio seguente viene restituito il tempo di attività di un database denominato `TESTDB`:
```
db2 "call rdsadmin.db2pd_command('-db TESTDB -')"
```
**Esempio 3: restituzione dell’utilizzo della memoria di un’istanza database**
Nell’esempio seguente viene restituito l’utilizzo della memoria di un’istanza database RDS per Db2:
```
db2 "call rdsadmin.db2pd_command('-dbptnmem')"
```
**Esempio 4: restituzione di set di memoria dell’istanza database e del database**
Nell’esempio seguente vengono restituiti i set di memoria di un’istanza database RDS per Db2 e di un database denominato `TESTDB`:
```
db2 "call rdsadmin.db2pd_command('-inst -db TESTDB -memsets')"
```
## rdsadmin.force\$1application
Forza la disconnessione delle applicazioni da un database RDS per Db2.
### Sintassi
```
db2 "call rdsadmin.force_application(
?,
'applications')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*applications*
Le applicazioni che desideri disconnettere da un database RDS per Db2. Il tipo di dati è `varchar`. Valori validi: `ALL` o *application\$1handle*.
Separa i nomi di più applicazioni con virgole. Esempio: '*application\$1handle\$11*,*application\$1handle\$12*'.
### Note per l’utilizzo
Questa stored procedure forza la disconnessione tutte le applicazioni da un database in modo da poter eseguire la manutenzione.
La stored procedure utilizza il comando IBM `FORCE APPLICATION`. Il comando `FORCE APPLICATION` richiede l’autorizzazione `SYSADM`, `SYSMAINT` o `SYSCTRL`, di cui l’utente master RDS per Db2 non dispone. Tuttavia, con la stored procedure di Amazon RDS, l’utente master è in grado di utilizzare il comando. Per ulteriori informazioni, consulta [FORCE APPLICATION command](https://www.ibm.com/docs/en/db2/11.1?topic=commands-force-application) nella documentazione di IBM Db2.
Per informazioni sulla verifica dello stato dell’esclusione di applicazioni da un database, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: specifica di tutte le applicazioni**
Nell’esempio seguente viene forzata la disconnessione di tutte le applicazioni da un database RDS per Db2:
```
db2 "call rdsadmin.force_application(
?,
'ALL')"
```
**Esempio 2: specificazione di più applicazioni**
Nell’esempio seguente viene forzata la disconnessione degli handle `9991`, `8891` e `1192` da un database RDS per Db2:
```
db2 "call rdsadmin.force_application(
?,
'9991, 8891, 1192')"
```
## rdsadmin.set\$1archive\$1log\$1retention
Configura la quantità di tempo (in ore) della conservazione dei file di log archiviati per il database RDS per Db2 specificato.
### Sintassi
```
db2 "call rdsadmin.set_archive_log_retention(
?,
'database_name',
'archive_log_retention_hours')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database per cui configurare la conservazione dei log archiviati. Il tipo di dati è `varchar`.
*archive\$1log\$1retention\$1hours*
Il numero di ore della conservazione dei file di log archiviati. Il tipo di dati è `smallint`. L'impostazione predefinita è `0` e il massimo è `840` (35 giorni).
Se il valore è `0`, Amazon RDS non conserva i file di log archiviati.
### Note per l’utilizzo
Per impostazione predefinita, RDS per Db2 conserva i log per 5 minuti. Si consiglia di utilizzare strumenti di replica come AWS DMS CDC (Change Data Capture) o IBM Q Replication di impostare la conservazione dei log in tali strumenti per più di 5 minuti.
Per visualizzare l’impostazione corrente di conservazione dei log archiviati, chiama [rdsadmin.show\$1archive\$1log\$1retention](#db2-sp-show-archive-log-retention).
Non è possibile configurare l’impostazione di conservazione dei log archiviati nel database `rdsadmin`.
### Esempi
**Esempio 1: impostazione del tempo di conservazione**
Nell’esempio seguente, il tempo di conservazione dei log archiviati per un database denominato `TESTDB` viene impostato su 24 ore.
```
db2 "call rdsadmin.set_archive_log_retention(
?,
'TESTDB',
'24')"
```
**Esempio 2: disabilitazione del tempo di conservazione**
Nell’esempio seguente, il tempo di conservazione dei log archiviati per un database denominato `TESTDB` viene disabilitato.
```
db2 "call rdsadmin.set_archive_log_retention(
?,
'TESTDB',
'0')"
```
## rdsadmin.show\$1archive\$1log\$1retention
Restituisce l’impostazione corrente di conservazione dei log archiviati per il database specificato.
### Sintassi
```
db2 "call rdsadmin.show_archive_log_retention(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database di cui visualizzare l’impostazione di conservazione dei log archiviati. Il tipo di dati è `varchar`.
### Esempi
Nell’esempio seguente viene mostrata l’impostazione del tempo di conservazione dei log archiviati per un database denominato `TESTDB`.
```
db2 "call rdsadmin.show_archive_log_retention(?,'TESTDB')"
```
## rdsadmin.list\$1archive\$1log\$1information
Restituisce dettagli sui file di log archiviati, come la dimensione, la data e l’ora di creazione e il nome dei singoli file di log, per il database specificato. Restituisce inoltre la quantità totale di archiviazione utilizzata dai file di log nel database.
### Sintassi
```
db2 "call rdsadmin.list_archive_log_information(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database di cui visualizzare le informazioni relative ai log archiviati. Il tipo di dati è `varchar`.
### Esempi
Nell’esempio seguente vengono restituite le informazioni relative ai log archiviati per un database denominato `TESTDB`.
```
db2 "call rdsadmin.list_archive_log_information(
?,
'TESTDB')"
```
## rdsadmin.enable\$1archive\$1log\$1copy
Abilita la copia del log di archivio del database RDS Db2 su Amazon S3.
### Sintassi
```
db2 "call rdsadmin.enable_archive_log_copy(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database per il quale abilitare la copia dei log di archivio su Amazon S3. Il tipo di dati è `varchar`.
### Esempi
L'esempio seguente abilita la copia del registro di archivio per un database chiamato`TESTDB`.
```
db2 "call rdsadmin.enable_archive_log_copy(
?,
'TESTDB')"
```
## rdsadmin.disable\$1archive\$1log\$1copy
Disattiva la copia del log di archivio del database RDS Db2 su Amazon S3.
### Sintassi
```
db2 "call rdsadmin.disable_archive_log_copy(
?,
'database_name')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
Il parametro di input seguente è obbligatorio:
*database\$1name*
Il nome del database per il quale disabilitare la copia dei log di archivio su Amazon S3. Il tipo di dati è `varchar`.
### Esempi
L'esempio seguente disabilita la copia del registro di archivio per un database chiamato. `TESTDB`
```
db2 "call rdsadmin.disable_archive_log_copy(
?,
'TESTDB')"
```
## rdsadmin.fgac\$1command
Esegue comandi di controllo degli accessi (FGAC) granulari.
### Sintassi
```
db2 "call rdsadmin.fgac_command(
?,
'database_name',
'fgac_cmd')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database su cui si desidera eseguire i comandi FGAC. Il tipo di dati è `varchar`.
*fgac\$1cmd*
Il comando di controllo degli accessi dettagliato che si desidera eseguire. Il tipo di dati è `varchar`.
I seguenti comandi sono validi:
+ `ALTER MASK`— Modifica una maschera di colonna esistente nel controllo dell'accesso a righe e colonne (RCAC).
+ `ALTER PERMISSION`— Modifica le proprietà di un'autorizzazione di riga esistente in RCAC.
+ `ALTER SECURITY POLICY`— Modifica una politica di sicurezza esistente per RCAC.
+ `ALTER SECURITY LABEL`— Modifica le proprietà di un'etichetta di sicurezza esistente nel controllo degli accessi basato su etichette (LBAC).
+ `ALTER TABLE`— Modifica la struttura della tabella, inclusa l'aggiunta di controlli RCAC o LBAC.
+ `CREATE MASK`— Crea una nuova maschera di colonna per RCAC.
+ `CREATE PERMISSION`— Crea una nuova autorizzazione di riga per RCAC.
+ `CREATE SECURITY LABEL`— Crea una nuova etichetta di sicurezza per LBAC.
+ `CREATE SECURITY POLICY`— Crea una nuova politica di sicurezza per RCAC.
+ `DROP MASK`— Elimina una maschera di colonna esistente.
+ `DROP PERMISSION`— Elimina l'autorizzazione di una riga esistente.
+ `DROP SECURITY LABEL`— Elimina un'etichetta di sicurezza da LBAC.
+ `DROP SECURITY POLICY`— Elimina una politica di sicurezza RCAC esistente.
+ `GRANT EXEMPTION ON RULE`— Consente a un utente di ignorare regole LBAC specifiche.
+ `GRANT SECURITY LABEL`— Assegna un'etichetta di sicurezza LBAC a un utente.
+ `REVOKE EXEMPTION ON RULE`— Rimuove l'esenzione di un utente dalle regole LBAC.
+ `REVOKE SECURITY LABEL`— Rimuove un'etichetta di sicurezza LBAC da un utente.
### Note per l’utilizzo
Questa stored procedure controlla l'accesso a livello di riga o colonna ai dati della tabella nel database su un'istanza DB RDS for Db2. RDS per Db2 supporta due tipi di FGAC sul database:
+ Controllo degli accessi basato su etichette (LBAC)
+ Controllo dell'accesso a righe e colonne (RCAC)
Prima di chiamare la stored procedure, esamina le seguenti considerazioni:
+ Per evitare una virgoletta singola ('), usa una virgoletta singola aggiuntiva. Gli esempi seguenti mostrano come fuggire `'apple'``'banana'`, e`'fruit'`.
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE SECURITY LABEL COMPONENT FRUITSET SET{''apple'',''banana''}')"
```
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE SECURITY LABEL COMPONENT FRUITTREE TREE(''fruit'' ROOT, ''apple'' UNDER ''fruit'', ''banana'' UNDER ''fruit'')')"
```
+ Per evitare le parentesi ([]), usate una barra rovesciata (\$1). L'esempio seguente mostra come fuggire. `[''apple'',''banana'']`
```
db2 "call rdsadmin.fgac_command(
?, '
testdb',
'CREATE SECURITY LABEL COMPONENT FRUITARRAY ARRAY\[''apple'',''banana''\]')"
```
### Esempi
Gli esempi seguenti eseguono tutti i comandi FGAC su un database chiamato. `testdb`
**Esempio 1: creazione di una nuova etichetta di sicurezza denominata `FRUITSET`**
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE SECURITY LABEL COMPONENT FRUITSET SET{''apple'',''banana''}')"
```
**Esempio 2: creazione di una nuova maschera per la `EMP_ID` colonna che è abilitata quando `EMP_ID` è impostata su meno di tre**
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE MASK id_MASK ON EMPLOYEE FOR COLUMN EMP_ID RETURN CASE WHEN (EMP_ID < 3) THEN EMP_ID ELSE NULL END ENABLE')"
```
**Esempio 3: creazione di una nuova maschera per la `DEPARTMENT` colonna che è abilitata quando `SESSION_USER` è impostata su `security_user`**
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE MASK DEPARTMENT_MASK ON EMPLOYEE FOR COLUMN DEPARTMENT RETURN CASE WHEN SESSION_USER = ''security_user'' THEN DEPARTMENT ELSE NULL END ENABLE')"
```
**Esempio 4: creazione di una nuova etichetta di sicurezza denominata `treelabel`**
```
db2 "call rdsadmin.fgac_command(
?,
'testdb',
'CREATE SECURITY LABEL COMPONENT treelabel TREE(''COMPANY'' ROOT, ''HR'' UNDER ''COMPANY'', ''FINANCE'' UNDER ''COMPANY'', ''IT'' UNDER ''COMPANY'')')"
```
## rdsadmin.db2support\$1command
Raccoglie informazioni diagnostiche su un database RDS for Db2 e le carica in un bucket Amazon S3.
### Sintassi
```
db2 "call rdsadmin.db2support_command(
?,
'database_name',
's3_bucket_name',
's3_prefix')"
```
### Parameters
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo `?`
I parametri di input seguenti sono obbligatori:
*database\$1name*
Il nome del database per cui raccogliere informazioni diagnostiche. Il tipo di dati è `varchar`.
*s3\$1bucket\$1name*
Il nome del bucket Amazon S3 in cui desideri caricare le informazioni diagnostiche. Il tipo di dati è `varchar`.
*s3\$1prefix*
Il prefisso del percorso verso Amazon S3 in cui RDS per Db2 carica i file di diagnostica. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Questa procedura memorizzata raccoglie informazioni diagnostiche che possono aiutare nella risoluzione dei problemi RDS per i database Db2 e carica le informazioni in un bucket Amazon S3.
La procedura memorizzata utilizza l'utilità per raccogliere dati diagnostici. IBM `db2support` Per ulteriori informazioni sull'utilità, vedere [db2support - Comando dello strumento di analisi dei problemi e raccolta dell'ambiente](https://www.ibm.com/docs/en/db2/11.5?topic=commands-db2support-problem-analysis-environment-collection-tool) nella IBM Db2 documentazione.
Prima di chiamare la stored procedure, esamina le seguenti considerazioni:
+ Per caricare i file di diagnostica su Amazon S3, devi aver già configurato l'integrazione. Per ulteriori informazioni, consulta [Integrazione di un’istanza database Amazon RDS per Db2 con Amazon S3](db2-s3-integration.md).
+ Affinché un'istanza DB RDS for Db2 sia in grado di interagire con Amazon S3, è necessario disporre di un VPC e di un endpoint gateway Amazon S3 per l'utilizzo di sottoreti private. Per ulteriori informazioni, consultare [Fase 1: creare un endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-creating-endpoint) e [Fase 2: verificare l’esistenza dell’endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-confirming-endpoint).
Prima di chiamare `rdsadmin.db2support_command`, è necessario connettersi al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le informazioni sull'istanza DB RDS for Db2:
```
db2 connect to rdsadmin user master_username using master_password
```
Per informazioni sulla verifica dello stato della raccolta delle informazioni diagnostiche, vedere. [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status)
### Esempi
**Esempio 1: raccolta di informazioni diagnostiche per un database**
L'esempio seguente raccoglie informazioni diagnostiche per un database chiamato `TESTDB` e le carica nel bucket `amzn-s3-demo-bucket` Amazon S3 chiamato con il prefisso: `diagnostics/testdb`
```
db2 "call rdsadmin.db2support_command(
?,
'TESTDB',
'amzn-s3-demo-bucket',
'diagnostics/testdb')"
```
**Esempio 2: raccolta di informazioni diagnostiche con un prefisso basato sulla data**
L'esempio seguente raccoglie informazioni diagnostiche per un database chiamato `MYDB` e le carica nel bucket Amazon S3 `amzn-s3-demo-bucket` chiamato con un prefisso basato sulla data:
```
db2 "call rdsadmin.db2support_command(
?,
'MYDB',
'amzn-s3-demo-bucket',
'support/2024/01/15')"
```
# Stored procedure per l’accesso all’archiviazione per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono l’accesso all’archiviazione per i database RDS per Db2 che utilizzano Amazon S3 per la migrazione dei dati. Per ulteriori informazioni, consulta [Migrazione dei dati Db2 ad Amazon RDS per Db2 tramite Amazon S3](db2-migration-load-from-s3.md).
Fai riferimento alle seguenti stored procedure integrate per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi.
**Topics**
+ [rdsadmin.catalog\$1storage\$1access](#db2-sp-catalog-storage-access)
+ [rdsadmin.uncatalog\$1storage\$1access](#db2-sp-uncatalog-storage-access)
## rdsadmin.catalog\$1storage\$1access
Cataloga un alias di archiviazione per l’accesso a un bucket Amazon S3 con file di dati Db2.
### Sintassi
```
db2 "call rdsadmin.catalog_storage_access(
?,
'alias',
's3_bucket_name',
'grantee_type',
'grantee'
)"
```
### Parametri
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Il tipo di dati è `varchar`.
I parametri di input seguenti sono obbligatori:
*alias*
Il nome alias per l’accesso all’archiviazione remota in un bucket Amazon S3. Il tipo di dati è `varchar`.
*s3\$1bucket\$1name*
Il nome del bucket Amazon S3 in cui risiedono i dati. Il tipo di dati è `varchar`.
*grantee\$1type*
Il tipo di assegnatario dell’autorizzazione. Il tipo di dati è `varchar`. Valori validi: `USER`, `GROUP`.
*grantee*
L’utente o il gruppo che riceverà l’autorizzazione. Il tipo di dati è `varchar`.
### Note per l'utilizzo
Amazon RDS include l’alias catalogato nel ruolo IAM aggiunto all’istanza database RDS per Db2. Se rimuovi il ruolo IAM dall’istanza database, Amazon RDS elimina l’alias. Per ulteriori informazioni, consulta [Migrazione dei dati Db2 ad Amazon RDS per Db2 tramite Amazon S3](db2-migration-load-from-s3.md).
Per informazioni su come verificare lo stato della catalogazione dell’alias, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente registra un alias denominato `SAMPLE`. All’utente `jorge_souza` viene concesso l’accesso al bucket Amazon S3 denominato `amzn-s3-demo-bucket`.
```
db2 "call rdsadmin.catalog_storage_access(
?,
'SAMPLE',
'amzn-s3-demo-bucket',
'USER',
'jorge_souza')"
```
## rdsadmin.uncatalog\$1storage\$1access
Rimuove un alias di accesso all’archiviazione.
### Sintassi
```
db2 "call rdsadmin.uncatalog_storage_access(
?,
'alias')"
```
### Parametri
Il parametro di output seguente è obbligatorio:
?
Un indicatore di parametro che genera un messaggio di errore. Il tipo di dati è `varchar`.
Il parametro di input seguente è obbligatorio:
*alias*
Il nome dell’alias di archiviazione da rimuovere. Il tipo di dati è `varchar`.
### Note per l'utilizzo
Per informazioni su come verificare lo stato della rimozione dell’alias, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente rimuove un alias denominato `SAMPLE`. L’alias non fornirà più l’accesso al bucket Amazon S3 a cui era associato.
```
db2 "call rdsadmin.uncatalog_storage_access(
?,
'SAMPLE')"
```
# Stored procedure relative ai tablespace per RDS per Db2
Le stored procedure integrate descritte in questo argomento gestiscono i tablespace per i database Amazon RDS per Db2. Per eseguire queste procedure, l’utente master deve prima connettersi al database `rdsadmin`.
Queste stored procedure vengono utilizzate in diverse attività. L'elenco non è completo.
+ [Attività comuni per i tablespace](db2-managing-tablespaces.md)
+ [Generazione di report sulle prestazioni](db2-managing-databases.md#db2-generating-performance-reports)
+ [Copia dei metadati del database con db2look](db2-native-db2-tools-db2look.md)
+ [Creazione di un database di repository per IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md#db2-creating-repo-db-monitoring-dmc)
Fai riferimento alle seguenti stored procedure integrate per informazioni sulla sintassi, i parametri, le note per l’utilizzo e gli esempi.
**Topics**
+ [rdsadmin.create\$1tablespace](#db2-sp-create-tablespace)
+ [rdsadmin.alter\$1tablespace](#db2-sp-alter-tablespace)
+ [rdsadmin.rename\$1tablespace](#db2-sp-rename-tablespace)
+ [rdsadmin.drop\$1tablespace](#db2-sp-drop-tablespace)
## rdsadmin.create\$1tablespace
Crea un tablespace.
### Sintassi
```
db2 "call rdsadmin.create_tablespace(
'database_name',
'tablespace_name',
'buffer_pool_name',
tablespace_page_size,
tablespace_initial_size,
tablespace_increase_size,
'tablespace_type',
'tablespace_prefetch_size')"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database in cui creare il tablespace. Il tipo di dati è `varchar`.
*tablespace\$1name*
Il nome del tablespace da creare. Il tipo di dati è `varchar`.
Il nome del tablespace presenta le seguenti limitazioni:
+ Non può essere uguale al nome di un tablespace esistente nel database.
+ Può contenere solo i caratteri `_$#@a-zA-Z0-9`.
+ Non può iniziare con `_` o `$`.
+ Non può iniziare con `SYS`.
I parametri seguenti sono facoltativi:
*buffer\$1pool\$1name*
Il nome del pool di buffer a cui assegnare il tablespace. Il tipo di dati è `varchar`. L'impostazione predefinita è una stringa vuota.
È necessario disporre già di un pool di buffer della stessa dimensione di pagina da associare al tablespace.
*tablespace\$1page\$1size*
La dimensione di pagina del tablespace, espressa in byte. Il tipo di dati è `integer`. Valori validi: `4096`, `8192`, `16384`, `32768`. L’impostazione predefinita è la dimensione di pagina utilizzata al momento della creazione del database chiamando [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
Amazon RDS supporta l’atomicità di scrittura per pagine da 4 KiB, 8 KiB e 16 KiB. Per contro, le pagine da 32 KiB rischiano di causare scritture incomplete o la scrittura parziale dei dati sul desktop. Se utilizzi pagine da 32 KiB, ti consigliamo di abilitare il point-in-time ripristino e i backup automatici. Altrimenti, corri il rischio di non riuscire a recuperare le pagine danneggiate. Per ulteriori informazioni, consultare [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md) e [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
*tablespace\$1initial\$1size*
La dimensione iniziale del tablespace in kilobyte (KB). Il tipo di dati è `integer`. Valori validi: `48` o superiore. Il valore predefinito è null.
Se non imposti un valore, Db2 imposta automaticamente un valore appropriato.
Questo parametro non è applicabile per i tablespace temporanei poiché questi vengono gestiti dal sistema.
*tablespace\$1increase\$1size*
La percentuale in base alla quale aumentare la dimensione del tablespace quando è pieno. Il tipo di dati è `integer`. Valori validi: `1`-`100`. Il valore predefinito è null.
Se non imposti un valore, Db2 imposta automaticamente un valore appropriato.
Questo parametro non è applicabile per i tablespace temporanei poiché questi vengono gestiti dal sistema.
*tablespace\$1type*
Il tipo di tablespace. Il tipo di dati è `char`. Valori validi: `U` (per i dati dell’utente), `T` (per i dati temporanei dell’utente) o `S` (per i dati temporanei del sistema). Il valore predefinito è `U`.
*tablespace\$1prefetch\$1size*
La dimensione di pagina di prefetch del tablespace. Il tipo di dati è `char`. Valori validi: `AUTOMATIC` (senza distinzione tra maiuscole e minuscole) o numeri interi positivi diversi da zero minori o uguali a 32.767.
### Note per l’utilizzo
RDS per Db2 crea sempre un database di grandi dimensioni per i dati.
Per informazioni su come verificare lo stato della creazione di un tablespace, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
**Esempio 1: creazione di un tablespace e assegnazione di un pool di buffer**
L’esempio seguente crea un tablespace denominato `SP8` e assegna il pool di buffer `BP8` per il database `TESTDB`. Il tablespace ha una dimensione di pagina di 4.096 byte, una dimensione di pagina di 1.000 KB e una percentuale di incremento della dimensione di tabella del 50%.
```
db2 "call rdsadmin.create_tablespace(
'TESTDB',
'SP8',
'BP8',
4096,
1000,
50)"
```
**Esempio 2: creazione di un tablespace temporaneo e assegnazione di un pool di buffer**
L’esempio seguente crea un tablespace temporaneo denominato `SP8`. Assegna un pool di buffer denominato `BP8` della dimensione di 8 KiB per il database `TESTDB`.
```
db2 "call rdsadmin.create_tablespace(
'TESTDB',
'SP8',
'BP8',
8192,
NULL,
NULL,
'T')"
```
**Esempio 3: creazione di un tablespace e assegnazione di una dimensione di pagina di prefetch**
L’esempio seguente crea un tablespace denominato `SP8` per il database `TESTDB`. Il tablespace ha una dimensione di incremento iniziale pari a `50` e una dimensione di pagina di prefetch pari a `800`.
```
db2 "call rdsadmin.create_tablespace(
'TESTDB',
'SP8',
NULL,
NULL,
NULL,
50,
NULL,
'800')"
```
## rdsadmin.alter\$1tablespace
Modifica un tablespace.
### Sintassi
```
db2 "call rdsadmin.alter_tablespace(
'database_name',
'tablespace_name',
'buffer_pool_name',
tablespace_increase_size,
'max_size',
'reduce_max',
'reduce_stop',
'reduce_value',
'lower_high_water',
'lower_high_water_stop',
'switch_online',
'tablespace_prefetch_size')"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database che utilizza il tablespace. Il tipo di dati è `varchar`.
*tablespace\$1name*
Il nome del tablespace da modificare. Il tipo di dati è `varchar`.
I parametri seguenti sono facoltativi:
*buffer\$1pool\$1name*
Il nome del pool di buffer a cui assegnare il tablespace. Il tipo di dati è `varchar`. L'impostazione predefinita è una stringa vuota.
È necessario disporre già di un pool di buffer della stessa dimensione di pagina da associare al tablespace.
*tablespace\$1increase\$1size*
La percentuale in base alla quale aumentare la dimensione del tablespace quando è pieno. Il tipo di dati è `integer`. Valori validi: `1`-`100`. Il valore predefinito è `0`.
*max\$1size*
La dimensione massima per il tablespace. Il tipo di dati è `varchar`. Valori validi: *integer* `K` \$1 `M` \$1`G`, or`NONE`. Il valore predefinito è `NONE`.
*reduce\$1max*
Specifica se ridurre il limite massimo consentito. Il tipo di dati è `char`. Il valore predefinito è `N`.
*reduce\$1stop*
Specifica se interrompere un comando `reduce_max` o `reduce_value` precedente. Il tipo di dati è `char`. Il valore predefinito è `N`.
*reduce\$1value*
Il numero o la percentuale in base a cui ridurre il limite massimo per il tablespace. Il tipo di dati è `varchar`. Valori validi: *integer* `K` `M` \$1 \$1 `G` o `1` —`100`. Il valore predefinito è `N`.
*lower\$1high\$1water*
Specifica se eseguire il comando `ALTER TABLESPACE LOWER HIGH WATER MARK`. Il tipo di dati è `char`. Il valore predefinito è `N`.
*lower\$1high\$1water\$1stop*
Specifica se eseguire il comando `ALTER TABLESPACE LOWER HIGH WATER MARK STOP`. Il tipo di dati è `char`. Il valore predefinito è `N`.
*switch\$1online*
Specifica se eseguire il comando `ALTER TABLESPACE SWITCH ONLINE`. Il tipo di dati è `char`. Il valore predefinito è `N`.
*tablespace\$1prefetch\$1size*
La dimensione di pagina di prefetch del tablespace. Il tipo di dati è `char`. Valori validi: `AUTOMATIC` (senza distinzione tra maiuscole e minuscole) o numeri interi positivi diversi da zero minori o uguali a 32.767.
Questo parametro funziona solo con `buffer_pool_name`, `table_increase_size`, `max_size` e `switch_online`. Non funziona con `reduce_max`, `reduce_stop`, `reduce_value`, `lower_high_water` e `lower_high_water_stop`.
### Note per l’utilizzo
Prima di chiamare la stored procedure, esamina le seguenti considerazioni:
+ La stored procedure `rdsadmin.alter_tablespace` non funziona su un tablespace con `tablespace_type` impostato su `T` per i dati temporanei dell’utente.
+ I parametri facoltativi `reduce_max`, `reduce_stop`, `reduce_value`, `lower_high_water`, `lower_high_water_stop` e `switch_online` si escludono a vicenda. Non puoi combinarli con altri parametri facoltativi, ad esempio `buffer_pool_name`, nel comando `rdsadmin.alter_tablespace`. Per ulteriori informazioni, consulta [Statement not valid](db2-troubleshooting.md#alter-tablespace-sp-statement-not-valid).
Per informazioni su come verificare lo stato della modifica di un tablespace, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Per i messaggi di errore restituiti durante le chiamate alle stored procedure, consulta [Errori delle stored procedure](db2-troubleshooting.md#db2-troubleshooting-stored-procedures).
### Esempi
**Esempio 1: diminuzione del valore del limite massimo**
L’esempio seguente modifica un tablespace denominato `SP8` e assegna il pool di buffer `BP8` per il database `TESTDB` al fine di diminuire il valore del limite massimo.
```
db2 "call rdsadmin.alter_tablespace(
'TESTDB',
'SP8',
'BP8',
NULL,
NULL,
'Y')"
```
**Esempio 2: riduzione del limite massimo**
L’esempio seguente esegue il comando `REDUCE MAX` su un tablespace denominato `TBSP_TEST` nel database `TESTDB`.
```
db2 "call rdsadmin.alter_tablespace(
'TESTDB',
'TBSP_TEST',
NULL,
NULL,
NULL,
'Y')"
```
**Esempio 3: interruzione dei comandi per la riduzione del limite massimo**
L’esempio seguente esegue il comando `REDUCE STOP` su un tablespace denominato `TBSP_TEST` nel database `TESTDB`.
```
db2 "call rdsadmin.alter_tablespace(
'TESTDB',
'TBSP_TEST',
NULL,
NULL,
NULL,
NULL,
'Y')"
```
**Esempio 4: modifica della dimensione di pagina di prefetch esistente**
L’esempio seguente esegue il comando `ALTER TABLESPACE SWITCH ONLINE` su un tablespace denominato `TSBP_TEST` e modifica la dimensione di pagina di prefetch esistente in `64`.
```
db2 "call rdsadmin.alter_tablespace(
'TESTDB',
'TBSP_TEST',
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
‘Y’,
‘64’)"
```
## rdsadmin.rename\$1tablespace
Rinomina un tablespace.
### Sintassi
```
db2 "call rdsadmin.rename_tablespace(
?,
'database_name',
'source_tablespace_name',
'target_tablespace_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
?
Un indicatore di parametro che genera un messaggio di errore. Questo parametro accetta solo ?.
*database\$1name*
Il nome del database a cui appartiene il tablespace. Il tipo di dati è `varchar`.
*source\$1tablespace\$1name*
Il nome del tablespace da rinominare. Il tipo di dati è `varchar`.
*target\$1tablespace\$1name*
Il nuovo nome del tablespace. Il tipo di dati è `varchar`.
Il nuovo nome presenta le seguenti limitazioni:
+ Non può essere uguale al nome di un tablespace esistente.
+ Può contenere solo i caratteri `_$#@a-zA-Z0-9`.
+ Non può iniziare con `_` o `$`.
+ Non può iniziare con `SYS`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato della ridenominazione di un tablespace, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
Non è possibile rinominare i tablespace che appartengono al database `rdsadmin`.
### Esempi
L’esempio seguente rinomina in `SP9` un tablespace denominato `SP8` nel database `TESTDB`.
```
db2 "call rdsadmin.rename_tablespace(
?,
'TESTDB',
'SP8',
'SP9')"
```
## rdsadmin.drop\$1tablespace
Elimina un tablespace.
### Sintassi
```
db2 "call rdsadmin.drop_tablespace(
'database_name',
'tablespace_name')"
```
### Parameters
I parametri seguenti sono obbligatori:
*database\$1name*
Il nome del database a cui appartiene il tablespace. Il tipo di dati è `varchar`.
*tablespace\$1name*
Il nome del tablespace da eliminare. Il tipo di dati è `varchar`.
### Note per l’utilizzo
Per informazioni su come verificare lo stato dell’eliminazione di un tablespace, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status).
### Esempi
L’esempio seguente elimina un tablespace denominato `SP8` dal database `TESTDB`.
```
db2 "call rdsadmin.drop_tablespace(
'TESTDB',
'SP8')"
```