Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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à.
# Esempi
L'esempio seguente concede all'utente il privilegio SELECT sulla tabella SALES `fred`.
```
grant select on table sales to fred;
```
L'esempio seguente concede all'utente il privilegio SELECT su tutte le tabelle dello schema QA\_TICKIT `fred`.
```
grant select on all tables in schema qa_tickit to fred;
```
L'esempio seguente concede tutti i privilegi dello schema sullo schema QA\_TICKIT al gruppo di utenti QA\_USERS. I privilegi dello schema sono CREATE e USAGE. USAGE concede agli utenti l'accesso agli oggetti nello schema, ma non concede i privilegi come INSERT o SELECT su quegli oggetti. Concedere i privilegi a ciascun oggetto separatamente.
```
create group qa_users;
grant all on schema qa_tickit to group qa_users;
```
L'esempio seguente concede tutti i privilegi sulla tabella SALES nello schema QA\_TICKIT a tutti gli utenti del gruppo QA\_USERS.
```
grant all on table qa_tickit.sales to group qa_users;
```
L'esempio seguente concede tutti i privilegi sulla tabella SALES nello schema QA\_TICKIT a tutti gli utenti del gruppo QA\_USERS e RO\_USERS.
```
grant all on table qa_tickit.sales to group qa_users, group ro_users;
```
L'esempio seguente concede il privilegio DROP sulla tabella SALES nello schema QA\_TICKIT a tutti gli utenti del gruppo QA\_USERS.
```
grant drop on table qa_tickit.sales to group qa_users;>
```
La seguente sequenza di comandi mostra come l'accesso a uno schema non concede privilegi su una tabella nello schema.
```
create user schema_user in group qa_users password 'Abcd1234';
create schema qa_tickit;
create table qa_tickit.test (col1 int);
grant all on schema qa_tickit to schema_user;
set session authorization schema_user;
select current_user;
current_user
--------------
schema_user
(1 row)
select count(*) from qa_tickit.test;
ERROR: permission denied for relation test [SQL State=42501]
set session authorization dw_user;
grant select on table qa_tickit.test to schema_user;
set session authorization schema_user;
select count(*) from qa_tickit.test;
count
-------
0
(1 row)
```
La seguente sequenza di comandi mostra come l'accesso a una vista non implica l'accesso alle tabelle sottostanti. L'utente chiamato VIEW\_USER non può selezionare dalla tabella DATE sebbene a questo utente siano stati concessi tutti i privilegi su VIEW\_DATE.
```
create user view_user password 'Abcd1234';
create view view_date as select * from date;
grant all on view_date to view_user;
set session authorization view_user;
select current_user;
current_user
--------------
view_user
(1 row)
select count(*) from view_date;
count
-------
365
(1 row)
select count(*) from date;
ERROR: permission denied for relation date
```
Nell'esempio seguente vengono concessi privilegi SELECT sulle colonne `cust_name` e `cust_phone` della tabella `cust_profile` all'utente `user1`.
```
grant select(cust_name, cust_phone) on cust_profile to user1;
```
L'esempio seguente concede il privilegio SELECT sulle colonne `cust_name` e `cust_phone` e il privilegio UPDATE sulla colonna `cust_contact_preference` della tabella `cust_profile` tabella al gruppo `sales_group`.
```
grant select(cust_name, cust_phone), update(cust_contact_preference) on cust_profile to group sales_group;
```
Nell'esempio seguente viene illustrato l'utilizzo della parola chiave ALL per concedere i privilegi SELECT e UPDATE su tre colonne della tabella `cust_profile` al gruppo `sales_admin`.
```
grant ALL(cust_name, cust_phone,cust_contact_preference) on cust_profile to group sales_admin;
```
L'esempio seguente concede all'utente `user2` il privilegio SELECT sulla colonna `cust_name` della vista `cust_profile_vw`.
```
grant select(cust_name) on cust_profile_vw to user2;
```
## Esempi di assegnazione dell'accesso alle unità di condivisione dati
Gli esempi di seguito riportano le autorizzazioni di utilizzo per la condivisione dei dati GRANT su un database o uno schema specifico creato da una unità di condivisione dati.
Nell'esempio seguente, un amministratore lato producer assegna l'autorizzazione USAGE dell'unità di condivisione dati `salesshare` allo spazio dei nomi specificato.
```
GRANT USAGE ON DATASHARE salesshare TO NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d';
```
Nell'esempio seguente, un amministratore lato consumer assegna l'autorizzazione USAGE di `sales_db` a `Bob`.
```
GRANT USAGE ON DATABASE sales_db TO Bob;
```
Nell'esempio seguente, un amministratore lato consumer assegna l'autorizzazione GRANT USAGE dello schema `sales_schema` al ruolo `Analyst_role`. `sales_schema` è uno schema esterno che fa riferimento a sales\_db.
```
GRANT USAGE ON SCHEMA sales_schema TO ROLE Analyst_role;
```
A questo punto, `Bob` e `Analyst_role` possono accedere a tutti gli oggetti del database in `sales_schema` e `sales_db`.
L'esempio seguente mostra l'assegnazione di autorizzazioni aggiuntive per gli oggetti in un database condiviso. Queste autorizzazioni aggiuntive sono necessarie solo se il comando CREATE DATABASE utilizzato per creare il database condiviso includeva la clausola WITH PERMISSIONS. Se il comando CREATE DATABASE non includeva WITH PERMISSIONS, l'assegnazione di USAGE per il database condiviso consente l'accesso completo a tutti gli oggetti in quel database.
```
GRANT SELECT ON sales_db.sales_schema.tickit_sales_redshift to Bob;
```
## Esempi di assegnazione di autorizzazioni con ambito
L'esempio seguente assegna al ruolo `Sales` l'utilizzo di tutti gli schemi attuali e futuri nel database `Sales_db`.
```
GRANT USAGE FOR SCHEMAS IN DATABASE Sales_db TO ROLE Sales;
```
L'esempio seguente assegna all'utente `alice` l'autorizzazione SELECT per tutte le tabelle correnti e future del database `Sales_db` e assegna ad `alice` l'autorizzazione a fornire ad altri utenti le autorizzazioni con ambito per le tabelle in `Sales_db`.
```
GRANT SELECT FOR TABLES IN DATABASE Sales_db TO alice WITH GRANT OPTION;
```
L'esempio seguente concede all'utente `bob` l'autorizzazione EXECUTE per le funzioni dello schema `Sales_schema`.
```
GRANT EXECUTE FOR FUNCTIONS IN SCHEMA Sales_schema TO bob;
```
L'esempio seguente concede al ruolo `Sales` tutte le autorizzazioni per tutte le tabelle dello schema `ShareSchema` del database `ShareDb`. Quando si specifica lo schema, è possibile indicare il database dello schema utilizzando il formato in due parti `database.schema`.
```
GRANT ALL FOR TABLES IN SCHEMA ShareDb.ShareSchema TO ROLE Sales;
```
L'esempio seguente è uguale al precedente. Puoi specificare il database utilizzando la parola chiave `DATABASE` anziché utilizzare un formato in due parti.
```
GRANT ALL FOR TABLES IN SCHEMA ShareSchema DATABASE ShareDb TO ROLE Sales;
```
## Esempi di concessione del privilegio ASSUMEROLE
Di seguito sono riportati esempi di concessione del privilegio ASSUMEROLE.
Nell'esempio seguente viene illustrata l'istruzione REVOKE che un utente con privilegi avanzati esegue una volta nel cluster per abilitare l'utilizzo del privilegio ASSUMEROLE per utenti e gruppi. Quindi, l'utente con privilegi avanzati concede il privilegio ASSUMEROLE a utenti e gruppi per i comandi appropriati. Per informazioni su come abilitare l'utilizzo del privilegio ASSUMEROLE per utenti e gruppi, consultare [Note di utilizzo per la concessione dell'autorizzazione ASSUMEROLE](r_GRANT-usage-notes.md#r_GRANT-usage-notes-assumerole).
```
revoke assumerole on all from public for all;
```
L'esempio seguente concede il privilegio ASSUMEROLE all'utente `reg_user1` per il ruolo IAM `Redshift-S3-Read` per eseguire operazioni COPY.
```
grant assumerole on 'arn:aws:iam::123456789012:role/Redshift-S3-Read'
to reg_user1 for copy;
```
L'esempio seguente concede il privilegio ASSUMEROLE all'utente `reg_user1` per la catena di ruoli IAM `RoleA`, `RoleB` per eseguire operazioni COPY.
```
grant assumerole
on 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB'
to reg_user1
for unload;
```
Di seguito è riportato un esempio del comando UNLOAD utilizzando la catena di ruoli IAM `RoleA`, `RoleB`.
```
unload ('select * from venue limit 10')
to 's3://companyb/redshift/venue_pipe_'
iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';
```
L'esempio seguente concede il privilegio ASSUMEROLE all'utente `reg_user1` per il ruolo IAM `Redshift-Exfunc` per creare funzioni esterne.
```
grant assumerole on 'arn:aws:iam::123456789012:role/Redshift-Exfunc'
to reg_user1 for external function;
```
L'esempio seguente concede il privilegio ASSUMEROLE all'utente `reg_user1` per il ruolo IAM `Redshift-model` per creare modelli di machine learning.
```
grant assumerole on 'arn:aws:iam::123456789012:role/Redshift-ML'
to reg_user1 for create model;
```
## Esempi di concessione dei privilegi ROLE
L'esempio seguente concede sample\_role1 a user1.
```
CREATE ROLE sample_role1;
GRANT ROLE sample_role1 TO user1;
```
L'esempio seguente concede sample\_role1 a user1 con l'opzione WITH ADMIN OPTION, imposta la sessione corrente per user1 e user1 concede sample\_role1 a user2.
```
GRANT ROLE sample_role1 TO user1 WITH ADMIN OPTION;
SET SESSION AUTHORIZATION user1;
GRANT ROLE sample_role1 TO user2;
```
L'esempio seguente concede sample\_role1 a sample\_role2.
```
GRANT ROLE sample_role1 TO ROLE sample_role2;
```
L'esempio seguente concede sample\_role2 a sample\_role3 e sample\_role4. Quindi tenta di concedere sample\_role3 a sample\_role1.
```
GRANT ROLE sample_role2 TO ROLE sample_role3;
GRANT ROLE sample_role3 TO ROLE sample_role2;
ERROR: cannot grant this role, a circular dependency was detected between these roles
```
L'esempio seguente concede i privilegi di sistema CREATE USER a sample\_role1.
```
GRANT CREATE USER TO ROLE sample_role1;
```
L'esempio seguente concede il ruolo definito dal sistema `sys:dba` a user1.
```
GRANT ROLE sys:dba TO user1;
```
L'esempio seguente tenta di concedere sample\_role3 in una dipendenza circolare a sample\_role2.
```
CREATE ROLE sample_role3;
GRANT ROLE sample_role2 TO ROLE sample_role3;
GRANT ROLE sample_role3 TO ROLE sample_role2; -- fail
ERROR: cannot grant this role, a circular dependency was detected between these roles
```