Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# 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.