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à. # Modifica le applicazioni Python e Perl per supportare la migrazione dei database da Microsoft SQL Server a Amazon Aurora PostgreSQL Compatible Edition *Dwarika Patra e Deepesh Jayaprakash, Amazon Web Services* ## Riepilogo Questo modello descrive le modifiche ai repository delle applicazioni che potrebbero essere necessarie durante la migrazione dei database da Microsoft SQL Server a Amazon Aurora PostgreSQL Compatible Edition. Il modello presuppone che queste applicazioni siano basate su Python o su Perl e fornisce istruzioni separate per questi linguaggi di scripting. La migrazione dei database di SQL Server verso la compatibilità con Aurora PostgreSQL comporta la conversione dello schema, la conversione degli oggetti del database, la migrazione dei dati e il caricamento dei dati. A causa delle differenze tra PostgreSQL e SQL Server (relative ai tipi di dati, agli oggetti di connessione, alla sintassi e alla logica), l'attività di migrazione più difficile consiste nell'apportare le modifiche necessarie alla base di codice in modo che funzioni correttamente con PostgreSQL. Per un'applicazione basata su Python, gli oggetti e le classi di connessione sono sparsi in tutto il sistema. Inoltre, la base di codice Python potrebbe utilizzare più librerie per connettersi al database. Se l'interfaccia di connessione al database cambia, anche gli oggetti che eseguono le query in linea dell'applicazione richiedono modifiche. Per un'applicazione basata su Perl, le modifiche riguardano oggetti di connessione, driver di connessione al database, istruzioni SQL in linea statiche e dinamiche e il modo in cui l'applicazione gestisce query DML dinamiche complesse e set di risultati. Quando esegui la migrazione della tua applicazione, puoi anche prendere in considerazione possibili miglioramenti su AWS, come la sostituzione del server FTP con l'accesso ad Amazon Simple Storage Service (Amazon S3). Il processo di migrazione delle applicazioni comporta le seguenti sfide: + Oggetti di connessione. Se gli oggetti di connessione sono sparsi nel codice con più librerie e chiamate di funzioni, potrebbe essere necessario trovare un modo generalizzato per modificarli per supportare PostgreSQL. + Gestione degli errori o delle eccezioni durante il recupero o l'aggiornamento dei record. Se sul database sono presenti operazioni condizionali di creazione, lettura, aggiornamento ed eliminazione (CRUD) che restituiscono variabili, set di risultati o frame di dati, eventuali errori o eccezioni potrebbero causare errori di applicazione con effetti a cascata. Queste devono essere gestite con cura con convalide e punti di salvataggio adeguati. Uno di questi punti di salvataggio consiste nel richiamare query SQL in linea di grandi dimensioni o oggetti di database all'interno di blocchi. `BEGIN...EXCEPTION...END` + Controllo delle transazioni e loro convalida. Questi includono commit e rollback manuali e automatici. Il driver PostgreSQL per Perl richiede di impostare sempre in modo esplicito l'attributo auto-commit. + Gestione di query SQL dinamiche. Ciò richiede una conoscenza approfondita della logica delle query e dei test iterativi per garantire che le query funzionino come previsto. + Prestazioni. È necessario assicurarsi che le modifiche al codice non comportino un peggioramento delle prestazioni dell'applicazione. Questo modello spiega in dettaglio il processo di conversione. ## Prerequisiti e limitazioni **Prerequisiti** + Conoscenza pratica della sintassi Python e Perl. + Competenze di base in SQL Server e PostgreSQL. + Comprensione dell'architettura applicativa esistente. + Accesso al codice dell'applicazione, al database SQL Server e al database PostgreSQL. + Accesso all'ambiente di sviluppo Windows o Linux (o altro Unix) con credenziali per lo sviluppo, il test e la convalida delle modifiche alle applicazioni. + **Per un'applicazione basata su Python, le librerie Python standard che l'applicazione potrebbe richiedere, come **Pandas per gestire i frame di dati e psycopg2** per le connessioni al database. **SQLAlchemy**** + Per un'applicazione basata su Perl, sono necessari pacchetti Perl con librerie o moduli dipendenti. Il modulo Comprehensive Perl Archive Network (CPAN) può supportare la maggior parte dei requisiti delle applicazioni. + Tutte le librerie o i moduli personalizzati dipendenti richiesti.  + Credenziali del database per l'accesso in lettura a SQL Server e read/write l'accesso ad Aurora. + PostgreSQL per convalidare ed eseguire il debug delle modifiche alle applicazioni con servizi e utenti. + Accesso a strumenti di sviluppo durante la migrazione delle applicazioni come Visual Studio Code, Sublime Text o **pgAdmin**. **Limitazioni** + Alcune versioni, moduli, librerie e pacchetti di Python o Perl non sono compatibili con l'ambiente cloud. + Alcune librerie e framework di terze parti utilizzati per SQL Server non possono essere sostituiti per supportare la migrazione PostgreSQL.  + Le variazioni delle prestazioni potrebbero richiedere modifiche all'applicazione, alle query Transact-SQL (T-SQL) in linea, alle funzioni del database e alle stored procedure. + PostgreSQL supporta nomi minuscoli per nomi di tabelle, nomi di colonne e altri oggetti di database.  + Alcuni tipi di dati, come le colonne UUID, vengono memorizzati solo in lettere minuscole. Le applicazioni Python e Perl devono gestire tali differenze di casi.  + Le differenze di codifica dei caratteri devono essere gestite con il tipo di dati corretto per le colonne di testo corrispondenti nel database PostgreSQL.                                 **Versioni del prodotto** + Python 3.6 o versione successiva (usa la versione che supporta il tuo sistema operativo) + Perl 5.8.3 o versione successiva (usa la versione che supporta il tuo sistema operativo) + [Aurora PostgreSQL Compatible Edition 4.2 o versione successiva (vedi dettagli)](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Updates.20180305.html#AuroraPostgreSQL.Updates.20180305.42) ## Architecture **Stack tecnologico di origine** + Linguaggio di scripting (programmazione di applicazioni): Python 2.7 o successivo o Perl 5.8  + Database: Microsoft SQL Server versione 13 + Sistema operativo: Red Hat Enterprise Linux (RHEL) 7  **Stack tecnologico Target** + Linguaggio di scripting (programmazione di applicazioni): Python 3.6 o successivo o Perl 5.8 o successivo  + Database: Aurora PostgreSQL compatibile 4.2 + Sistema operativo: RHEL 7  **Architettura di migrazione** ![Migrazione di un'applicazione Perl o Python con SQL Server a Aurora compatibile con PostgreSQL](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b64de64a-bd55-4db7-ba7b-0a2557862af1/images/b8fab3e2-ded5-4f58-86bf-3f645252e9fc.png) ## Tools (Strumenti) **Servizi e strumenti AWS** + [Aurora PostgreSQL—Compatible Edition è un motore di database relazionale completamente gestito, compatibile con](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) PostgreSQL e conforme ad ACID che combina la velocità e l'affidabilità dei database commerciali di fascia alta con l'economicità dei database open source. Aurora PostgreSQL è un sostituto immediato di PostgreSQL e semplifica e rende più conveniente configurare, utilizzare e scalare le implementazioni PostgreSQL nuove ed esistenti. + [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che consente di interagire con i servizi AWS utilizzando i comandi nella shell della riga di comando. **Altri strumenti** + [Librerie di connessione al database [Python](https://www.python.org/) e PostgressSQL come psycopg2 e [SQLAlchemy](https://www.sqlalchemy.org/)](https://pypi.org/project/psycopg2/) + [Perl](https://www.perl.org/) e [i](https://metacpan.org/pod/DBD::Pg) suoi moduli DBI + Terminale [interattivo PostgreSQL (psql](https://www.postgresql.org/docs/13/app-psql.html)) ## Epiche ### Migra il tuo repository di applicazioni a PostgreSQL: passaggi di alto livello | Operazione | Description | Competenze richieste | | --- | --- | --- | | Segui questi passaggi di conversione del codice per migrare la tua applicazione a PostgreSQL. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html)I seguenti poemi epici forniscono istruzioni dettagliate per alcune di queste attività di conversione per applicazioni Python e Perl. | Sviluppatore di app | | Usa una lista di controllo per ogni fase della migrazione. | Aggiungi quanto segue alla tua lista di controllo per ogni fase della migrazione delle applicazioni, inclusa la fase finale:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | ### Analizza e aggiorna la tua applicazione — Python code base | Operazione | Description | Competenze richieste | | --- | --- | --- | | Analizza la tua base di codice Python esistente. | L'analisi dovrebbe includere quanto segue per facilitare il processo di migrazione delle applicazioni:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | | Converti le connessioni al database per supportare PostgreSQL. | La maggior parte delle applicazioni Python utilizza la libreria **pyodbc** per connettersi ai database di SQL Server come segue.
import pyodbc
....
try:
    conn_string = "Driver=ODBC Driver 17 for SQL
    Server;UID={};PWD={};Server={};Database={}".format (conn_user, conn_password,
    conn_server, conn_database)
    conn = pyodbc.connect(conn_string)
    cur = conn.cursor()
    result = cur.execute(query_string)
    for row in result:
    print (row)
except Exception as e:
    print(str(e))

Converti la connessione al database per supportare PostgreSQL come segue.
import pyodbc
import psycopg2
....
try:
    conn_string = ‘postgresql+psycopg2://’+
    conn_user+’:’+conn_password+’@’+conn_server+’/’+conn_database
    conn = pyodbc.connect(conn_string, connect_args={‘options’:’-csearch_path=dbo’})
    cur = conn.cursor()
    result = cur.execute(query_string)
    for row in result:
    print (row)
except Exception as e:
    print(str(e))
| Sviluppatore di app | | Cambia le query SQL in linea in PostgreSQL. | Converti le tue query SQL in linea in un formato compatibile con PostgreSQL. Ad esempio, la seguente query di SQL Server recupera una stringa da una tabella.
dtype = "type1"
stm = ‘"SELECT TOP 1 searchcode FROM TypesTable (NOLOCK)
WHERE code="’ + "’" + str(dtype) + "’"
# For Microsoft SQL Server Database Connection
engine = create_engine(‘mssql+pyodbc:///?odbc_connect=%s’ % urllib.parse.quote_plus(conn_string), connect_args={‘connect_timeout’:login_timeout})
conn = engine_connect()
rs = conn.execute(stm)
for row in rs:
    print(row)

Dopo la conversione, la query SQL in linea compatibile con PostgreSQL ha il seguente aspetto.
dtype = "type1"
stm = ‘"SELECT searchcode FROM TypesTable
WHERE code="’ + "’" + str(dtype) + "’ LIMIT 1"
# For PostgreSQL Database Connection
engine = create_engine(‘postgres+psycopg2://%s’ %conn_string, connect_args={‘connect_timeout’:login_timeout})
conn = engine.connect()
rs = conn.execute(stm)
for row in rs:
    print(row)
| Sviluppatore di app | | Gestisci le query SQL dinamiche. | L'SQL dinamico può essere presente in uno script o in più script Python. Gli esempi precedenti hanno mostrato come utilizzare la funzione di sostituzione delle stringhe di Python per inserire variabili per la costruzione di query SQL dinamiche. Un approccio alternativo consiste nell'aggiungere la stringa di query con variabili laddove applicabile. 
Nell'esempio seguente, la stringa di query viene costruita al volo in base ai valori restituiti da una funzione.
query = ‘"SELECT id from equity e join issues i on e.permId=i.permId where e.id’"
query += get_id_filter(ids) + " e.id is NOT NULL

Questi tipi di interrogazioni dinamiche sono molto comuni durante la migrazione delle applicazioni. Segui questi passaggi per gestire le query dinamiche:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | | Gestisci set di risultati, variabili e frame di dati. | Per Microsoft SQL Server, si utilizzano metodi Python come `fetchone()` o `fetchall()` per recuperare il set di risultati dal database. È inoltre possibile utilizzare `fetchmany(size)` e specificare il numero di record da restituire dal set di risultati. A tale scopo, è possibile utilizzare l'oggetto di connessione **pyodbc** come illustrato nell'esempio seguente.
**pyodbc (Microsoft SQL Server)**
import pyodbc 
server = 'tcp:myserver.database.windows.net' 
database = 'exampledb' 
username = 'exampleusername' 
password = 'examplepassword' 
conn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+server+';DATABASE='+database+';UID='+username+';PWD='+ password)
cursor = conn.cursor()
cursor.execute("SELECT * FROM ITEMS") 
row = cursor.fetchone() 
while row: 
    print(row[0])
    row = cursor.fetchone()

**In Aurora, per eseguire attività simili come la connessione a PostgreSQL e il recupero dei set di risultati, puoi usare psycopg2 o. **SQLAlchemy**** Queste librerie Python forniscono il modulo di connessione e l'oggetto cursore da attraversare tra i record del database PostgreSQL, come mostrato nell'esempio seguente.
**psycopg2 (compatibile con Aurora PostgreSQL)**
import psycopg2
query = "SELECT * FROM ITEMS;"
//Initialize variables
host=dbname=user=password=port=sslmode=connect_timeout=""
connstring = "host='{host}' dbname='{dbname}' user='{user}' \
password='{password}'port='{port}'".format(host=host,dbname=dbname,\
user=user,password=password,port=port) 
conn = psycopg2.connect(connstring)
cursor = conn.cursor()
cursor.execute(query)
column_names = [column[0] for column in cursor.description]
print("Column Names: ", column_names)
print("Column values: "
for row in cursor:
    print("itemid :", row[0])
    print("itemdescrption :", row[1])
    print("itemprice :", row[3]))

**SQLAlchemy (Compatibile con Aurora PostgreSQL)**
from sqlalchemy import create_engine
from pandas import DataFrame
conn_string = 'postgresql://core:database@localhost:5432/exampledatabase'
engine = create_engine(conn_string)
conn = engine.connect()
dataid = 1001
result = conn.execute("SELECT * FROM ITEMS")
df = DataFrame(result.fetchall())
df.columns = result.keys()
df = pd.DataFrame()
engine.connect()
df = pd.read_sql_query(sql_query, engine, coerce_float=False)
print("df=", df)
| Sviluppatore di app | | Testa la tua applicazione durante e dopo la migrazione. | Il test dell'applicazione Python migrata è un processo continuo. Poiché la migrazione include modifiche agli oggetti di connessione (**psycopg2** o **SQLAlchemy**), gestione degli errori, nuove funzionalità (frame di dati), modifiche SQL in linea, funzionalità di copia in blocco (`bcp`anziché`COPY`) e modifiche simili, deve essere testata attentamente durante e dopo la migrazione dell'applicazione. Controlla:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | ### Analizza e aggiorna la tua applicazione: codice base Perl | Operazione | Description | Competenze richieste | | --- | --- | --- | | Analizza la tua base di codice Perl esistente. | L'analisi dovrebbe includere quanto segue per facilitare il processo di migrazione delle applicazioni. È necessario identificare:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | | Converti le connessioni dall'applicazione Perl e dal modulo DBI per supportare PostgreSQL. | Le applicazioni basate su Perl utilizzano generalmente il modulo Perl DBI, che è un modulo di accesso al database standard per il linguaggio di programmazione Perl. È possibile utilizzare lo stesso modulo DBI con driver diversi per SQL Server e PostgreSQL.
[Per ulteriori informazioni sui moduli Perl richiesti, sulle installazioni e altre istruzioni, consultate la documentazione di DBD: :Pg.](https://metacpan.org/pod/DBD::Pg) L'esempio seguente si connette a Aurora, compatibile con PostgreSQL all'indirizzo. `exampletest-aurorapg-database.cluster-sampleclusture.us-east.-rds.amazonaws.com`
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "Pg";
my $hostname = "exampletest-aurorapg-database-sampleclusture.us-east.rds.amazonaws.com"
my $dsn = "DBI:$driver: dbname = $hostname;host = 127.0.0.1;port = 5432";
my $username = "postgres";
my $password = "pass123";
$dbh = DBI->connect("dbi:Pg:dbname=$hostname;host=$host;port=$port;options=$options",
      $username,
      $password,
      {AutoCommit => 0, RaiseError => 1, PrintError => 0}
      );
| Sviluppatore di app | | Cambia le query SQL in linea in PostgreSQL. | L'applicazione potrebbe avere query SQL in linea con`SELECT`, `DELETE``UPDATE`, e istruzioni simili che includono clausole di query non supportate da PostgreSQL. Ad esempio, parole chiave di query come `TOP` e `NOLOCK` non sono supportate in PostgreSQL. Gli esempi seguenti mostrano come è possibile gestire le variabili `TOP` `NOLOCK` booleane e.
In SQL Server:
$sqlStr = $sqlStr
. "WHERE a.student_id in (SELECT TOP $numofRecords c_student_id   \
FROM active_student_record b WITH (NOLOCK) \
INNER JOIN student_contributor c WITH (NOLOCK) on c.contributor_id = b.c_st)

Per PostgreSQL, converti in:
$sqlStr = $sqlStr
. "WHERE a.student_id in (SELECT TOP $numofRecords c_student_id  \
FROM active_student_record b INNER JOIN student_contributor c  \
on c.contributor_id = b.c_student_contr_id WHERE b_current_1 is true \
LIMIT $numofRecords)"
| Sviluppatore di app | | Gestisci query SQL dinamiche e variabili Perl. | Le query SQL dinamiche sono istruzioni SQL create in fase di esecuzione dell'applicazione. Queste query vengono create dinamicamente durante l'esecuzione dell'applicazione, a seconda di determinate condizioni, in modo che il testo completo della query non sia noto fino all'esecuzione. Un esempio è un'applicazione di analisi finanziaria che analizza quotidianamente le prime 10 azioni e queste azioni cambiano ogni giorno. Le tabelle SQL vengono create in base alle migliori prestazioni e i valori sono noti solo in fase di esecuzione.
Supponiamo che le query SQL in linea per questo esempio vengano passate a una funzione wrapper per ottenere i risultati impostati in una variabile e che quindi una variabile utilizzi una condizione per determinare se la tabella esiste:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html)
Ecco un esempio di gestione delle variabili, seguito dalle query SQL Server e PostgreSQL per questo caso d'uso.
my $tableexists = db_read( arg 1, $sql_qry, undef, 'writer');
my $table_already_exists = $tableexists->[0]{table_exists};
if ($table_already_exists){
# do some thing
}
else {
# do something else
}

SQL Server:
my $sql_qry = "SELECT OBJECT_ID('$backendTable', 'U') table_exists", undef, 'writer')";

PostgreSQL:
my $sql_qry = "SELECT TO_REGCLASS('$backendTable', 'U') table_exists", undef, 'writer')";

L'esempio seguente utilizza una variabile**** Perl in SQL in linea, che esegue un'`SELECT`istruzione con `JOIN` a per recuperare la chiave primaria della tabella e la posizione della colonna chiave.
SQL Server:
my $sql_qry = "SELECT column_name', character_maxi mum_length \
FROM INFORMATION_SCHEMA.COLUMNS \
WHERE TABLE_SCHEMA='$example_schemaInfo' \
AND TABLE_NAME='$example_table' \
AND DATA_TYPE IN ('varchar','nvarchar');";

PostgreSQL:
my $sql_qry = "SELECT c1.column_name, c1.ordinal_position \
FROM information_schema.key_column_usage AS c LEFT \
JOIN information_schema.table_constraints AS t1 \
ON t1.constraint_name = c1.constraint_name \
WHERE t1.table_name = $example_schemaInfo'.'$example_table’ \
AND t1.constraint_type = 'PRIMARY KEY' ;";
| Sviluppatore di app | ### Apporta ulteriori modifiche alla tua applicazione basata su Perl o Python per supportare PostgreSQL | Operazione | Description | Competenze richieste | | --- | --- | --- | | Converti costrutti SQL Server aggiuntivi in PostgreSQL. | Le seguenti modifiche si applicano a tutte le applicazioni, indipendentemente dal linguaggio di programmazione.[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.html) | Sviluppatore di app | ### Migliora le prestazioni | Operazione | Description | Competenze richieste | | --- | --- | --- | | Sfrutta i servizi AWS per migliorare le prestazioni. | Quando esegui la migrazione al cloud AWS, puoi perfezionare la progettazione di applicazioni e database per sfruttare i servizi AWS. Ad esempio, se le query della tua applicazione Python, connessa a un server di database Aurora compatibile con PostgreSQL, richiedono più tempo rispetto alle query originali di Microsoft SQL Server, potresti prendere in considerazione la creazione di un feed di dati storici direttamente in un bucket Amazon Simple Storage Service (Amazon S3) dal server Aurora e utilizzare Amazon Athena Query SQL per generare report e query di dati analitici per i dashboard degli utenti. | Sviluppatore di app, architetto cloud | ## Risorse correlate + [Perl](https://www.perl.org/) + [Modulo Perl DBI](https://metacpan.org/pod/DBI) + [Python](https://www.python.org/) + [psycopg2](https://pypi.org/project/psycopg2/) + [SQLAlchemy](https://www.sqlalchemy.org/) + [Copia in blocco - PostgreSQL](https://www.postgresql.org/docs/9.2/sql-copy.html) + [Copia in blocco - Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/tools/bcp-utility?view=sql-server-ver15) + [PostgreSQL](https://www.postgresql.org/) + [Lavorare con Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) ## Informazioni aggiuntive Sia Microsoft SQL Server che Aurora PostgreSQL sono compatibili con ANSI SQL. Tuttavia, dovresti comunque essere consapevole di eventuali incompatibilità nella sintassi, nei tipi di dati delle colonne, nelle funzioni native specifiche del database, negli inserimenti in blocco e nella distinzione tra maiuscole e minuscole quando migri la tua applicazione Python o Perl da SQL Server a PostgreSQL. Le sezioni seguenti forniscono ulteriori informazioni sulle possibili incongruenze. **Confronto dei tipi di dati** Le modifiche ai tipi di dati da SQL Server a PostgreSQL possono portare a differenze significative nei dati risultanti su cui operano le applicazioni. [Per un confronto dei tipi di dati, consulta la tabella sul sito Web Sqlines.](https://www.sqlines.com/sql-server-to-postgresql) **Funzioni SQL native o integrate** Il comportamento di alcune funzioni è diverso tra i database SQL Server e PostgreSQL. La tabella seguente fornisce un confronto. | | | Microsoft SQL Server | Description | PostgreSQL | | --- |--- |--- | | `CAST`  | Converte un valore da un tipo di dati a un altro. | PostgreSQL `type :: operator` | | `GETDATE()` | Restituisce la data e l'ora correnti del sistema di database, in un formato. `YYYY-MM-DD hh:mm:ss.mmm` | `CLOCK_TIMESTAMP` | | `DATEADD` | Aggiunge un time/date intervallo a una data. | `INTERVAL`espressione | | `CONVERT` | Converte un valore in un formato di dati specifico. | `TO_CHAR` | | `DATEDIFF` | Restituisce la differenza tra due date. | `DATE_PART` | | `TOP` | Limita il numero di righe in un set di `SELECT` risultati. | `LIMIT/FETCH` | **Blocchi anonimi** Una query SQL strutturata è organizzata in sezioni quali dichiarazione, eseguibili e gestione delle eccezioni. La tabella seguente confronta le versioni Microsoft SQL Server e PostgreSQL di un semplice blocco anonimo. Per blocchi anonimi complessi, si consiglia di richiamare una funzione di database personalizzata all'interno dell'applicazione. | | | Microsoft SQL Server | PostgreSQL | | --- |--- | | 
my $sql_qry1=
my $sql_qry2 =
my $sqlqry = "BEGIN TRAN
$sql_qry1 $sql_qry2
if @\@error !=0 ROLLBACK
TRAN
else COMIT TRAN";
| 
my $sql_qry1=
my $sql_qry2 =
my $sql_qry = " DO \$\$
BEGIN
$header_sql $content_sql
END
\$\$";
|   **Altre differenze** + **Inserimenti di righe in blocco:** [l'equivalente PostgreSQL dell'utilità bcp di [Microsoft](https://docs.microsoft.com/en-us/sql/tools/bcp-utility?view=sql-server-ver15) SQL Server è COPY.](https://www.postgresql.org/docs/9.2/sql-copy.html) + **Sensibilità tra maiuscole e minuscole:** i nomi delle colonne fanno distinzione tra maiuscole e minuscole in PostgreSQL, quindi è necessario convertire i nomi delle colonne di SQL Server in lettere minuscole o maiuscole. Questo diventa un fattore quando si estraggono o si confrontano dati o si inseriscono nomi di colonna in set di risultati o variabili. L'esempio seguente identifica le colonne in cui i valori possono essere memorizzati in lettere maiuscole o minuscole. ``` my $sql_qry = "SELECT $record_id FROM $exampleTable WHERE LOWER($record_name) = \'failed transaction\'"; ``` + **Concatenazione:** SQL Server utilizza `+` come operatore per la concatenazione di stringhe, mentre PostgreSQL utilizza. `||` + **Convalida:** è necessario testare e convalidare le query e le funzioni SQL in linea prima di utilizzarle nel codice dell'applicazione per PostgreSQL. + **Inclusione della libreria ORM:** [puoi anche cercare di includere o sostituire la libreria di connessione al database esistente con librerie ORM Python come [SQLAlchemy](https://www.sqlalchemy.org/)Python e PynomODB.](https://pynamodb.readthedocs.io/en/latest/quickstart.html) Ciò contribuirà a interrogare e manipolare facilmente i dati da un database utilizzando un paradigma orientato agli oggetti.