# Importar dump PostgreSQL no phpPgAdmin sem perder dados

A sequência que evita perder dados ao subir um .sql no phpPgAdmin do cPanel, e o que fazer quando o arquivo é grande demais para o formulário.

> abra o banco com prefixo da conta no phpPgAdmin, rode um SELECT de conferência, exporte pela aba Exportar e só então importe pela aba SQL. Se o arquivo estourar o limite de upload do PHP, divida o dump com pg_dump --schema-only e --data-only ou use psql via SSH.

João Rizzon · 2026-10-18 · Painéis

---

Você migrou um sistema que não roda em MySQL (Django, Odoo, um ERP qualquer), criou o banco PostgreSQL no cPanel e agora tem um arquivo `.sql` na mão. A parte que ninguém documenta direito é a ordem das coisas: importar primeiro e conferir depois costuma terminar em tabela duplicada, chave primária estourada ou um banco que você não consegue mais abrir.

A ordem segura é outra: abrir o banco certo, olhar o que já existe, exportar o estado atual e só então importar. Abaixo está esse caminho, clique a clique, com as três armadilhas que o painel não avisa.

## Bancos de Dados PostgreSQL e phpPgAdmin fazem coisas diferentes

No cPanel, o PostgreSQL aparece em duas ferramentas distintas e é comum confundir:

| Ferramenta no cPanel | Para que serve |
|---|---||
| Bancos de Dados PostgreSQL | Criar banco, criar usuário e **associar** usuário ao banco |
| phpPgAdmin | Abrir o banco já criado, rodar SQL, exportar e importar dados |

A [documentação oficial do cPanel](https://docs.cpanel.net/cpanel/databases/phppgadmin/) descreve o phpPgAdmin como a interface para gerenciar os bancos PostgreSQL da sua conta. Ele não cria a conta nem resolve permissão: isso é na outra tela.

Se o phpPgAdmin abrir e você não vir nenhum banco na árvore da esquerda, o problema quase sempre não é o phpPgAdmin. É associação de usuário, e está tratado mais abaixo.

## O prefixo da conta muda o nome do banco e quebra o dump

O cPanel adiciona o prefixo da sua conta de usuário aos nomes de banco e de usuário de banco. Você digita `loja` no formulário e o objeto criado se chama algo como `minhaconta_loja` (exemplo fictício, troque pelo prefixo real que aparece acinzentado antes do campo).

Isso quebra duas coisas de uma vez:

- A string de conexão da aplicação. Se o `settings.py` do Django ou o `odoo.conf` tem `NAME: loja`, a conexão falha, porque o banco se chama `minhaconta_loja`.
- O conteúdo do dump. Dump gerado em outro servidor costuma trazer linhas de `CREATE DATABASE`, `\connect`, `OWNER TO` ou `GRANT` apontando para nomes de banco e de dono que não existem aqui.

O que fazer: abra o `.sql` em um editor de texto antes de importar e procure por `OWNER TO`, `CREATE DATABASE`, `\connect` e `GRANT`. Substitua os nomes antigos pelos nomes com prefixo. Se o dump for grande demais para o editor, veja a seção do `psql`, onde esse ajuste pode ser feito em outro ponto.

## O banco não aparece na árvore porque o usuário não foi associado

Criar usuário e criar banco são dois botões. Ligar um ao outro é um terceiro, e é o que mais fica esquecido. O sintoma é claro: o login no phpPgAdmin funciona, ou a aplicação até autentica, mas o banco não aparece, ou aparece vazio, ou qualquer `INSERT` volta com erro de permissão.

Como resolver:

### Abra Bancos de Dados PostgreSQL no menu do cPanel

No menu do cPanel, seção Bancos de Dados, clique em **Bancos de Dados PostgreSQL**.

### Associe usuário e banco com privilégios ALL

Escolha o usuário em um campo, o banco no outro e confirme. Dê privilégios completos (ALL) se a aplicação for criar e alterar tabelas, que é o caso de qualquer framework que roda migrations.

### Confirme no phpPgAdmin que o banco abre ao clique

O banco precisa aparecer na árvore da esquerda e abrir ao clique. Se não abrir, o passo 2 não foi concluído.

## A ordem que evita tabela duplicada e chave primária estourada

Quatro etapas, nesta sequência. Pular a terceira é o erro que não tem desfazer.

### Confira no topo da tela qual banco está selecionado

Entre em **phpPgAdmin** no cPanel. Na árvore à esquerda, clique no servidor, depois no nome do banco com prefixo, depois em **Schemas** e em **public**. Confira no topo da tela qual banco está selecionado antes de digitar qualquer comando. Se você tem homologação e produção na mesma conta, os nomes diferem por uma palavra e o clique errado é fácil.

### Liste as tabelas e conte as linhas antes de mexer

Clique na aba **SQL** e rode uma consulta que não altera nada, só para saber o que existe:

```sql
SELECT tablename
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY tablename;
```

Resultado esperado: a lista das tabelas do schema público. Se vier vazia, o banco está zerado e a importação é direta. Se vier com as tabelas que o dump também cria, você tem conflito, e importar por cima vai gerar erro de objeto duplicado ou, pior, duplicar linhas.

Para conferir o volume de uma tabela específica antes de mexer nela (exemplo fictício de nome de tabela):

```sql
SELECT count(*) FROM clientes;
```

Anote o número. Depois da importação, rode de novo. É a forma mais barata de saber se o arquivo entrou inteiro.

### Exporte o estado atual antes de alterar qualquer linha

Esta é a etapa inegociável. Com o banco selecionado, clique na aba **Exportar**. A documentação do cPanel aponta a exportação no phpPgAdmin como a forma de gerar uma cópia do banco ou da tabela a partir do painel.

Escolha o formato SQL, marque para incluir estrutura e dados, e salve o arquivo no seu computador com data no nome, por exemplo `loja-2026-10-16-antes-import.sql`. Guarde fora do servidor. Backup que mora no mesmo disco do banco não é backup.

Se for alterar só uma tabela, exporte essa tabela: selecione a tabela na árvore e use Exportar a partir dela.

### Importe o dump e corrija as sequences com setval

Na aba **SQL** do banco selecionado existe um campo para colar comandos e um campo de upload de arquivo. Para um dump pequeno, escolher o arquivo e enviar resolve. Para um dump grande, ele vai morrer no meio, e a próxima seção é sobre isso.

Depois de importar, rode de novo o `count(*)` da etapa 2 e compare com o número esperado. Confira também se as sequences vieram junto: no PostgreSQL, um dump importado sem o valor atual das sequences faz o próximo `INSERT` da aplicação colidir com chave primária existente.

Para conferir, rode na aba **SQL** (nomes de exemplo, troque pelos seus):

```sql
SELECT last_value FROM clientes_id_seq;
SELECT max(id) FROM clientes;
```

O nome da sequence segue o padrão `tabela_coluna_seq` e aparece na árvore da esquerda, dentro de **public**, em Sequences. Resultado esperado: `last_value` maior ou igual ao `max(id)`. Se o `last_value` for menor, a sequence está defasada e o próximo cadastro pela aplicação vai falhar.

Para corrigir:

```sql
SELECT setval('clientes_id_seq', (SELECT max(id) FROM clientes));
```

O `setval` reposiciona o contador no maior id existente. Resultado esperado: uma linha com o novo valor, igual ao `max(id)`. Repita para cada tabela com coluna serial. Se a tabela estiver vazia, `max(id)` volta nulo e o `setval` falha: nesse caso não há o que corrigir.

## Como reconhecer que o limite de upload cortou o arquivo

O formulário de importação do phpPgAdmin é um upload HTTP comum. Ele obedece aos limites do PHP do servidor, principalmente `upload_max_filesize`, `post_max_size` e `max_execution_time`. Quando o arquivo passa do limite, o navegador não costuma dizer isso com todas as letras: volta uma página em branco, um erro genérico, ou pior, uma importação parcial, com metade das tabelas dentro e metade fora.

Como reconhecer cada caso:

| Sintoma | Causa provável | Saída |
|---|---|---||
| Página em branco ou erro logo ao enviar | Arquivo maior que `upload_max_filesize` ou `post_max_size` | Dividir o dump ou usar linha de comando |
| Envio começa e para no meio do caminho | Tempo de execução esgotado | Dividir o dump ou usar linha de comando |
| Importou, mas faltam tabelas | Importação parcial interrompida | Limpar o schema e só então restaurar o export da etapa 3 |
| Erro de objeto já existente | Tabela já existia antes da importação | Limpar o schema ou ajustar o dump |

Se acontecer importação parcial, não insista por cima: importar de novo sobre as tabelas que já entraram devolve erro de objeto já existente. O banco precisa voltar a ficar vazio antes de receber o arquivo da etapa 3.

No phpPgAdmin, confira no topo da tela que o banco selecionado é o certo, abra a aba **SQL** e rode:

```sql
DROP SCHEMA public CASCADE;
CREATE SCHEMA public;
```

Risco: a primeira linha apaga todas as tabelas, views e sequences do schema público, e não tem desfazer. Só rode com o arquivo da etapa 3 salvo no seu computador. Se preferir apagar só o que conflita, troque pelas linhas `DROP TABLE nome_da_tabela CASCADE;` das tabelas envolvidas.

Resultado esperado: a mensagem de comando executado e a árvore da esquerda com **public** sem nenhuma tabela. Com o schema limpo, importe o arquivo exportado na etapa 3 pela aba **SQL**, confira os `count(*)` anotados e só então tente de novo o dump novo, por outro caminho.

### Elevar upload_max_filesize e post_max_size no MultiPHP INI Editor

No cPanel, a seção Software costuma ter o **MultiPHP INI Editor**. Nele dá para elevar `upload_max_filesize`, `post_max_size` e `max_execution_time` do domínio. Dois avisos: o valor de `post_max_size` precisa ser maior que o de `upload_max_filesize`, senão o upload continua sendo cortado, e nem toda configuração de servidor permite que esses valores sejam alterados pelo usuário. Se o limite não subir, o caminho é outro.

## Duas saídas quando o dump não cabe no formulário

Duas saídas, em ordem de preferência.

Aviso de origem: `pg_dump` e `psql` não são ferramentas do cPanel, e os parâmetros descritos abaixo vêm da documentação oficial do PostgreSQL, não da página do phpPgAdmin citada neste artigo. O comportamento depende da versão do PostgreSQL e das permissões do seu plano, e não testamos esses comandos em laboratório para publicar medição aqui. Confira a saída de cada comando antes de seguir para o próximo.

### Dividir o dump com --schema-only e --data-only

Um dump do `pg_dump` em formato texto é só SQL em sequência. Dá para separar a parte de estrutura da parte de dados, ou separar por tabela, e importar um pedaço de cada vez pela aba SQL.

O jeito mais previsível é gerar os arquivos já separados na origem, antes de trazer para cá:

```bash
# Só a estrutura (tabelas, índices, constraints)
pg_dump --schema-only -U usuario -d banco > estrutura.sql

# Só os dados
pg_dump --data-only -U usuario -d banco > dados.sql
```

Linha a linha: `--schema-only` gera o arquivo com a definição dos objetos e nenhuma linha de dado; `--data-only` gera o inverso. Importe `estrutura.sql` primeiro, confira na árvore do phpPgAdmin que as tabelas apareceram, e só então importe `dados.sql`. Se mesmo o arquivo de dados for grande demais, gere um arquivo por tabela com `--table=nome_da_tabela`.

### Importar por SSH com psql e ignorar o limite do PHP

Se a sua hospedagem oferece acesso SSH, suba o `.sql` para a conta (por FTP ou pelo Gerenciador de Arquivos) e rode:

```bash
psql -U minhaconta_usuario -d minhaconta_loja -f dump.sql
```

O que cada parte faz: `-U` é o usuário do banco, com o prefixo da conta; `-d` é o banco de destino, também com prefixo; `-f` é o arquivo a executar. Os nomes acima são exemplo fictício, troque pelos seus. O `psql` vai pedir a senha e depois imprimir uma linha por comando executado (`CREATE TABLE`, `COPY 1240`, e assim por diante). Qualquer linha começando com `ERROR:` merece leitura: ela diz exatamente qual comando falhou e por quê.

Esse caminho ignora os limites de upload do PHP por completo, porque não passa por formulário nenhum. Se o SSH não estiver disponível no seu plano, a opção A resolve a mesma coisa com mais cliques.

## Checklist final antes de dar a migração por encerrada

- O nome do banco e do usuário na string de conexão da aplicação tem o prefixo da conta.
- O usuário está associado ao banco em Bancos de Dados PostgreSQL, com privilégios suficientes.
- Existe um arquivo de export salvo fora do servidor, gerado antes de qualquer alteração.
- O `count(*)` das tabelas principais bate com o esperado depois da importação.
- As sequences foram importadas: o `last_value` de cada sequence é maior ou igual ao `max(id)` da tabela, ajustado com `setval` quando preciso, e um `INSERT` novo pela aplicação não colide com chave primária.
- A saída da importação foi lida inteira, não só a última linha.

Se alguma coisa sair do lugar no meio do caminho, o item três é o que salva: restaurar o export e recomeçar custa minutos. Reconstruir dados perdidos custa dias.

Fonte consultada: [documentação oficial do cPanel sobre phpPgAdmin](https://docs.cpanel.net/cpanel/databases/phppgadmin/), consultada em 16 de outubro de 2026. Ela cobre o painel; `pg_dump`, `psql` e `setval` estão documentados pelo projeto PostgreSQL, em postgresql.org/docs. Os nomes de banco, usuário e tabela usados aqui são exemplos fictícios.

