Exportar linhas específicas de uma tabela do PostgreSQL como script INSERT SQL

Eu tenho um esquema de banco de dados chamado: nyummye uma tabela chamada cimory:

create table nyummy.cimory (
  id numeric(10,0) not null,
  name character varying(60) not null,
  city character varying(50) not null,
  CONSTRAINT cimory_pkey PRIMARY KEY (id)
);

Quero exportar os cimorydados da tabela como inserir arquivo de script SQL. No entanto, eu só quero exportar registros / dados onde a cidade é igual a 'tokyo' (suponha que os dados da cidade sejam todos minúsculos).

Como fazer isso?

Não importa se a solução está em ferramentas GUI de freeware ou em linha de comando (embora a solução de ferramentas GUI seja melhor). Eu tentei o pgAdmin III, mas não consigo encontrar uma opção para fazer isso.

Crie uma tabela com o conjunto que você deseja exportar e, em seguida, use o utilitário de linha de comando pg_dump para exportar para um arquivo:

create table export_table as 
select id, name, city
from nyummy.cimory
where city = 'tokyo'

$ pg_dump --table=export_table --data-only --column-inserts my_database > data.sql

--column-inserts irá despejar como comandos de inserção com nomes de colunas.

--data-only não despeje o esquema.

Conforme comentado abaixo, a criação de uma exibição em vez de uma tabela evitará a criação da tabela sempre que uma nova exportação for necessária.

Para um uso de exportação apenas de dadosCOPY .
Você obtém um arquivo com uma linha da tabela por linha como texto sem formatação (não INSERTcomandos), é menor e mais rápido:

COPY (SELECT * FROM nyummy.cimory WHERE city = 'tokio') TO '/path/to/file.csv';

Importe o mesmo para outra tabela da mesma estrutura em qualquer lugar com:

COPY other_tbl FROM '/path/to/file.csv';

COPYescreve e lê arquivos locais para o servidor , ao contrário de programas clientes como pg_dumpou psqlo que ler e escrever arquivos local para o cliente . Se os dois rodam na mesma máquina, não importa muito, mas é para conexões remotas.

Há também o \copycomando do psql que:

Executa uma cópia de front-end (cliente). Essa é uma operação que executa um COPYcomando SQL , mas, em vez de o servidor ler ou gravar o arquivo especificado, o psql lê ou grava o arquivo e roteia os dados entre o servidor e o sistema de arquivos local. Isso significa que a acessibilidade e os privilégios de arquivo são do usuário local, não do servidor, e não são necessários privilégios de superusuário SQL.

Esta é uma maneira fácil e rápida de exportar uma tabela para um script com o pgAdmin manualmente sem instalações extras :

1. Clique com o botão direito na tabela de destino e selecione "Backup".
2. Selecione um caminho de arquivo para armazenar o backup. Como Formato, escolha "Simples".
3. Abra a guia "Opções de despejo nº 2" na parte inferior e marque "Usar inserções de coluna".
4. Clique no botão Backup.
5. Se você abrir o arquivo resultante com um leitor de texto (por exemplo, o bloco de notas ++), receberá um script para criar a tabela inteira. A partir daí, você pode simplesmente copiar as INSERT-Statements geradas.

Esse método também funciona com a técnica de criar uma tabela export_ conforme demonstrado na resposta de @Clodoaldo Neto.

O SQL Workbench possui esse recurso.

Após executar uma consulta, clique com o botão direito do mouse nos resultados da consulta e escolha "Copiar dados como SQL> Inserir SQL"

Para o meu caso de uso, eu era capaz de simplesmente canalizar para grep.

pg_dump -U user_name --data-only --column-inserts -t nyummy.cimory | grep "tokyo" > tokyo.sql

Tentei escrever um procedimento para isso, com base nos códigos @PhilHibbs, de uma maneira diferente. Por favor, dê uma olhada e teste.

 CREATE OR REPLACE FUNCTION dump(IN p_schema text, IN p_table text, IN p_where text)
   RETURNS setof text AS
 $BODY$
 DECLARE
     dumpquery_0 text;
     dumpquery_1 text;
     selquery text;
     selvalue text;
     valrec record;
     colrec record;
 BEGIN

     -- ------ --
     -- GLOBAL --
     --   build base INSERT
     --   build SELECT array[ ... ]
     dumpquery_0 := 'INSERT INTO ' ||  quote_ident(p_schema) || '.' || quote_ident(p_table) || '(';
     selquery    := 'SELECT array[';

     <<label0>>
     FOR colrec IN SELECT table_schema, table_name, column_name, data_type
                   FROM information_schema.columns
                   WHERE table_name = p_table and table_schema = p_schema
                   ORDER BY ordinal_position
     LOOP
         dumpquery_0 := dumpquery_0 || quote_ident(colrec.column_name) || ',';
         selquery    := selquery    || 'CAST(' || quote_ident(colrec.column_name) || ' AS TEXT),';
     END LOOP label0;

     dumpquery_0 := substring(dumpquery_0 ,1,length(dumpquery_0)-1) || ')';
     dumpquery_0 := dumpquery_0 || ' VALUES (';
     selquery    := substring(selquery    ,1,length(selquery)-1)    || '] AS MYARRAY';
     selquery    := selquery    || ' FROM ' ||quote_ident(p_schema)||'.'||quote_ident(p_table);
     selquery    := selquery    || ' WHERE '||p_where;
     -- GLOBAL --
     -- ------ --

     -- ----------- --
     -- SELECT LOOP --
     --   execute SELECT built and loop on each row
     <<label1>>
     FOR valrec IN  EXECUTE  selquery
     LOOP
         dumpquery_1 := '';
         IF not found THEN
             EXIT ;
         END IF;

         -- ----------- --
         -- LOOP ARRAY (EACH FIELDS) --
         <<label2>>
         FOREACH selvalue in ARRAY valrec.MYARRAY
         LOOP
             IF selvalue IS NULL
             THEN selvalue := 'NULL';
             ELSE selvalue := quote_literal(selvalue);
             END IF;
             dumpquery_1 := dumpquery_1 || selvalue || ',';
         END LOOP label2;
         dumpquery_1 := substring(dumpquery_1 ,1,length(dumpquery_1)-1) || ');';
         -- LOOP ARRAY (EACH FIELD) --
         -- ----------- --

         -- debug: RETURN NEXT dumpquery_0 || dumpquery_1 || ' --' || selquery;
         -- debug: RETURN NEXT selquery;
         RETURN NEXT dumpquery_0 || dumpquery_1;

     END LOOP label1 ;
     -- SELECT LOOP --
     -- ----------- --

 RETURN ;
 END
 $BODY$
   LANGUAGE plpgsql VOLATILE;

E depois :

-- for a range
SELECT dump('public', 'my_table','my_id between 123456 and 123459'); 
-- for the entire table
SELECT dump('public', 'my_table','true');

testado no meu postgres 9.1, com uma tabela com tipo de dados de campo misto (texto, double, int, timestamp sem fuso horário, etc.).

É por isso que o CAST no tipo TEXT é necessário. Meu teste foi executado corretamente por cerca de 9 milhões de linhas, parece que falhou pouco antes dos 18 minutos de execução.

ps: Encontrei um equivalente para mysql na WEB.

Você pode visualizar a tabela com registros específicos e depois despejar o arquivo sql

CREATE VIEW foo AS
SELECT id,name,city FROM nyummy.cimory WHERE city = 'tokyo'

Acabei de iniciar um procedimento rápido para fazer isso. Funciona apenas para uma única linha, portanto, crio uma exibição temporária que apenas seleciona a linha desejada e substituo o pg_temp.temp_view pela tabela real na qual desejo inserir.

CREATE OR REPLACE FUNCTION dv_util.gen_insert_statement(IN p_schema text, IN p_table text)
  RETURNS text AS
$BODY$
DECLARE
    selquery text; 
    valquery text; 
    selvalue text; 
    colvalue text; 
    colrec record;
BEGIN

    selquery := 'INSERT INTO ' ||  quote_ident(p_schema) || '.' || quote_ident(p_table);

    selquery := selquery || '(';

    valquery := ' VALUES (';
    FOR colrec IN SELECT table_schema, table_name, column_name, data_type
                  FROM information_schema.columns 
                  WHERE table_name = p_table and table_schema = p_schema 
                  ORDER BY ordinal_position 
    LOOP
      selquery := selquery || quote_ident(colrec.column_name) || ',';

      selvalue := 
        'SELECT CASE WHEN ' || quote_ident(colrec.column_name) || ' IS NULL' || 
                   ' THEN ''NULL''' || 
                   ' ELSE '''' || quote_literal('|| quote_ident(colrec.column_name) || ')::text || ''''' || 
                   ' END' || 
        ' FROM '||quote_ident(p_schema)||'.'||quote_ident(p_table);
      EXECUTE selvalue INTO colvalue;
      valquery := valquery || colvalue || ',';
    END LOOP;
    -- Replace the last , with a )
    selquery := substring(selquery,1,length(selquery)-1) || ')';
    valquery := substring(valquery,1,length(valquery)-1) || ')';

    selquery := selquery || valquery;

RETURN selquery;
END
$BODY$
  LANGUAGE plpgsql VOLATILE;

Invocado assim:

SELECT distinct dv_util.gen_insert_statement('pg_temp_' || sess_id::text,'my_data') 
from pg_stat_activity 
where procpid = pg_backend_pid()

Não testei isso contra ataques de injeção. Informe-me se a chamada quote_literal não for suficiente para isso.

Também funciona apenas para colunas que podem ser simplesmente convertidas em :: text e retornadas novamente.

Também é para o Greenplum, mas não consigo pensar em uma razão pela qual ele não funcionaria no Postgres, CMIIW.

você tentou no pgadmin executando a consulta com " EXECUTE QUERY WRITE RESULT TO FILE " opção

é apenas exportar os dados, caso contrário tente

pg_dump -t view_name DB_name > db.sql

-t opção usada para ==> Despejar apenas tabelas (ou visualizações ou sequências) tabela correspondente, consulte