PostgreSQL: So sichern Sie nur ein Schema aus einer Datenbank und stellen es auf einem anderen Server wieder her

Ich habe eine Datenbank mit dem Namen "A", die zwei Schemata "B" und "C" hat. Ich möchte Schema "B" auf einem anderen Server sichern und wiederherstellen. Ich bin mir nicht sicher, wie ich das machen soll, da ich neu bei Postgres bin. Muss ich eine neue Datenbank auf einem neuen Server mit dem Namen "A" erstellen und dann das Schema "B" darauf wiederherstellen? Bitte helfen Sie mit Befehlen.

--- Informationen aus dem Kommentar zu Peters Antwort:

Ich möchte Schema "B" + Daten sichern und wiederherstellen. Zweitens habe ich vergessen zu erwähnen, dass Postgresql 9.1 unter Ubuntu 12.04 läuft

Mit der -nOption pg_dump können Sie auswählen, welche Schemas gesichert werden sollen. Erstellen Sie einen Speicherauszug von Schema B:

pg_dump ...other...options... -Fc -n B >dump.dmp

Stellen Sie die Sicherungsdatei wieder her:

pg_restore -d somedb dump.dmp

Die Zieldatenbank muss nicht denselben Namen wie die ursprüngliche Datenbank haben.

Beachten Sie, dass Sie Probleme haben werden, wenn Schema B Abhängigkeiten von Schema C aufweist. Dann können Sie es nicht separat wiederherstellen.

Sie können Parameter hinzufügen. -n [schema name] Der Kommentar zu diesem Parameter lautet:

-n schema
--schema=schema

Nur Schemas sichern, die mit dem Schema übereinstimmen; Dadurch werden sowohl das Schema selbst als auch alle darin enthaltenen Objekte ausgewählt. Wenn diese Option nicht angegeben wird, werden alle Nicht-Systemschemata in der Zieldatenbank gesichert.

• Sie können das Tool pg_dump (siehe pg_dump doc ) und pg_restore ( pg_restore doc ) verwenden.
• Sie müssen keinen neuen Datenbanknamen "A" auf einem neuen Server erstellen.

* Einfaches Beispiel:

Ich erstelle "dump.bat" & "restore.bat" -Dateien in einem Fenster zum Sichern / Wiederherstellen

1 / Backup:

"C:\Program Files\PostgreSQL\9.1\bin\pg_dump.exe" --host localhost --port 5432 --username "postgres" --role "postgres" --format plain --encoding UTF8 --schema-only  --file "dump_resul.sql" --schema "name_schema_B" "name_database_A" 

Ergebnisse:

-- PostgreSQL database dump

-- Dumped from database version 9.1.4
-- Dumped by pg_dump version 9.1.4

SET statement_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET client_min_messages = warning;

SET search_path = public, pg_catalog;

CREATE TABLE abtb_temp (
    id bigint NOT NULL,
    app_code character varying(100)
); ....

* Hinweis: Einige wichtige Optionen:

--data-only, --format=format (ex: format=tar -> if you have a big database), --schema-only, --table=table (ex: --table=schema_name.table_name) ...

2 / Wiederherstellen: "C:\Program Files\PostgreSQL\9.1\bin\pg_restore.exe" --host localhost --port 5432 --username "postgres" --dbname "any_database" --no-password --no-owner --no-privileges --schema name_schema_B --verbose "C:\dump_resul.sql"(**)

(**) In Wirklichkeit können Sie pgAdmin (oder psql) zum Wiederherstellen verwenden, wenn Ihre Formatdatei * .sql ist. Sie sollten pg_restore verwenden, um eine Datei mit der Erweiterung .tar ( .bakup ...) wiederherzustellen.

Ich habe ein Skript geschrieben, das dies trivial macht. Einfaches Exportieren von SQL-Funktionen und Tabellenschemata in einzelne *.sqlDateien. Vereinfacht die Verwaltung, Sicherung und Quellcodeverwaltung:

#!/bin/sh

# Export all table schemas and functions into individual *.sql files for easy management and source control.

TEMP_WORK_PATH="/tmp/postgres"
BACKUP_ROOT_PATH="/vagrant/backup" # This is where your *.sql files will be exported at
DATABASE_NAME="myapp_db"
DATABASE_TABLES_PREFIX="myapp_"
POSTGRES_USER="postgres"
POSTGRES_PASSWORD="postgres"


[ -d $TEMP_WORK_PATH ] || mkdir -p $TEMP_WORK_PATH
rm -rf $TEMP_WORK_PATH/*

[ -d $BACKUP_ROOT_PATH ] || mkdir -p $BACKUP_ROOT_PATH
rm -rf $BACKUP_ROOT_PATH/*

mkdir $BACKUP_ROOT_PATH/tables
mkdir $BACKUP_ROOT_PATH/routines

export PGPASSWORD=$POSTGRES_PASSWORD

cd $TEMP_WORK_PATH

# Get all table schemas and write to individual files
echo "Export table schemas..."
for table in $(psql -U $POSTGRES_USER -d $DATABASE_NAME -t -c "Select table_name From information_schema.tables Where table_type='BASE TABLE' and table_name like '$DATABASE_TABLES_PREFIX%'");
do pg_dump -st $table -U $POSTGRES_USER $DATABASE_NAME > $BACKUP_ROOT_PATH/tables/$table.sql;
done;

# Get all functions in db and output to one file
echo "Getting stored functions..."
psql -U $POSTGRES_USER -At $DATABASE_NAME > $TEMP_WORK_PATH/db_functions.sql <<EOF
SELECT pg_get_functiondef(f.oid)
FROM pg_catalog.pg_proc f
INNER JOIN pg_catalog.pg_namespace n ON (f.pronamespace = n.oid)
WHERE n.nspname = 'public';
EOF

# Split function file into separate files per function
echo "Exporting stored functions..."
csplit -f function -b '%d.sql' db_functions.sql '/FUNCTION/' '{*}'

# Rename the function files to match the function name in the file
# then place the files into the target backup directory
counter=1
while [ -f $TEMP_WORK_PATH/function$counter.sql ]
do
  name=$(head -1 function$counter.sql | awk {'print $5'})
  name=$(echo $name | cut -d "." --f 2 | cut -d "(" --f 1)
  mv function$counter.sql $BACKUP_ROOT_PATH/routines/$name.sql
  counter=$((counter+1))
done

echo "done"

https://gist.github.com/dantheman213/aff70ee42a11f2d1fa46983878cd62e1

Dies kann verwendet werden, um eine Schemasicherung durchzuführen

pg_dump -U UserName -h HostName -s DBName > "file.sql"

Dies kann verwendet werden, um die DB wiederherzustellen

psql -d DBName -h HostName -U UserName <  "file.sql"