`.
È possibile trovare esempi nella tabella seguente.
| Istruzione Oracle | Istruzione MySQL |
| --- | --- |
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01
(p_state IN NUMBER)
AS
l_dept_id NUMBER := 1;
BEGIN
FOR cur IN
(WITH dept_empl(id, name, surname,
lastname, state, dept_id)
AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = p_state AND
dept_id = l_dept_id)
SELECT id,state
FROM dept_empl
ORDER BY id) LOOP
NULL;
END LOOP;
| CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 1;
DECLARE var$id VARCHAR (8000);
DECLARE var$state VARCHAR (8000);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
ID, STATE
FROM (SELECT
ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl
ORDER BY ID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$id, var$state;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01
AS
BEGIN
FOR cur IN (
WITH dept_empl AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1),
dept AS
(SELECT id deptid, parent_id,
name deptname
FROM test_ora_pg.department
)
SELECT dept_empl.*,dept.*
FROM dept_empl, dept
WHERE dept_empl.dept_id = dept.deptid
) LOOP
NULL;
END LOOP;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT id, name, surname, lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1);
CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
`(deptid, parent_id,deptname)
AS
(SELECT id deptid, parent_id, name deptname
FROM test_ora_pg.department);
CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
BEGIN
DECLARE var$ID DOUBLE;
DECLARE var$NAME VARCHAR (30);
DECLARE var$SURNAME VARCHAR (30);
DECLARE var$LASTNAME VARCHAR (30);
DECLARE var$STATE DOUBLE;
DECLARE var$DEPT_ID DOUBLE;
DECLARE var$deptid DOUBLE;
DECLARE var$PARENT_ID DOUBLE;
DECLARE var$deptname VARCHAR (200);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
dept_empl.*, dept.*
FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
` AS dept_empl,
TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
` AS dept
WHERE dept_empl.DEPT_ID = dept.DEPTID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID, var$NAME, var$SURNAME,
var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid,
var$PARENT_ID, var$deptname;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)
AS
l_dept_id NUMBER := 10;
BEGIN
FOR cur IN (
WITH emp AS
(SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE dept_id > 10
),
active_emp AS
(
SELECT id
FROM emp
WHERE emp.state = p_state
)
SELECT *
FROM active_emp
) LOOP
NULL;
END LOOP;
END;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT
id, name, surname, lastname,
state, dept_id
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE DEPT_ID > 10);
CREATE PROCEDURE
test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 10;
DECLARE var$ID DOUBLE;
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT *
FROM (SELECT
ID
FROM
TEST_ORA_PG.
`P_WITH_SELECT_VAR_CROSS_01$emp` AS emp
WHERE emp.STATE = par_p_state)
AS active_emp;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
# Migrazione da Oracle Database ad Amazon RDS for Oracle con AWS Schema Conversion Tool
Alcuni aspetti da considerare durante la migrazione dello schema e del codice Oracle ad Amazon RDS per Oracle:
+ AWS SCT può aggiungere oggetti di directory all'albero degli oggetti. *Gli oggetti directory* sono strutture logiche che rappresentano ciascuna una directory fisica sul file system del server. È possibile utilizzare gli oggetti di directory con pacchetti come DBMS\$1LOB, UTL\$1FILE, DBMS\$1FILE\$1TRANSFER, la utility DATAPUMP e così via.
+ AWS SCT supporta la conversione di tablespace Oracle in un'istanza database Amazon RDS for Oracle. Oracle memorizza i dati logicamente in spazi tabelle e fisicamente in file di dati associati allo spazio tabella corrispondente. In Oracle è possibile creare spazi tabella con i nomi dei file di dati. Amazon RDS supporta Oracle Managed Files (OMF) solo per file di dati, file di log e file di controllo. AWS SCT crea i file di dati necessari durante la conversione.
+ AWS SCT può convertire ruoli e privilegi a livello di server. Il motore di database Oracle utilizza la protezione basata sui ruoli. Un ruolo è una raccolta di privilegi che è possibile concedere o revocare a un utente. Un ruolo predefinito in Amazon RDS, denominato DBA, normalmente consente tutti i privilegi di amministrazione a un motore di database Oracle. I seguenti privilegi non sono disponibili per il ruolo DBA su un'istanza database di Amazon RDS utilizzando il motore Oracle:
+ Alter di database
+ Alter system
+ Creazione di una directory
+ Concessione di qualsiasi privilegio
+ Concessione di qualsiasi ruolo
+ Creazione di un processo esterno
È possibile concedere tutti gli altri privilegi a un ruolo utente Amazon RDS per Oracle, tra cui il filtro avanzato e i privilegi di colonna.
+ AWS SCT supporta la conversione dei job Oracle in job eseguibili su Amazon RDS for Oracle. La conversione presenta alcuni limiti, inclusi i seguenti:
+ I processi eseguibili non sono supportati.
+ I processi di pianificazione che utilizzano il tipo di dati ANYDATA come un argomento non sono supportati.
+ One Node RAC (Real Application Cluster) Oracle è un'opzione disponibile per Oracle Database Enterprise Edition che è stata introdotta con Oracle Database 11g Release 2. Amazon RDS per Oracle non supporta la caratteristica RAC. Per alta disponibilità, utilizzare Amazon RDS Implementazioni Multi-AZ.
In un'implementazione Multi-AZ, Amazon RDS effettua automaticamente il provisioning e mantiene una replica standby sincrona in un'altra zona di disponibilità. L'istanza database principale viene replicata in modo sincrono tra le zone di disponibilità in una replica di standby. Questa funzionalità fornisce ridondanza dei dati, elimina i I/O blocchi e riduce al minimo i picchi di latenza durante i backup di sistema.
+ Oracle Spatial offre uno schema SQL e funzioni che semplificano le operazioni di storage, recupero, aggiornamento ed esecuzione di query per le raccolte di dati spaziali in un database Oracle. Oracle Locator offre funzionalità che sono solitamente richieste per il supporto di applicazioni Internet e wireless basate su servizi e di soluzioni GIS basate su partner. Oracle Locator è un sottoinsieme limitato di Oracle Spatial.
Per utilizzare le funzionalità di Oracle Spatial e Oracle Locator aggiungi l'opzione SPATIAL o l'opzione LOCATOR (che si escludono reciprocamente) al gruppo di opzioni dell'istanza database.
Esistono alcuni requisiti preliminari per l'utilizzo di Oracle Spatial e Oracle Locator su un'istanza database di Amazon RDS per Oracle:
+ L'istanza deve utilizzare la versione Oracle Enterprise Edition 12.1.0.2.v6 o successiva oppure 11.2.0.4.v10 o successiva.
+ L'istanza deve essere all'interno di un cloud privato virtuale (VPC).
+ L'istanza deve avere la classe dell'istanza database che può supportare la funzionalità Oracle. Ad esempio, Oracle Spatial non è supportato per le classi di istanza database db.m1.small, db.t1.micro, db.t2.micro o db.t2.small. [Per ulteriori informazioni, consulta Supporto delle classi di istanze DB per Oracle.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html#Oracle.Concepts.InstanceClasses)
+ L'istanza deve avere l'opzione Auto Minor Version Upgrade abilitata. Amazon RDS aggiorna l'istanza database al PSU Oracle più recente se esistono vulnerabilità di sicurezza con un punteggio CVSS score di 9\$1 o altre vulnerabilità di sicurezza annunciate. Per ulteriori informazioni, consultare la pagina
[Impostazioni per le istanze di Oracle DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ModifyInstance.Oracle.html#USER_ModifyInstance.Oracle.Settings).
+ Se l'istanza DB è la versione 11.2.0.4.v10 o successiva, è necessario installare l'opzione XMLDB. Per ulteriori informazioni, consultare la pagina
[Oracle XML DB.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.XMLDB.html)
+ È necessaria una licenza per Oracle Spatial rilasciata da Oracle. Per ulteriori informazioni, consulta [Oracle Spatial and Graph](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph) nella documentazione Oracle.
+ Data Guard è incluso con Oracle Database Enterprise Edition. Per alta disponibilità, utilizzare la caratteristica Amazon RDS Implementazioni Multi-AZ.
In un'implementazione Multi-AZ, Amazon RDS effettua automaticamente il provisioning e mantiene una replica standby sincrona in un'altra zona di disponibilità. L'istanza database principale viene replicata in modo sincrono tra le zone di disponibilità in una replica di standby. Questa funzionalità fornisce ridondanza dei dati, elimina i I/O blocchi e riduce al minimo i picchi di latenza durante i backup di sistema.
+ AWS SCT supporta la conversione di oggetti Oracle DBMS\$1SCHEDULER durante la migrazione ad Amazon RDS for Oracle. Il rapporto di AWS SCT valutazione indica se un oggetto di pianificazione può essere convertito. Per ulteriori informazioni sull'uso di oggetti di pianificazione con Amazon RDS, consulta la [ documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.System.html#Appendix.Oracle.CommonDBATasks.ModifyScheduler).
+ Per le conversioni da Oracle ad Amazon RDS per Oracle, è supportato DB Links. Un collegamento di database è un oggetto dello schema in un database che consente di accedere agli oggetti in un altro database. Non è necessario che gli altri database siano Oracle. Tuttavia, per accedere ai database diversi da Oracle, devi utilizzare gli Oracle Heterogeneous Services.
Dopo aver creato un link al database, è possibile utilizzarlo nelle istruzioni SQL per fare riferimento a tabelle, viste e PL/SQL oggetti nell'altro database. Per utilizzare un database link, aggiungilo `@dblink` alla tabella, alla vista o al nome PL/SQL dell'oggetto. Puoi eseguire query su una tabella o vista nell'altro database con l'istruzione SELECT. Per ulteriori informazioni sull'utilizzo dei collegamenti di database Oracle, consulta la [ documentazione di Oracle ](https://docs.oracle.com/cd/B28359_01/server.111/b28310/ds_concepts002.htm#ADMIN12083).
Per ulteriori informazioni sull'uso dei collegamenti di database con Amazon RDS, consulta la [ documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Database.html#Appendix.Oracle.CommonDBATasks.DBLinks).
+ Il rapporto di AWS SCT valutazione fornisce le metriche del server per la conversione. Questi parametri sull'istanza Oracle includono quanto segue:
+ Capacità di calcolo e di memoria dell'istanza database di destinazione.
+ Funzionalità Oracle non supportate come Real Application Clusters che Amazon RDS non supporta.
+ Caricamento di lettura e scrittura su disco
+ Throughput del disco totale medio
+ Informazioni sul server quali il nome del server, il sistema operativo, il nome host e il set di caratteri.
## Privilegi per RDS for Oracle come destinazione
Per migrare ad Amazon RDS for Oracle, crea un utente privilegiato del database. È possibile utilizzare il seguente esempio di codice.
```
CREATE USER user_name IDENTIFIED BY your_password;
-- System privileges
GRANT DROP ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE TO user_name;
GRANT CREATE ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY ASSEMBLY TO user_name;
GRANT ALTER ANY RULE TO user_name;
GRANT SELECT ANY DICTIONARY TO user_name;
GRANT ALTER ANY DIMENSION TO user_name;
GRANT CREATE ANY DIMENSION TO user_name;
GRANT ALTER ANY TYPE TO user_name;
GRANT DROP ANY TRIGGER TO user_name;
GRANT CREATE ANY VIEW TO user_name;
GRANT ALTER ANY CUBE BUILD PROCESS TO user_name;
GRANT CREATE ANY CREDENTIAL TO user_name;
GRANT DROP ANY CUBE DIMENSION TO user_name;
GRANT DROP ANY ASSEMBLY TO user_name;
GRANT DROP ANY PROCEDURE TO user_name;
GRANT ALTER ANY PROCEDURE TO user_name;
GRANT ALTER ANY SQL TRANSLATION PROFILE TO user_name;
GRANT DROP ANY MEASURE FOLDER TO user_name;
GRANT CREATE ANY MEASURE FOLDER TO user_name;
GRANT DROP ANY CUBE TO user_name;
GRANT DROP ANY MINING MODEL TO user_name;
GRANT CREATE ANY MINING MODEL TO user_name;
GRANT DROP ANY EDITION TO user_name;
GRANT CREATE ANY EVALUATION CONTEXT TO user_name;
GRANT DROP ANY DIMENSION TO user_name;
GRANT ALTER ANY INDEXTYPE TO user_name;
GRANT DROP ANY TYPE TO user_name;
GRANT CREATE ANY PROCEDURE TO user_name;
GRANT CREATE ANY SQL TRANSLATION PROFILE TO user_name;
GRANT CREATE ANY CUBE TO user_name;
GRANT COMMENT ANY MINING MODEL TO user_name;
GRANT ALTER ANY MINING MODEL TO user_name;
GRANT DROP ANY SQL PROFILE TO user_name;
GRANT CREATE ANY JOB TO user_name;
GRANT DROP ANY EVALUATION CONTEXT TO user_name;
GRANT ALTER ANY EVALUATION CONTEXT TO user_name;
GRANT CREATE ANY INDEXTYPE TO user_name;
GRANT CREATE ANY OPERATOR TO user_name;
GRANT CREATE ANY TRIGGER TO user_name;
GRANT DROP ANY ROLE TO user_name;
GRANT DROP ANY SEQUENCE TO user_name;
GRANT DROP ANY CLUSTER TO user_name;
GRANT DROP ANY SQL TRANSLATION PROFILE TO user_name;
GRANT ALTER ANY ASSEMBLY TO user_name;
GRANT CREATE ANY RULE SET TO user_name;
GRANT ALTER ANY OUTLINE TO user_name;
GRANT UNDER ANY TYPE TO user_name;
GRANT CREATE ANY TYPE TO user_name;
GRANT DROP ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY ROLE TO user_name;
GRANT DROP ANY VIEW TO user_name;
GRANT ALTER ANY INDEX TO user_name;
GRANT COMMENT ANY TABLE TO user_name;
GRANT CREATE ANY TABLE TO user_name;
GRANT CREATE USER TO user_name;
GRANT DROP ANY RULE SET TO user_name;
GRANT CREATE ANY CONTEXT TO user_name;
GRANT DROP ANY INDEXTYPE TO user_name;
GRANT ALTER ANY OPERATOR TO user_name;
GRANT CREATE ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY SEQUENCE TO user_name;
GRANT DROP ANY SYNONYM TO user_name;
GRANT CREATE ANY SYNONYM TO user_name;
GRANT DROP USER TO user_name;
GRANT ALTER ANY MEASURE FOLDER TO user_name;
GRANT ALTER ANY EDITION TO user_name;
GRANT DROP ANY RULE TO user_name;
GRANT CREATE ANY RULE TO user_name;
GRANT ALTER ANY RULE SET TO user_name;
GRANT CREATE ANY OUTLINE TO user_name;
GRANT UNDER ANY TABLE TO user_name;
GRANT UNDER ANY VIEW TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
GRANT ALTER ANY CLUSTER TO user_name;
GRANT CREATE ANY CLUSTER TO user_name;
GRANT ALTER ANY TABLE TO user_name;
GRANT CREATE ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY EDITION TO user_name;
GRANT CREATE ANY SQL PROFILE TO user_name;
GRANT ALTER ANY SQL PROFILE TO user_name;
GRANT DROP ANY OUTLINE TO user_name;
GRANT DROP ANY CONTEXT TO user_name;
GRANT DROP ANY OPERATOR TO user_name;
GRANT DROP ANY LIBRARY TO user_name;
GRANT ALTER ANY LIBRARY TO user_name;
GRANT CREATE ANY LIBRARY TO user_name;
GRANT ALTER ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY TRIGGER TO user_name;
GRANT CREATE ANY SEQUENCE TO user_name;
GRANT DROP ANY INDEX TO user_name;
GRANT CREATE ANY INDEX TO user_name;
GRANT DROP ANY TABLE TO user_name;
GRANT SELECT_CATALOG_ROLE TO user_name;
GRANT SELECT ANY SEQUENCE TO user_name;
-- Database Links
GRANT CREATE DATABASE LINK TO user_name;
GRANT CREATE PUBLIC DATABASE LINK TO user_name;
GRANT DROP PUBLIC DATABASE LINK TO user_name;
-- Server Level Objects (directory)
GRANT CREATE ANY DIRECTORY TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
-- (for RDS only)
GRANT EXECUTE ON RDSADMIN.RDSADMIN_UTIL TO user_name;
-- Server Level Objects (tablespace)
GRANT CREATE TABLESPACE TO user_name;
GRANT DROP TABLESPACE TO user_name;
-- Server Level Objects (user roles)
/* (grant source privileges with admin option or convert roles/privs as DBA) */
-- Queues
grant execute on DBMS_AQADM to user_name;
grant aq_administrator_role to user_name;
-- for Materialized View Logs creation
GRANT SELECT ANY TABLE TO user_name;
-- Roles
GRANT RESOURCE TO user_name;
GRANT CONNECT TO user_name;
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome dell'utente. Quindi, *your\$1password* sostituiscilo con una password sicura.
## Limitazioni durante la conversione da Oracle ad Amazon RDS for Oracle
Alcuni limiti da considerare durante la migrazione dello schema e del codice Oracle ad Amazon RDS per Oracle:
+ Un ruolo predefinito in Amazon RDS, denominato DBA, normalmente consente tutti i privilegi di amministrazione a un motore di database Oracle. I seguenti privilegi non sono disponibili per il ruolo DBA su un'istanza database di Amazon RDS utilizzando il motore Oracle:
+ Alter di database
+ Alter system
+ Creazione di una directory
+ Concessione di qualsiasi privilegio
+ Concessione di qualsiasi ruolo
+ Creazione di un processo esterno
È possibile concedere tutti gli altri privilegi a un ruolo utente Oracle RDS.
+ Amazon RDS for Oracle supporta il controllo tradizionale, il controllo granulare tramite il pacchetto DBMS\$1FGA e Oracle Unified Auditing.
+ Amazon RDS per Oracle non supporta la funzionalità CDC (Change Data Capture). Per eseguire CDC durante e dopo una migrazione di database, usa. AWS Database Migration Service
# Connessione ai database PostgreSQL con AWS Schema Conversion Tool
È possibile utilizzare AWS SCT per convertire schemi, oggetti di codice del database e codice dell'applicazione da PostgreSQL ai seguenti obiettivi:
+ Amazon RDS per MySQL
+ Amazon Aurora edizione compatibile con MySQL
+ Amazon RDS per PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
Per ulteriori informazioni, consulta le sezioni seguenti:
**Topics**
+ [Privilegi per PostgreSQL come database sorgente](#CHAP_Source.PostgreSQL.Permissions)
+ [Connessione a PostgreSQL come sorgente](#CHAP_Source.PostgreSQL.Connecting)
+ [Privilegi per MySQL come database di destinazione](#CHAP_Source.PostgreSQL.ConfigureMySQL)
## Privilegi per PostgreSQL come database sorgente
I privilegi richiesti per PostgreSQL come sorgente sono i seguenti:
+ CONNETTITI AL DATABASE **
+ UTILIZZO SU SCHEMA **
+ SELEZIONA SU TUTTE LE TABELLE DELLO SCHEMA **
+ SELEZIONA SU TUTTE LE SEQUENZE DELLO SCHEMA **
## Connessione a PostgreSQL come sorgente
Utilizza la seguente procedura per connetterti al database di origine PostgreSQL con AWS Schema Conversion Tool.
**Per connetterti a un database di origine PostgreSQL**
1. **Nella AWS Schema Conversion Tool, scegli Aggiungi fonte.**
1. **Scegli **PostgreSQL**, quindi scegli Avanti.**
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Secret**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al database di origine PostgreSQL, usa le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.PostgreSQL.html)
1. Scegli **Test Connection** per verificare che sia in AWS SCT grado di connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Privilegi per MySQL come database di destinazione
I privilegi richiesti per MySQL come destinazione durante la migrazione da PostgreSQL sono i seguenti:
+ CREA SU\$1 . \$1
+ PIÙ TARDI \$1 . \$1
+ SCENDI SU \$1 . \$1
+ INDICE SU\$1 . \$1
+ RIFERIMENTI SU\$1 . \$1
+ SELECT ON \$1.\$1
+ CREA UNA VISTA SU\$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ GRILLETTO SU \$1 . \$1
+ CREA ROUTINE SU\$1 . \$1
+ MODIFICA LA ROUTINE SU \$1 . \$1
+ ESEGUI SU\$1 . \$1
+ INSERISCI, AGGIORNA SU AWS\$1POSTGRESQL \$1EXT. \$1
+ INSERISCI, AGGIORNA, ELIMINA SU AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
+ CREA TABELLE TEMPORANEE SU AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_POSTGRESQL_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome del tuo utente. Quindi, *your\$1password* sostituiscilo con una password sicura.
Per utilizzare Amazon RDS per MySQL o Aurora MySQL come destinazione, imposta il parametro `lower_case_table_names` su `1`. Questo valore indica che il server MySQL gestisce gli identificatori di nomi di oggetti come tabelle, indici, trigger e database senza distinzione tra maiuscole e minuscole. Se hai attivato la registrazione binaria nell'istanza di destinazione, imposta il parametro `log_bin_trust_function_creators` su `1`. In questo caso, non è necessario utilizzare le caratteristiche `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` per creare funzioni archiviate. Per configurare questi parametri, crea un nuovo gruppo di parametri di database o modifica un gruppo di parametri di database esistente.
# Connessione ai database SAP con AWS Schema Conversion Tool
È possibile utilizzare AWS SCT per convertire schemi, oggetti di codice di database e codice applicativo da SAP (Sybase) Adaptive Server Enterprise (ASE) ai seguenti obiettivi:
+ Amazon RDS per MySQL
+ Amazon Aurora edizione compatibile con MySQL
+ Amazon RDS per MariaDB
+ Amazon RDS per PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
Per ulteriori informazioni, consulta le sezioni seguenti:
**Topics**
+ [Privilegi per SAP ASE come database di origine](#CHAP_Source.SAP.Permissions)
+ [Connessione a SAP ASE (Sybase) come fonte](#CHAP_Source.SAP.Connecting)
+ [Privilegi per MySQL come database di destinazione](#CHAP_Source.SAP.ConfigureMySQL)
+ [Impostazioni di conversione da SAP ASE a MySQL](#CHAP_Source.SAP.MySQLConversionSettings)
+ [Privilegi per PostgreSQL come database di destinazione](#CHAP_Source.SAP.ConfigurePostgreSQL)
+ [Impostazioni di conversione da SAP ASE a PostgreSQL](#CHAP_Source.SAP.PostgreSQLConversionSettings)
## Privilegi per SAP ASE come database di origine
Per utilizzare un database SAP ASE come origine, è necessario creare un utente del database e concedere le autorizzazioni. Per fare ciò, procedi nel seguente modo.
**Crea e configura un utente del database**
1. Connettiti al database di origine.
1. Crea un utente del database con i seguenti comandi. Fornisci una password per il nuovo utente.
```
USE master
CREATE LOGIN min_privs WITH PASSWORD
sp_adduser min_privs
grant select on dbo.spt_values to min_privs
grant select on asehostname to min_privs
```
1. Per ogni database da migrare, concedi i seguenti privilegi.
```
USE
sp_adduser min_privs
grant select on dbo.sysusers to min_privs
grant select on dbo.sysobjects to min_privs
grant select on dbo.sysindexes to min_privs
grant select on dbo.syscolumns to min_privs
grant select on dbo.sysreferences to min_privs
grant select on dbo.syscomments to min_privs
grant select on dbo.syspartitions to min_privs
grant select on dbo.syspartitionkeys to min_privs
grant select on dbo.sysconstraints to min_privs
grant select on dbo.systypes to min_privs
grant select on dbo.sysqueryplans to min_privs
```
## Connessione a SAP ASE (Sybase) come fonte
Utilizzare la procedura seguente per connettersi al database di origine SAP ASE con. AWS Schema Conversion Tool
**Per connettersi a un database di origine SAP ASE**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **SAP ASE**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Secret**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni sulla connessione al database di origine SAP ASE, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.SAP.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Privilegi per MySQL come database di destinazione
I privilegi richiesti per MySQL come destinazione sono i seguenti:
+ CREA SU\$1 . \$1
+ PIÙ TARDI \$1 . \$1
+ SCENDI SU \$1 . \$1
+ INDICE SU\$1 . \$1
+ RIFERIMENTI SU\$1 . \$1
+ SELECT ON \$1.\$1
+ CREA UNA VISTA SU\$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ GRILLETTO SU \$1 . \$1
+ CREA ROUTINE SU\$1 . \$1
+ MODIFICA LA ROUTINE SU \$1 . \$1
+ ESEGUI SU\$1 . \$1
+ INSERISCI, AGGIORNA SU AWS\$1SAPASE \$1EXT. \$1
+ CREA TABELLE TEMPORANEE SU AWS\$1SAPASE \$1EXT. \$1
È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_SAPASE_EXT.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SAPASE_EXT.* TO 'user_name';
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome del tuo utente. Quindi, *your\$1password* sostituiscilo con una password sicura.
Per utilizzare Amazon RDS per MySQL o Aurora MySQL come destinazione, imposta il parametro `lower_case_table_names` su `1`. Questo valore indica che il server MySQL gestisce gli identificatori di nomi di oggetti come tabelle, indici, trigger e database senza distinzione tra maiuscole e minuscole. Se hai attivato la registrazione binaria nell'istanza di destinazione, imposta il parametro `log_bin_trust_function_creators` su `1`. In questo caso, non è necessario utilizzare le caratteristiche `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` per creare funzioni archiviate. Per configurare questi parametri, crea un nuovo gruppo di parametri di database o modifica un gruppo di parametri di database esistente.
## Impostazioni di conversione da SAP ASE a MySQL
**Per modificare le impostazioni di conversione da SAP ASE a MySQL, scegli Impostazioni, quindi **scegli** Impostazioni di conversione.** Dall'elenco in alto, scegli **SAP ASE**, quindi scegli **SAP ASE — MySQL o SAP ASE — **Amazon Aurora** (compatibile con MySQL**). AWS SCT visualizza tutte le impostazioni disponibili per la conversione da SAP ASE a PostgreSQL.
Le impostazioni di conversione da SAP ASE a MySQL includono opzioni per quanto AWS SCT segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per utilizzare i nomi esatti degli oggetti del database di origine nel codice convertito.
Per impostazione predefinita, AWS SCT converte i nomi degli oggetti, delle variabili e dei parametri del database in lettere minuscole. Per mantenere la distinzione tra maiuscole e minuscole originali per questi nomi, seleziona Fai distinzione tra maiuscole e **minuscole nei nomi degli oggetti del database di origine**. Scegli questa opzione se utilizzi nomi di oggetti con distinzione tra maiuscole e minuscole nel server di database SAP ASE di origine.
## Privilegi per PostgreSQL come database di destinazione
Per utilizzare PostgreSQL come destinazione, è necessario il privilegio. AWS SCT `CREATE ON DATABASE` Assicurati di concedere questo privilegio per ogni database PostgreSQL di destinazione.
Per utilizzare i sinonimi pubblici convertiti, modifica il percorso di ricerca predefinito del database in. `"$user", public_synonyms, public`
È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.
```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome dell'utente. Quindi, *db\$1name* sostituiscilo con il nome del database di destinazione. Infine, *your\$1password* sostituiscilo con una password sicura.
In PostgreSQL, solo il proprietario di uno schema o un `superuser` può rilasciare uno schema. Il proprietario può eliminare uno schema e tutti gli oggetti inclusi in questo schema anche se il proprietario dello schema non possiede alcuni dei suoi oggetti.
Quando utilizzi utenti diversi per convertire e applicare schemi diversi al database di destinazione, puoi ricevere un messaggio di errore quando non AWS SCT puoi eliminare uno schema. Per evitare questo messaggio di errore, utilizza il ruolo `superuser`.
## Impostazioni di conversione da SAP ASE a PostgreSQL
**Per modificare le impostazioni di conversione da SAP ASE a PostgreSQL, scegli Impostazioni, quindi **scegli** Impostazioni di conversione.** Dall'elenco in alto, scegli **SAP ASE**, quindi scegli SAP ASE — **PostgreSQL o SAP ASE **— Amazon** Aurora (compatibile con PostgreSQL**). AWS SCT visualizza tutte le impostazioni disponibili per la conversione da SAP ASE a PostgreSQL.
Le impostazioni AWS SCT di conversione da SAP ASE a PostgreSQL includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per definire il modello da utilizzare per i nomi degli schemi nel codice convertito. Per il **modello di generazione del nome dello schema**, scegliete una delle seguenti opzioni:
+ ****— Utilizza il nome del database SAP ASE come nome dello schema in PostgreSQL.
+ ****— Utilizza il nome dello schema SAP ASE come nome dello schema in PostgreSQL.
+ **\$1** — Utilizza una combinazione del database SAP ASE e dei nomi dello schema come nome dello schema in PostgreSQL.
+ Per utilizzare i nomi esatti degli oggetti del database di origine nel codice convertito.
Per impostazione predefinita, AWS SCT converte i nomi degli oggetti, delle variabili e dei parametri del database in lettere minuscole. Per mantenere la distinzione tra maiuscole e minuscole originali per questi nomi, seleziona Fai distinzione tra maiuscole e **minuscole nei nomi degli oggetti del database di origine**. Scegli questa opzione se utilizzi nomi di oggetti con distinzione tra maiuscole e minuscole nel server di database SAP ASE di origine.
Per le operazioni con distinzione tra maiuscole e minuscole, AWS SCT può evitare la conversione dei nomi degli oggetti del database in lettere minuscole. A tale scopo, selezionate **Evita di utilizzare lettere minuscole per le operazioni con distinzione tra maiuscole e minuscole**.
+ Per consentire l'uso di indici con lo stesso nome in tabelle diverse in SAP ASE.
In PostgreSQL, tutti i nomi di indice utilizzati nello schema devono essere univoci. Per assicurarti che ciò AWS SCT generi nomi univoci per tutti i tuoi indici, seleziona **Genera** nomi univoci per gli indici.
# Connetti i server Microsoft SQL con AWS Schema Conversion Tool
È possibile AWS SCT utilizzarlo per convertire schemi, oggetti di codice di database e codice applicativo da SQL Server ai seguenti obiettivi:
+ Amazon RDS per MySQL
+ Amazon Aurora edizione compatibile con MySQL
+ Amazon RDS per PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
+ Amazon RDS per SQL Server
+ Amazon RDS per MariaDB
**Nota**
AWS SCT non supporta l'utilizzo di Amazon RDS for SQL Server come sorgente.
È possibile utilizzare per AWS SCT creare un rapporto di valutazione per la migrazione di schemi, oggetti di codice del database e codice applicativo da SQL Server a Babelfish per Aurora PostgreSQL, come descritto di seguito.
**Topics**
+ [Privilegi per Microsoft SQL Server come origine](#CHAP_Source.SQLServer.Permissions)
+ [Utilizzo dell'autenticazione di Windows quando si utilizza Microsoft SQL Server come origine](#CHAP_Source.SQLServer.Permissions.WinAuth)
+ [Connessione a SQL Server come origine](#CHAP_Source.SQLServer.Connecting)
+ [Conversione da SQL Server a MySQL](CHAP_Source.SQLServer.ToMySQL.md)
+ [Migrazione da SQL Server a PostgreSQL con AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToPostgreSQL.md)
+ [Migrazione da SQL Server ad Amazon RDS per SQL Server con AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToRDSSQLServer.md)
## Privilegi per Microsoft SQL Server come origine
I privilegi richiesti per Microsoft SQL Server come origine sono i seguenti:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Il `VIEW DEFINITION` privilegio consente agli utenti con accesso pubblico di visualizzare le definizioni degli oggetti. AWS SCT utilizza il `VIEW DATABASE STATE` privilegio per verificare le funzionalità dell'edizione SQL Server Enterprise.
Ripeti l'assegnazione per ogni database di cui desideri convertire lo schema.
Inoltre, assegna i seguenti privilegi sul database `master`:
+ VIEW SERVER STATE
+ VIEW ANY DEFINITION
AWS SCT utilizza il `VIEW SERVER STATE` privilegio per raccogliere le impostazioni e la configurazione del server. Assicurati di concedere il `VIEW ANY DEFINITION` privilegio di visualizzare gli endpoint.
Per leggere le informazioni su Microsoft Analysis Services, esegui il seguente comando sul database `master`.
```
EXEC master..sp_addsrvrolemember @loginame = N'', @rolename = N'sysadmin'
```
Nell'esempio precedente, sostituisci il `` segnaposto con il nome dell'utente a cui hai concesso in precedenza i privilegi.
Per leggere informazioni su SQL Server Agent, aggiungi il tuo utente al ruolo. `SQLAgentUser` Esegui il comando seguente sul database `msdb`.
```
EXEC sp_addrolemember , ;
```
Nell'esempio precedente, sostituisci il segnaposto `` con il nome del ruolo SQL Server Agent. Sostituisci quindi il `` segnaposto con il nome dell'utente a cui hai concesso in precedenza i privilegi. Per ulteriori informazioni, consulta [Aggiungere un utente al ruolo SQLAgent Utente](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.Agent.html#SQLServerAgent.AddUser) nella *Guida per l'utente di Amazon RDS*.
Per rilevare l'invio dei log, fornisci il privilegio `SELECT on dbo.log_shipping_primary_databases` sul database `msdb`.
Per utilizzare l'approccio di notifica della replica DDL, concedi il `RECEIVE ON .` privilegio sui tuoi database di origine. In questo esempio, sostituisci il segnaposto `` con il nome dello schema di database. Quindi, sostituisci il segnaposto `` con il nome di una tabella di coda.
## Utilizzo dell'autenticazione di Windows quando si utilizza Microsoft SQL Server come origine
Se la tua applicazione viene eseguita su un'intranet basata su Windows, puoi utilizzare l'autenticazione di Windows per l'accesso al database. Per accedere al database SQL Server, l'autenticazione di Windows utilizza l'identità Windows corrente stabilita sul thread del sistema operativo. Puoi quindi mappare l'identità Windows a un database SQL Server e alle autorizzazioni. Per connettersi a SQL Server utilizzando l'autenticazione di Windows, devi specificare l'identità Windows utilizzata dall'applicazione sta utilizzando. Inoltre, devi concedere l'accesso all'identità Windows al database SQL Server.
SQL Server prevede due modalità di accesso: modalità autenticazione di Windows e modalità mista. La modalità autenticazione di Windows abilita l'autenticazione di Windows e disabilita l'autenticazione di SQL Server. La modalità mista abilita sia l'autenticazione di Windows che l'autenticazione di SQL Server. L'autenticazione di Windows è sempre disponibile e non può essere disattivata. Per ulteriori informazioni sull'autenticazione di Windows, consulta la documentazione di Microsoft Windows.
Di seguito è riportato un possibile esempio di creazione di un utente in TEST\$1DB
```
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
```
### Utilizzo dell'autenticazione di Windows con una connessione JDBC
Il driver JDBC non supporta l'autenticazione di Windows se viene utilizzato su sistemi operativi diversi da Windows. Le credenziali di autenticazione di Windows, ad esempio nome utente e password, non vengono specificate automaticamente durante la connessione a SQL Server da sistemi operativi non Windows. In questi casi, le applicazioni devono invece utilizzare l'autenticazione di SQL Server.
Nella stringa di connessione a JDBC, per connettersi utilizzando l'autenticazione di Windows deve essere specificato il parametro `integratedSecurity`. Il driver JDBC supporta l'autenticazione integrata di Windows su sistemi operativi Windows tramite il parametro della stringa di connessione `integratedSecurity`.
Per utilizzare l'autenticazione integrata
1. Installa il driver JDBC.
1. Copia il file `sqljdbc_auth.dll` in una directory nel percorso di sistema di Windows sul computer in cui è installato il driver JDBC.
I `sqljdbc_auth.dll` file vengono installati nella seguente posizione:
<*directory di installazione*>\$1sqljdbc\$1<*versione*>\$1<*lingua*>\$1auth\$1
Quando tenti di stabilire una connessione al database SQL Server utilizzando l'autenticazione di Windows, potresti ricevere l'errore "Il driver non è configurato per l'autenticazione integrata". Questo problema può essere risolto tramite le operazioni seguenti:
+ dichiarare due variabili che puntano al percorso di installazione del JDBC:
`variable name: SQLJDBC_HOME; variable value: D:\lib\JDBC4.1\enu`(dove esiste il file sqljdbc4.jar);
`variable name: SQLJDBC_AUTH_HOME; variable value: D\lib\JDBC4.1\enu\auth\x86`(se utilizzi un sistema operativo a 32 bit) o `D\lib\JDBC4.1\enu\auth\x64` (se utilizzi un sistema operativo a 64 bit). Qui è dove si `sqljdbc_auth.dll` trova il tuo.
+ Copia `sqljdbc_auth.dll` nella cartella in cui JDK/JRE è in esecuzione. è possibile eseguire la copia nella cartella lib, bin, ecc. Ad esempio, è possibile copiare nella cartella seguente.
```
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
```
+ Assicurati che nella cartella della libreria JDBC sia presente solo il SQLJDBC4 file.jar. Rimuovi tutti gli altri file sqljdbc\$1.jar da quella cartella (o copiali in un'altra cartella). Se stai aggiungendo il driver come parte del tuo programma, assicurati di aggiungere solo SQLJDBC4 .jar come driver da utilizzare.
+ copiare il file sqljdbc\$1auth.dll nella cartella dell'applicazione.
**Nota**
Se è in esecuzione una Java Virtual Machine (JVM) a 32 bit, utilizza il file sqljdbc\$1auth.dll nella cartella x86 anche se la versione del sistema operativo è x64. Se è in esecuzione una JVM a 64 bit su un processore x64, utilizza il file sqljdbc\$1auth.dll nella cartella x64.
Quando effettui la connessione a un database SQL Server, puoi scegliere **Autenticazione Windows** o **Autenticazione SQL Server** per l'opzione **Autenticazione**.
## Connessione a SQL Server come origine
Utilizza la seguente procedura per connetterti al database di origine Microsoft SQL Server con AWS Schema Conversion Tool.
**Per connettersi a un database di origine Microsoft SQL Server**
1. In AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **Microsoft SQL Server**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Secret**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni sulla connessione al database di origine di Microsoft SQL Server, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al database di origine.
# Conversione da SQL Server a MySQL
Per emulare le funzioni del database di Microsoft SQL Server nel codice MySQL convertito, usa il pacchetto di estensione da SQL Server a MySQL. AWS SCT Per ulteriori informazioni sui pacchetti di estensione, consulta [Utilizzo dei pacchetti di estensione con AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Privilegi per MySQL come database di destinazione](#CHAP_Source.SQLServer.ToMySQL.ConfigureTarget)
+ [Impostazioni di conversione da SQL Server a MySQL](#CHAP_Source.SQLServer.ToMySQL.ConversionSettings)
+ [Considerazioni sulla migrazione](#CHAP_Source.SQLServer.ToMySQL.MigrationConsiderations)
## Privilegi per MySQL come database di destinazione
I privilegi richiesti per MySQL come destinazione sono i seguenti:
+ CREA SU\$1 . \$1
+ PIÙ TARDI \$1 . \$1
+ SCENDI SU \$1 . \$1
+ INDICE SU\$1 . \$1
+ RIFERIMENTI SU\$1 . \$1
+ SELECT ON \$1.\$1
+ CREA UNA VISTA SU\$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ GRILLETTO SU \$1 . \$1
+ CREA ROUTINE SU\$1 . \$1
+ MODIFICA LA ROUTINE SU \$1 . \$1
+ ESEGUI SU\$1 . \$1
+ INSERISCI, AGGIORNA SU AWS\$1SQLSERVER \$1EXT. \$1
+ INSERISCI, AGGIORNA, ELIMINA SU AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
+ CREA TABELLE TEMPORANEE SU AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_SQLSERVER_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome del tuo utente. Quindi, *your\$1password* sostituiscilo con una password sicura.
Se utilizzi un database MySQL versione 5.7 o precedente come destinazione, esegui il comando seguente. Per i database MySQL versione 8.0 e successive, questo comando è obsoleto.
```
GRANT SELECT ON mysql.proc TO 'user_name';
```
Per utilizzare Amazon RDS per MySQL o Aurora MySQL come destinazione, imposta il parametro `lower_case_table_names` su `1`. Questo valore indica che il server MySQL gestisce gli identificatori di nomi di oggetti come tabelle, indici, trigger e database senza distinzione tra maiuscole e minuscole. Se hai attivato la registrazione binaria nell'istanza di destinazione, imposta il parametro `log_bin_trust_function_creators` su `1`. In questo caso, non è necessario utilizzare le caratteristiche `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` per creare funzioni archiviate. Per configurare questi parametri, crea un nuovo gruppo di parametri di database o modifica un gruppo di parametri di database esistente.
## Impostazioni di conversione da SQL Server a MySQL
**Per modificare le impostazioni di conversione da SQL Server a MySQL, scegli Impostazioni, AWS SCT quindi **scegli** Impostazioni di conversione.** Dall'elenco superiore, scegli **SQL Server**, quindi scegli **SQL Server — MySQL**. AWS SCT visualizza tutte le impostazioni disponibili per la conversione da SQL Server a MySQL.
Le impostazioni AWS SCT di conversione da SQL Server a MySQL includono le seguenti opzioni:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per consentire al database SQL Server di origine di archiviare l'output di `EXEC` in una tabella. AWS SCT crea tabelle temporanee e una procedura aggiuntiva per emulare questa funzionalità. Per utilizzare questa emulazione, seleziona **Crea routine aggiuntive per la gestione** di set di dati aperti.
## Considerazioni sulla migrazione
Considerate questi aspetti durante la migrazione di uno schema di SQL Server su MySQL:
+ MySQL non supporta l'istruzione. `MERGE` Tuttavia, AWS SCT può emulare l'`MERGE`istruzione durante la conversione utilizzando la `INSERT ON DUPLICATE KEY` clausola e le istruzioni. `UPDATE FROM and DELETE FROM`
Per un corretto utilizzo dell'emulazione`INSERT ON DUPLICATE KEY`, assicurati che esista un vincolo univoco o una chiave primaria sul database MySQL di destinazione.
+ È possibile utilizzare un'`GOTO`istruzione e un'etichetta per modificare l'ordine in cui vengono eseguite le istruzioni. Tutte le istruzioni Transact-SQL che seguono un'`GOTO`istruzione vengono ignorate e l'elaborazione continua dall'etichetta. È possibile utilizzare `GOTO` istruzioni ed etichette ovunque all'interno di una procedura, di un batch o di un blocco di istruzioni. È inoltre possibile annidare `GOTO` le istruzioni.
MySQL non utilizza istruzioni. `GOTO` Quando AWS SCT converte il codice che contiene un'`GOTO`istruzione, converte l'istruzione in modo che utilizzi un'istruzione or. `BEGIN…END` `LOOP…END LOOP` È possibile trovare esempi di come AWS SCT converte `GOTO` le istruzioni nella tabella seguente.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL non supporta funzioni con valori di tabella a più istruzioni. AWS SCT simula funzioni con valori di tabella durante una conversione creando tabelle temporanee e riscrivendo le istruzioni per utilizzare queste tabelle temporanee.
# Migrazione da SQL Server a PostgreSQL con AWS Schema Conversion Tool
È possibile utilizzare il pacchetto di estensione da SQL Server a PostgreSQL in. AWS SCT Questo pacchetto di estensione emula le funzioni del database di SQL Server nel codice PostgreSQL convertito. Usa il pacchetto di estensione SQL Server to PostgreSQL per emulare SQL Server Agent e SQL Server Database Mail. Per ulteriori informazioni sui pacchetti di estensione, consulta [Utilizzo dei pacchetti di estensione con AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Privilegi per PostgreSQL come database di destinazione](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [Impostazioni di conversione da SQL Server a PostgreSQL](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [Conversione di partizioni SQL Server in partizioni PostgreSQL versione 10](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [Considerazioni sulla migrazione](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [Utilizzo di un pacchetto di AWS SCT estensione per emulare SQL Server Agent in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [Utilizzo di un pacchetto di AWS SCT estensione per emulare SQL Server Database Mail in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## Privilegi per PostgreSQL come database di destinazione
Per utilizzare PostgreSQL come destinazione, è necessario il privilegio. AWS SCT `CREATE ON DATABASE` Assicurati di concedere questo privilegio per ogni database PostgreSQL di destinazione.
Per utilizzare i sinonimi pubblici convertiti, modifica il percorso di ricerca predefinito del database in. `"$user", public_synonyms, public`
È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.
```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome dell'utente. Quindi, *db\$1name* sostituiscilo con il nome del database di destinazione. Infine, *your\$1password* sostituiscilo con una password sicura.
In PostgreSQL, solo il proprietario di uno schema o un `superuser` può rilasciare uno schema. Il proprietario può eliminare uno schema e tutti gli oggetti inclusi in questo schema anche se il proprietario dello schema non possiede alcuni dei suoi oggetti.
Quando utilizzi utenti diversi per convertire e applicare schemi diversi al database di destinazione, puoi ricevere un messaggio di errore quando non AWS SCT puoi eliminare uno schema. Per evitare questo messaggio di errore, utilizza il ruolo `superuser`.
## Impostazioni di conversione da SQL Server a PostgreSQL
**Per modificare le impostazioni di conversione da SQL Server a PostgreSQL, scegli Impostazioni, quindi **scegli** Impostazioni di conversione.** Dall'elenco superiore, scegli **SQL Server**, quindi scegli **SQL Server — PostgreSQL**. AWS SCT visualizza tutte le impostazioni disponibili per la conversione da SQL Server a PostgreSQL.
Le impostazioni di conversione da SQL Server a PostgreSQL includono le seguenti opzioni AWS SCT :
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per consentire l'utilizzo di indici con lo stesso nome in tabelle diverse in SQL Server.
In PostgreSQL, tutti i nomi di indice utilizzati nello schema devono essere univoci. Per assicurarti che ciò AWS SCT generi nomi univoci per tutti i tuoi indici, seleziona **Genera** nomi univoci per gli indici.
+ Per convertire le procedure di SQL Server in funzioni PostgreSQL.
PostgreSQL versione 10 e precedenti non supportano le procedure. Per i clienti che non hanno familiarità con l'uso delle procedure in PostgreSQL AWS SCT , possono convertire le procedure in funzioni. A tale scopo, seleziona **Converti procedure in funzioni**.
+ Per emulare l'output di `EXEC` una tabella.
Il database SQL Server di origine può memorizzare l'output di `EXEC` in una tabella. AWS SCT crea tabelle temporanee e una procedura aggiuntiva per emulare questa funzionalità. Per utilizzare questa emulazione, seleziona **Crea routine aggiuntive per la gestione** di set di dati aperti.
+ Per definire il modello da utilizzare per i nomi degli schemi nel codice convertito. Per il **modello di generazione del nome dello schema**, scegliete una delle seguenti opzioni:
+ ****— Utilizza il nome del database SQL Server come nome dello schema in PostgreSQL.
+ ****— Utilizza il nome dello schema di SQL Server come nome dello schema in PostgreSQL.
+ **\$1** — Utilizza una combinazione del database di SQL Server e dei nomi dello schema come nome dello schema in PostgreSQL.
+ Per mantenere le lettere maiuscole e minuscole dei nomi degli oggetti di origine.
Per evitare la conversione dei nomi degli oggetti in lettere minuscole, selezionate **Evita la conversione in lettere minuscole per le operazioni con distinzione tra maiuscole** e minuscole. Questa opzione si applica solo quando si attiva l'opzione di distinzione tra maiuscole e minuscole nel database di destinazione.
+ Per mantenere i nomi dei parametri lontani dal database di origine.
Per aggiungere virgolette doppie ai nomi dei parametri nel codice convertito, selezionate **Mantieni i nomi dei parametri originali**.
## Conversione di partizioni SQL Server in partizioni PostgreSQL versione 10
Quando converti un database Microsoft SQL Server in Amazon Aurora PostgreSQL Compatible Edition (Aurora PostgreSQL) o Amazon Relational Database Service for PostgreSQL (Amazon RDS per PostgreSQL), tieni presente quanto segue.
In SQL Server, è necessario creare partizioni con le funzioni di partizione. Quando esegui la conversione da una tabella porzionata SQL Server a una tabella partizionata PostgreSQL versione 10, devi essere consapevole di alcuni problemi potenziali:
+ SQL Server consente di partizionare una tabella utilizzando una colonna senza un vincolo NOT NULL. In questo caso, tutti i valori NULL vanno alla partizione più a sinistra. PostgreSQL non supporta valori NULL per il partizionamento RANGE.
+ SQL Server consente di creare chiavi primarie e univoche per le tabelle partizionate. Per PostgreSQL, è necessario creare chiavi primarie o univoche per ogni partizione direttamente. Pertanto, il vincolo PRIMARY o UNIQUE KEY deve essere rimosso dalla tabella padre durante la migrazione a PostgreSQL. I nomi chiave risultanti assumono il formato. `_`
+ SQL Server consente di creare un vincolo di chiave esterna da e verso tabelle partizionate. PostgreSQL non supporta le chiavi esterne che fanno riferimento a tabelle partizionate. Inoltre, PostgreSQL non supporta i riferimenti delle chiavi esterne da una tabella partizionata a un'altra tabella.
+ SQL Server consente di creare indici per le tabelle partizionate. Per PostgreSQL, è necessario creare un indice per ogni partizione direttamente. In questo modo, gli indici devono essere rimossi dalle loro tabelle padre durante la migrazione a PostgreSQL. I nomi degli indici risultanti avranno il formato `_`.
+ PostgreSQL non supporta indici partizionati.
## Considerazioni sulla migrazione
Alcuni aspetti da considerare durante la migrazione di uno schema di SQL Server a PostgreSQL:
+ In PostgreSQL, tutti i nomi di oggetti in uno schema devono essere univoci, inclusi gli indici. I nomi degli indici devono essere univoci nello schema della tabella di base. In SQL Server, un nome indice può essere lo stesso per tabelle diverse.
Per garantire l'unicità dei nomi degli indici, AWS SCT offre la possibilità di generare nomi di indice univoci se i nomi degli indici non sono univoci. A questo scopo scegli l'opzione **Genera nomi indici univoci** nelle proprietà del progetto. Per impostazione predefinita, questa opzione è abilitata. Se questa opzione è attiva, i nomi indice univoci vengono creati utilizzando il formato IX\$1table\$1name\$1index\$1name. Se questa opzione è disattivata, i nomi indice non vengono modificati.
+ Un'istruzione GOTO e un'etichetta possono essere utilizzati per modificare l'ordine in cui vengono eseguite le istruzioni. Qualsiasi istruzione Transact-SQL che segue un'istruzione GOTO viene ignorata e l'elaborazione continua a livello di etichetta. Le istruzioni e le etichette GOTO possono essere utilizzate ovunque all'interno di una procedura, di un batch o di un blocco dell'istruzione. Le istruzioni GOTO possono anche essere nidificate.
PostgreSQL non utilizza le istruzioni GOTO. Quando AWS SCT converte il codice che contiene un'istruzione GOTO, converte l'istruzione in modo che utilizzi un'istruzione BEGIN... END o LOOP... END LOOP. Puoi trovare esempi di come AWS SCT convertire le istruzioni GOTO nella tabella seguente.
**Istruzioni GOTO SQL Server e istruzioni PostgreSQL convertite**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL non supporta un'istruzione MERGE. AWS SCT emula il comportamento di un'istruzione MERGE nei seguenti modi:
+ Tramite la costruzione INSERT ON CONFLICT.
+ Utilizzando l'istruzione UPDATE FROM DML, ad esempio MERGE senza una clausola WHEN NOT MATCHED.
+ Utilizzando CURSOR, ad esempio con una clausola MERGE with DELETE o utilizzando un'istruzione di condizione MERGE ON complessa.
+ AWS SCT può aggiungere trigger di database all'albero degli oggetti quando Amazon RDS è la destinazione.
+ AWS SCT può aggiungere trigger a livello di server all'albero degli oggetti quando Amazon RDS è la destinazione.
+ SQL Server crea e gestisce automaticamente le tabelle. `deleted` `inserted` È possibile utilizzare queste tabelle temporanee residenti in memoria per testare gli effetti di determinate modifiche ai dati e impostare le condizioni per le azioni di attivazione DML. AWS SCT può convertire l'utilizzo di queste tabelle all'interno delle istruzioni trigger DML.
+ AWS SCT può aggiungere server collegati all'albero degli oggetti quando Amazon RDS è la destinazione.
+ Durante la migrazione da Microsoft SQL Server a PostgreSQL, la funzione SUSER\$1SNAME integrata viene convertita come segue:
+ SUSER\$1SNAME - Restituisce il nome di accesso associato a un numero di identificazione di sicurezza (SID).
+ SUSER\$1SNAME() – Non supportata.
+ SUSER\$1SNAME() CURRENT\$1USER – Restituisce il nome utente del contesto di esecuzione corrente.
+ SUSER\$1SNAME(NULL) – Restituisce NULL.
+ La conversione di funzioni valutate a livello di tabella è supportata. Le funzioni valutate a livello di tabella restituiscono una tabella e possono prendere il posto di una tabella in una query.
+ PATINDEX restituisce la posizione iniziale della prima occorrenza di un modello in una determinata espressione su tutti i tipi di dati di carattere e testo validi. Restituisce zeri se il modello non viene trovato. Durante la conversione da SQL Server ad Amazon RDS AWS SCT for PostgreSQL, sostituisce il codice dell'applicazione che utilizza PATINDEX con aws\$1sqlserver\$1ext.patindex (,).
+ In SQL Server, un tipo di tabella definita dall'utente è un tipo che rappresenta la definizione di una struttura di tabella. Utilizza un tipo di tabella definito dall'utente per dichiarare i parametri del valore di tabella per le stored procedure o le funzioni. È inoltre possibile utilizzare un tipo di tabella definito dall'utente per dichiarare le variabili di tabella che si desidera utilizzare in un batch o nel corpo di una procedura o funzione memorizzata. AWS SCT ha emulato questo tipo in PostgreSQL creando una tabella temporanea.
Durante la conversione da SQL Server a PostgreSQL AWS SCT , converte gli oggetti di sistema SQL Server in oggetti riconoscibili in PostgreSQL. La tabella seguente mostra il modo in cui vengono convertiti gli oggetti di sistema.
| Casi d'uso di MS SQL Server | Sostituzione PostgreSQL |
| --- | --- |
| SYS.SCHEMAS | AWS\$1SQLSERVER\$1EXT.SYS\$1SCHEMI |
| SYS.TABLES | AWS\$1SQLSERVER\$1EXT.SYS\$1TABELLE |
| SYS.VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1VIEWS |
| SYS.ALL\$1VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1VIEWS |
| SYS.TYPES | AWS\$1SQLSERVER\$1EXT.SYS\$1TIPI |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1COLUMNS |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1COLONNE |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEYS |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYS FOREIGNKEYS |
| SYS.FOREIGN\$1KEY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEY\$1COLUMNS |
| SYS.KEY\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.SYS\$1KEY\$1CONSTRAINTS |
| SYS.IDENTITY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1IDENTITY\$1COLUMNS |
| SYS.PROCEDURES | AWS\$1SQLSERVER\$1EXT.SYS\$1PROCEDURE |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1INDEXES |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXES |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJECTS |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1OBJECTS |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJECTS |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULES |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1DATABASE |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SCHEMATA |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1VIEWS |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABELLE |
| INFORMATION\$1SCHEMA.COLUMNS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1COLUMNS |
| INFORMATION\$1SCHEMA.CHECK\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CHECK\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.REFERENTIAL\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1REFERENTIAL\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.TABLE\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLE\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.KEY\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1KEY\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1TABLE\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1TABLE\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.ROUTINES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1ROUTINES |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYS PROCESSI |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYS\$1SISTEMA\$1OBJECTS |
# Utilizzo di un pacchetto di AWS SCT estensione per emulare SQL Server Agent in PostgreSQL
SQL Server Agent è un servizio di Microsoft Windows che esegue i job di SQL Server. SQL Server Agent esegue i processi in base a una pianificazione, in risposta a un evento specifico o su richiesta. Per ulteriori informazioni su SQL Server Agent, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15).
PostgreSQL non ha un equivalente per SQL Server Agent. Per emulare le funzionalità di SQL Server Agent, AWS SCT crea un pacchetto di estensione. Questo pacchetto di estensione utilizza AWS Lambda Amazon CloudWatch. AWS Lambda implementa l'interfaccia utilizzata per gestire le pianificazioni ed eseguire i lavori. Amazon CloudWatch mantiene le regole di pianificazione.
AWS Lambda e Amazon CloudWatch utilizzano un parametro JSON per interagire. Questo parametro JSON ha la seguente struttura.
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
Nell'esempio precedente, *`mode`* è il tipo di attività ed `list of parameters` è un insieme di parametri che dipendono dal tipo di attività. Inoltre, `procedure name` è il nome della procedura che viene eseguita dopo il completamento dell'attività.
AWS SCT utilizza una funzione Lambda per controllare ed eseguire i job. La CloudWatch regola avvia l'esecuzione del processo e fornisce le informazioni necessarie per avviarlo. Quando la CloudWatch regola viene attivata, avvia la funzione Lambda utilizzando i parametri della regola.
Per creare un processo semplice che richiama una procedura, utilizzate il seguente formato.
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
Per creare un lavoro con diversi passaggi, utilizzate il formato seguente.
```
{
"mode": "run_job",
"parameters": {
"job_name": "Job1",
"enabled": "true",
"start_step_id": 1,
"notify_level_email": [0|1|2|3],
"notify_email": email,
"delete_level": [0|1|2|3],
"job_callback": "ProcCallBackJob(job_name, code, message)",
"step_callback": "ProcCallBackStep(job_name, step_id, code, message)"
},
"steps": [
{
"id":1,
"cmd": "ProcStep1",
"cmdexec_success_code": 0,
"on_success_action": [|2|3|4],
"on_success_step_id": 1,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
{
"id":2,
"cmd": "ProcStep2",
"cmdexec_success_code": 0,
"on_success_action": [1|2|3|4],
"on_success_step_id": 0,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
...
]
}
```
Per emulare il comportamento di SQL Server Agent in PostgreSQL, il pacchetto di estensione crea anche AWS SCT le seguenti tabelle e procedure.
## Tabelle che emulano SQL Server Agent in PostgreSQL
Per emulare SQL Server Agent, il pacchetto di estensione utilizza le seguenti tabelle:
**sysjobs**
Memorizza le informazioni sui lavori.
**sysjobsteps**
Memorizza le informazioni sulle fasi di un lavoro.
**pianificazioni di sistema**
Memorizza le informazioni sulle pianificazioni dei lavori.
**sysjobschedules**
Memorizza le informazioni sulla pianificazione per i singoli lavori.
**sysjobhistory**
Memorizza le informazioni sulle esecuzioni dei lavori pianificati.
## Procedure che emulano SQL Server Agent in PostgreSQL
Per emulare SQL Server Agent, il pacchetto di estensione utilizza le seguenti procedure:
**sp\$1add\$1job**
Aggiunge un nuovo lavoro.
**sp\$1add\$1jobstep**
Aggiunge un passaggio a un lavoro.
**sp\$1add\$1schedule**
Crea una nuova regola di pianificazione in Amazon CloudWatch. Puoi utilizzare questa pianificazione con un numero qualsiasi di lavori.
**sp\$1attach\$1schedule**
Imposta una pianificazione per il lavoro selezionato.
**sp\$1add\$1jobschedule**
Crea una regola di pianificazione per un lavoro in Amazon CloudWatch e imposta l'obiettivo per questa regola.
**sp\$1update\$1job**
Aggiorna gli attributi del lavoro creato in precedenza.
**sp\$1update\$1jobstep**
Aggiorna gli attributi della fase di un lavoro.
**sp\$1update\$1schedule**
Aggiorna gli attributi di una regola di pianificazione in Amazon CloudWatch.
**sp\$1update\$1jobschedule**
Aggiorna gli attributi della pianificazione per il lavoro specificato.
**sp\$1delete\$1job**
Elimina un lavoro.
**sp\$1delete\$1jobstep**
Elimina una fase di lavoro da un lavoro.
**sp\$1delete\$1schedule**
Elimina una pianificazione.
**sp\$1delete\$1jobschedule**
Elimina la regola di pianificazione per il lavoro specificato da Amazon CloudWatch.
**sp\$1detach\$1schedule**
Rimuove un'associazione tra una pianificazione e un lavoro.
**get\$1jobs, update\$1job**
Procedure interne che interagiscono con. AWS Elastic Beanstalk
**sp\$1verify\$1job\$1date, sp\$1verify\$1job\$1time, sp\$1verify\$1job, sp\$1verify\$1jobstep, sp\$1verify\$1schedule, sp\$1verify\$1job\$1identifiers, sp\$1verify\$1schedule\$1identifiers, sp\$1verify\$1schedule\$1identifiers**
Procedure interne che controllano le impostazioni.
## Sintassi per le procedure che emulano SQL Server Agent in PostgreSQL
La `aws_sqlserver_ext.sp_add_job` procedura nel pacchetto di estensione emula la procedura. `msdb.dbo.sp_add_job` Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-job-transact-sql?view=sql-server-ver15).
```
par_job_name varchar,
par_enabled smallint = 1,
par_description varchar = NULL::character varying,
par_start_step_id integer = 1,
par_category_name varchar = NULL::character varying,
par_category_id integer = NULL::integer,
par_owner_login_name varchar = NULL::character varying,
par_notify_level_eventlog integer = 2,
par_notify_level_email integer = 0,
par_notify_level_netsend integer = 0,
par_notify_level_page integer = 0,
par_notify_email_operator_name varchar = NULL::character varying,
par_notify_netsend_operator_name varchar = NULL::character varying,
par_notify_page_operator_name varchar = NULL::character varying,
par_delete_level integer = 0,
inout par_job_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sp_add_jobstep` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_add_jobstep` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
par_step_name varchar = NULL::character varying,
par_subsystem varchar = 'TSQL'::bpchar,
par_command text = NULL::text,
par_additional_parameters text = NULL::text,
par_cmdexec_success_code integer = 0,
par_on_success_action smallint = 1,
par_on_success_step_id integer = 0,
par_on_fail_action smallint = 2,
par_on_fail_step_id integer = 0,
par_server varchar = NULL::character varying,
par_database_name varchar = NULL::character varying,
par_database_user_name varchar = NULL::character varying,
par_retry_attempts integer = 0,
par_retry_interval integer = 0,
par_os_run_priority integer = 0,
par_output_file_name varchar = NULL::character varying,
par_flags integer = 0,
par_proxy_id integer = NULL::integer,
par_proxy_name varchar = NULL::character varying,
inout par_step_uid char = NULL::bpchar,
out returncode integer
```
La `aws_sqlserver_ext.sp_add_schedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_add_schedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_name varchar,
par_enabled smallint = 1,
par_freq_type integer = 0,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
par_owner_login_name varchar = NULL::character varying,
*inout par_schedule_uid char = NULL::bpchar,*
inout par_schedule_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sp_attach_schedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_attach_schedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-attach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_automatic_post smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sp_add_jobschedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_add_jobschedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_enabled smallint = 1,
par_freq_type integer = 1,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
inout par_schedule_id integer = NULL::integer,
par_automatic_post smallint = 1,
inout par_schedule_uid char = NULL::bpchar,
out returncode integer
```
La `aws_sqlserver_ext.sp_delete_job` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_delete_job` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_originating_server varchar = NULL::character varying,
par_delete_history smallint = 1,
par_delete_unused_schedule smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sp_delete_jobstep` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_delete_jobstep` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobsteplog-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
out returncode integer
```
La `aws_sqlserver_ext.sp_delete_jobschedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_delete_jobschedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_keep_schedule integer = 0,
par_automatic_post smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sp_delete_schedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_delete_schedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_force_delete smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sp_detach_schedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_detach_schedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-detach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_delete_unused_schedule smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sp_update_job` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_update_job` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_description varchar = NULL::character varying
par_start_step_id integer = NULL::integer
par_category_name varchar = NULL::character varying
par_owner_login_name varchar = NULL::character varying
par_notify_level_eventlog integer = NULL::integer
par_notify_level_email integer = NULL::integer
par_notify_level_netsend integer = NULL::integer
par_notify_level_page integer = NULL::integer
par_notify_email_operator_name varchar = NULL::character varying
par_notify_netsend_operator_name varchar = NULL::character varying
par_notify_page_operator_name varchar = NULL::character varying
par_delete_level integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
La `aws_sqlserver_ext.sp_update_jobschedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_update_jobschedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
La `aws_sqlserver_ext.sp_update_jobstep` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_update_jobstep` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_step_id integer = NULL::integer
par_step_name varchar = NULL::character varying
par_subsystem varchar = NULL::character varying
par_command text = NULL::text
par_additional_parameters text = NULL::text
par_cmdexec_success_code integer = NULL::integer
par_on_success_action smallint = NULL::smallint
par_on_success_step_id integer = NULL::integer
par_on_fail_action smallint = NULL::smallint
par_on_fail_step_id integer = NULL::integer
par_server varchar = NULL::character varying
par_database_name varchar = NULL::character varying
par_database_user_name varchar = NULL::character varying
par_retry_attempts integer = NULL::integer
par_retry_interval integer = NULL::integer
par_os_run_priority integer = NULL::integer
par_output_file_name varchar = NULL::character varying
par_flags integer = NULL::integer
par_proxy_id integer = NULL::integer
par_proxy_name varchar = NULL::character varying
out returncode integer
```
La `aws_sqlserver_ext.sp_update_schedule` procedura nel pacchetto di estensione emula la `msdb.dbo.sp_update_schedule` procedura. Per ulteriori informazioni sulla procedura SQL Server Agent di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_owner_login_name varchar = NULL::character varying
par_automatic_post smallint = 1
out returncode integer
```
## Esempi di utilizzo di procedure che emulano SQL Server Agent in PostgreSQL
Per aggiungere un nuovo lavoro, utilizzare la `aws_sqlserver_ext.sp_add_job` procedura illustrata di seguito.
```
SELECT * FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_job',
par_enabled := 1::smallint,
par_start_step_id := 1::integer,
par_category_name := '[Uncategorized (Local)]',
par_owner_login_name := 'sa');
```
Per aggiungere una nuova fase del processo, utilizzare la `aws_sqlserver_ext.sp_add_jobstep` procedura illustrata di seguito.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_job',
par_step_id := 1::smallint,
par_step_name := 'test_job_step1',
par_subsystem := 'TSQL',
par_command := 'EXECUTE [dbo].[PROC_TEST_JOB_STEP1];',
par_server := NULL,
par_database_name := 'GOLD_TEST_SS');
```
Per aggiungere una pianificazione semplice, utilizzare la `aws_sqlserver_ext.sp_add_schedule` procedura illustrata di seguito.
```
SELECT * FROM aws_sqlserver_ext.sp_add_schedule(
par_schedule_name := 'RunOnce',
par_freq_type := 1,
par_active_start_time := 233000);
```
Per impostare una pianificazione per un lavoro, utilizzare la `aws_sqlserver_ext.sp_attach_schedule` procedura illustrata di seguito.
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
Per creare una pianificazione per un lavoro, utilizzare la `aws_sqlserver_ext.sp_add_jobschedule` procedura illustrata di seguito.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_job2',
par_name := 'test_schedule2',
par_enabled := 1::smallint,
par_freq_type := 4,
par_freq_interval := 1,
par_freq_subday_type := 4,
par_freq_subday_interval := 1,
par_freq_relative_interval := 0,
par_freq_recurrence_factor := 0,
par_active_start_date := 20100801,
par_active_end_date := 99991231,
par_active_start_time := 0,
par_active_end_time := 0);
```
## Esempi di casi d'uso per l'emulazione di SQL Server Agent in PostgreSQL
Se il codice del database sorgente utilizza SQL Server Agent per eseguire i lavori, puoi utilizzare il pacchetto di estensione SQL Server to PostgreSQL AWS SCT per convertire questo codice in PostgreSQL. Il pacchetto di estensione utilizza AWS Lambda funzioni per emulare il comportamento di SQL Server Agent.
È possibile creare una nuova AWS Lambda funzione o registrare una funzione esistente.
**Per creare una nuova AWS Lambda funzione**
1. Nella struttura del database di destinazione AWS SCT, apri il menu contestuale (fai clic con il pulsante destro del mouse), scegli **Applica pacchetto di estensione per**, quindi scegli **PostgreSQL**.
Viene visualizzata la procedura guidata del pacchetto di estensione.
1. Nella scheda del **servizio di emulazione di SQL Server Agent**, procedi come segue:
+ Scegli **Crea una AWS Lambda funzione.**
+ Per l'**accesso al database**, inserisci il nome dell'utente del database di destinazione.
+ Per **Password del database**, inserisci la password per il nome utente che hai inserito nel passaggio precedente.
+ Per la **cartella della libreria Python**, inserisci il percorso della cartella della libreria Python.
+ **Scegliete **Crea AWS Lambda funzione**, quindi scegliete Avanti.**
**Per registrare una AWS Lambda funzione distribuita in precedenza**
+ Esegui lo script seguente sul database di destinazione.
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
Nell'esempio precedente, *`ARN`* è l'Amazon Resource Name (ARN) della funzione distribuita AWS Lambda .
L'esempio seguente crea un'attività semplice che consiste in un solo passaggio. Ogni cinque minuti, questa attività esegue la `job_example` funzione creata in precedenza. Questa funzione inserisce i record nella `job_example_table` tabella.
**Per creare questa semplice operazione**
1. Crea un lavoro utilizzando la `aws_sqlserver_ext.sp_add_job` funzione come illustrato di seguito.
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. Create una fase di lavoro utilizzando la `aws_sqlserver_ext.sp_add_jobstep` funzione come illustrato di seguito.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_simple_job',
par_step_name := 'test_simple_job_step1',
par_command := 'PERFORM job_simple_example;');
```
La fase di lavoro specifica cosa fa la funzione.
1. Crea uno scheduler per il lavoro utilizzando la `aws_sqlserver_ext.sp_add_jobschedule` funzione come illustrato di seguito.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_simple_job',
par_name := 'test_schedule',
par_freq_type := 4, /* Daily */
par_freq_interval := 1, /* frequency_interval is unused */
par_freq_subday_type := 4, /* Minutes */
par_freq_subday_interval := 5 /* 5 minutes */);
```
La fase del processo specifica cosa fa la funzione.
Per eliminare questo lavoro, utilizzare la `aws_sqlserver_ext.sp_delete_job` funzione come illustrato di seguito.
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# Utilizzo di un pacchetto di AWS SCT estensione per emulare SQL Server Database Mail in PostgreSQL
È possibile utilizzare SQL Server Database Mail per inviare messaggi di posta elettronica agli utenti dal motore di database di SQL Server o dall'istanza gestita SQL di Azure. Questi messaggi di posta elettronica possono contenere risultati di query o includere file provenienti da qualsiasi risorsa della rete. Per ulteriori informazioni su SQL Server Database Mail, vedere [la documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15).
PostgreSQL non ha un equivalente per SQL Server Database Mail. Per emulare le funzionalità di SQL Server Database Mail, AWS SCT crea un pacchetto di estensione. Questo pacchetto di estensione utilizza AWS Lambda Amazon Simple Email Service (Amazon SES). AWS Lambda fornisce agli utenti un'interfaccia per interagire con il servizio di invio e-mail di Amazon SES. Per configurare questa interazione, aggiungi l'Amazon Resource Name (ARN) della tua funzione Lambda.
Per un nuovo account e-mail, usa il seguente comando.
```
do
$$
begin
PERFORM sysmail_add_account_sp (
par_account_name :='your_account_name',
par_email_address := 'your_account_email',
par_display_name := 'your_account_display_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
Per aggiungere l'ARN della funzione Lambda all'account e-mail esistente, utilizzare il comando seguente.
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
Negli esempi precedenti, *`ARN`* è l'ARN della funzione Lambda.
Per emulare il comportamento di SQL Server Database Mail in PostgreSQL, il pacchetto di estensione utilizza AWS SCT le seguenti tabelle, viste e procedure.
## Tabelle che emulano la posta del database SQL Server in PostgreSQL
Per emulare SQL Server Database Mail, il pacchetto di estensione utilizza le seguenti tabelle:
**sysmail\$1account**
Memorizza le informazioni sugli account di posta elettronica.
**sysmail\$1profile**
Memorizza le informazioni sui profili utente.
**sysmail\$1server**
Memorizza le informazioni sui server di posta elettronica.
**sysmail\$1mailitems**
Memorizza l'elenco dei messaggi e-mail.
**sysmail\$1attachments**
Contiene una riga per ogni allegato di posta elettronica.
**sysmail\$1log**
Memorizza le informazioni di servizio relative all'invio di messaggi di posta elettronica.
**sysmail\$1profileaccount**
Memorizza le informazioni sui profili utente e gli account di posta elettronica.
## Visualizzazioni che emulano la posta del database SQL Server in PostgreSQL
Per emulare SQL Server Database Mail, AWS SCT crea le seguenti viste nel database PostgreSQL per garantire la compatibilità. Il pacchetto di estensione non le utilizza, ma il codice convertito può interrogare queste visualizzazioni.
**sysmail\$1allitems**
Include un elenco di tutte le email.
**sysmail\$1faileditems**
Include un elenco di e-mail che non è stato possibile inviare.
**sysmail\$1sentitems**
Include un elenco di e-mail inviate.
**sysmail\$1unsentitems**
Include un elenco di e-mail che non sono ancora state inviate.
**sysmail\$1mailattachments**
Include un elenco di file allegati.
## Procedure che emulano la posta del database SQL Server in PostgreSQL
Per emulare SQL Server Database Mail, il pacchetto di estensione utilizza le seguenti procedure:
**sp\$1send\$1dbmail**
Invia un messaggio di posta elettronica ai destinatari specificati.
**sysmail\$1add\$1profile\$1sp**
Crea un nuovo profilo utente.
**sysmail\$1add\$1account\$1sp**
Crea un nuovo account e-mail che memorizza informazioni come le credenziali SMTP (Simple Mail Transfer Protocol) e così via.
**sysmail\$1add\$1profileaccount\$1sp**
Aggiunge un account e-mail al profilo utente specificato.
**sysmail\$1update\$1profile\$1sp**
Modifica gli attributi del profilo utente come descrizione, nome e così via.
**sysmail\$1update\$1account\$1sp**
Modifica le informazioni nell'account di posta elettronica esistente.
**sysmail\$1update\$1profileaccount\$1sp**
Aggiorna le informazioni dell'account e-mail nel profilo utente specificato.
**sysmail\$1delete\$1profileaccount\$1sp**
Rimuove un account e-mail dal profilo utente specificato.
**sysmail\$1delete\$1account\$1sp**
Elimina l'account e-mail.
**sysmail\$1delete\$1profile\$1sp**
Elimina il profilo utente.
**sysmail\$1delete\$1mailitems\$1sp**
Elimina i messaggi di posta elettronica dalle tabelle interne.
**sysmail\$1help\$1profile\$1sp**
Visualizza informazioni sul profilo utente.
**sysmail\$1help\$1account\$1sp**
Visualizza informazioni sull'account e-mail.
**sysmail\$1help\$1profileaccount\$1sp**
Visualizza informazioni sugli account e-mail associati al profilo utente.
**sysmail\$1dbmail\$1json**
Una procedura interna che genera richieste JSON per le funzioni. AWS Lambda
**sysmail\$1verify\$1profile\$1sp, sysmail\$1verify\$1account\$1sp, sysmail\$1verify\$1addressparams\$1sp**
Procedure interne che controllano le impostazioni.
**sp\$1get\$1dbmail, sp\$1set\$1dbmail, sysmail\$1dbmail\$1xml**
Procedure interne obsolete.
## Sintassi per le procedure che emulano SQL Server Database Mail in PostgreSQL
La `aws_sqlserver_ext.sp_send_dbmail` procedura nel pacchetto di estensione emula la procedura. `msdb.dbo.sp_send_dbmail` Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar = NULL::character varying,
par_recipients text = NULL::text,
par_copy_recipients text = NULL::text,
par_blind_copy_recipients text = NULL::text,
par_subject varchar = NULL::character varying,
par_body text = NULL::text,
par_body_format varchar = NULL::character varying,
par_importance varchar = 'NORMAL'::character varying,
par_sensitivity varchar = 'NORMAL'::character varying,
par_file_attachments text = NULL::text,
par_query text = NULL::text,
par_execute_query_database varchar = NULL::character varying,
par_attach_query_result_as_file smallint = 0,
par_query_attachment_filename varchar = NULL::character varying,
par_query_result_header smallint = 1,
par_query_result_width integer = 256,
par_query_result_separator VARCHAR = ' '::character varying,
par_exclude_query_output smallint = 0,
par_append_query_error smallint = 0,
par_query_no_truncate smallint = 0,
par_query_result_no_padding smallint = 0,
out par_mailitem_id integer,
par_from_address text = NULL::text,
par_reply_to text = NULL::text,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_delete_mailitems_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_delete_mailitems_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-mailitems-sp-transact-sql?view=sql-server-ver15).
```
par_sent_before timestamp = NULL::timestamp without time zone,
par_sent_status varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_add_profile_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_add_profile_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar,
par_description varchar = NULL::character varying,
out par_profile_id integer,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_add_account_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_add_account_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_name varchar
par_email_address varchar
par_display_name varchar = NULL::character varying
par_replyto_address varchar = NULL::character varying
par_description varchar = NULL::character varying
par_mailserver_name varchar = NULL::character varying
par_mailserver_type varchar = 'SMTP'::bpchar
par_port integer = 25
par_username varchar = NULL::character varying
par_password varchar = NULL::character varying
par_use_default_credentials smallint = 0
par_enable_ssl smallint = 0
out par_account_id integer
out returncode integer
```
La `aws_sqlserver_ext.sysmail_add_profileaccount_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_add_profileaccount_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_help_profile_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_help_profile_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_update_profile_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_update_profile_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_description varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_delete_profile_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_delete_profile_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_force_delete smallint = 1,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_help_account_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_help_account_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_update_account_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_update_account_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_email_address varchar = NULL::character varying,
par_display_name varchar = NULL::character varying,
par_replyto_address varchar = NULL::character varying,
par_description varchar = NULL::character varying,
par_mailserver_name varchar = NULL::character varying,
par_mailserver_type varchar = NULL::character varying,
par_port integer = NULL::integer,
par_username varchar = NULL::character varying,
par_password varchar = NULL::character varying,
par_use_default_credentials smallint = NULL::smallint,
par_enable_ssl smallint = NULL::smallint,
par_timeout integer = NULL::integer,
par_no_credential_change smallint = NULL::smallint,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_delete_account_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_delete_account_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_help_profileaccount_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_help_profileaccount_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_update_profileaccount_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_update_profileaccount_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
La `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` procedura nel pacchetto di estensione emula la `msdb.dbo.sysmail_delete_profileaccount_sp` procedura. Per ulteriori informazioni sulla procedura SQL Server Database Mail di origine, vedere la [documentazione tecnica Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
## Esempi di utilizzo di procedure che emulano SQL Server Database Mail in PostgreSQL
Per inviare un'e-mail, utilizzare la `aws_sqlserver_ext.sp_send_dbmail` procedura illustrata di seguito.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
L'esempio seguente mostra come inviare un'e-mail con i risultati delle query.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Account with id = 1',
par_query := 'SELECT COUNT(*)FROM Account WHERE id = 1'
);
```
L'esempio seguente mostra come inviare un'e-mail con codice HTML.
```
DECLARE var_tableHTML TEXT;
SET var_tableHTML := CONCAT(
'Work Order Report
',
'',
'| Work Order ID | Product ID | ',
'Name | Order Qty | Due Date | ',
'Expected Revenue |
|---|
',
'
'
);
PERFORM sp_send_dbmail (
par_recipients := 'hello@rusgl.info',
par_subject := 'Work Order List',
par_body := var_tableHTML,
par_body_format := 'HTML'
);
```
Per eliminare i messaggi di posta elettronica, utilizzare la `aws_sqlserver_ext.sysmail_delete_mailitems_sp` procedura illustrata di seguito.
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
L'esempio seguente mostra come eliminare i messaggi di posta elettronica più vecchi.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
L'esempio seguente mostra come eliminare tutte le email che non possono essere inviate.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
Per creare un nuovo profilo utente, utilizzare la `aws_sqlserver_ext.sysmail_add_profile_sp` procedura illustrata di seguito.
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
L'esempio seguente mostra come creare un nuovo profilo e salvare l'identificatore univoco del profilo in una variabile.
```
DECLARE var_profileId INT;
SELECT par_profile_id
FROM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := ' Profile used for administrative mail.')
INTO var_profileId;
SELECT var_profileId;
```
Per creare un nuovo account e-mail, utilizzare la `aws_sqlserver_ext.sysmail_add_account_sp` procedura illustrata di seguito.
```
PERFORM sysmail_add_account_sp (
par_account_name :='Audit Account',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_description := 'Account for administrative e-mail.',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'arn:aws:lambda:us-west-2:555555555555:function:pg_v3'
);
```
Per aggiungere un account e-mail al profilo utente, utilizzare la `aws_sqlserver_ext.sysmail_add_profileaccount_sp` procedura illustrata di seguito.
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## Esempi di casi d'uso per emulare SQL Server Database Mail in PostgreSQL
Se il codice del database sorgente utilizza SQL Server Database Mail per inviare e-mail, puoi utilizzare il pacchetto di AWS SCT estensione per convertire questo codice in PostgreSQL.
**Per inviare un'e-mail dal database PostgreSQL**
1. Crea e configura la tua funzione. AWS Lambda
1. Applica il pacchetto di AWS SCT estensione.
1. Crea un profilo utente utilizzando la `sysmail_add_profile_sp` funzione illustrata di seguito.
1. Crea un account e-mail utilizzando la `sysmail_add_account_sp` funzione illustrata di seguito.
1. Aggiungi questo account e-mail al tuo profilo utente utilizzando la `sysmail_add_profileaccount_sp` funzione illustrata di seguito.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_settings_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sysmail_add_profile_sp(
par_profile_name := 'Administrator',
par_description := 'administrative mail'
);
PERFORM aws_sqlserver_ext.sysmail_add_account_sp(
par_account_name := 'Audit Account',
par_description := 'Account for administrative e-mail.',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'your_ARN'
);
PERFORM aws_sqlserver_ext.sysmail_add_profileaccount_sp(
par_profile_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
END;
$BODY$
LANGUAGE plpgsql;
```
1. Inviate un'e-mail utilizzando la `sp_send_dbmail` funzione illustrata di seguito.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_send_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sp_send_dbmail(
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_body := 'The stored procedure finished',
par_subject := 'Automated Success Message'
);
END;
$BODY$
LANGUAGE plpgsql;
```
Per visualizzare le informazioni su tutti i profili utente, utilizzare la `sysmail_help_profile_sp` procedura illustrata di seguito.
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
L'esempio seguente visualizza le informazioni sul profilo utente specifico.
```
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_name := 'Administrator');
```
Per visualizzare le informazioni su tutti gli account di posta elettronica, utilizzare la `sysmail_help_account_sp` procedura illustrata di seguito.
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
L'esempio seguente visualizza le informazioni sull'account di posta elettronica specifico.
```
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_name := 'Audit Account');
```
Per visualizzare le informazioni su tutti gli account di posta elettronica associati ai profili utente, utilizzare la `sysmail_help_profileaccount_sp` procedura illustrata di seguito.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
L'esempio seguente filtra i record in base all'identificatore, al nome del profilo o al nome dell'account.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1, par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_name := 'Administrator');
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_account_name := 'Audit Account');
```
Per modificare il nome o la descrizione del profilo utente, utilizzare la `sysmail_update_profile_sp` procedura illustrata di seguito.
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
Per modificare le impostazioni dell'account e-mail, utilizzare la `ysmail_update_account_sp` procedura illustrata di seguito.
```
select from aws_sqlserver_ext.sysmail_update_account_sp (
par_account_name := 'Audit Account',
par_mailserver_name := 'arn:aws:lambda:region:XXXXXXXXXXXX:function:func_test',
par_mailserver_type := 'AWSLAMBDA'
);
```
# Migrazione da SQL Server ad Amazon RDS per SQL Server con AWS Schema Conversion Tool
Alcuni aspetti da considerare durante la migrazione dello schema e del codice SQL Server ad Amazon RDS per SQL Server:
+ AWS SCT può convertire SQL Server Agent per fornire pianificazioni, avvisi e processi su un'istanza DB di Amazon RDS for SQL Server. Dopo la conversione, è possibile usare un'istanza database Amazon RDS for SQL Server con SQL Server Reporting Service (SSRS), SQL Server Analysis Services (SSAS) e SQL Server Integration Services (SSIS).
+ Amazon RDS non supporta attualmente SQL Server Service Broker o endpoint T-SQL aggiuntivi che richiedono l'esecuzione del comando CREATE ENDPOINT.
+ Amazon RDS dispone di supporto limitato per i server collegati. Quando converte il codice dell'applicazione SQL Server che utilizza server collegati, AWS SCT converte il codice dell'applicazione. Tuttavia, assicurarsi di esaminare il comportamento degli oggetti che utilizzano server collegati prima di eseguire il codice convertito.
+ Si utilizza Sempre acceso.
+ Il rapporto di AWS SCT valutazione fornisce le metriche del server per la conversione. Questi parametri sull'istanza SQL Server includono quanto segue:
+ Viene utilizzato il mirroring dei dati.
+ SQL Server Log Shipping è configurato.
+ Il cluster di failover viene utilizzato.
+ Database Mail è configurato.
+ Full Text Search Service viene utilizzato. Amazon RDS per SQL Server ha una ricerca full-text limitata e non supporta la ricerca semantica.
+ Data Quality Service (DQS) è installato. Amazon RDS non supporta DQS quindi consigliamo di installare SQL Server su un'istanza Amazon EC2.
## Privilegi per RDS for SQL Server come destinazione
Per eseguire la migrazione a RDS per SQL Server, crea un utente del database e quindi concedi i privilegi richiesti per ogni database. È possibile utilizzare il seguente esempio di codice.
```
CREATE LOGIN user_name WITH PASSWORD 'your_password';
USE db_name
CREATE USER user_name FOR LOGIN user_name
GRANT VIEW DEFINITION TO user_name
GRANT VIEW DATABASE STATE TO user_name
GRANT CREATE SCHEMA TO user_name;
GRANT CREATE TABLE TO user_name;
GRANT CREATE VIEW TO user_name;
GRANT CREATE TYPE TO user_name;
GRANT CREATE DEFAULT TO user_name;
GRANT CREATE FUNCTION TO user_name;
GRANT CREATE PROCEDURE TO user_name;
GRANT CREATE ASSEMBLY TO user_name;
GRANT CREATE AGGREGATE TO user_name;
GRANT CREATE FULLTEXT CATALOG TO user_name;
GRANT CREATE SYNONYM TO user_name;
GRANT CREATE XML SCHEMA COLLECTION TO user_name;
```
Nell'esempio precedente, sostituiscilo *user\$1name* con il nome dell'utente. Quindi, *db\$1name* sostituiscilo con il nome del database di destinazione. Infine, *your\$1password* sostituiscilo con una password sicura.
# Fonti di data warehouse per AWS Schema Conversion Tool
AWS SCT può convertire gli schemi per i seguenti data warehouse di origine in una destinazione supportata. Per informazioni sulle autorizzazioni, sulle connessioni e su cosa è AWS SCT possibile convertire per l'uso con il database o il data warehouse di destinazione, consulta i dettagli di seguito.
**Topics**
+ [Connessione di Amazon Redshift con AWS Schema Conversion Tool](CHAP_Source.Redshift.md)
+ [Connessione di Azure Synapse Analytics con AWS Schema Conversion Tool](CHAP_Source.AzureSynapse.md)
+ [Connessione a Google BigQuery con AWS Schema Conversion Tool](CHAP_Source.BigQuery.md)
+ [Connessione del database Greenplum con AWS Schema Conversion Tool](CHAP_Source.Greenplum.md)
+ [Connessione a Netezza con AWS Schema Conversion Tool](CHAP_Source.Netezza.md)
+ [Connettere Oracle Data Warehouse con AWS SCT](CHAP_Source.OracleDW.md)
+ [Connessione a un data warehouse Snowflake con AWS Schema Conversion Tool](CHAP_Source.Snowflake.md)
+ [Connessione a un data warehouse di SQL Server con AWS Schema Conversion Tool](CHAP_Source.SQLServerDW.md)
+ [Connessione a un Data Warehouse Teradata con AWS Schema Conversion Tool](CHAP_Source.Teradata.md)
+ [Connessione dei AWS Schema Conversion Tool database a Vertica](CHAP_Source.Vertica.md)
# Connessione di Amazon Redshift con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per ottimizzare il tuo cluster Amazon Redshift. AWS SCT ti fornisce consigli sulla selezione delle chiavi di distribuzione e ordinamento per il tuo cluster Amazon Redshift. Puoi considerare il progetto di ottimizzazione di Amazon Redshift come un AWS SCT progetto con origine e destinazione che puntano ai diversi cluster Amazon Redshift.
## Privilegi per Amazon Redshift come database di origine
Per utilizzare Amazon Redshift come fonte sono necessari i seguenti privilegi:
+ UTILIZZO SU SCHEMA **
+ SELEZIONA SU TUTTE LE TABELLE DELLO SCHEMA **
+ SELECT ON PG\$1CATALOG.PG\$1STATISTIC
+ SELECT ON SVV\$1TABLE\$1INFO
+ SELECT ON TABLE STV\$1BLOCKLIST
+ SELECT ON TABLE STV\$1TBL\$1PERM
+ SELEZIONA SU SYS\$1SERVERLESS\$1USAGE
+ SELEZIONA PG\$1DATABASE\$1INFO
+ SELEZIONA SU PG\$1STATISTIC
Negli esempi precedenti, sostituisci il ** segnaposto con il nome dello schema di origine.
Per i privilegi richiesti per Amazon Redshift come destinazione, consulta. [Autorizzazioni per Amazon Redshift come destinazione](CHAP_Converting.DW.md#CHAP_Converting.DW.ConfigureTarget)
## Connessione ad Amazon Redshift come fonte
Utilizza la seguente procedura per connetterti al tuo database di origine Amazon Redshift con. AWS Schema Conversion Tool
**Per connettersi a un database di origine Amazon Redshift**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. **Scegli **Amazon Redshift**, quindi scegli Avanti.**
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire le informazioni di connessione per il database di origine di Amazon Redshift, utilizza le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Redshift.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di ottimizzazione di Amazon Redshift
Per modificare le impostazioni di ottimizzazione di Amazon Redshift, seleziona **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco in alto, scegli **Amazon Redshift**, quindi scegli Amazon **Redshift — Amazon Redshift**. AWS SCT mostra tutte le impostazioni disponibili per l'ottimizzazione di Amazon Redshift.
Le impostazioni di ottimizzazione di Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se il numero di tabelle è superiore a quello che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per scegliere la strategia di migrazione.
AWS consiglia di utilizzare cluster diversi come origine e destinazione per il progetto di ottimizzazione. Prima di iniziare il processo di ottimizzazione di Amazon Redshift, crei una copia del cluster Amazon Redshift di origine. Puoi includere i dati di origine in questa copia o creare un cluster vuoto.
Per la **strategia** di **migrazione, scegli Migrazione a una copia** per includere i dati del cluster di origine nel cluster di destinazione.
Per la **strategia di migrazione**, scegli **Migrazione verso una tabula** rasa per esaminare i suggerimenti di ottimizzazione. Dopo aver accettato questi suggerimenti, migra i dati di origine nel cluster di destinazione.
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando è stata selezionata l'opzione **Usa codifica di compressione**.
+ Per utilizzare l'ottimizzazione automatica delle tabelle.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per utilizzarlo solo sull'ottimizzazione automatica delle tabelle, scegli **Strategie di ottimizzazione** nel riquadro a sinistra. Quindi seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift e scegli **Nessuno** per la** strategia **iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico, scegli l'utente** del database di cui desideri analizzare le statistiche delle query.
# Connessione di Azure Synapse Analytics con AWS Schema Conversion Tool
Puoi usarlo AWS SCT per convertire schemi, oggetti di codice e codice dell'applicazione da Azure Synapse Analytics ad Amazon Redshift.
## Privilegi per Azure Synapse Analytics come database di origine
I seguenti privilegi sono necessari per usare un data warehouse di Azure Synapse Analytics come fonte:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Applica i privilegi per ogni database di cui stai convertendo lo schema.
## Connessione ad Azure Synapse Analytics come fonte
Usa la seguente procedura per connetterti al tuo data warehouse di Azure Synapse Analytics con. AWS Schema Conversion Tool
**Per connettersi a un data warehouse di Azure Synapse Analytics come fonte**
1. **Nella AWS Schema Conversion Tool, scegli Aggiungi fonte.**
1. **Scegli **Azure Synapse Analytics**, quindi scegli Avanti.**
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione per il data warehouse di Azure Synapse Analytics, usa le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.AzureSynapse.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di conversione da Azure Synapse Analytics ad Amazon Redshift
**Per modificare le impostazioni di conversione da Azure Synapse Analytics ad Amazon Redshift, scegli Impostazioni in AWS SCT, quindi scegli **Impostazioni** di conversione.** Dall'elenco superiore, scegli **Azure Synapse**, quindi scegli **Azure Synapse** — Amazon Redshift. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Azure Synapse Analytics ad Amazon Redshift.
Le impostazioni di conversione da Azure Synapse Analytics ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione della conversione da Azure Synapse Analytics ad Amazon Redshift
**Per modificare le impostazioni di ottimizzazione delle conversioni da Azure Synapse Analytics ad Amazon Redshift, scegli Impostazioni in AWS SCT, **quindi scegli Impostazioni** di conversione.** Dall'elenco superiore, scegli **Azure Synapse**, quindi scegli **Azure Synapse** — Amazon Redshift. **Nel riquadro a sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Azure Synapse Analytics ad Amazon Redshift.
Le impostazioni di ottimizzazione della conversione da Azure Synapse Analytics ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione a Google BigQuery con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo BigQuery da Amazon Redshift.
## Privilegi come fonte BigQuery
Per utilizzare un BigQuery data warehouse come fonte in AWS SCT, crea un account di servizio. In Google Cloud, le applicazioni utilizzano gli account di servizio per effettuare chiamate API autorizzate. Gli account di servizio sono diversi dagli account utente. Per ulteriori informazioni, consulta [Account di servizio](https://cloud.google.com/iam/docs/service-accounts) nella documentazione di Google Cloud Identity and Access Management.
Assicurati di assegnare i seguenti ruoli al tuo account di servizio:
+ `BigQuery Admin`
+ `Storage Admin`
Il `BigQuery Admin` ruolo fornisce le autorizzazioni per gestire tutte le risorse all'interno del progetto. AWS SCT utilizza questo ruolo per caricare i BigQuery metadati nel progetto di migrazione.
Il `Storage Admin` ruolo garantisce il pieno controllo degli oggetti di dati e dei bucket. Puoi trovare questo ruolo in. `Cloud Storage` AWS SCT utilizza questo ruolo per estrarre i dati BigQuery e caricarli in Amazon Redshift.
**Per creare un file chiave dell'account di servizio**
1. Accedi alla console di gestione di Google Cloud all'indirizzo [https://console.cloud.google.com/](https://console.cloud.google.com/).
1. Nella pagina [BigQuery API](https://console.cloud.google.com/apis/library/bigquery.googleapis.com), scegli **Abilita**. Salta questo passaggio se vedi **API abilitata**.
1. Nella pagina [Account di servizio](https://console.cloud.google.com/iam-admin/serviceaccounts), scegli il tuo progetto, quindi scegli **Crea account di servizio**.
1. Nella pagina dei **dettagli dell'account di servizio**, inserisci un valore descrittivo per il **nome dell'account di servizio**. Scegli **Crea e continua**. Viene visualizzata la **pagina Concedi all'account di servizio l'accesso al progetto**.
1. Per **Seleziona un ruolo**, scegli **BigQuery**, quindi scegli **BigQuery Amministratore**.
1. Scegli **Aggiungi un altro ruolo**. Per **Seleziona un ruolo**, scegli **Cloud Storage**, quindi scegli **Storage Admin**.
1. Scegli **Continua**, quindi scegli **Fine**.
1. Nella pagina [Account di servizio](https://console.cloud.google.com/iam-admin/serviceaccounts), scegli l'account di servizio che hai creato.
1. Scegli **Chiavi**, quindi scegli **Crea nuova chiave** per **Aggiungi chiave**.
1. Scegli **JSON**, quindi scegli **Crea**. Scegli la cartella in cui salvare la chiave privata o seleziona la cartella predefinita per i download nel tuo browser.
Per estrarre dati da un BigQuery data warehouse, AWS SCT utilizza la cartella bucket di Google Cloud Storage. Crea questo bucket prima di iniziare la migrazione dei dati. Inserisci il percorso della cartella bucket di Google Cloud Storage nella finestra di dialogo **Crea attività locale**. Per ulteriori informazioni, consulta [Creazione, esecuzione e monitoraggio di qualsiasi AWS SCT attività](agents.md#agents.Tasks).
## Connessione a BigQuery come fonte
Usa la seguente procedura per connetterti al tuo BigQuery progetto sorgente con AWS Schema Conversion Tool.
**Per connettersi a un data warehouse di BigQuery origine**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **BigQuery**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. In **Nome della connessione**, inserisci un nome per il tuo BigQuery progetto. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. In **Percorso chiave**, inserisci il percorso del file chiave dell'account di servizio. Per ulteriori informazioni sulla creazione di questo file, vedere[Privilegi come fonte BigQuery](#CHAP_Source.BigQuery.Permissions).
1. Scegliete **Test Connection** per verificare che sia AWS SCT possibile connettersi al BigQuery progetto sorgente.
1. Scegli **Connect** per connetterti al tuo BigQuery progetto sorgente.
## Limitazioni all'utilizzo BigQuery come fonte per AWS SCT
Le seguenti limitazioni si applicano quando si utilizza BigQuery come fonte per AWS SCT:
+ AWS SCT non supporta la conversione di sottoquery nelle funzioni analitiche.
+ Non è possibile utilizzare le istruzioni AWS SCT to convert BigQuery `SELECT AS STRUCT`. `SELECT AS VALUE`
+ AWS SCT non supporta la conversione dei seguenti tipi di funzioni:
+ Aggregato approssimativo
+ Bit
+ Debug
+ Interrogazione federata
+ Geografia
+ Hash
+ Matematiche
+ Rete
+ Aggregato statistico
+ UUID
+ AWS SCT fornisce un supporto limitato per la conversione delle funzioni di stringa.
+ AWS SCT non supporta la conversione degli `UNNEST` operatori.
+ Non è possibile convertire le operazioni di join correlate in AWS SCT.
+ AWS SCT non supporta la conversione delle `OFFSET` clausole `QUALIFY``WINDOW`,`LIMIT`, e.
+ Non è possibile utilizzare AWS SCT per convertire espressioni di tabella comuni ricorsive.
+ AWS SCT non supporta la conversione di `INSERT` istruzioni con sottoquery all'interno di clausole. `VALUES`
+ AWS SCT non supporta la conversione di `UPDATE` istruzioni per campi annidati e record ripetuti.
+ Non è possibile utilizzare AWS SCT per convertire tipi `STRUCT` di `ARRAY` dati.
## BigQuery alle impostazioni di conversione in Amazon Redshift
BigQuery Per modificare le impostazioni di conversione in Amazon Redshift, seleziona **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco superiore, scegli **Google BigQuery**, quindi scegli **Google BigQuery — Amazon Redshift**. AWS SCT mostra tutte le impostazioni disponibili BigQuery per la conversione in Amazon Redshift.
BigQuery le impostazioni di conversione in Amazon Redshift AWS SCT includono le seguenti opzioni:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## BigQuery alle impostazioni di ottimizzazione delle conversioni di Amazon Redshift
BigQuery Per modificare le impostazioni di ottimizzazione delle conversioni in Amazon Redshift, seleziona **Impostazioni** in AWS SCT, quindi seleziona Impostazioni di **conversione**. Dall'elenco superiore, scegli **Google BigQuery**, quindi scegli **Google BigQuery — Amazon Redshift**. Nel riquadro a sinistra, scegli **Strategie di ottimizzazione**. AWS SCT visualizza le impostazioni di ottimizzazione della conversione BigQuery per la conversione in Amazon Redshift.
BigQuery alle impostazioni di ottimizzazione delle conversioni di Amazon Redshift nelle opzioni di AWS SCT inclusione per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione del database Greenplum con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Greenplum Database ad Amazon Redshift.
## Privilegi per il database Greenplum come fonte
I seguenti privilegi sono necessari per utilizzare Greenplum Database come fonte:
+ CONNETTITI AL DATABASE **
+ UTILIZZO SU SCHEMA **
+ SELEZIONA ON *.*
+ SELEZIONA IN SEQUENZA *.*
Nell'esempio precedente, sostituite i segnaposto come segue:
+ Sostituire *database\$1name* con il nome del database di origine.
+ Sostituire *schema\$1name* con il nome dello schema di origine.
+ Sostituire *table\$1name* con il nome della tabella di origine.
+ Sostituire *sequence\$1name* con il nome del nome della sequenza.
## Connessione al database Greenplum come fonte
Utilizza la seguente procedura per connetterti al tuo database di origine Greenplum con. AWS SCT
**Per connetterti al database di origine Greenplum**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi** fonte.
1. Scegli **SAP ASE**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le credenziali del database di origine Greenplum, utilizzate le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Greenplum.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di conversione da Greenplum ad Amazon Redshift
**Per modificare le impostazioni di conversione da Greenplum ad Amazon Redshift, **scegli Impostazioni AWS SCT in, quindi scegli** Impostazioni di conversione.** Dall'elenco in alto, scegli **Greenplum**, quindi scegli **Greenplum — Amazon** Redshift. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Greenplum ad Amazon Redshift.
Le impostazioni di conversione da Greenplum ad Amazon Redshift includono AWS SCT le seguenti opzioni:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione della conversione da Greenplum ad Amazon Redshift
**Per modificare le impostazioni di ottimizzazione delle conversioni da Greenplum ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi scegli Impostazioni di conversione.** Dall'elenco in alto, scegli **Greenplum**, quindi scegli **Greenplum — Amazon** Redshift. **Nel riquadro di sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Greenplum ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Greenplum ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione a Netezza con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Netezza ad Amazon Redshift.
## Privilegi per Netezza come fonte
I seguenti privilegi sono necessari per utilizzare Netezza come fonte:
+ seleziona nella vista system.definition\$1schema.system
+ seleziona nella tabella system.definition\$1schema.system
+ seleziona nella tabella system.definition\$1schema.management
+ elenco su **
+ elenco su **
+ elenco su ** .all.table
+ elenco nella tabella .all.external **
+ elenco su .all.view **
+ elenco su .all.materialized view **
+ elenco su ** .all.procedure
+ elenco su .all.sequence **
+ elenco su .all.function **
+ elenco su .all.aggregate **
Nell'esempio precedente, sostituite i segnaposto come segue:
+ Sostituire *database\$1name* con il nome del database di origine.
+ Sostituire *schema\$1name* con il nome dello schema di origine.
AWS SCT richiede l'accesso alle seguenti tabelle e viste di sistema. È possibile concedere l'accesso a questi oggetti anziché concedere l'accesso a `system.definition_schema.system view` e `system.definition_schema.system tables` nell'elenco precedente.
+ selezionate su system.definition\$1schema. \$1t\$1aggregate
+ seleziona su system.definition\$1schema. \$1t\$1class
+ seleziona su system.definition\$1schema. \$1t\$1constraint
+ seleziona su system.definition\$1schema. \$1t\$1const\$1relattr
+ seleziona su system.definition\$1schema. \$1t\$1database
+ seleziona su system.definition\$1schema. \$1t\$1grobj\$1priv
+ seleziona su system.definition\$1schema. \$1t\$1groupsr
+ seleziona su system.definition\$1schema. \$1t\$1hist\$1config
+ seleziona su system.definition\$1schema. \$1t\$1object
+ seleziona su system.definition\$1schema. \$1t\$1object\$1classes
+ seleziona su system.definition\$1schema. \$1t\$1proc
+ seleziona su system.definition\$1schema. \$1t\$1type
+ seleziona su system.definition\$1schema. \$1t\$1user
+ seleziona su system.definition\$1schema. \$1t\$1usrobj\$1priv
+ seleziona system.definition\$1schema. \$1vt\$1sequence
+ seleziona su system.definition\$1schema. \$1v\$1aggregate
+ seleziona su system.definition\$1schema. \$1v\$1constraint\$1depends
+ seleziona su system.definition\$1schema. \$1v\$1database
+ seleziona su system.definition\$1schema. \$1v\$1datatype
+ seleziona su system.definition\$1schema. \$1v\$1dslice
+ seleziona su system.definition\$1schema. \$1v\$1function
+ seleziona su system.definition\$1schema. \$1v\$1group
+ seleziona su system.definition\$1schema. \$1v\$1obj\$1relation
+ seleziona su system.definition\$1schema. \$1v\$1obj\$1relation\$1xdb
+ seleziona su system.definition\$1schema. \$1v\$1procedura
+ seleziona su system.definition\$1schema. \$1v\$1relation\$1column
+ seleziona su system.definition\$1schema. \$1v\$1relation\$1keydata
+ seleziona system.definition\$1schema. \$1v\$1relobjclasses
+ seleziona su system.definition\$1schema. \$1v\$1schema\$1xdb
+ seleziona su system.definition\$1schema. \$1v\$1sequenza
+ seleziona su system.definition\$1schema. \$1v\$1synonym
+ seleziona su system.definition\$1schema. \$1v\$1system\$1info
+ seleziona system.definition\$1schema. \$1v\$1sys\$1constraint
+ seleziona system.definition\$1schema. \$1v\$1sys\$1object\$1dslice\$1info
+ seleziona su system.definition\$1schema. \$1v\$1sys\$1user
+ seleziona su system.definition\$1schema. \$1v\$1table
+ seleziona su system.definition\$1schema. \$1v\$1table\$1constraint
+ seleziona system.definition\$1schema. \$1v\$1table\$1dist\$1map
+ seleziona su system.definition\$1schema. \$1v\$1table\$1organize\$1column
+ seleziona system.definition\$1schema. \$1v\$1table\$1storage\$1stat
+ seleziona system.definition\$1schema. \$1v\$1user
+ seleziona su system.definition\$1schema. \$1v\$1view
+ seleziona su system.information\$1schema. \$1v\$1relation\$1column
+ seleziona su system.information\$1schema. \$1v\$1table
+ seleziona su \$1hist\$1column\$1access\$1\$1
## Connessione a Netezza come sorgente
Utilizza la seguente procedura per connetterti al database di origine Netezza con AWS Schema Conversion Tool.
**Per connetterti a un database di origine Netezza**
1. Nel AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **Netezza**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al database di origine Netezza, utilizzate le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Netezza.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Configurazione della replica continua dei dati
Dopo aver convertito gli schemi del database Netezza e averli applicati al database Amazon Redshift, puoi migrare i dati con agenti di estrazione dei dati AWS SCT . L'agente estrae i tuoi dati e li carica nel tuo bucket Amazon S3. Puoi quindi utilizzarli AWS SCT per copiare i dati da Amazon S3 ad Amazon Redshift.
Se i dati nel database di origine cambiano durante il processo di migrazione, puoi acquisire le modifiche in corso con AWS SCT i tuoi agenti di estrazione dei dati. È quindi possibile replicare queste modifiche in corso nel database di destinazione dopo aver completato la migrazione iniziale dei dati. Questo processo è chiamato replica continua dei dati o *acquisizione dei dati di modifica* (CDC).
**Per configurare la replica continua dei dati per le migrazioni da Netezza ad Amazon Redshift**
1. Nel tuo database di origine, crea un database di cronologia. È possibile utilizzare il seguente esempio di codice nell'interfaccia a riga di comando (CLI) di Netezza.
```
nzhistcreatedb -d history_database_name -t query -v 1 -u load_user -o histdb_owner -p your_password
```
Nell'esempio precedente, sostituiscilo *history\$1database\$1name* con il nome del tuo database di cronologia. Quindi, sostituiscilo *load\$1user* con il nome dell'utente che hai definito per caricare i dati della cronologia nel database. Quindi, sostituiscili *histdb\$1owner* con il nome dell'utente che hai definito come proprietario del database di cronologia. Assicurati di aver già creato questo utente e di aver concesso l'`CREATE DATABASE`autorizzazione. Infine, *your\$1password* sostituiscilo con una password sicura.
1. Configura la registrazione della cronologia. A tale scopo, utilizzate il seguente esempio di codice.
```
CREATE HISTORY CONFIGURATION history_configuration_name HISTTYPE QUERY
DATABASE history_database_name USER load_user PASSWORD your_password COLLECT PLAN, COLUMN
LOADINTERVAL 1 LOADMINTHRESHOLD 0 LOADMAXTHRESHOLD 0 STORAGELIMIT 25
LOADRETRY 2 VERSION 1;
```
Nell'esempio precedente, sostituite *history\$1configuration\$1name* e *history\$1database\$1name* con i nomi della configurazione della cronologia e del database della cronologia. Quindi, sostituiscilo *load\$1user* con il nome dell'utente che hai definito per caricare i dati della cronologia nel database. Quindi, *your\$1password* sostituiscili con una password sicura.
1. Concedi le autorizzazioni di lettura per tutte le tabelle nel database di cronologia. È possibile utilizzare il seguente esempio di codice per concedere l'`SELECT`autorizzazione.
```
GRANT SELECT ON history_database_name.ALL.TABLE TO your_user;
```
Nell'esempio precedente, sostituiscilo *history\$1database\$1name* con il nome del tuo database di cronologia. Successivamente, *your\$1user* sostituiscilo con il nome dell'utente con le autorizzazioni minime per lavorare con il tuo database Netezza. Le credenziali di questo utente del database vengono utilizzate in. AWS SCT
1. Raccogli statistiche per ogni tabella del tuo schema di origine per ottenere informazioni sulla cardinalità delle colonne. È possibile utilizzare il seguente comando per generare statistiche nel database della cronologia.
```
GENERATE STATISTICS on "schema_name"."table_name";
```
Nell'esempio precedente, sostituite *schema\$1name* e *table\$1name* con il nome dello schema e della tabella del database.
1. Assicurati di aver completato i prerequisiti eseguendo la seguente query:
```
SELECT COUNT(*) FROM history_database_name.history_schema_name."$hist_column_access_N";
```
Nell'esempio precedente, sostituite *history\$1database\$1name* e *history\$1schema\$1name* con il nome del database e dello schema di cronologia. Quindi, *N* sostituiscilo con il numero di versione del tuo database di cronologia. Per ulteriori informazioni sulle versioni del database di cronologia, consulta la documentazione [IBM Netezza](https://www.ibm.com/docs/en/netezza?topic=history-database-versions).
1. Installa i tuoi agenti di estrazione dei dati. Per ulteriori informazioni, consulta [Installazione degli agenti di estrazione](agents.md#agents.Installing).
Assicurati che il `{working.folder}` parametro nel `settings.properties` file per tutte le istanze dell'estrattore punti alla stessa cartella. In questo caso, i vostri estrattori possono coordinare la sessione CDC e utilizzare un unico punto di transazione per tutte le sottoattività.
1. Registra il tuo agente di estrazione dei dati. Per ulteriori informazioni, consulta [Registrazione degli agenti di estrazione con AWS Schema Conversion Tool](agents.md#agents.Using).
1. Crea la tua attività CDC. Per ulteriori informazioni, consulta [Creazione, esecuzione e monitoraggio di qualsiasi AWS SCT attività](agents.md#agents.Tasks).
1. Apri il tuo progetto in AWS SCT. Nel riquadro a sinistra, scegli la tabella di origine. Apri il menu contestuale (fai clic con il pulsante destro del mouse) e scegli **Crea attività locale**.
1. In **Nome attività**, inserisci un nome descrittivo per l'attività di migrazione dei dati.
1. Per la **modalità di migrazione**, scegli **Estrai, carica e copia**.
1. Seleziona **Abilita CDC.**
1. Scegli la scheda **delle impostazioni CDC** e definisci l'ambito e la pianificazione delle sessioni CDC.
1. Scegli **Test task** per verificare che sia possibile connettersi alla cartella di lavoro, al bucket Amazon S3 e al data warehouse Amazon Redshift.
1. Scegli **Crea per creare** la tua attività.
1. Scegli la scheda **Attività**, scegli l'attività dall'elenco e scegli **Avvia**.
1. L' AWS SCT attività mantiene la coerenza transazionale nel database di destinazione. L'agente di estrazione dei dati replica le transazioni dall'origine nell'ordine degli ID delle transazioni.
Se si interrompe una delle sessioni di migrazione o se questa non riesce, si interrompe anche l'elaborazione CDC.
## Impostazioni di conversione da Netezza ad Amazon Redshift
Per modificare le impostazioni di conversione da Netezza ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi **scegli** Impostazioni di conversione. Dall'elenco superiore, scegli **Netezza**, quindi scegli **Netezza — Amazon Redshift**. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Netezza ad Amazon Redshift.
Le impostazioni AWS SCT di conversione da Netezza ad Amazon Redshift includono le seguenti opzioni:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione delle conversioni da Netezza ad Amazon Redshift
Per modificare le impostazioni di ottimizzazione delle conversioni da Netezza ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi **scegli** Impostazioni di conversione. Dall'elenco superiore, scegli **Netezza**, quindi scegli **Netezza — Amazon Redshift**. **Nel riquadro di sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Netezza ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Netezza ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connettere Oracle Data Warehouse con AWS SCT
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Oracle Data Warehouse ad Amazon Redshift o Amazon Redshift e utilizzarli in combinazione. AWS Glue
## Privilegi per Oracle Data Warehouse come fonte
I seguenti privilegi sono necessari per utilizzare Oracle Data Warehouse come fonte:
+ connect
+ select\$1catalog\$1role
+ select any dictionary
## Connessione a Oracle Data Warehouse come origine
Utilizza la seguente procedura per connetterti al database di origine del data warehouse Oracle con AWS Schema Conversion Tool.
**Per connettersi a un database di origine di Oracle Data Warehouse**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **Oracle**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al data warehouse di Oracle Source, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.OracleDW.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di conversione da Oracle Data Warehouse ad Amazon Redshift
Per modificare le impostazioni di conversione da Oracle Data Warehouse ad Amazon Redshift, scegli **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco superiore, scegli **Oracle**, quindi scegli **Oracle — Amazon Redshift**. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Oracle Data Warehouse ad Amazon Redshift.
Le impostazioni di conversione da Oracle Data Warehouse ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per convertire le funzioni di formattazione dei tipi di dati come `TO_CHAR` e `TO_NUMBER` con elementi di formato datetime che Amazon Redshift non supporta. `TO_DATE` Per impostazione predefinita, AWS SCT utilizza le funzioni del pacchetto di estensione per emulare l'uso di questi elementi di formato non supportati nel codice convertito.
Il modello di formato datetime di Oracle include più elementi rispetto alle stringhe di formato datetime di Amazon Redshift. Se il codice sorgente include solo elementi in formato datetime supportati da Amazon Redshift, non sono necessarie le funzioni del pacchetto di estensione nel codice convertito. Per evitare di utilizzare le funzioni del pacchetto di estensione nel codice convertito, seleziona **gli elementi di formato Datetype che usi nel codice Oracle sono simili alle stringhe di formato datetime in Amazon** Redshift. In questo caso, il codice convertito funziona più velocemente.
Il modello di formato numerico di Oracle include più elementi rispetto alle stringhe in formato numerico di Amazon Redshift. Se il codice sorgente include solo elementi in formato numerico supportati da Amazon Redshift, non sono necessarie le funzioni del pacchetto di estensione nel codice convertito. Per evitare di utilizzare le funzioni del pacchetto di estensione nel codice convertito, seleziona **Gli elementi di formato numerico utilizzati nel codice Oracle sono simili alle stringhe di formato numerico in Amazon Redshift**. In questo caso, il codice convertito funziona più velocemente.
+ Per convertire funzioni Oracle `LEAD` e analitiche. `LAG` Per impostazione predefinita, AWS SCT genera un'azione per ogni funzione`LEAD`. `LAG`
Quando il codice sorgente non utilizza i valori predefiniti per l'offset in queste funzioni, AWS SCT può emulare l'utilizzo di queste funzioni con la funzione. `NVL` A tale scopo, seleziona **Usa la funzione NVL per emulare il comportamento delle funzioni Oracle LEAD** e LAG.
+ Per emulare il comportamento delle chiavi primarie e univoche nel tuo cluster Amazon Redshift, **seleziona Emula il comportamento delle chiavi primarie** e uniche.
Amazon Redshift non impone chiavi uniche e primarie e le utilizza solo a scopo informativo. Se utilizzi questi vincoli nel codice, assicurati che il loro comportamento venga AWS SCT emulato nel codice convertito.
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione delle conversioni da Oracle Data Warehouse ad Amazon Redshift
Per modificare le impostazioni di ottimizzazione delle conversioni da Oracle Data Warehouse ad Amazon Redshift, scegli **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco superiore, scegli **Oracle**, quindi scegli **Oracle — Amazon Redshift**. Nel riquadro a sinistra, scegli **Strategie di ottimizzazione**. AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Oracle Data Warehouse ad Amazon Redshift.
Le impostazioni di ottimizzazione della conversione da Oracle Data Warehouse ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione a un data warehouse Snowflake con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Snowflake ad Amazon Redshift.
## Privilegi per Snowflake come database di origine
È possibile creare un ruolo con privilegi e assegnare a questo ruolo il nome di un utente utilizzando il `SECURITYADMIN` ruolo e il contesto della sessione. `SECURITYADMIN`
L'esempio seguente crea privilegi minimi e li concede all'utente. `min_privs`
```
create role role_name;
grant role role_name to role sysadmin;
grant usage on database db_name to role role_name;
grant usage on schema db_name.schema_name to role role_name;
grant usage on warehouse datawarehouse_name to role role_name;
grant monitor on database db_name to role role_name;
grant monitor on warehouse datawarehouse_name to role role_name;
grant select on all tables in schema db_name.schema_name to role role_name;
grant select on future tables in schema db_name.schema_name to role role_name;
grant select on all views in schema db_name.schema_name to role role_name;
grant select on future views in schema db_name.schema_name to role role_name;
grant select on all external tables in schema db_name.schema_name to role role_name;
grant select on future external tables in schema db_name.schema_name to role role_name;
grant usage on all sequences in schema db_name.schema_name to role role_name;
grant usage on future sequences in schema db_name.schema_name to role role_name;
grant usage on all functions in schema db_name.schema_name to role role_name;
grant usage on future functions in schema db_name.schema_name to role role_name;
grant usage on all procedures in schema db_name.schema_name to role role_name;
grant usage on future procedures in schema db_name.schema_name to role role_name;
create user min_privs password='real_user_password'
DEFAULT_ROLE = role_name DEFAULT_WAREHOUSE = 'datawarehouse_name';
grant role role_name to user min_privs;
```
Nell'esempio precedente, sostituite i segnaposto come segue:
+ Sostituire *`role_name`* con il nome di un ruolo con privilegi di sola lettura.
+ Sostituire `db_name` con il nome del database di origine.
+ Sostituire `schema_name` con il nome dello schema di origine.
+ Sostituisci *`datawarehousename`* con il nome di un data warehouse richiesto.
+ Sostituisci `min_privs` con il nome di un utente con privilegi minimi.
I `DEFAULT_WAREHOUSE` parametri `DEFAULT_ROLE` and sono sensibili ai tasti.
## Configurazione dell'accesso sicuro ad Amazon S3
Le politiche di sicurezza e gestione degli accessi per un bucket Amazon S3 consentono a Snowflake di accedere, leggere e scrivere dati nel bucket S3. Puoi configurare l'accesso sicuro a un bucket Amazon S3 privato utilizzando il tipo di oggetto `STORAGE INTEGRATION` Snowflake. Un oggetto di integrazione dello storage Snowflake delega la responsabilità di autenticazione a un'entità di gestione delle identità e degli accessi Snowflake.
Per ulteriori informazioni, consulta [Configurazione di un'integrazione di storage Snowflake per accedere ad Amazon S3 nella documentazione di Snowflake](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html).
## Connessione a Snowflake come sorgente
Utilizzare la procedura seguente per connettersi al database di origine con. AWS Schema Conversion Tool
**Per connettersi a un database di origine Snowflake**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi** fonte.
1. **Scegli **Snowflake**, quindi scegli Avanti.**
Viene visualizzata la finestra **di dialogo Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al data warehouse di origine Snowflake, utilizzate le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Snowflake.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Limitazioni per Snowflake come fonte
Di seguito sono riportate le limitazioni relative all'utilizzo di Snowflake come fonte per: AWS SCT
+ Gli identificatori di oggetto devono essere univoci nel contesto del tipo di oggetto e dell'oggetto principale:
**Database**
Gli identificatori dello schema devono essere univoci all'interno di un database.
**Schemi**
Gli identificatori di oggetti, ad esempio per tabelle e viste, devono essere univoci all'interno di uno schema.
**Tabelle/viste**
Gli identificatori di colonna devono essere univoci all'interno di una tabella.
+ Il numero massimo di tabelle per i tipi di nodi cluster large e xlarge è 9.900. Per i tipi di nodi di cluster di dimensioni 8xlarge, il numero massimo di tabelle è 100.000. Il limite include tabelle temporanee, definite dall'utente e create da Amazon Redshift durante l'elaborazione delle query o la manutenzione del sistema. Per informazioni, consultare [Quote di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione dei cluster Amazon Redshift*.
+ Per le stored procedure, il numero massimo di argomenti di input e output è 32.
## Tipi di dati di origine per Snowflake
Di seguito, puoi trovare i tipi di dati di origine Snowflake supportati durante l'utilizzo AWS SCT e la mappatura predefinita su un target Amazon Redshift.
| Tipi di dati Snowflake | Tipi di dati Amazon Redshift |
| --- | --- |
| NUMBER | NUMERICO (38) |
| NUMBER(p) | Se p è =< 4, allora SMALLINT Se p è => 5 e =< 9, allora INTEGER Se p è => 10 e =< 18, allora BIGINT Se p è => 19 allora NUMERIC (p) |
| NUMERO (p, 0) | Se p è =< 4, allora SMALLINT Se p è => 5 e =< 9, allora INTEGER Se p è => 10 e =< 18, allora BIGINT Se p è => 19 allora: NUMERIC (p,0) |
| NUMERO (p, s) | Se p è => 1 e =< 38 e se s è => 1 e =< 37, allora NUMERIC(p,s) |
| FLOAT | FLOAT |
| TEXT Caratteri Unicode fino a 16.777.216 byte; fino a 4 byte per carattere. | VARCHAR(MAX) |
| TESTO (p) Caratteri Unicode fino a 65.535 byte; fino a 4 byte per carattere. | Se p è =< 65.535 allora, VARCHAR (p) |
| TESTO (p) Caratteri Unicode fino a 16.777.216 byte; fino a 4 byte per carattere. | Se p è => 65.535 e =< 16.777.216 allora, VARCHAR (MAX) |
| BINARY Caratteri a byte singolo fino a 8.388.608 byte; 1 byte per carattere. | VARCHAR(MAX) |
| BINARIO (p) Caratteri a byte singolo fino a 65.535 byte; 1 byte per carattere. | VARCHAR (p) |
| BINARIO (p) Caratteri a byte singolo fino a 8.388.608 byte; 1 byte per carattere. | VARCHAR(MAX) |
| BOOLEAN | BOOLEAN |
| DATE | DATE |
| TIME Valori temporali compresi tra 00:00:00 e 23:59:59.999 999999. | VARCHAR(18) |
| ORA (f) Valori temporali compresi tra 00:00:00 e 23:59:59.9 (f). | VARCHAR (n) — 9\$1 dt-attr-1 |
| TIMESTAMP\$1NTZ | TIMESTAMP |
| TIMESTAMP\$1TZ | TIMESTAMPTZ |
## Impostazioni di conversione da Snowflake ad Amazon Redshift
**Per modificare le impostazioni di conversione da Snowflake ad Amazon Redshift, **scegli Impostazioni AWS SCT in, quindi scegli** Impostazioni di conversione.** Dall'elenco superiore, scegli **Snowflake**, quindi scegli **Snowflake — Amazon** Redshift. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Snowflake ad Amazon Redshift.
Le impostazioni AWS SCT di conversione da Snowflake ad Amazon Redshift includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione delle conversioni da Snowflake ad Amazon Redshift
**Per modificare le impostazioni di ottimizzazione delle conversioni da Snowflake ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi scegli Impostazioni di conversione.** Dall'elenco superiore, scegli **Snowflake**, quindi scegli **Snowflake — Amazon** Redshift. **Nel riquadro a sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Snowflake ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Snowflake ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione a un data warehouse di SQL Server con AWS Schema Conversion Tool
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Microsoft SQL Server DW ad Amazon Redshift o Amazon Redshift e utilizzarli in combinazione. AWS Glue
## Privilegi per Microsoft SQL Server Data Warehouse come origine
I seguenti privilegi sono necessari per utilizzare il data warehouse di Microsoft SQL Server come origine:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
+ SELEZIONA UNO SCHEMA: **
Nell'esempio precedente, sostituisci il ** segnaposto con il nome dell'origine source\$1schema.
Ripeti l'assegnazione per ogni database di cui desideri convertire lo schema.
Inoltre, concedere i seguenti privilegi ed eseguire l'assegnazione per il database master:
+ VIEW SERVER STATE
## Limitazioni per SQL Server Data Warehouse come origine
L'utilizzo di Microsoft SQL Server Parallel Data Warehouse (PDW) come origine non è attualmente supportato.
## Connessione a SQL Server Data Warehouse come origine
Utilizzare la procedura seguente per connettersi al database di origine di SQL Server Data Warehouse con AWS Schema Conversion Tool.
**Per connettersi a un database di origine di SQL Server Data Warehouse**
1. Nella AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **Microsoft SQL Server**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni sulla connessione del data warehouse di origine di Microsoft SQL Server, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServerDW.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di conversione da SQL Server Data Warehouse ad Amazon Redshift
Per modificare le impostazioni di conversione da SQL Server Data Warehouse ad Amazon Redshift, scegli **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco superiore, scegli **Microsoft SQL Server**, quindi scegli **Microsoft SQL Server — Amazon Redshift**. AWS SCT visualizza tutte le impostazioni disponibili per la conversione da SQL Server Data Warehouse ad Amazon Redshift.
Le impostazioni di conversione da SQL Server Data Warehouse ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione della conversione da SQL Server Data Warehouse ad Amazon Redshift
Per modificare le impostazioni di ottimizzazione delle conversioni da SQL Server Data Warehouse ad Amazon Redshift, scegli **Impostazioni** in AWS SCT, quindi scegli Impostazioni di **conversione**. Dall'elenco superiore, scegli **Microsoft SQL Server**, quindi scegli **Microsoft SQL Server — Amazon Redshift**. Nel riquadro di sinistra, scegli **Strategie di ottimizzazione**. AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da SQL Server Data Warehouse ad Amazon Redshift.
Le impostazioni di ottimizzazione della conversione da SQL Server Data Warehouse ad Amazon Redshift AWS SCT includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione a un Data Warehouse Teradata con AWS Schema Conversion Tool
È possibile utilizzarli AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Teradata ad Amazon Redshift o Amazon Redshift e utilizzarli in combinazione. AWS Glue
## Privilegi per Teradata come fonte
I seguenti privilegi sono necessari per utilizzare Teradata come fonte:
+ SELECT ON DBC
+ SELEZIONA SU SYSUDTLIB
+ SELEZIONA SU SYSLIB
+ SELEZIONA ON **
+ CREA PROCEDURA SU **
Nell'esempio precedente, sostituite il ** segnaposto con il nome del database di origine.
AWS SCT richiede il privilegio CREATE PROCEDURE per eseguire HELP PROCEDURE su tutte le procedure nel database di origine. AWS SCT non utilizza questo privilegio per creare nuovi oggetti nel database Teradata di origine.
## Connessione a Teradata come fonte
Utilizza la seguente procedura per connetterti al database di origine Teradata con AWS Schema Conversion Tool.
**Per connetterti a un database di origine Teradata**
1. Nel AWS Schema Conversion Tool, scegli **Aggiungi** fonte.
1. **Scegli **Teradata**, quindi scegli Avanti.**
Viene visualizzata la finestra **di dialogo Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al database di origine Teradata, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
### Utilizzo dell'autenticazione LDAP con una fonte Teradata
Per configurare l'autenticazione del Lightweight Directory Access Protocol (LDAP) per gli utenti Teradata che eseguono Microsoft Active Directory in Windows, utilizza la seguente procedura.
Nella procedura seguente, il dominio Active Directory è. `test.local.com` Il server Windows è `DC` configurato con le impostazioni predefinite. Lo script seguente crea l'account `test_ldap` Active Directory e questo account utilizza la `test_ldap` password.
**Per configurare l'autenticazione LDAP per gli utenti Teradata che eseguono Microsoft Active Directory in Windows**
1. Nella directory `/opt/teradata/tdat/tdgss/site`, modifica il file `TdgssUserConfigFile.xml` . Modifica la sezione LDAP come indicato di seguito.
```
AuthorizationSupported="no"
LdapServerName="DC.test.local.com"
LdapServerPort="389"
LdapServerRealm="test.local.com"
LdapSystemFQDN="dc= test, dc= local, dc=com"
LdapBaseFQDN="dc=test, dc=local, dc=com"
```
1. Applica le modifiche eseguendo la configurazione come indicato di seguito.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Testa la configurazione eseguendo il seguente comando.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
L’output visualizzato dovrebbe essere simile al seguente.
```
LdapGroupBaseFQDN: dc=Test, dc=local, dc=com
LdapUserBaseFQDN: dc=Test, dc=local, dc=com
LdapSystemFQDN: dc= test, dc= local, dc=com
LdapServerName: DC.test.local.com
LdapServerPort: 389
LdapServerRealm: test.local.com
LdapClientUseTls: no
LdapClientTlsReqCert: never
LdapClientMechanism: SASL/DIGEST-MD5
LdapServiceBindRequired: no
LdapClientTlsCRLCheck: none
LdapAllowUnsafeServerConnect: yes
UseLdapConfig: no
AuthorizationSupported: no
FQDN: CN=test, CN=Users, DC=Anthem, DC=local, DC=com
AuthUser: ldap://DC.test.local.com:389/CN=test1,CN=Users,DC=test,DC=local,DC=com
DatabaseName: test
Service: tdsbind
```
1. Riavvia TPA utilizzando il seguente comando.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Crea lo stesso utente nel database Teradata e in Active Directory, come illustrato di seguito.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Se si modifica la password utente in Active Directory per il proprio utente LDAP, specificare questa nuova password durante la connessione a Teradata in modalità LDAP. In modalità DEFAULT, ci si connette a Teradata utilizzando il nome utente LDAP e qualsiasi password.
## Configurazione della raccolta di statistiche nel data warehouse Teradata di origine
Per convertire il data warehouse Teradata di origine, AWS SCT utilizza le statistiche per ottimizzare il data warehouse Amazon Redshift convertito. Puoi raccogliere statistiche AWS SCT o caricare il file delle statistiche. Per ulteriori informazioni, consulta [Raccolta o caricamento di statistiche](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Per assicurarti che sia AWS SCT possibile raccogliere statistiche dal tuo data warehouse, completa le seguenti attività preliminari.
**Per raccogliere statistiche dal tuo data warehouse Teradata**
1. Esegui la seguente query per raccogliere le statistiche per tutte le tabelle del tuo data warehouse.
```
collect summary statistics on table_name;
```
Nell'esempio precedente, sostituiscilo *table\$1name* con il nome della tabella di origine. Ripeti l'interrogazione per ogni tabella che converti.
1. Esegui la seguente query per determinare la stringa dell'account per l'utente, da utilizzare per convertire il data warehouse.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Attiva la registrazione delle query per un utente specifico utilizzando la stringa dell'account dell'esempio precedente.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
In alternativa, attiva la registrazione delle query per tutti gli utenti del database.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Dopo aver completato la raccolta delle statistiche del data warehouse, disattiva la registrazione delle query. A tale scopo, è possibile utilizzare il seguente esempio di codice.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Raccolta di statistiche in modalità offline dal data warehouse Teradata di origine
Dopo aver configurato la raccolta delle statistiche nel data warehouse Teradata, puoi raccogliere statistiche nel tuo AWS SCT progetto. In alternativa, è possibile utilizzare gli script Basic Teradata Query (BTEQ) per raccogliere statistiche in modalità offline. Quindi, puoi caricare i file con le statistiche raccolte nel tuo progetto. AWS SCT Per ulteriori informazioni, consulta [Raccolta o caricamento di statistiche](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Per raccogliere statistiche dal data warehouse Teradata in modalità offline**
1. Crea lo `off-line_stats.bteq` script con il seguente contenuto.
```
.OS IF EXIST column-stats-tera.csv del /F column-stats-tera.csv
.OS IF EXIST table-stats-tera.csv del /F table-stats-tera.csv
.OS IF EXIST column-skew-script-tera.csv del /F column-skew-script-tera.csv
.OS IF EXIST column-skew-stats-tera.csv del /F column-skew-stats-tera.csv
.OS IF EXIST query-stats-tera.csv del /F query-stats-tera.csv
.LOGON your_teradata_server/your_login, your_password
.EXPORT REPORT FILE = table-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'"' || OREPLACE(COALESCE(c.DatabaseName, ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(c.TableName, ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(s.reference_count, '0')) || '";' ||
'"' || TRIM(COALESCE(CAST(p.RowCount AS BIGINT), '0')) || '";' ||
'"' || CAST(CAST(w.size_in_mb AS DECIMAL (38,1) FORMAT 'Z9.9') AS VARCHAR(38)) || '";' ||
'"' || TRIM(COALESCE(r.stat_fk_dep_count, '0')) || '";' ||
'"' || CAST(CAST(current_timestamp(0) as timestamp(0) format 'YYYY-MM-DDBHH:MI:SS') as VARCHAR(19)) || '"'
(TITLE '"database_name";"table_name";"reference_count";"row_count";"size_in_mb";"stat_fk_dep_count";"current_ts"')
FROM (select databasename, tablename
from DBC.tablesv
where tablekind IN ('T','O')
and databasename = 'your_database_name'
) c
left join
(select DatabaseName, TableName, max(RowCount) RowCount
from dbc.tableStatsv
group by 1,2)p
on p.databasename = c.databasename
and p.tablename = c.tablename
left join
(SELECT r.ChildDB as DatabaseName,
r.ChildTable as TableName,
COUNT(DISTINCT r.ParentTable) reference_count
FROM DBC.All_RI_ChildrenV r
GROUP BY r.ChildDB, r.ChildTable) s
on s.databasename = c.databasename
and s.tablename = c.tablename
left join
(SELECT r.ParentDB as DatabaseName,
r.ParentTable as TableName,
COUNT(DISTINCT r.ChildTable) stat_fk_dep_count
FROM DBC.All_RI_ParentsV r
GROUP BY r.ParentDB, r.ParentTable) r
on r.databasename = c.databasename
and r.tablename = c.tablename
left join
(select databasename, tablename,
sum(currentperm)/1024/1024 as size_in_mb
from dbc.TableSizeV
group by 1,2) w
on w.databasename = c.databasename
and w.tablename = c.tablename
WHERE COALESCE(r.stat_fk_dep_count,0) + COALESCE(CAST(p.RowCount AS BIGINT),0) + COALESCE(s.reference_count,0) > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
SELECT
'"' || OREPLACE(COALESCE(trim(tv.DatabaseName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.TableName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.columnname), ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
'"' || CAST(current_timestamp AS VARCHAR(19)) || '"' (TITLE '"database_name";"table_name";"column_name";"cardinality";"current_ts"')
FROM dbc.columnsv tv
LEFT JOIN
(
SELECT
c.DatabaseName AS DATABASE_NAME,
c.TABLENAME AS TABLE_NAME,
c.ColumnName AS COLUMN_NAME,
c.UniqueValueCount AS CARD
FROM dbc.tablestatsv c
WHERE c.DatabaseName = 'your_database_name'
AND c.RowCount <> 0
) t2
ON tv.DATABASENAME = t2.DATABASE_NAME
AND tv.TABLENAME = t2.TABLE_NAME
AND tv.COLUMNNAME = t2.COLUMN_NAME
WHERE t2.card > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-script-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'SELECT CAST(''"' || TRIM(c.DatabaseName) || '";"' || TRIM(c.TABLENAME) || '";"' || TRIM(c.COLUMNNAME) || '";"'' ||
TRIM(CAST(COALESCE(MAX(cnt) * 1.0 / SUM(cnt), 0) AS NUMBER FORMAT ''9.9999'')) || ''";"'' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || ''"'' AS VARCHAR(512))
AS """DATABASE_NAME"";""TABLE_NAME"";""COLUMN_NAME"";""SKEWED"";""CURRENT_TS"""
FROM(
SELECT COUNT(*) AS cnt
FROM "' || c.DATABASENAME || '"."' || c.TABLENAME ||
'" GROUP BY "' || c.COLUMNNAME || '") t' ||
CASE WHEN ROW_NUMBER() OVER(PARTITION BY c.DATABASENAME
ORDER BY c.TABLENAME DESC, c.COLUMNNAME DESC) <> 1
THEN ' UNION ALL'
ELSE ';' END (TITLE '--SKEWED--')
FROM dbc.columnsv c
INNER JOIN
(SELECT databasename, TABLENAME
FROM dbc.tablesv WHERE tablekind = 'T'
AND databasename = 'your_database_name') t
ON t.databasename = c.databasename
AND t.TABLENAME = c.TABLENAME
INNER JOIN
(SELECT databasename, TABLENAME, columnname FROM dbc.indices GROUP BY 1,2,3
WHERE TRANSLATE_CHK (databasename USING LATIN_TO_UNICODE) + TRANSLATE_CHK (TABLENAME USING LATIN_TO_UNICODE) + TRANSLATE_CHK (columnname USING LATIN_TO_UNICODE) = 0
) i
ON i.databasename = c.databasename
AND i.TABLENAME = c.TABLENAME
AND i.columnname = c.columnname
WHERE c.ColumnType NOT IN ('CO','JN','N','++','VA','UT','AN','XM','A1','BO')
ORDER BY c.TABLENAME, c.COLUMNNAME;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
.RUN FILE = column-skew-script-tera.csv
.EXPORT RESET
.EXPORT REPORT FILE = query-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 32000
SELECT
'"' || RTRIM(CAST(SqlTextInfo AS VARCHAR(31900)), ';') || '";"' ||
TRIM(QueryCount) || '";"' ||
TRIM(QueryId) || '";"' ||
TRIM(SqlRowNo) || '";"' ||
TRIM(QueryParts) || '";"' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || '"'
(TITLE '"query_text";"query_count";"query_id";"sql_row_no";"query_parts";"current_ts"')
FROM
(
SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
SUM(QueryFirstRow) OVER (ORDER BY QueryCount DESC, QueryId ASC, SqlRowNo ASC
ROWS UNBOUNDED PRECEDING) AS topN
FROM
(SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
CASE WHEN
ROW_NUMBER() OVER (PARTITION BY QueryCount, SqlTextInfo ORDER BY QueryId, SqlRowNo) = 1 AND SqlRowNo = 1
THEN 1 ELSE 0 END AS QueryFirstRow
FROM (
SELECT q.QueryId, q.SqlTextInfo, q.SqlRowNo,
MAX(q.SqlRowNo) OVER (PARTITION BY q.QueryId) QueryParts,
COUNT(q.SqlTextInfo) OVER (PARTITION BY q.SqlTextInfo) QueryCount
FROM DBC.dbqlsqltbl q
INNER JOIN
(
SELECT QueryId
FROM DBC.DBQLogTbl t
WHERE TRIM(t.StatementType) IN ('SELECT')
AND TRIM(t.AbortFlag) = '' AND t.ERRORCODE = 0
AND (CASE WHEN 'All users' IN ('All users') THEN 'All users' ELSE TRIM(t.USERNAME) END) IN ('All users') --user_name list
AND t.StartTime > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) t
ON q.QueryId = t.QueryId
INNER JOIN
(
SELECT QueryId
FROM DBC.QryLogObjectsV
WHERE ObjectDatabaseName = 'your_database_name'
AND ObjectType = 'Tab'
AND CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) r
ON r.QueryId = t.QueryId
WHERE q.CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
) t
) t
WHERE SqlTextInfo NOT LIKE '%";"%'
) q
WHERE
QueryParts >=1
AND topN <= 50
ORDER BY QueryCount DESC, QueryId, SqlRowNo
QUALIFY COUNT(QueryId) OVER (PARTITION BY QueryId) = QueryParts;
.EXPORT RESET
.LOGOFF
.QUIT
```
1. Create il `td_run_bteq.bat` file che esegue lo script BTEQ creato nel passaggio precedente. Utilizza il seguente contenuto per questo file.
```
@echo off > off-line_stats1.bteq & setLocal enableDELAYedexpansion
@echo off > off-line_stats2.bteq & setLocal enableDELAYedexpansion
set old1=your_teradata_server
set new1=%1
set old2=your_login
set new2=%2
set old3=your_database_name
set new3=%3
set old4=your_password
set /p new4=Input %2 pass?
for /f "tokens=* delims= " %%a in (off-line_stats.bteq) do (
set str1=%%a
set str1=!str1:%old1%=%new1%!
>> off-line_stats1.bteq echo !str1!
)
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str2=%%a
set str2=!str2:%old2%=%new2%!
>> off-line_stats2.bteq echo !str2!
)
type nul > off-line_stats1.bteq
for /f "tokens=* delims= " %%a in (off-line_stats2.bteq) do (
set str3=%%a
set str3=!str3:%old3%=%new3%!
>> off-line_stats1.bteq echo !str3!
)
type nul > off-line_stats2.bteq
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str4=%%a
set str4=!str4:%old4%=%new4%!
>> off-line_stats2.bteq echo !str4!
)
del .\off-line_stats1.bteq
echo export starting...
bteq -c UTF8 < off-line_stats.bteq > metadata_export.log
pause
```
1. Crea il `runme.bat` file che esegue il file batch creato nel passaggio precedente. Utilizza il seguente contenuto per questo file.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
Nel `runme.bat` file *ServerName**UserName*, sostituisci e *DatabaseName* con i valori applicabili.
Quindi, esegui il `runme.bat` file. Ripeti questo passaggio per ogni data warehouse convertito in Amazon Redshift.
Dopo aver eseguito questo script, ricevi tre file con statistiche per ogni database. Puoi caricare questi file nel tuo AWS SCT progetto. Per farlo, scegli il tuo data warehouse dal pannello di sinistra del progetto e apri il menu contestuale (fai clic con il pulsante destro del mouse). Scegli **Statistiche di caricamento**.
## Impostazioni di conversione da Teradata ad Amazon Redshift
**Per modificare le impostazioni di conversione da Teradata ad Amazon Redshift, **scegli Impostazioni AWS SCT in, quindi scegli** Impostazioni di conversione.** Dall'elenco in alto, scegli **Teradata**, quindi scegli **Teradata — Amazon** Redshift. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Teradata ad Amazon Redshift.
Le impostazioni AWS SCT di conversione da Teradata ad Amazon Redshift includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
+ Per utilizzare un elenco esplicito di colonne nel codice convertito per le `SELECT *` istruzioni, seleziona **Usa dichiarazione esplicita** di colonna.
+ Per emulare il comportamento delle chiavi primarie e univoche nel tuo cluster Amazon Redshift, **seleziona Emula il comportamento delle chiavi primarie** e uniche.
Amazon Redshift non impone chiavi uniche e primarie e le utilizza solo a scopo informativo. Se utilizzi questi vincoli nel codice, assicurati che il loro comportamento venga AWS SCT emulato nel codice convertito.
+ Per garantire l'unicità dei dati nelle tabelle Amazon Redshift di destinazione. Per farlo, seleziona **Emula il comportamento delle tabelle SET**.
Teradata crea tabelle utilizzando l'elemento di `SET` sintassi come opzione predefinita. Non è possibile aggiungere righe duplicate in una tabella. `SET` Se il codice sorgente non utilizza questo vincolo di unicità, disattiva questa opzione. In questo caso, il codice convertito funziona più velocemente.
Se il codice sorgente utilizza l'`SET`opzione nelle tabelle come vincolo di unicità, attiva questa opzione. In questo caso, AWS SCT riscrive `INSERT..SELECT` le istruzioni nel codice convertito per emulare il comportamento del database di origine.
## Impostazioni di ottimizzazione della conversione da Teradata ad Amazon Redshift
**Per modificare le impostazioni di ottimizzazione delle conversioni da Teradata ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi scegli Impostazioni di conversione.** Dall'elenco in alto, scegli **Teradata**, quindi scegli **Teradata — Amazon** Redshift. **Nel riquadro di sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Teradata ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Teradata ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
# Connessione dei AWS Schema Conversion Tool database a Vertica
Puoi utilizzarlo AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Vertica ad Amazon Redshift.
## Privilegi per Vertica come fonte
I seguenti privilegi sono necessari per utilizzare Vertica come fonte:
+ UTILIZZO SU SCHEMA **
+ USAGE ON SCHEMA PUBLIC
+ SELEZIONA SU TUTTE LE TABELLE DELLO SCHEMA **
+ SELEZIONA SU TUTTE LE SEQUENZE DELLO SCHEMA **
+ ESEGUI SU TUTTE LE FUNZIONI DELLO SCHEMA **
+ ESEGUI SULLA PROCEDURA **
Nell'esempio precedente, sostituite i segnaposto come segue:
+ Sostituire *schema\$1name* con il nome dello schema di origine.
+ Sostituire *procedure\$1name* con il nome di una procedura di origine. Ripeti la concessione per ogni procedura che stai convertendo.
+ Sostituisci *procedure\$1signature* con l'elenco delimitato da virgole dei tipi di argomenti della procedura.
## Connessione a Vertica come sorgente
Utilizza la seguente procedura per connetterti al database di origine Vertica con AWS Schema Conversion Tool.
**Per connetterti a un database di origine Vertica**
1. Nel AWS Schema Conversion Tool, scegli **Aggiungi fonte**.
1. Scegli **Vertica**, quindi scegli **Avanti**.
Viene visualizzata la finestra di dialogo **Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni sulla connessione al database di origine Vertica, utilizzare le seguenti istruzioni:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Vertica.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
## Impostazioni di conversione da Vertica ad Amazon Redshift
Per modificare le impostazioni di conversione da Vertica ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi **scegli** Impostazioni di conversione. Dall'elenco superiore, scegli **Vertica**, quindi scegli **Vertica — Amazon Redshift**. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Vertica ad Amazon Redshift.
Le impostazioni AWS SCT di conversione da Vertica ad Amazon Redshift includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
## Impostazioni di ottimizzazione della conversione da Vertica ad Amazon Redshift
Per modificare le impostazioni di ottimizzazione delle conversioni da Vertica ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi **scegli** Impostazioni di conversione. Dall'elenco superiore, scegli **Vertica**, quindi scegli **Vertica — Amazon Redshift**. **Nel riquadro a sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Vertica ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Vertica ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.