Aller au contenu
Accueil IntoSQL
Convertir un fichier

Convertir PostgreSQL en SQL Server

Déposez un dump texte de pg_dump ou pg_dumpall, en .sql ou .sql.gz, et téléchargez un script SQL Server avec les mêmes tables, clés, index et données. Chaque valeur que SQL Server ne peut pas contenir telle quelle, et chaque objet qu'il ne reprend pas, est listé dans le rapport.

Guide de migration de PostgreSQL vers SQL ServerTypes de données de PostgreSQL vers SQL Server
Votre fichier
sqlshop_2024_postgres.sqlFichier d'exemple, 6,2 ko
Votre base de données

18 lignes converties, 2 corrections, aucune rejetée

Afficher

Tables de shop_2024_postgres.sqlDump PostgreSQL 18.6 · écrit par pg_dump · utf8mb4

  • customers8 lignes1
    8 colonnes
    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 lignes1
    10 colonnes
    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 converti

  • Vue paid_orders

Chaque base de données les écrit dans son propre langage. Réécrivez-les pour 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

Corrections

  1. "tags" de customers est text[], que SQL Server n'a pas ; elle est donc en nvarchar(max) avec les mêmes valeurs.
  2. "delivery" de orders est interval, que SQL Server n'a pas ; elle est donc en nvarchar(100) avec les mêmes valeurs.

À vérifier

  • 1 objet non converti (vues, déclencheurs, routines ou événements) ; le rapport les liste un par un. Recréez-les à la main dans SQL Server.
  • La valeur par défaut de "tags" dans customers ne peut pas être écrite pour SQL Server (a value its type can't hold) ; la colonne n'a donc pas de valeur par défaut. Ajoutez la valeur par défaut à la main si les nouvelles lignes en ont besoin.
  • L'index idx_orders_details sur orders utilise une expression qui ne peut pas être écrite pour SQL Server (an index on an expression) ; il n'est donc pas créé. Créez l'index à la main si les requêtes en ont besoin.
  • 1 date de "shipped_at" dans orders, que SQL Server ne peut pas stocker (par exemple infinity), devient NULL. SQL Server stocke les années 1 à 9999, sans infini ; remplacez ces dates dans la source si elles comptent.

Votre fichier est converti sur cet ordinateur et n'est jamais envoyé.

Autres exemples :

Ce qui change de PostgreSQL à SQL Server

Chaque ligne est une règle appliquée par le convertisseur, avec la ligne de rapport qu'il écrit quand la règle change quelque chose dans vos données.

  • boolean

    bit

    bit stocke true comme 1 et false comme 0.

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

    nvarchar(n) ; text en nvarchar(max), ou nvarchar(450) si une clé l'utilise et que chaque valeur y tient

    nvarchar contient tous les caractères. SQL Server ne peut pas indexer nvarchar(max), donc un texte dans une clé est dimensionné pour tenir dans une clé.

  • text comparison

    exacte (Latin1_General_100_BIN2) ; citext insensible à la casse (Latin1_General_100_CI_AS_SC)

    La collation habituelle de SQL Server ignore la casse, pas le texte de PostgreSQL ; chaque colonne indique donc comment elle compare, et les clés uniques distinguent les mêmes lignes.

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

    nvarchar ; decimal(p,s) ajusté aux valeurs si elles tiennent en 38 chiffres

    Le decimal de SQL Server contient 38 chiffres. Un numeric sans précision reçoit le plus petit decimal où tiennent ses valeurs ; les nombres plus larges sont gardés en texte pour que chaque chiffre reste exact.

    Ligne du rapport: decimal_as_text

  • money

    decimal(19,2)

    Le money de SQL Server est plus petit que celui de PostgreSQL et a quatre décimales ; decimal(19,2) contient chaque montant, sans le symbole monétaire ajouté par la locale du serveur.

    Ligne du rapport: type_replaced

  • interval

    nvarchar(100) avec le texte de PostgreSQL

    SQL Server n'a pas de type intervalle ; le texte en garde chaque partie.

    Ligne du rapport: type_replaced

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

    nvarchar(max) avec un tableau JSON

    SQL Server n'a pas de tableaux. Un tableau JSON garde chaque élément et NULL, et OPENJSON le lit.

    Ligne du rapport: type_replaced

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

    nvarchar(max) avec le texte de PostgreSQL

    SQL Server n'a pas de type équivalent ; chaque valeur garde donc le texte écrit par PostgreSQL.

    Ligne du rapport: type_replaced

  • json, jsonb

    nvarchar(max)

    Les fonctions JSON de SQL Server lisent le JSON depuis du texte.

  • timestamp

    datetime2

    Un timestamp sans fuseau horaire est une date et une heure locales, comme datetime2.

  • timestamp with time zone

    datetimeoffset en UTC

    datetimeoffset garde l'instant ; chaque valeur est écrite en UTC, le même instant quel que soit le décalage écrit par le dump.

  • time with 24:00:00 in it

    nvarchar(17)

    Le time de SQL Server s'arrête à 23:59:59.9999999 ; une colonne qui contient 24:00:00 garde donc son texte.

    Ligne du rapport: time_as_interval

  • infinity, -infinity and BC dates

    NULL

    SQL Server stocke les années 1 à 9999, sans infini. Ces valeurs deviennent NULL et le rapport les compte.

    Ligne du rapport: date_out_of_range

  • NaN and Infinity in numeric, real and double precision

    NULL

    Les nombres de SQL Server n'ont ni NaN ni Infinity ; ces valeurs deviennent donc NULL et le rapport les compte.

    Ligne du rapport: invalid_value_null

  • NOT NULL columns with values that become NULL

    NOT NULL retiré

    Une colonne dont des valeurs ont dû devenir NULL ne peut pas garder NOT NULL, sinon le chargement s'arrêterait.

    Ligne du rapport: not_null_relaxed

  • enum types

    nvarchar avec un CHECK de ses libellés

    Un texte avec une contrainte CHECK garde les mêmes valeurs.

  • enum columns holding values outside their labels

    nvarchar sans CHECK

    Les valeurs absentes des libellés feraient échouer la contrainte CHECK, qui n'est donc pas créée.

    Ligne du rapport: enum_check_skipped

  • uuid, inet, cidr, macaddr

    uniqueidentifier ; adresses en nvarchar

    uniqueidentifier est l'UUID de SQL Server ; les adresses sont gardées en texte.

  • bytea

    varbinary(max)

    Les octets restent des octets.

  • bit(n), bit varying

    bit pour un seul bit ; bigint jusqu'à 63 bits ; chiffres en texte au-delà

    Un seul bit est un oui ou un non ; les chaînes de bits plus longues sont stockées comme le nombre que forment leurs bits.

  • oid, xid, cid

    bigint avec un CHECK qui interdit les négatifs

    bigint contient chaque valeur.

  • serial, identity

    IDENTITY, qui reprend après l'identifiant le plus élevé

    Les identifiants copiés se chargent avec IDENTITY_INSERT, et le compteur reprend après le plus élevé ou après la prochaine valeur de la séquence, selon le plus grand.

  • a second serial or identity column in a table

    un entier simple

    SQL Server compte une colonne IDENTITY par table ; toute autre garde ses valeurs sans compteur.

    Ligne du rapport: counter_dropped

  • sequences not owned by a column

    CREATE SEQUENCE ... AS bigint, avec sa prochaine valeur

    SQL Server a des séquences avec les mêmes options ; chacune reprend là où le dump l'a laissée.

  • generated columns

    colonnes calculées, PERSISTED quand la source les stocke

    SQL Server les calcule des deux mêmes façons.

  • generated columns with functions SQL Server lacks

    une colonne simple avec les valeurs

    Une formule qui ne peut pas être écrite pour SQL Server laisse une colonne simple avec les valeurs du dump et une ligne dans le rapport.

    Ligne du rapport: generated_not_translated

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

    aucune valeur par défaut

    Une valeur par défaut qui ne peut pas être écrite pour SQL Server est omise et signalée.

    Ligne du rapport: default_not_translated

  • CHECK constraints

    traduites, en ligne dans CREATE TABLE

    Les CHECK en ligne sont vérifiés au chargement de chaque ligne.

  • CHECK constraints with functions SQL Server lacks

    non créée

    Une contrainte CHECK qui ne peut pas être écrite pour SQL Server est omise et signalée.

    Ligne du rapport: check_skipped

  • CHECK ... NOT VALID

    non créée

    PostgreSQL n'a jamais vérifié les lignes déjà présentes, qui peuvent donc l'enfreindre.

    Ligne du rapport: check_not_valid

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

    non créé

    SQL Server indexe des colonnes, pas des expressions, et pas nvarchar(max).

    Ligne du rapport: index_skipped

  • foreign keys

    après les données WITH NOCHECK, puis vérifiée avec un avertissement sur les orphelins

    La clé est créée après les lignes et vérifiée en dernier ; des lignes sans parent la laissent non vérifiée avec un avertissement au lieu d'arrêter le chargement.

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

    NO ACTION

    SQL Server refuse les cascades qui pourraient atteindre une table deux fois ; PostgreSQL les autorise.

    Ligne du rapport: foreign_key_action_dropped

  • foreign keys to tables the dump doesn't create

    non créée

    Une clé ne peut pas désigner une table absente.

    Ligne du rapport: foreign_key_skipped

  • partitioned tables

    une seule table avec les lignes de chaque partition

    Les lignes sont les mêmes ; partitionnez à nouveau la table dans SQL Server si besoin.

    Ligne du rapport: partitions_dropped

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

    listés dans le rapport

    Leur code est écrit dans le langage de PostgreSQL ; ils sont donc listés pour que vous les recréiez.

    Ligne du rapport: not_converted_objects

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

    types déduits des valeurs

    Un dump de données seules ne contient que des lignes, donc les types viennent des valeurs.

    Ligne du rapport: no_schema

  • expressions in INSERT values

    NULL

    Un convertisseur qui n'exécute pas de base de données ne peut pas les évaluer.

    Ligne du rapport: expression_value

  • types IntoSQL doesn't know

    nvarchar(max)

    Le texte accepte toute valeur ; changez le type après le chargement.

    Ligne du rapport: unknown_type

  • text that isn't valid in its encoding

    les octets invalides deviennent le caractère de remplacement

    nvarchar contient du texte Unicode.

    Ligne du rapport: invalid_utf8_replaced

  • text decoded twice (ñ)

    copié tel quel

    Le dump contient exactement ces caractères, ils sont donc copiés ; le rapport les signale.

    Ligne du rapport: mojibake_suspected

Dans PostgreSQLDans SQL ServerLigne du rapport
booleanbitbit stocke true comme 1 et false comme 0.
varchar(n), char(n), textnvarchar(n) ; text en nvarchar(max), ou nvarchar(450) si une clé l'utilise et que chaque valeur y tientnvarchar contient tous les caractères. SQL Server ne peut pas indexer nvarchar(max), donc un texte dans une clé est dimensionné pour tenir dans une clé.
text comparisonexacte (Latin1_General_100_BIN2) ; citext insensible à la casse (Latin1_General_100_CI_AS_SC)La collation habituelle de SQL Server ignore la casse, pas le texte de PostgreSQL ; chaque colonne indique donc comment elle compare, et les clés uniques distinguent les mêmes lignes.
numeric(p,s) past 38 digits; numeric without a precisionnvarchar ; decimal(p,s) ajusté aux valeurs si elles tiennent en 38 chiffresLe decimal de SQL Server contient 38 chiffres. Un numeric sans précision reçoit le plus petit decimal où tiennent ses valeurs ; les nombres plus larges sont gardés en texte pour que chaque chiffre reste exact.decimal_as_text
moneydecimal(19,2)Le money de SQL Server est plus petit que celui de PostgreSQL et a quatre décimales ; decimal(19,2) contient chaque montant, sans le symbole monétaire ajouté par la locale du serveur.type_replaced
intervalnvarchar(100) avec le texte de PostgreSQLSQL Server n'a pas de type intervalle ; le texte en garde chaque partie.type_replaced
arrays (integer[], text[]...)nvarchar(max) avec un tableau JSONSQL Server n'a pas de tableaux. Un tableau JSON garde chaque élément et NULL, et OPENJSON le lit.type_replaced
ranges, geometric types, tsvector, xml, hstore, PostGIS, composite and extension typesnvarchar(max) avec le texte de PostgreSQLSQL Server n'a pas de type équivalent ; chaque valeur garde donc le texte écrit par PostgreSQL.type_replaced
json, jsonbnvarchar(max)Les fonctions JSON de SQL Server lisent le JSON depuis du texte.
timestampdatetime2Un timestamp sans fuseau horaire est une date et une heure locales, comme datetime2.
timestamp with time zonedatetimeoffset en UTCdatetimeoffset garde l'instant ; chaque valeur est écrite en UTC, le même instant quel que soit le décalage écrit par le dump.
time with 24:00:00 in itnvarchar(17)Le time de SQL Server s'arrête à 23:59:59.9999999 ; une colonne qui contient 24:00:00 garde donc son texte.time_as_interval
infinity, -infinity and BC datesNULLSQL Server stocke les années 1 à 9999, sans infini. Ces valeurs deviennent NULL et le rapport les compte.date_out_of_range
NaN and Infinity in numeric, real and double precisionNULLLes nombres de SQL Server n'ont ni NaN ni Infinity ; ces valeurs deviennent donc NULL et le rapport les compte.invalid_value_null
NOT NULL columns with values that become NULLNOT NULL retiréUne colonne dont des valeurs ont dû devenir NULL ne peut pas garder NOT NULL, sinon le chargement s'arrêterait.not_null_relaxed
enum typesnvarchar avec un CHECK de ses libellésUn texte avec une contrainte CHECK garde les mêmes valeurs.
enum columns holding values outside their labelsnvarchar sans CHECKLes valeurs absentes des libellés feraient échouer la contrainte CHECK, qui n'est donc pas créée.enum_check_skipped
uuid, inet, cidr, macaddruniqueidentifier ; adresses en nvarcharuniqueidentifier est l'UUID de SQL Server ; les adresses sont gardées en texte.
byteavarbinary(max)Les octets restent des octets.
bit(n), bit varyingbit pour un seul bit ; bigint jusqu'à 63 bits ; chiffres en texte au-delàUn seul bit est un oui ou un non ; les chaînes de bits plus longues sont stockées comme le nombre que forment leurs bits.
oid, xid, cidbigint avec un CHECK qui interdit les négatifsbigint contient chaque valeur.
serial, identityIDENTITY, qui reprend après l'identifiant le plus élevéLes identifiants copiés se chargent avec IDENTITY_INSERT, et le compteur reprend après le plus élevé ou après la prochaine valeur de la séquence, selon le plus grand.
a second serial or identity column in a tableun entier simpleSQL Server compte une colonne IDENTITY par table ; toute autre garde ses valeurs sans compteur.counter_dropped
sequences not owned by a columnCREATE SEQUENCE ... AS bigint, avec sa prochaine valeurSQL Server a des séquences avec les mêmes options ; chacune reprend là où le dump l'a laissée.
generated columnscolonnes calculées, PERSISTED quand la source les stockeSQL Server les calcule des deux mêmes façons.
generated columns with functions SQL Server lacksune colonne simple avec les valeursUne formule qui ne peut pas être écrite pour SQL Server laisse une colonne simple avec les valeurs du dump et une ligne dans le rapport.generated_not_translated
defaults with functions SQL Server lacks, and defaults from a sequenceaucune valeur par défautUne valeur par défaut qui ne peut pas être écrite pour SQL Server est omise et signalée.default_not_translated
CHECK constraintstraduites, en ligne dans CREATE TABLELes CHECK en ligne sont vérifiés au chargement de chaque ligne.
CHECK constraints with functions SQL Server lacksnon crééeUne contrainte CHECK qui ne peut pas être écrite pour SQL Server est omise et signalée.check_skipped
CHECK ... NOT VALIDnon crééePostgreSQL n'a jamais vérifié les lignes déjà présentes, qui peuvent donc l'enfreindre.check_not_valid
gin, gist, brin and hash indexes, partial and expression indexes, and indexes on text that doesn't fit a keynon crééSQL Server indexe des colonnes, pas des expressions, et pas nvarchar(max).index_skipped
foreign keysaprès les données WITH NOCHECK, puis vérifiée avec un avertissement sur les orphelinsLa clé est créée après les lignes et vérifiée en dernier ; des lignes sans parent la laissent non vérifiée avec un avertissement au lieu d'arrêter le chargement.
ON DELETE or ON UPDATE that cascades in a cycle or along a second pathNO ACTIONSQL Server refuse les cascades qui pourraient atteindre une table deux fois ; PostgreSQL les autorise.foreign_key_action_dropped
foreign keys to tables the dump doesn't createnon crééeUne clé ne peut pas désigner une table absente.foreign_key_skipped
partitioned tablesune seule table avec les lignes de chaque partitionLes lignes sont les mêmes ; partitionnez à nouveau la table dans SQL Server si besoin.partitions_dropped
views, functions, procedures, triggers, rules, policies, extensions and typeslistés dans le rapportLeur code est écrit dans le langage de PostgreSQL ; ils sont donc listés pour que vous les recréiez.not_converted_objects
dumps without CREATE TABLE (--data-only)types déduits des valeursUn dump de données seules ne contient que des lignes, donc les types viennent des valeurs.no_schema
expressions in INSERT valuesNULLUn convertisseur qui n'exécute pas de base de données ne peut pas les évaluer.expression_value
types IntoSQL doesn't knownvarchar(max)Le texte accepte toute valeur ; changez le type après le chargement.unknown_type
text that isn't valid in its encodingles octets invalides deviennent le caractère de remplacementnvarchar contient du texte Unicode.invalid_utf8_replaced
text decoded twice (ñ)copié tel quelLe dump contient exactement ces caractères, ils sont donc copiés ; le rapport les signale.mojibake_suspected

Charger le script dans SQL Server

Le script crée les tables, copie les lignes, puis ajoute les clés, les index et les clés étrangères ; il se charge donc vite et s'arrête à la première erreur.

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

Les clés étrangères sont ajoutées WITH NOCHECK, puis vérifiées. Si une ligne pointe vers une ligne qui n'existe pas, le script indique quelle contrainte et la laisse non vérifiée, au lieu d'échouer à mi-chemin.

Pour un gros dump, exécutez sqlcmd sur la machine du serveur. Chaque lot de 1000 lignes au plus est validé à part, donc le journal des transactions reste petit.

Faire le dump PostgreSQL pour un meilleur résultat

Le convertisseur lit ce que contient le dump. Ces options y gardent davantage de vos données :

  • --format=plain, le format par défaut de pg_dump, écrit du SQL. Une archive custom ou directory (-Fc, -Fd) devient du SQL avec pg_restore -f dump.sql, sans serveur de base de données.
  • --no-owner --no-privileges omettent les rôles et les droits, que le convertisseur ignore de toute façon ; le dump est donc plus petit.
  • pg_dumpall met toutes les bases de données dans un seul fichier ; les tables de chacune sont préfixées par son nom, donc rien n'entre en collision.

Ce qui n'est pas converti

Les vues, vues matérialisées, fonctions, procédures, déclencheurs, règles, politiques de sécurité des lignes, extensions et types sont écrits dans le langage propre à PostgreSQL. Ils sont listés par nom dans le rapport, jamais supprimés en silence, pour que vous puissiez les réécrire pour SQL Server.

Questions sur PostgreSQL vers SQL Server

Pas de réponse ici ? Écrivez-nous depuis la page de contact, une personne vous répond. Page de contact

Mon dump est-il envoyé ?

Non. Le convertisseur s'exécute dans votre navigateur et lit le dump depuis votre disque par morceaux ; il ne quitte donc jamais votre ordinateur. L'application de bureau et la ligne de commande convertissent aussi sur votre ordinateur.

Quelle taille peut avoir le dump ?

Le convertisseur ne garde jamais tout le dump en mémoire : il lit le fichier deux fois, par plages, et écrit le script au fur et à mesure. Les dumps de plusieurs gigaoctets se convertissent dans le navigateur, dans l'application de bureau et avec la ligne de commande.

Lit-il les archives pg_dump -Fc ?

Pas directement : une archive custom est un format binaire. pg_restore -f dump.sql dump.backup la transforme en SQL texte que le convertisseur lit, sans se connecter à un serveur. Le convertisseur le signale quand il reçoit une archive.

De quelles versions de PostgreSQL le dump peut-il venir ?

Les dumps écrits par pg_dump et pg_dumpall depuis PostgreSQL 10, avec des lignes COPY ou INSERT. Chaque dump de test vient de PostgreSQL 13 et 18 et est comparé à sa source cellule par cellule.

Les valeurs serial et identity sont-elles conservées ?

Oui. La colonne serial ou identity de chaque table devient une colonne IDENTITY, chaque ligne garde son identifiant, et le prochain identifiant reprend après le plus élevé. SQL Server compte une colonne par table ; toute autre garde donc ses valeurs sans compteur.

Que deviennent les tableaux, les enums et les autres types PostgreSQL ?

Les tableaux deviennent des tableaux JSON, les booléens bit, uuid uniqueidentifier, et les timestamps avec fuseau horaire datetimeoffset. Le texte se compare exactement, comme dans PostgreSQL, et citext sans tenir compte de la casse. Les plages, types géométriques et types composites gardent le texte de PostgreSQL.

Et les fonctions, les déclencheurs et les vues ?

Ils sont listés par nom dans le rapport et ne sont pas convertis, car chaque base de données les écrit dans son propre langage.

Sur quelles versions de SQL Server le script se charge-t-il ?

SQL Server 2017 à 2025. Le même script se charge sur chacune, et s'arrête à la première erreur en cas de problème.