Vai al contenuto
Home di IntoSQL
Converti un file

Converti PostgreSQL in SQL Server

Trascina un dump plain di pg_dump o pg_dumpall, come .sql o .sql.gz, e scarica uno script per SQL Server con le stesse tabelle, chiavi, indici e dati. Ogni valore che SQL Server non può contenere così com'è, e ogni oggetto che non supporta, è elencato nel report.

Guida alla migrazione da PostgreSQL a SQL ServerTipi di dati da PostgreSQL a SQL Server
Il tuo file
sqlshop_2024_postgres.sqlFile di esempio, 6,2 kB
Il tuo database

18 righe convertite, 2 correzioni, nessuna rifiutata

Mostra

Tabelle in shop_2024_postgres.sqlDump PostgreSQL 18.6 · scritto da pg_dump · utf8mb4

  • customers8 righe1
    8 colonne
    idint not null
    namenvarchar(max) not null
    emailnvarchar(450) not null
    countrynvarchar(2) not null
    is_activebit not null
    tagsnvarchar(max) not null
    signed_update
    created_atdatetimeoffset(6) not null
  • orders10 righe1
    10 colonne
    idint not null
    customer_idint not null
    statusnvarchar(9) not null
    totaldecimal(10,2) not null
    itemssmallint not null
    ordered_atdatetime2(6) not null
    shipped_atdatetime2(6)
    notenvarchar(max)
    detailsnvarchar(max)
    deliverynvarchar(100)

Non convertiti

  • Vista paid_orders

Ogni database li scrive nel proprio linguaggio. Riscrivili per SQL Server.

-- Written by IntoSQL from a PostgreSQL dump. Load it with: sqlcmd -b -f 65001 -d <database> -i <file>
SET NOCOUNT ON;
SET ANSI_NULLS ON;
SET QUOTED_IDENTIFIER ON;
SET ANSI_PADDING ON;
SET ANSI_WARNINGS ON;
SET ARITHABORT ON;
SET CONCAT_NULL_YIELDS_NULL ON;
SET NUMERIC_ROUNDABORT OFF;
GO

CREATE TABLE [dbo].[customers] (
    [id] int IDENTITY(1001, 1) NOT NULL,
    [name] nvarchar(max) COLLATE Latin1_General_100_BIN2 NOT NULL,
    [email] nvarchar(450) COLLATE Latin1_General_100_BIN2 NOT NULL,
    [country] nvarchar(2) COLLATE Latin1_General_100_BIN2 DEFAULT N'US' NOT NULL,
    [is_active] bit DEFAULT 1 NOT NULL,
    [tags] nvarchar(max) COLLATE Latin1_General_100_BIN2 NOT NULL,
    [signed_up] date NULL,
    [created_at] datetimeoffset(6) DEFAULT SYSDATETIMEOFFSET() NOT NULL,
    CONSTRAINT [PK_customers] PRIMARY KEY ([id])
);
GO

CREATE TABLE [dbo].[orders] (
    [id] int IDENTITY(5001, 1) NOT NULL,
    [customer_id] int NOT NULL,
    [status] nvarchar(9) COLLATE Latin1_General_100_BIN2 DEFAULT N'pending' NOT NULL,
    [total] decimal(10,2) NOT NULL,
    [items] smallint DEFAULT 1 NOT NULL,
    [ordered_at] datetime2(6) NOT NULL,
    [shipped_at] datetime2(6) NULL,
    [note] nvarchar(max) COLLATE Latin1_General_100_BIN2 NULL,
    [details] nvarchar(max) COLLATE Latin1_General_100_BIN2 NULL,
    [delivery] nvarchar(100) COLLATE Latin1_General_100_BIN2 NULL,
    CONSTRAINT [CK_orders_status] CHECK ([status] IN (N'pending', N'paid', N'shipped', N'cancelled')),
    CONSTRAINT [orders_total_check] CHECK ([total] >= (0)),
    CONSTRAINT [PK_orders] PRIMARY KEY ([id])
);
GO

SET IDENTITY_INSERT [dbo].[customers] ON;
INSERT INTO [dbo].[customers] ([id], [name], [email], [country], [is_active], [tags], [signed_up], [created_at]) VALUES
(1,N'Ana Martínez',N'ana@example.com',N'MX',1,N'["vip"]','2023-01-15','2023-01-15 10:24:00+00:00'),
(2,N'Zoë Müller',N'zoe@example.de',N'DE',1,N'[]','2023-02-03','2023-02-03 08:11:42+00:00'),
(3,N'José Peña',N'jose@example.es',N'ES',0,N'["wholesale","late payer"]','2023-03-21','2023-03-21 19:05:17+00:00'),
(4,N'李雷',N'lilei@example.cn',N'CN',1,N'[]','2023-05-09','2023-05-09 02:40:00+00:00'),
(5,N'Noah O''Brien',N'noah@example.ie',N'IE',1,N'[]',NULL,'2023-06-30 14:00:00+00:00'),
(6,N'Amélie Laurent',N'amelie@example.fr',N'FR',1,N'["vip"]','2024-01-02','2024-01-02 09:30:00+00:00'),
(7,N'Ravi Patel',N'ravi@example.in',N'IN',0,N'[]','2024-02-29','2024-02-29 23:59:59+00:00'),
(8,N'Sofia Rossi 🌻',N'sofia@example.it',N'IT',1,N'[]','2024-04-12','2024-04-12 12:12:12+00:00');
SET IDENTITY_INSERT [dbo].[customers] OFF;
GO
SET IDENTITY_INSERT [dbo].[orders] ON;
INSERT INTO [dbo].[orders] ([id], [customer_id], [status], [total], [items], [ordered_at], [shipped_at], [note], [details], [delivery]) VALUES
(1,1,N'shipped',129.90,3,'2024-03-01 10:00:00','2024-03-02 16:30:00',NULL,N'{"gift": false}',N'1 day 06:30:00'),
(2,2,N'paid',54.00,1,'2024-03-02 11:15:00',NULL,N'Gift wrap 🎁',N'{"gift": true, "wrap": "red"}',NULL),
(3,1,N'cancelled',12.50,1,'2024-03-03 09:45:00',NULL,N'Customer changed their mind',NULL,NULL),
(4,4,N'shipped',980.00,12,'2024-03-05 02:10:00','2024-03-07 08:00:00',N'请小心轻放',N'{"fragile": true}',N'2 days 05:50:00'),
(5,5,N'pending',45.75,2,'2024-03-08 17:20:00',NULL,N'Leave at the door; ring twice',NULL,NULL),
(6,6,N'shipped',310.40,5,'2024-03-10 13:00:00','2024-03-11 09:00:00',N'Fragile: "glass"',N'{"fragile": true}',N'20:00:00'),
(7,8,N'paid',76.20,2,'2024-03-11 18:45:00',NULL,NULL,NULL,NULL),
(8,2,N'shipped',19.99,1,'2024-03-12 08:00:00',NULL,N'Shipped date set to infinity by an old import',NULL,NULL),
(9,3,N'shipped',64.00,2,'2024-03-14 15:30:00','2024-03-15 10:00:00',N'Two parcels',N'{"parcels": [1, 2]}',N'18:30:00'),
(10,7,N'paid',1499.00,1,'2024-03-15 21:05:00',NULL,N'C:\Users\ravi\invoice.pdf',NULL,NULL);
SET IDENTITY_INSERT [dbo].[orders] OFF;
GO

-- Indexes, foreign keys, counters and triggers, after the rows.
CREATE UNIQUE INDEX [customers_email_key] ON [dbo].[customers] ([email]);
CREATE INDEX [idx_orders_customer] ON [dbo].[orders] ([customer_id]);
CREATE INDEX [idx_orders_status_date] ON [dbo].[orders] ([status], [ordered_at]);
ALTER TABLE [dbo].[orders] WITH NOCHECK ADD CONSTRAINT [orders_customer_id_fkey] FOREIGN KEY ([customer_id]) REFERENCES [dbo].[customers] ([id]);
BEGIN TRY ALTER TABLE [dbo].[orders] WITH CHECK CHECK CONSTRAINT [orders_customer_id_fkey]; END TRY BEGIN CATCH PRINT N'Foreign key ' + N'[orders_customer_id_fkey]' + N' has rows without a parent: it stays unchecked, and new rows are checked.'; END CATCH;
DECLARE @next decimal(38,0) = (SELECT MAX([id]) FROM [dbo].[customers]); IF @next IS NOT NULL BEGIN IF @next < 1000 SET @next = 1000; DBCC CHECKIDENT (N'[dbo].[customers]', RESEED, @next) WITH NO_INFOMSGS; END;
GO
EXEC sys.sp_addextendedproperty @name = N'MS_Description', @value = N'People who bought at least once', @level0type = N'SCHEMA', @level0name = N'dbo', @level1type = N'TABLE', @level1name = N'customers';
DECLARE @next decimal(38,0) = (SELECT MAX([id]) FROM [dbo].[orders]); IF @next IS NOT NULL BEGIN IF @next < 5000 SET @next = 5000; DBCC CHECKIDENT (N'[dbo].[orders]', RESEED, @next) WITH NO_INFOMSGS; END;
GO
GO

Correzioni

  1. "tags" di customers è text[], che SQL Server non ha, quindi è nvarchar(max) con gli stessi valori.
  2. "delivery" di orders è interval, che SQL Server non ha, quindi è nvarchar(100) con gli stessi valori.

Da controllare

  • 1 vista, trigger, routine o evento non è convertito; il report li elenca uno per uno. Ricreali a mano in SQL Server.
  • Il valore predefinito di "tags" in customers non si può scrivere per SQL Server (a value its type can't hold), quindi la colonna non ha un valore predefinito. Aggiungi a mano il valore predefinito se le nuove righe ne hanno bisogno.
  • L'indice idx_orders_details su orders usa un'espressione che non si può scrivere per SQL Server (an index on an expression), quindi non viene creato. Crea l'indice a mano se le query ne hanno bisogno.
  • 1 valore in "shipped_at" di orders è una data che SQL Server non può salvare, come infinity, quindi è NULL. SQL Server salva gli anni dall'1 al 9999 senza infinito; sostituisci quelle date nella sorgente se contano.

Il tuo file viene convertito su questo computer e non viene mai caricato.

Altri esempi:

Cosa cambia da PostgreSQL a SQL Server

Ogni riga è una regola che il convertitore applica, con la riga del report che scrive quando la regola cambia qualcosa nei tuoi dati.

  • boolean

    bit

    bit contiene true come 1 e false come 0.

  • varchar(n), char(n), text

    nvarchar(n); text come nvarchar(max), o nvarchar(450) quando una chiave lo usa e ogni valore ci sta

    nvarchar contiene ogni carattere. SQL Server non può indicizzare nvarchar(max), quindi il testo in una chiave ha una dimensione adatta a una chiave.

  • text comparison

    esatto (Latin1_General_100_BIN2); citext ignorando le maiuscole (Latin1_General_100_CI_AS_SC)

    La collation abituale di SQL Server ignora le maiuscole e il text di PostgreSQL no, quindi ogni colonna indica come confronta e le chiavi univoche separano le stesse righe.

  • numeric(p,s) past 38 digits; numeric without a precision

    nvarchar; decimal(p,s) adattato ai valori quando stanno in 38 cifre

    Il decimal di SQL Server contiene 38 cifre. Un numeric senza precisione riceve il decimal più stretto in cui stanno i suoi valori; i numeri più ampi restano testo così ogni cifra resta esatta.

    Riga del report: decimal_as_text

  • money

    decimal(19,2)

    Il money di SQL Server è più piccolo di quello di PostgreSQL e ha quattro decimali; decimal(19,2) contiene ogni importo, senza il simbolo di valuta aggiunto dal locale del server.

    Riga del report: type_replaced

  • interval

    nvarchar(100) con il testo di PostgreSQL

    SQL Server non ha un tipo interval; il testo mantiene ogni parte.

    Riga del report: type_replaced

  • arrays (integer[], text[]...)

    nvarchar(max) con un array JSON

    SQL Server non ha array. Un array JSON mantiene ogni elemento e i NULL, e OPENJSON lo legge.

    Riga del report: type_replaced

  • ranges, geometric types, tsvector, xml, hstore, PostGIS, composite and extension types

    nvarchar(max) con il testo di PostgreSQL

    SQL Server non ha un tipo equivalente, quindi ogni valore mantiene il testo scritto da PostgreSQL.

    Riga del report: type_replaced

  • json, jsonb

    nvarchar(max)

    Le funzioni JSON di SQL Server leggono il JSON dal testo.

  • timestamp

    datetime2

    Un timestamp senza fuso orario è l'ora letta su un orologio, come datetime2.

  • timestamp with time zone

    datetimeoffset in UTC

    datetimeoffset mantiene l'istante; ogni valore è scritto in UTC, lo stesso istante qualunque offset abbia scritto il dump.

  • time with 24:00:00 in it

    nvarchar(17)

    Il time di SQL Server finisce a 23:59:59.9999999, quindi una colonna che contiene 24:00:00 mantiene il suo testo.

    Riga del report: time_as_interval

  • infinity, -infinity and BC dates

    NULL

    SQL Server salva gli anni dall'1 al 9999 senza infinito. Quei valori diventano NULL e il report li conta.

    Riga del report: date_out_of_range

  • NaN and Infinity in numeric, real and double precision

    NULL

    I numeri di SQL Server non hanno NaN né Infinity, quindi quei valori diventano NULL e il report li conta.

    Riga del report: invalid_value_null

  • NOT NULL columns with values that become NULL

    NOT NULL rimosso

    Una colonna i cui valori sono dovuti diventare NULL non può mantenere NOT NULL, altrimenti il caricamento si fermerebbe.

    Riga del report: not_null_relaxed

  • enum types

    nvarchar con un CHECK delle sue etichette

    Il testo con un vincolo CHECK mantiene gli stessi valori.

  • enum columns holding values outside their labels

    nvarchar senza CHECK

    I valori che le etichette non nominano violerebbero il vincolo CHECK, quindi il vincolo non viene creato.

    Riga del report: enum_check_skipped

  • uuid, inet, cidr, macaddr

    uniqueidentifier; indirizzi come nvarchar

    uniqueidentifier è l'UUID di SQL Server; gli indirizzi restano come testo.

  • bytea

    varbinary(max)

    I byte restano byte.

  • bit(n), bit varying

    bit per un bit; bigint fino a 63 bit; cifre come testo oltre

    Un singolo bit è un sì o un no; le stringhe di bit più lunghe sono salvate come il numero formato dai loro bit.

  • oid, xid, cid

    bigint con un CHECK che non sia negativo

    bigint contiene ogni valore.

  • serial, identity

    IDENTITY, che riparte dopo l'id più alto

    Gli id copiati si caricano con IDENTITY_INSERT, e il contatore riparte dopo il più alto o dal valore successivo della sequenza, quello maggiore.

  • a second serial or identity column in a table

    un intero semplice

    SQL Server conta una colonna IDENTITY per tabella; ogni altra mantiene i suoi valori senza contatore.

    Riga del report: counter_dropped

  • sequences not owned by a column

    CREATE SEQUENCE ... AS bigint, con il suo valore successivo

    SQL Server ha sequenze con le stesse opzioni; ognuna riparte da dove l'ha lasciata il dump.

  • generated columns

    colonne calcolate, PERSISTED quando la sorgente le salva

    SQL Server le calcola negli stessi due modi.

  • generated columns with functions SQL Server lacks

    una colonna semplice con i valori

    Una formula che non si può scrivere per SQL Server lascia una colonna semplice con i valori del dump e una riga nel report.

    Riga del report: generated_not_translated

  • defaults with functions SQL Server lacks, and defaults from a sequence

    nessun valore predefinito

    Un valore predefinito che non si può scrivere per SQL Server viene omesso e segnalato.

    Riga del report: default_not_translated

  • CHECK constraints

    tradotti, dentro CREATE TABLE

    I CHECK nella tabella si verificano mentre ogni riga si carica.

  • CHECK constraints with functions SQL Server lacks

    non creato

    Un vincolo CHECK che non si può scrivere per SQL Server viene omesso e segnalato.

    Riga del report: check_skipped

  • CHECK ... NOT VALID

    non creato

    PostgreSQL non ha mai verificato le righe che c'erano prima, quindi potrebbero violarlo.

    Riga del report: check_not_valid

  • gin, gist, brin and hash indexes, partial and expression indexes, and indexes on text that doesn't fit a key

    non creato

    SQL Server indicizza colonne, non espressioni, e non nvarchar(max).

    Riga del report: index_skipped

  • foreign keys

    dopo i dati WITH NOCHECK, poi controllata con un avviso sulle righe orfane

    La chiave viene creata dopo le righe e controllata alla fine; righe senza padre la lasciano non controllata con un avviso invece di fermare il caricamento.

  • ON DELETE or ON UPDATE that cascades in a cycle or along a second path

    NO ACTION

    SQL Server rifiuta le cascate che potrebbero raggiungere una tabella due volte; PostgreSQL le permette.

    Riga del report: foreign_key_action_dropped

  • foreign keys to tables the dump doesn't create

    non creato

    Una chiave non può riferirsi a una tabella che non c'è.

    Riga del report: foreign_key_skipped

  • partitioned tables

    una tabella con le righe di ogni partizione

    Le righe sono le stesse; partiziona di nuovo la tabella in SQL Server se serve.

    Riga del report: partitions_dropped

  • views, functions, procedures, triggers, rules, policies, extensions and types

    elencati nel report

    Il loro codice è scritto nel linguaggio di PostgreSQL, quindi vengono elencati perché tu li ricrei.

    Riga del report: not_converted_objects

  • dumps without CREATE TABLE (--data-only)

    tipi ricavati dai valori

    Un dump di soli dati contiene solo righe, quindi i tipi vengono ricavati dai valori.

    Riga del report: no_schema

  • expressions in INSERT values

    NULL

    Un convertitore che non esegue un database non può valutarle.

    Riga del report: expression_value

  • types IntoSQL doesn't know

    nvarchar(max)

    Il testo contiene qualsiasi valore; cambia il tipo dopo il caricamento.

    Riga del report: unknown_type

  • text that isn't valid in its encoding

    i byte errati come carattere di sostituzione

    nvarchar contiene testo Unicode.

    Riga del report: invalid_utf8_replaced

  • text decoded twice (ñ)

    copiato così com'è

    Il dump contiene esattamente questi caratteri, quindi vengono copiati; il report li segnala.

    Riga del report: mojibake_suspected

In PostgreSQLIn SQL ServerRiga del report
booleanbitbit contiene true come 1 e false come 0.
varchar(n), char(n), textnvarchar(n); text come nvarchar(max), o nvarchar(450) quando una chiave lo usa e ogni valore ci stanvarchar contiene ogni carattere. SQL Server non può indicizzare nvarchar(max), quindi il testo in una chiave ha una dimensione adatta a una chiave.
text comparisonesatto (Latin1_General_100_BIN2); citext ignorando le maiuscole (Latin1_General_100_CI_AS_SC)La collation abituale di SQL Server ignora le maiuscole e il text di PostgreSQL no, quindi ogni colonna indica come confronta e le chiavi univoche separano le stesse righe.
numeric(p,s) past 38 digits; numeric without a precisionnvarchar; decimal(p,s) adattato ai valori quando stanno in 38 cifreIl decimal di SQL Server contiene 38 cifre. Un numeric senza precisione riceve il decimal più stretto in cui stanno i suoi valori; i numeri più ampi restano testo così ogni cifra resta esatta.decimal_as_text
moneydecimal(19,2)Il money di SQL Server è più piccolo di quello di PostgreSQL e ha quattro decimali; decimal(19,2) contiene ogni importo, senza il simbolo di valuta aggiunto dal locale del server.type_replaced
intervalnvarchar(100) con il testo di PostgreSQLSQL Server non ha un tipo interval; il testo mantiene ogni parte.type_replaced
arrays (integer[], text[]...)nvarchar(max) con un array JSONSQL Server non ha array. Un array JSON mantiene ogni elemento e i NULL, e OPENJSON lo legge.type_replaced
ranges, geometric types, tsvector, xml, hstore, PostGIS, composite and extension typesnvarchar(max) con il testo di PostgreSQLSQL Server non ha un tipo equivalente, quindi ogni valore mantiene il testo scritto da PostgreSQL.type_replaced
json, jsonbnvarchar(max)Le funzioni JSON di SQL Server leggono il JSON dal testo.
timestampdatetime2Un timestamp senza fuso orario è l'ora letta su un orologio, come datetime2.
timestamp with time zonedatetimeoffset in UTCdatetimeoffset mantiene l'istante; ogni valore è scritto in UTC, lo stesso istante qualunque offset abbia scritto il dump.
time with 24:00:00 in itnvarchar(17)Il time di SQL Server finisce a 23:59:59.9999999, quindi una colonna che contiene 24:00:00 mantiene il suo testo.time_as_interval
infinity, -infinity and BC datesNULLSQL Server salva gli anni dall'1 al 9999 senza infinito. Quei valori diventano NULL e il report li conta.date_out_of_range
NaN and Infinity in numeric, real and double precisionNULLI numeri di SQL Server non hanno NaN né Infinity, quindi quei valori diventano NULL e il report li conta.invalid_value_null
NOT NULL columns with values that become NULLNOT NULL rimossoUna colonna i cui valori sono dovuti diventare NULL non può mantenere NOT NULL, altrimenti il caricamento si fermerebbe.not_null_relaxed
enum typesnvarchar con un CHECK delle sue etichetteIl testo con un vincolo CHECK mantiene gli stessi valori.
enum columns holding values outside their labelsnvarchar senza CHECKI valori che le etichette non nominano violerebbero il vincolo CHECK, quindi il vincolo non viene creato.enum_check_skipped
uuid, inet, cidr, macaddruniqueidentifier; indirizzi come nvarcharuniqueidentifier è l'UUID di SQL Server; gli indirizzi restano come testo.
byteavarbinary(max)I byte restano byte.
bit(n), bit varyingbit per un bit; bigint fino a 63 bit; cifre come testo oltreUn singolo bit è un sì o un no; le stringhe di bit più lunghe sono salvate come il numero formato dai loro bit.
oid, xid, cidbigint con un CHECK che non sia negativobigint contiene ogni valore.
serial, identityIDENTITY, che riparte dopo l'id più altoGli id copiati si caricano con IDENTITY_INSERT, e il contatore riparte dopo il più alto o dal valore successivo della sequenza, quello maggiore.
a second serial or identity column in a tableun intero sempliceSQL Server conta una colonna IDENTITY per tabella; ogni altra mantiene i suoi valori senza contatore.counter_dropped
sequences not owned by a columnCREATE SEQUENCE ... AS bigint, con il suo valore successivoSQL Server ha sequenze con le stesse opzioni; ognuna riparte da dove l'ha lasciata il dump.
generated columnscolonne calcolate, PERSISTED quando la sorgente le salvaSQL Server le calcola negli stessi due modi.
generated columns with functions SQL Server lacksuna colonna semplice con i valoriUna formula che non si può scrivere per SQL Server lascia una colonna semplice con i valori del dump e una riga nel report.generated_not_translated
defaults with functions SQL Server lacks, and defaults from a sequencenessun valore predefinitoUn valore predefinito che non si può scrivere per SQL Server viene omesso e segnalato.default_not_translated
CHECK constraintstradotti, dentro CREATE TABLEI CHECK nella tabella si verificano mentre ogni riga si carica.
CHECK constraints with functions SQL Server lacksnon creatoUn vincolo CHECK che non si può scrivere per SQL Server viene omesso e segnalato.check_skipped
CHECK ... NOT VALIDnon creatoPostgreSQL non ha mai verificato le righe che c'erano prima, quindi potrebbero violarlo.check_not_valid
gin, gist, brin and hash indexes, partial and expression indexes, and indexes on text that doesn't fit a keynon creatoSQL Server indicizza colonne, non espressioni, e non nvarchar(max).index_skipped
foreign keysdopo i dati WITH NOCHECK, poi controllata con un avviso sulle righe orfaneLa chiave viene creata dopo le righe e controllata alla fine; righe senza padre la lasciano non controllata con un avviso invece di fermare il caricamento.
ON DELETE or ON UPDATE that cascades in a cycle or along a second pathNO ACTIONSQL Server rifiuta le cascate che potrebbero raggiungere una tabella due volte; PostgreSQL le permette.foreign_key_action_dropped
foreign keys to tables the dump doesn't createnon creatoUna chiave non può riferirsi a una tabella che non c'è.foreign_key_skipped
partitioned tablesuna tabella con le righe di ogni partizioneLe righe sono le stesse; partiziona di nuovo la tabella in SQL Server se serve.partitions_dropped
views, functions, procedures, triggers, rules, policies, extensions and typeselencati nel reportIl loro codice è scritto nel linguaggio di PostgreSQL, quindi vengono elencati perché tu li ricrei.not_converted_objects
dumps without CREATE TABLE (--data-only)tipi ricavati dai valoriUn dump di soli dati contiene solo righe, quindi i tipi vengono ricavati dai valori.no_schema
expressions in INSERT valuesNULLUn convertitore che non esegue un database non può valutarle.expression_value
types IntoSQL doesn't knownvarchar(max)Il testo contiene qualsiasi valore; cambia il tipo dopo il caricamento.unknown_type
text that isn't valid in its encodingi byte errati come carattere di sostituzionenvarchar contiene testo Unicode.invalid_utf8_replaced
text decoded twice (ñ)copiato così com'èIl dump contiene esattamente questi caratteri, quindi vengono copiati; il report li segnala.mojibake_suspected

Carica lo script in SQL Server

Lo script crea le tabelle, copia le righe, poi aggiunge chiavi, indici e chiavi esterne, così si carica in fretta e si ferma al primo errore.

sqlcmd -b -f 65001 -S localhost -d mydb -i postgresql.sql_server.sql

Le chiavi esterne vengono aggiunte WITH NOCHECK e poi controllate. Se una riga punta a una riga che non esiste, lo script dice quale vincolo e lo lascia non controllato, invece di fallire a metà.

Per un dump grande, esegui sqlcmd sulla stessa macchina del server. Ogni lotto di massimo 1000 righe fa il commit da solo, così il log delle transazioni resta piccolo.

Fai il dump di PostgreSQL per il miglior risultato

Il convertitore legge ciò che il dump contiene. Con queste opzioni il dump conserva più dei tuoi dati:

  • --format=plain, il default di pg_dump, scrive SQL. Un archivio custom o directory (-Fc, -Fd) diventa SQL con pg_restore -f dump.sql, senza un server di database.
  • --no-owner --no-privileges escludono ruoli e permessi, che il convertitore comunque salta, così il dump è più piccolo.
  • pg_dumpall esporta ogni database in un solo file; le tabelle di ognuno hanno il suo nome davanti, così niente entra in conflitto.

Cosa non viene convertito

Viste, viste materializzate, funzioni, procedure, trigger, regole, policy di sicurezza a livello di riga, estensioni e tipi sono scritti nel linguaggio di PostgreSQL. Sono elencati per nome nel report, mai rimossi in silenzio, così puoi riscriverli per SQL Server.

Domande sulla conversione da PostgreSQL a SQL Server

Non trovi la risposta? Scrivici dalla pagina dei contatti e ti risponde una persona. Pagina dei contatti

Il mio dump viene caricato?

No. Il convertitore funziona nel tuo browser e legge il dump dal tuo disco a pezzi, quindi non lascia mai il tuo computer. Anche l'app desktop e la riga di comando convertono sul tuo computer.

Quanto può essere grande il dump?

Il convertitore non tiene mai l'intero dump in memoria: legge il file due volte, per intervalli, e scrive lo script man mano. I dump di più gigabyte si convertono nel browser, nell'app desktop e con la riga di comando.

Legge gli archivi pg_dump -Fc?

Non direttamente: un archivio custom è un formato binario. pg_restore -f dump.sql dump.backup lo trasforma nel SQL plain che il convertitore legge, senza connettersi a un server. Il convertitore lo dice quando riceve un archivio.

Da quali versioni di PostgreSQL può provenire il dump?

Dump scritti da pg_dump e pg_dumpall da PostgreSQL 10 in poi, con righe COPY o INSERT. Ogni dump di test viene da PostgreSQL 13 e 18 ed è confrontato con la sorgente cella per cella.

I valori serial e identity vengono mantenuti?

Sì. La colonna serial o identity di ogni tabella diventa una colonna IDENTITY, ogni riga mantiene il suo id e l'id successivo riparte dopo il più alto. SQL Server conta una colonna per tabella, quindi ogni altra mantiene i suoi valori senza contatore.

Cosa succede ad array, enum e altri tipi di PostgreSQL?

Gli array diventano array JSON, i booleani bit, uuid uniqueidentifier e i timestamp con fuso orario datetimeoffset. Il testo si confronta in modo esatto, come in PostgreSQL, e citext ignorando le maiuscole. Range, tipi geometrici e tipi composti mantengono il testo di PostgreSQL.

E funzioni, trigger e viste?

Sono elencati per nome nel report e non vengono convertiti, perché ogni database li scrive nel proprio linguaggio.

Su quali versioni di SQL Server si carica lo script?

SQL Server dalla 2017 alla 2025. Lo stesso script si carica su ognuna, fermandosi al primo errore se qualcosa va storto.