Pular para o conteúdo
Início do IntoSQL

Converta PostgreSQL para SQL Server

Solte um dump simples do pg_dump ou pg_dumpall, em .sql ou .sql.gz, e baixe um script do SQL Server com as mesmas tabelas, chaves, índices e dados. Cada valor que o SQL Server não aceita como está, e cada objeto que ele não traz, aparece no relatório.

Seu arquivo
sqlshop_2024_postgres.sqlArquivo de exemplo, 6,2 kB
Seu banco de dados

18 linhas convertidas, 2 correções, nenhuma rejeitada

Mostrar

Tabelas em shop_2024_postgres.sqlDump do PostgreSQL 18.6 · gerado por pg_dump · utf8mb4

  • customers8 linhas1
    8 colunas
    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 linhas1
    10 colunas
    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)

Não convertidos

  • Visão paid_orders

Cada banco de dados escreve estes objetos na sua própria linguagem. Reescreva-os para o 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

Correções

  1. "tags" de customers é text[], que o SQL Server não tem, então vira nvarchar(max) com os mesmos valores.
  2. "delivery" de orders é interval, que o SQL Server não tem, então vira nvarchar(100) com os mesmos valores.

Para revisar

  • 1 visão, gatilho, rotina ou evento não foi convertido; o relatório lista cada um. Recrie-os manualmente no SQL Server.
  • O valor padrão de "tags" em customers não pode ser escrito para o SQL Server (a value its type can't hold), então a coluna fica sem valor padrão. Adicione o valor padrão manualmente se novas linhas precisarem dele.
  • O índice idx_orders_details de orders usa uma expressão que não pode ser escrita para o SQL Server (an index on an expression), então não é criado. Crie o índice manualmente se as consultas precisarem dele.
  • 1 valor em "shipped_at" de orders é uma data que o SQL Server não consegue guardar, como infinity, então ficou NULL. O SQL Server guarda os anos de 1 a 9999 sem infinito; substitua essas datas na origem se elas forem importantes.

Seu arquivo é convertido neste computador e nunca é enviado.

Outros exemplos:

O que muda do PostgreSQL para o SQL Server

Cada linha é uma regra que o conversor aplica, com a linha do relatório que ele escreve quando a regra muda algo nos seus dados.

  • boolean

    bit

    bit guarda true como 1 e false como 0.

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

    nvarchar(n); text como nvarchar(max), ou nvarchar(450) quando uma chave o usa e todo valor cabe

    nvarchar comporta qualquer caractere. O SQL Server não indexa nvarchar(max), então o texto em uma chave tem o tamanho que cabe em uma chave.

  • text comparison

    exata (Latin1_General_100_BIN2); citext sem diferenciar maiúsculas (Latin1_General_100_CI_AS_SC)

    A collation usual do SQL Server ignora maiúsculas, e o text do PostgreSQL não, então cada coluna diz como compara e as chaves únicas mantêm as mesmas linhas separadas.

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

    nvarchar; decimal(p,s) ajustado aos valores quando eles cabem em 38 dígitos

    O decimal do SQL Server comporta 38 dígitos. Um numeric sem precisão recebe o menor decimal em que seus valores cabem; números mais largos ficam como texto, para que cada dígito continue exato.

    Linha do relatório: decimal_as_text

  • money

    decimal(19,2)

    O money do SQL Server é menor que o do PostgreSQL e tem quatro decimais; decimal(19,2) comporta todo valor, sem o símbolo de moeda que a localidade do servidor adicionou.

    Linha do relatório: type_replaced

  • interval

    nvarchar(100) com o texto do PostgreSQL

    O SQL Server não tem tipo interval; o texto mantém cada parte.

    Linha do relatório: type_replaced

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

    nvarchar(max) com um array JSON

    O SQL Server não tem arrays. Um array JSON mantém cada item e NULL, e o OPENJSON o lê.

    Linha do relatório: type_replaced

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

    nvarchar(max) com o texto do PostgreSQL

    O SQL Server não tem um tipo equivalente, então cada valor mantém o texto que o PostgreSQL escreveu.

    Linha do relatório: type_replaced

  • json, jsonb

    nvarchar(max)

    As funções JSON do SQL Server leem JSON a partir de texto.

  • timestamp

    datetime2

    Um timestamp sem fuso horário é a leitura de um relógio de parede, como o datetime2.

  • timestamp with time zone

    datetimeoffset em UTC

    datetimeoffset mantém o instante; cada valor é escrito em UTC, o mesmo instante qualquer que seja o fuso que o dump escreveu.

  • time with 24:00:00 in it

    nvarchar(17)

    O time do SQL Server termina em 23:59:59.9999999, então uma coluna que contém 24:00:00 mantém seu texto.

    Linha do relatório: time_as_interval

  • infinity, -infinity and BC dates

    NULL

    O SQL Server guarda os anos de 1 a 9999 sem infinito. Esses valores viram NULL e o relatório os conta.

    Linha do relatório: date_out_of_range

  • NaN and Infinity in numeric, real and double precision

    NULL

    Os números do SQL Server não têm NaN nem Infinity, então esses valores viram NULL e o relatório os conta.

    Linha do relatório: invalid_value_null

  • NOT NULL columns with values that become NULL

    NOT NULL removido

    Uma coluna cujos valores tiveram de virar NULL não pode manter NOT NULL, senão a carga pararia.

    Linha do relatório: not_null_relaxed

  • enum types

    nvarchar com um CHECK dos rótulos

    Texto com um CHECK mantém os mesmos valores.

  • enum columns holding values outside their labels

    nvarchar sem CHECK

    Valores que os rótulos não nomeiam violariam o CHECK, então ele não é criado.

    Linha do relatório: enum_check_skipped

  • uuid, inet, cidr, macaddr

    uniqueidentifier; endereços como nvarchar

    uniqueidentifier é o UUID do SQL Server; os endereços ficam como texto.

  • bytea

    varbinary(max)

    Bytes continuam bytes.

  • bit(n), bit varying

    bit para um bit; bigint até 63 bits; dígitos em texto acima disso

    Um único bit é um sim ou não; strings de bits mais longas são guardadas como o número que seus bits formam.

  • oid, xid, cid

    bigint com um CHECK de que não é negativo

    bigint comporta todo valor.

  • serial, identity

    IDENTITY, continuando depois do maior id

    Os ids copiados carregam com IDENTITY_INSERT, e o contador continua depois do maior deles ou do próximo valor da sequência, o que for maior.

  • a second serial or identity column in a table

    um inteiro simples

    O SQL Server conta uma coluna IDENTITY por tabela; qualquer outra mantém seus valores sem contador.

    Linha do relatório: counter_dropped

  • sequences not owned by a column

    CREATE SEQUENCE ... AS bigint, com o próximo valor

    O SQL Server tem sequências com as mesmas opções; cada uma continua de onde o dump parou.

  • generated columns

    colunas computadas, PERSISTED quando a origem as armazena

    O SQL Server as calcula dos mesmos dois jeitos.

  • generated columns with functions SQL Server lacks

    uma coluna simples com os valores

    Uma fórmula que não pode ser escrita para o SQL Server deixa uma coluna simples com os valores do dump e uma linha no relatório.

    Linha do relatório: generated_not_translated

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

    sem valor padrão

    Um valor padrão que não pode ser escrito para o SQL Server fica de fora e é informado.

    Linha do relatório: default_not_translated

  • CHECK constraints

    traduzido, dentro do CREATE TABLE

    Os CHECKs são testados à medida que cada linha carrega.

  • CHECK constraints with functions SQL Server lacks

    não criado

    Um CHECK que não pode ser escrito para o SQL Server fica de fora e é informado.

    Linha do relatório: check_skipped

  • CHECK ... NOT VALID

    não criado

    O PostgreSQL nunca verificou as linhas que já existiam, então elas podem violá-lo.

    Linha do relatório: check_not_valid

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

    não criado

    O SQL Server indexa colunas, não expressões, e não nvarchar(max).

    Linha do relatório: index_skipped

  • foreign keys

    depois dos dados WITH NOCHECK, e então verificada com um aviso sobre órfãos

    A chave é criada depois das linhas e verificada por último; linhas sem pai a deixam sem verificação com um aviso, em vez de parar a carga.

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

    NO ACTION

    O SQL Server recusa cascatas que poderiam chegar a uma tabela duas vezes; o PostgreSQL as permite.

    Linha do relatório: foreign_key_action_dropped

  • foreign keys to tables the dump doesn't create

    não criada

    Uma chave não pode apontar para uma tabela que não existe.

    Linha do relatório: foreign_key_skipped

  • partitioned tables

    uma tabela com as linhas de todas as partições

    As linhas são as mesmas; particione a tabela de novo no SQL Server se precisar.

    Linha do relatório: partitions_dropped

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

    listados no relatório

    O código deles é escrito na linguagem do PostgreSQL, então eles são listados para você recriá-los.

    Linha do relatório: not_converted_objects

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

    tipos lidos dos valores

    Um dump só de dados tem apenas linhas, então os tipos vêm dos valores.

    Linha do relatório: no_schema

  • expressions in INSERT values

    NULL

    Um conversor que não executa um banco de dados não consegue avaliá-las.

    Linha do relatório: expression_value

  • types IntoSQL doesn't know

    nvarchar(max)

    O texto aceita qualquer valor; mude o tipo depois da carga.

    Linha do relatório: unknown_type

  • text that isn't valid in its encoding

    os bytes inválidos como o caractere de substituição

    nvarchar guarda texto Unicode.

    Linha do relatório: invalid_utf8_replaced

  • text decoded twice (ñ)

    copiado como está

    O dump contém exatamente esses caracteres, então eles são copiados; o relatório os aponta.

    Linha do relatório: mojibake_suspected

No PostgreSQLNo SQL ServerLinha do relatório
booleanbitbit guarda true como 1 e false como 0.
varchar(n), char(n), textnvarchar(n); text como nvarchar(max), ou nvarchar(450) quando uma chave o usa e todo valor cabenvarchar comporta qualquer caractere. O SQL Server não indexa nvarchar(max), então o texto em uma chave tem o tamanho que cabe em uma chave.
text comparisonexata (Latin1_General_100_BIN2); citext sem diferenciar maiúsculas (Latin1_General_100_CI_AS_SC)A collation usual do SQL Server ignora maiúsculas, e o text do PostgreSQL não, então cada coluna diz como compara e as chaves únicas mantêm as mesmas linhas separadas.
numeric(p,s) past 38 digits; numeric without a precisionnvarchar; decimal(p,s) ajustado aos valores quando eles cabem em 38 dígitosO decimal do SQL Server comporta 38 dígitos. Um numeric sem precisão recebe o menor decimal em que seus valores cabem; números mais largos ficam como texto, para que cada dígito continue exato.decimal_as_text
moneydecimal(19,2)O money do SQL Server é menor que o do PostgreSQL e tem quatro decimais; decimal(19,2) comporta todo valor, sem o símbolo de moeda que a localidade do servidor adicionou.type_replaced
intervalnvarchar(100) com o texto do PostgreSQLO SQL Server não tem tipo interval; o texto mantém cada parte.type_replaced
arrays (integer[], text[]...)nvarchar(max) com um array JSONO SQL Server não tem arrays. Um array JSON mantém cada item e NULL, e o OPENJSON o lê.type_replaced
ranges, geometric types, tsvector, xml, hstore, PostGIS, composite and extension typesnvarchar(max) com o texto do PostgreSQLO SQL Server não tem um tipo equivalente, então cada valor mantém o texto que o PostgreSQL escreveu.type_replaced
json, jsonbnvarchar(max)As funções JSON do SQL Server leem JSON a partir de texto.
timestampdatetime2Um timestamp sem fuso horário é a leitura de um relógio de parede, como o datetime2.
timestamp with time zonedatetimeoffset em UTCdatetimeoffset mantém o instante; cada valor é escrito em UTC, o mesmo instante qualquer que seja o fuso que o dump escreveu.
time with 24:00:00 in itnvarchar(17)O time do SQL Server termina em 23:59:59.9999999, então uma coluna que contém 24:00:00 mantém seu texto.time_as_interval
infinity, -infinity and BC datesNULLO SQL Server guarda os anos de 1 a 9999 sem infinito. Esses valores viram NULL e o relatório os conta.date_out_of_range
NaN and Infinity in numeric, real and double precisionNULLOs números do SQL Server não têm NaN nem Infinity, então esses valores viram NULL e o relatório os conta.invalid_value_null
NOT NULL columns with values that become NULLNOT NULL removidoUma coluna cujos valores tiveram de virar NULL não pode manter NOT NULL, senão a carga pararia.not_null_relaxed
enum typesnvarchar com um CHECK dos rótulosTexto com um CHECK mantém os mesmos valores.
enum columns holding values outside their labelsnvarchar sem CHECKValores que os rótulos não nomeiam violariam o CHECK, então ele não é criado.enum_check_skipped
uuid, inet, cidr, macaddruniqueidentifier; endereços como nvarcharuniqueidentifier é o UUID do SQL Server; os endereços ficam como texto.
byteavarbinary(max)Bytes continuam bytes.
bit(n), bit varyingbit para um bit; bigint até 63 bits; dígitos em texto acima dissoUm único bit é um sim ou não; strings de bits mais longas são guardadas como o número que seus bits formam.
oid, xid, cidbigint com um CHECK de que não é negativobigint comporta todo valor.
serial, identityIDENTITY, continuando depois do maior idOs ids copiados carregam com IDENTITY_INSERT, e o contador continua depois do maior deles ou do próximo valor da sequência, o que for maior.
a second serial or identity column in a tableum inteiro simplesO SQL Server conta uma coluna IDENTITY por tabela; qualquer outra mantém seus valores sem contador.counter_dropped
sequences not owned by a columnCREATE SEQUENCE ... AS bigint, com o próximo valorO SQL Server tem sequências com as mesmas opções; cada uma continua de onde o dump parou.
generated columnscolunas computadas, PERSISTED quando a origem as armazenaO SQL Server as calcula dos mesmos dois jeitos.
generated columns with functions SQL Server lacksuma coluna simples com os valoresUma fórmula que não pode ser escrita para o SQL Server deixa uma coluna simples com os valores do dump e uma linha no relatório.generated_not_translated
defaults with functions SQL Server lacks, and defaults from a sequencesem valor padrãoUm valor padrão que não pode ser escrito para o SQL Server fica de fora e é informado.default_not_translated
CHECK constraintstraduzido, dentro do CREATE TABLEOs CHECKs são testados à medida que cada linha carrega.
CHECK constraints with functions SQL Server lacksnão criadoUm CHECK que não pode ser escrito para o SQL Server fica de fora e é informado.check_skipped
CHECK ... NOT VALIDnão criadoO PostgreSQL nunca verificou as linhas que já existiam, então elas podem violá-lo.check_not_valid
gin, gist, brin and hash indexes, partial and expression indexes, and indexes on text that doesn't fit a keynão criadoO SQL Server indexa colunas, não expressões, e não nvarchar(max).index_skipped
foreign keysdepois dos dados WITH NOCHECK, e então verificada com um aviso sobre órfãosA chave é criada depois das linhas e verificada por último; linhas sem pai a deixam sem verificação com um aviso, em vez de parar a carga.
ON DELETE or ON UPDATE that cascades in a cycle or along a second pathNO ACTIONO SQL Server recusa cascatas que poderiam chegar a uma tabela duas vezes; o PostgreSQL as permite.foreign_key_action_dropped
foreign keys to tables the dump doesn't createnão criadaUma chave não pode apontar para uma tabela que não existe.foreign_key_skipped
partitioned tablesuma tabela com as linhas de todas as partiçõesAs linhas são as mesmas; particione a tabela de novo no SQL Server se precisar.partitions_dropped
views, functions, procedures, triggers, rules, policies, extensions and typeslistados no relatórioO código deles é escrito na linguagem do PostgreSQL, então eles são listados para você recriá-los.not_converted_objects
dumps without CREATE TABLE (--data-only)tipos lidos dos valoresUm dump só de dados tem apenas linhas, então os tipos vêm dos valores.no_schema
expressions in INSERT valuesNULLUm conversor que não executa um banco de dados não consegue avaliá-las.expression_value
types IntoSQL doesn't knownvarchar(max)O texto aceita qualquer valor; mude o tipo depois da carga.unknown_type
text that isn't valid in its encodingos bytes inválidos como o caractere de substituiçãonvarchar guarda texto Unicode.invalid_utf8_replaced
text decoded twice (ñ)copiado como estáO dump contém exatamente esses caracteres, então eles são copiados; o relatório os aponta.mojibake_suspected

Carregue o script no SQL Server

O script cria as tabelas, copia as linhas e depois adiciona chaves, índices e chaves estrangeiras, então carrega rápido e para no primeiro erro.

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

As chaves estrangeiras são adicionadas WITH NOCHECK e depois verificadas. Se uma linha aponta para uma linha que não existe, o script informa qual restrição e a deixa sem verificação, em vez de falhar no meio do caminho.

Para um dump grande, execute o sqlcmd na mesma máquina do servidor. Cada lote de até 1000 linhas faz commit sozinho, então o log de transações continua pequeno.

Gere o dump do PostgreSQL para o melhor resultado

O conversor lê o que o dump contém. Estas opções mantêm mais dos seus dados nele:

  • --format=plain, o padrão do pg_dump, escreve SQL. Um arquivo custom ou de diretório (-Fc, -Fd) vira SQL com pg_restore -f dump.sql, sem servidor de banco de dados.
  • --no-owner --no-privileges deixam de fora papéis e permissões, que o conversor ignora de qualquer forma, então o dump fica menor.
  • O pg_dumpall gera o dump de todos os bancos de dados em um arquivo; as tabelas de cada um recebem o nome dele, então nada colide.

O que não é convertido

Visões, visões materializadas, funções, procedimentos, gatilhos, regras, políticas de segurança de linha, extensões e tipos são escritos na linguagem própria do PostgreSQL. Eles aparecem no relatório pelo nome, nunca são descartados em silêncio, para que você possa reescrevê-los para o SQL Server.

Perguntas sobre PostgreSQL para SQL Server

Não encontrou a resposta? Escreva para nós pela página de contato e uma pessoa responde. Página de contato

Meu dump é enviado?

Não. O conversor roda no seu navegador e lê o dump do seu disco em partes, então ele nunca sai do seu computador. O app para desktop e a linha de comando também convertem no seu computador.

Qual o tamanho máximo do dump?

O conversor nunca guarda o dump inteiro na memória: ele lê o arquivo duas vezes, por intervalos, e escreve o script à medida que avança. Dumps de vários gigabytes são convertidos no navegador, no app para desktop e com a linha de comando.

Ele lê arquivos do pg_dump -Fc?

Não diretamente: um arquivo custom é um formato binário. pg_restore -f dump.sql dump.backup o transforma no SQL simples que o conversor lê, sem se conectar a um servidor. O conversor avisa quando recebe um arquivo desses.

De quais versões do PostgreSQL o dump pode vir?

Dumps escritos pelo pg_dump e pg_dumpall do PostgreSQL 10 em diante, com linhas em COPY ou INSERT. Cada dump de teste vem do PostgreSQL 13 e 18 e é comparado com a origem célula por célula.

Os valores serial e identity são mantidos?

Sim. A coluna serial ou identity de cada tabela vira uma coluna IDENTITY, cada linha mantém seu id, e o próximo id continua depois do maior. O SQL Server conta uma coluna por tabela, então qualquer outra mantém seus valores sem contador.

O que acontece com arrays, enums e outros tipos do PostgreSQL?

Arrays viram arrays JSON, booleanos bit, uuid uniqueidentifier, e timestamps com fuso horário datetimeoffset. O texto é comparado de forma exata, como no PostgreSQL, e citext sem diferenciar maiúsculas. Ranges, tipos geométricos e tipos compostos mantêm o texto do PostgreSQL.

E as funções, gatilhos e visões?

Eles aparecem no relatório pelo nome e não são convertidos, porque cada banco de dados os escreve na sua própria linguagem.

Em quais versões do SQL Server o script carrega?

SQL Server 2017 a 2025. O mesmo script carrega em cada uma delas e para no primeiro erro se algo der errado.