Exportieren Sie bestimmte Zeilen aus einer PostgreSQL-Tabelle als INSERT SQL-Skript

Ich habe ein Datenbankschema mit dem Namen: nyummyund eine Tabelle mit dem Namen 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)
);

Ich möchte cimorydie Daten der Tabelle als SQL-Skriptdatei einfügen exportieren . Ich möchte jedoch nur Datensätze / Daten exportieren, bei denen die Stadt gleich "Tokio" ist (vorausgesetzt, die Stadtdaten sind alle in Kleinbuchstaben).

Wie es geht?

Es spielt keine Rolle, ob sich die Lösung in Freeware-GUI-Tools oder in der Befehlszeile befindet (obwohl die GUI-Tools-Lösung besser ist). Ich habe pgAdmin III ausprobiert, kann aber keine Option dafür finden.

Erstellen Sie eine Tabelle mit dem Satz, den Sie exportieren möchten, und exportieren Sie dann mit dem Befehlszeilenprogramm pg_dump in eine Datei:

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 wird als Einfügebefehle mit Spaltennamen ausgegeben.

--data-only Schema nicht sichern.

Wie unten kommentiert, wird durch das Erstellen einer Ansicht anstelle einer Tabelle die Tabellenerstellung vermieden, wenn ein neuer Export erforderlich ist.

Für einen Nur-Daten-Export verwenden COPY.
Sie erhalten eine Datei mit einer Tabellenzeile pro Zeile als Klartext (keine INSERTBefehle). Sie ist kleiner und schneller:

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

Importieren Sie dasselbe in eine andere Tabelle derselben Struktur an einer beliebigen Stelle mit:

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

COPYschreibt und liest Dateien lokal auf dem Server , im Gegensatz zu Client-Programmen wie pg_dumpoder psqldie Dateien lokal auf dem Client lesen und schreiben . Wenn beide auf demselben Computer ausgeführt werden, spielt dies keine große Rolle, dies gilt jedoch für Remoteverbindungen.

Es gibt auch den \copyBefehl von psql, dass:

Führt eine Frontend-Kopie (Client-Kopie) durch. Dies ist eine Operation, die einen SQL- COPYBefehl ausführt. Statt dass der Server die angegebene Datei liest oder schreibt, liest oder schreibt psql die Datei und leitet die Daten zwischen dem Server und dem lokalen Dateisystem weiter. Dies bedeutet, dass Dateizugriff und Berechtigungen die des lokalen Benutzers und nicht des Servers sind und keine SQL-Superuser-Berechtigungen erforderlich sind.

Dies ist eine einfache und schnelle Möglichkeit, eine Tabelle mit pgAdmin manuell ohne zusätzliche Installationen in ein Skript zu exportieren :

1. Klicken Sie mit der rechten Maustaste auf die Zieltabelle und wählen Sie "Backup".
2. Wählen Sie einen Dateipfad zum Speichern der Sicherung. Wählen Sie als Format "Normal".
3. Öffnen Sie unten die Registerkarte "Dump Options # 2" und aktivieren Sie "Use Column Inserts".
4. Klicken Sie auf die Schaltfläche Sichern.
5. Wenn Sie die resultierende Datei mit einem Textleser (z. B. Notepad ++) öffnen, erhalten Sie ein Skript zum Erstellen der gesamten Tabelle. Von dort können Sie einfach die generierten INSERT-Anweisungen kopieren.

Diese Methode funktioniert auch mit der Technik, eine export_table zu erstellen, wie in der Antwort von @Clodoaldo Neto gezeigt.

SQL Workbench verfügt über eine solche Funktion.

Klicken Sie nach dem Ausführen einer Abfrage mit der rechten Maustaste auf die Abfrageergebnisse und wählen Sie "Daten als SQL kopieren> SQL einfügen".

Für meinen Anwendungsfall konnte ich einfach auf grep pfeifen.

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

Ich habe versucht, eine Prozedur zu schreiben, die auf @PhilHibbs-Codes basiert, auf eine andere Art und Weise. Bitte schauen Sie und testen Sie.

 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;

Und dann :

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

getestet auf meinem Postgres 9.1 mit einer Tabelle mit gemischtem Felddatentyp (Text, Double, Int, Zeitstempel ohne Zeitzone usw.).

Aus diesem Grund wird der Typ CAST in TEXT benötigt. Mein Testlauf wurde für ungefähr 9 Millionen Zeilen korrekt ausgeführt. Es sieht so aus, als ob er kurz vor 18 Minuten fehlschlägt.

ps: Ich habe im WEB ein Äquivalent für MySQL gefunden.

Sie können die Tabelle mit bestimmten Datensätzen anzeigen und dann die SQL-Datei sichern

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

Ich habe gerade eine schnelle Prozedur durchgeführt, um dies zu tun. Es funktioniert nur für eine einzelne Zeile, daher erstelle ich eine temporäre Ansicht, in der nur die gewünschte Zeile ausgewählt wird, und ersetze dann die pg_temp.temp_view durch die tatsächliche Tabelle, in die ich einfügen möchte.

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;

So aufgerufen:

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

Ich habe dies nicht gegen Injektionsangriffe getestet. Bitte lassen Sie mich wissen, wenn der Aufruf von quote_literal dafür nicht ausreicht.

Es funktioniert auch nur für Spalten, die einfach in :: text und wieder zurück umgewandelt werden können.

Auch dies ist für Greenplum, aber ich kann mir keinen Grund vorstellen, warum es bei Postgres, CMIIW nicht funktionieren würde.

Haben Sie versucht, in pgadmin eine Abfrage mit " EXECUTE QUERY WRITE RESULT TO FILE " Option auszuführen?

Es ist nur der Export der Daten, sonst versuchen Sie es wie

pg_dump -t view_name DB_name > db.sql

-t Option für ==> Dump nur Tabellen (oder Ansichten oder Sequenzen) passende Tabelle, siehe