Wie kann ich alle Tabellen in einer PostgreSQL-Datenbank löschen?

Wenn sich alle Ihre Tabellen in einem einzigen Schema befinden, könnte dieser Ansatz funktionieren (unterhalb des Codes wird davon ausgegangen, dass der Name Ihres Schemas public ist)

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;

Wenn Sie PostgreSQL 9.3 oder höher verwenden, müssen Sie möglicherweise auch die Standardzuschüsse wiederherstellen.

GRANT ALL ON SCHEMA public TO postgres;
GRANT ALL ON SCHEMA public TO public;

Sie können eine Abfrage schreiben, um ein SQL-Skript wie folgt zu generieren:

select 'drop table "' || tablename || '" cascade;' from pg_tables;

Oder:

select 'drop table if exists "' || tablename || '" cascade;' from pg_tables;

Falls einige Tabellen aufgrund einer Kaskadenoption in einem vorherigen Satz automatisch gelöscht werden.

Darüber hinaus möchten Sie, wie in den Kommentaren angegeben, die zu löschenden Tabellen nach dem Schemanamen filtern:

select 'drop table if exists "' || tablename || '" cascade;' 
  from pg_tables
 where schemaname = 'public'; -- or any other schema

Und dann führe es aus.

Glorious COPY + PASTE wird auch funktionieren.

Die am meisten akzeptierte Antwort zum jetzigen Zeitpunkt (Januar 2014) lautet:

drop schema public cascade;
create schema public;

Dies funktioniert zwar, wenn Sie jedoch beabsichtigen, das öffentliche Schema in seinem ursprünglichen Zustand wiederherzustellen, wird die Aufgabe nicht vollständig erfüllt. Wenn Sie unter pgAdmin III für PostgreSQL 9.3.1 auf das auf diese Weise erstellte "öffentliche" Schema klicken und im "SQL-Fenster" suchen, sehen Sie Folgendes:

-- Schema: public

-- DROP SCHEMA public;

CREATE SCHEMA public
  AUTHORIZATION postgres;

Im Gegensatz dazu hat eine brandneue Datenbank Folgendes:

-- Schema: public

-- DROP SCHEMA public;

CREATE SCHEMA public
  AUTHORIZATION postgres;

GRANT ALL ON SCHEMA public TO postgres;
GRANT ALL ON SCHEMA public TO public;
COMMENT ON SCHEMA public
  IS 'standard public schema';

Bei Verwendung eines Python-Web-Frameworks, das Datenbanktabellen (web2py) erstellt, sind bei Verwendung der vorherigen Probleme aufgetreten:

<class 'psycopg2.ProgrammingError'> no schema has been selected to create in 

Die richtige Antwort lautet meines Erachtens:

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;
GRANT ALL ON SCHEMA public TO postgres;
GRANT ALL ON SCHEMA public TO public;
COMMENT ON SCHEMA public IS 'standard public schema';

(Beachten Sie auch, dass Sie diese Befehle von pgAdmin III ausgeben möchten. Ich ging zu Plugins-> PSQL Console).

Sie können alle Tabellen mit löschen

DO $$ DECLARE
    r RECORD;
BEGIN
    -- if the schema you operate on is not "current", you will want to
    -- replace current_schema() in query with 'schematodeletetablesfrom'
    -- *and* update the generate 'DROP...' accordingly.
    FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = current_schema()) LOOP
        EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
    END LOOP;
END $$;

IMO Dies ist besser als drop schema public, da Sie die schema nicht neu erstellen und alle Berechtigungen wiederherstellen müssen. 

Zusätzlicher Vorteil, dass hierfür keine externe Skriptsprache erforderlich ist oder das generierte SQL-Verfahren zum Kopieren zurück in den Interpreter eingefügt wird.

Wenn alles, was Sie löschen möchten, besessen von demselben Benutzer ist, können Sie Folgendes verwenden: 

drop owned by the_user;

Dadurch wird alles, das der Benutzer besitzt, gelöscht. 

Dazu gehören materialisierte Ansichten, Ansichten, Sequenzen, Trigger, Schemas, Funktionen, Typen, Aggregate, Operatoren, Domänen usw. (also wirklich: alles), das the_user besitzt (= erstellt). 

Sie müssen the_user durch den tatsächlichen Benutzernamen ersetzen. Derzeit gibt es keine Option, um alles für "den aktuellen Benutzer" zu löschen. Die kommende Version 9.5 wird die Option drop owned by current_user haben.

Weitere Details im Handbuch: http://www.postgresql.org/docs/current/static/sql-drop-owned.html

Wie oben in Pablo beschrieben, um nur aus einem bestimmten Schema in Bezug auf den Fall zu fallen: 

select 'drop table "' || tablename || '" cascade;' 
from pg_tables where schemaname = 'public';

drop schema public cascade;

sollte den Trick tun. 

Nach Pablo und LenW folgt hier ein One-Liner, der sowohl alles vorbereitet als auch ausführt: 

psql -U $PGUSER $PGDB -t -c "select 'drop table \"' || tablename || '\" cascade;' from pg_tables where schemaname = 'public'" | psql -U $PGUSER $PGDB

NB: Setzen oder ersetzen Sie $PGUSER und $PGDB mit den gewünschten Werten  

Wenn Sie die prozedurale PL/PGSQL-Sprache installiert haben, können Sie Folgendes verwenden, um alles ohne ein externes Shell/Perl-Skript zu entfernen.

DROP FUNCTION IF EXISTS remove_all();

CREATE FUNCTION remove_all() RETURNS void AS $$
DECLARE
    rec RECORD;
    cmd text;
BEGIN
    cmd := '';

    FOR rec IN SELECT
            'DROP SEQUENCE ' || quote_ident(n.nspname) || '.'
                || quote_ident(c.relname) || ' CASCADE;' AS name
        FROM
            pg_catalog.pg_class AS c
        LEFT JOIN
            pg_catalog.pg_namespace AS n
        ON
            n.oid = c.relnamespace
        WHERE
            relkind = 'S' AND
            n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
            pg_catalog.pg_table_is_visible(c.oid)
    LOOP
        cmd := cmd || rec.name;
    END LOOP;

    FOR rec IN SELECT
            'DROP TABLE ' || quote_ident(n.nspname) || '.'
                || quote_ident(c.relname) || ' CASCADE;' AS name
        FROM
            pg_catalog.pg_class AS c
        LEFT JOIN
            pg_catalog.pg_namespace AS n
        ON
            n.oid = c.relnamespace WHERE relkind = 'r' AND
            n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
            pg_catalog.pg_table_is_visible(c.oid)
    LOOP
        cmd := cmd || rec.name;
    END LOOP;

    FOR rec IN SELECT
            'DROP FUNCTION ' || quote_ident(ns.nspname) || '.'
                || quote_ident(proname) || '(' || oidvectortypes(proargtypes)
                || ');' AS name
        FROM
            pg_proc
        INNER JOIN
            pg_namespace ns
        ON
            (pg_proc.pronamespace = ns.oid)
        WHERE
            ns.nspname =
            'public'
        ORDER BY
            proname
    LOOP
        cmd := cmd || rec.name;
    END LOOP;

    EXECUTE cmd;
    RETURN;
END;
$$ LANGUAGE plpgsql;

SELECT remove_all();

Anstatt dies bei der Eingabeaufforderung "psql" einzugeben, würde ich vorschlagen, dass Sie es in eine Datei kopieren und die Datei als Eingabe an psql übergeben, indem Sie die Optionen "--file" oder "-f" verwenden:

psql -f clean_all_pg.sql

Kredit, wo Kredit fällig ist: Ich habe die Funktion geschrieben, denke aber, dass die Anfragen (oder zumindest die erste) von jemandem stammten, der vor Jahren auf einer der pgsql-Mailinglisten stand. Erinnere dich nicht genau, wann oder welche.

Ich habe die Antwort von Pablo leicht modifiziert, um die generierten SQL-Befehle als eine einzige Zeichenfolge zurückzugeben:

select string_agg('drop table "' || tablename || '" cascade', '; ') 
from pg_tables where schemaname = 'public'

Verwenden Sie dieses Skript in pgAdmin:

DO $$
DECLARE 
    brow record;
BEGIN
    FOR brow IN (select 'drop table "' || tablename || '" cascade;' as table_name from pg_tables where schemaname = 'public') LOOP
        EXECUTE brow.table_name;
    END LOOP;
END; $$

Nur für den Fall ... Einfaches Python-Skript, das die Postgresql-Datenbank bereinigt

import psycopg2
import sys

# Drop all tables from a given database

try:
    conn = psycopg2.connect("dbname='akcja_miasto' user='postgres' password='postgres'")
    conn.set_isolation_level(0)
except:
    print "Unable to connect to the database."

cur = conn.cursor()

try:
    cur.execute("SELECT table_schema,table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_schema,table_name")
    rows = cur.fetchall()
    for row in rows:
        print "dropping table: ", row[1]   
        cur.execute("drop table " + row[1] + " cascade") 
    cur.close()
    conn.close()        
except:
    print "Error: ", sys.exc_info()[1]

Stellen Sie sicher, dass nach dem Kopieren die Einrückung richtig ist, da Python sich darauf verlässt.

Sie können die Funktion string_agg verwenden, um eine durch Kommas getrennte Liste zu erstellen, die sich ideal für DROP TABLE ..__ eignet.

#!/bin/bash
TABLES=`psql $PGDB -t --command "SELECT string_agg(table_name, ',') FROM information_schema.tables WHERE table_schema='public'"`

echo Dropping tables:${TABLES}
psql $PGDB --command "DROP TABLE IF EXISTS ${TABLES} CASCADE"

Sie müssen Tabellen und Sequenzen ablegen. Hier hat sich für mich gearbeitet

psql -qAtX -c "select 'DROP TABLE IF EXISTS ' || quote_ident(table_schema) || '.' || quote_ident(table_name) || ' CASCADE;' FROM information_schema.tables where table_type = 'BASE TABLE' and not table_schema ~ '^(information_schema|pg_.*)$'" | psql -qAtX
psql -qAtX -c "select 'DROP SEQUENCE IF EXISTS ' || quote_ident(relname) || ' CASCADE;' from pg_statio_user_sequences;" | psql -qAtX

bevor Sie den Befehl ausführen, müssen Sie möglicherweise Sudo/su an den Benutzer postgres oder (Verbindungsdetails PGHOST, PGPORT, PGUSER und PGPASSWORD exportieren) und dann export PGDATABASE=yourdatabase 

Wenn Sie Daten löschen möchten (keine Tabelle löschen):

-- Truncate tables and restart sequnces
SELECT 'TRUNCATE TABLE "' || table_schema || '"."' || table_name || '" RESTART IDENTITY CASCADE;' 
FROM information_schema.tables 
WHERE table_catalog = '<database>' AND table_schema = '<schema>';

Oder wenn Sie Drop-Tabelle möchten, können Sie diese SQL verwenden:

-- For tables
SELECT 'DROP TABLE "' || table_schema || '"."' || table_name || '" CASCADE;' 
FROM information_schema.tables 
WHERE table_catalog = '<database>' AND table_schema = '<schema>';

-- For sequences
SELECT 'DROP SEQUENCE d_a_seq "' || sequence_schema || '"."' || sequence_name || '";' 
FROM information_schema.sequences 
WHERE sequence_catalog = '<database>' AND sequence_schema = '<schema>';

Rake-Task für Rails zum Löschen aller Tabellen in der aktuellen Datenbank

namespace :db do
  # rake db:drop_all_tables
  task drop_all_tables: :environment do
    query = <<-QUERY
      SELECT
        table_name
      FROM
        information_schema.tables
      WHERE
        table_type = 'BASE TABLE'
      AND
        table_schema NOT IN ('pg_catalog', 'information_schema');
    QUERY

    connection = ActiveRecord::Base.connection
    results    = connection.execute query

    tables = results.map do |line|
      table_name = line['table_name']
    end.join ", "

    connection.execute "DROP TABLE IF EXISTS #{ tables } CASCADE;"
  end
end

in einer Windows-Batchdatei:

@echo off
FOR /f "tokens=2 delims=|" %%G IN ('psql --Host localhost --username postgres --command="\dt" YOUR_TABLE_NAME') DO (
   psql --Host localhost --username postgres --command="DROP table if exists %%G cascade" sfkb
   echo table %%G dropped
)

Ich habe die bash-Methode von jamie verbessert, indem ich mich um die Ansichten kümmere, weil er nur den Tabellentyp "Basistabelle" respektiert, der die Standardeinstellung ist.

der folgende bash-Code löscht zuerst die Ansichten und dann den Rest

#!/usr/bin/env bash

PGDB="yourDB"
# By exporting user & pass your dont need to interactively type them on execution
export PGUSER="PGusername"
export PGPASSWORD="PGpassword"

VIEWS=`psql -d $PGDB -t --command "SELECT string_agg(table_name, ',') FROM information_schema.tables WHERE table_schema='public' AND table_type='VIEW'"`
BASETBLS=`psql -d $PGDB -t --command "SELECT string_agg(table_name, ',') FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE'"`

echo Dropping views:${VIEWS}
psql $PGDB --command "DROP VIEW IF EXISTS ${VIEWS} CASCADE"
echo Dropping tables:${BASETBLS}
psql $PGDB --command "DROP TABLE IF EXISTS ${BASETBLS} CASCADE"

na ja, da ich gerne von der Kommandozeile aus arbeite ...

psql -U <user> -d <mydb> -c '\dt' | cut -d ' ' -f 4 | sed -e "s/^/drop table if exists /" | sed -e "s/$/;/"

-c '\dt' ruft den Befehl list tables auf.

List of relations Schema | Name | Type | Owner --------+-------------------+-------+---------- public | _d_psidxddlparm | table | djuser public | _d_psindexdefn | table | djuser

cut -d ' ' -f 4 pipe jetzt seine Ausgabe an das vierte Feld (wenn Leerzeichen als Trennzeichen verwendet werden), das ist die Tabelle.

Mit sed wird dann ein drop table vorangestellt und der ;-Befehlstrenner mit einem Suffix versehen. 

| egrep '_d_' - Leiten Sie etwas mehr in grep, und Sie können selektiver festlegen, welche Tabellen Sie ablegen.

drop table if exists _d_psidxddlparm; drop table if exists _d_psindexdefn;

Hinweis: Wie geschrieben, werden falsche Zeilen für die \dt-Befehle der Spaltenüberschriften und die Gesamtzeilen am Ende generiert. Ich vermeide das, indem ich grepping, aber Sie könnten head und tail verwenden.

Wenn Sie trotzdem alle Tabellen nuke machen wollen, können Sie auf Feinheiten wie CASCADE verzichten, indem Sie alle Tabellen in einer einzigen Anweisung zusammenfassen. Dies beschleunigt auch die Ausführung.

SELECT 'TRUNCATE TABLE ' || string_agg('"' || tablename || '"', ', ') || ';' 
FROM pg_tables WHERE schemaname = 'public';

Direkt ausführen:

DO $$
DECLARE tablenames text;
BEGIN    
    tablenames := string_agg('"' || tablename || '"', ', ') 
        FROM pg_tables WHERE schemaname = 'public';
    EXECUTE 'TRUNCATE TABLE ' || tablenames;
END; $$

Ersetzen Sie gegebenenfalls TRUNCATE durch DROP.

Der einfachste Weg ist, das öffentliche Schema zu löschen, wie andere in den vorherigen Antworten vorgeschlagen haben. Dies ist jedoch kein guter Weg. Sie wissen nie, was mit dem öffentlichen Schema gemacht wurde, das seither vergessen wurde und nicht dokumentiert wurde. Sie wissen auch nicht, ob dies auch in Zukunft funktionieren wird. In V9 wäre dies in Ordnung gewesen, aber in V10 würden alle Benutzer den Zugriff auf das Schema verlieren, und es muss erneut Zugriff gewährt werden, da sonst die Anwendung beschädigt wird. Ich habe V11 nicht überprüft, aber der Punkt ist, dass Sie nie wissen, was kaputt geht, wenn Sie von Maschine zu Maschine, von Site zu Site oder von Version zu Version wechseln. Dies ist auch nicht möglich, wenn Sie ein Benutzer sind, der Zugriff auf die Datenbank hat, jedoch nicht auf das Schema.

Wenn Sie dies programmgesteuert machen müssen, beziehen sich andere Antworten darauf, aber eine Sache, die die Antworten oben nicht berücksichtigen, ist, Postgres dazu zu bringen, die Arbeit für Sie zu erledigen. Wenn Sie pg_dump mit der Option -c wie folgt verwenden:

Sudo su postgres -c "pg_dump -U postgres WhateverDB -c -f "/home/Anyone/DBBackupWhateverDB-ServerUnscheduled.sql""

Dadurch wird ein DB-Wiederherstellungsskript mit SQL-Anweisungen erstellt, das alle Tabellen löscht.

Wenn der einzige Zweck bei der Frage war, die Tabellen vor der Wiederherstellung zu löschen, erledigt die Wiederherstellung die Arbeit für Sie.

Wenn Sie es jedoch für etwas anderes benötigen, können Sie die Drop-Anweisungen einfach aus dem SQL-Skript kopieren.

Für die Fälle, in denen Sie nicht einfach DROP SCHEMA public CASCADE;, DROP OWNED BY current_user; oder etwas anderes tun können, haben Sie hier ein eigenständiges SQL-Skript geschrieben, das transaktionssicher ist (dh Sie können es zwischen BEGIN; und entweder ROLLBACK; setzen, um es einfach zu testen oder COMMIT;, um es tatsächlich zu testen tun Sie die Tat) und bereinigt "alle" Datenbankobjekte ... nun, alle in der Datenbank verwendeten Daten, die unsere Anwendung verwendet, oder ich könnte sinnvoll hinzufügen, und zwar:

• löst auf Tischen aus
• einschränkungen für Tabellen (FK, PK, CHECK, UNIQUE)
• indicēs
• VIEWs (normal oder materialisiert)
• tische
• sequenzen
• funktionen/Prozeduren ( pg_proc.proisagg wahrscheinlich sollten beachtet werden obwohl)
• alle nōn-default-Schemata (d. h. nicht public oder DB-intern) "we" besitzen: Das Skript ist nützlich, wenn es als "kein Datenbank-Superuser" ausgeführt wird. ein Superuser kann all -Schemata ablegen (die wirklich wichtigen werden jedoch immer noch explizit ausgeschlossen)

Nicht fallen gelassen (einige sind absichtlich; einige nur, weil ich kein Beispiel in unserer Datenbank hatte):

• das public-Schema (z. B. für Erweiterungen, die von Erweiterungen bereitgestellt werden)
• erweiterungen
• aggregatfunktionen
• kollatierungen und anderes lokales Zeug
• ereignisauslöser
• textsuche,… (siehe hier für andere Sachen, die ich vielleicht vermisst hätte)
• rollen oder andere Sicherheitseinstellungen
• zusammengesetzte Arten
• toasttische
• FDW und ausländische Tabellen

Ich habe auch eine Version, die "alles außer zwei Tabellen und was dazu gehört" löscht, falls jemand interessiert ist. Der Unterschied ist klein. Kontaktieren Sie mich wenn nötig.

SQL

-- Copyright © 2019
--      mirabilos <[email protected]>
--
-- Provided that these terms and disclaimer and all copyright notices
-- are retained or reproduced in an accompanying document, permission
-- is granted to deal in this work without restriction, including un‐
-- limited rights to use, publicly perform, distribute, sell, modify,
-- merge, give away, or sublicence.
--
-- This work is provided “AS IS” and WITHOUT WARRANTY of any kind, to
-- the utmost extent permitted by applicable law, neither express nor
-- implied; without malicious intent or gross negligence. In no event
-- may a licensor, author or contributor be held liable for indirect,
-- direct, other damage, loss, or other issues arising in any way out
-- of dealing in the work, even if advised of the possibility of such
-- damage or existence of a defect, except proven that it results out
-- of said person’s immediate fault when using the work as intended.
-- -
-- Drop everything from the PostgreSQL database.

DO $$
DECLARE
        r RECORD;
BEGIN
        -- triggers
        FOR r IN (SELECT pns.nspname, pc.relname, pt.tgname
                FROM pg_trigger pt, pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace AND pc.oid=pt.tgrelid
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pt.tgisinternal=false
            ) LOOP
                EXECUTE format('DROP TRIGGER %I ON %I.%I;',
                    r.tgname, r.nspname, r.relname);
        END LOOP;
        -- constraints #1: foreign key
        FOR r IN (SELECT pns.nspname, pc.relname, pcon.conname
                FROM pg_constraint pcon, pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace AND pc.oid=pcon.conrelid
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pcon.contype='f'
            ) LOOP
                EXECUTE format('ALTER TABLE ONLY %I.%I DROP CONSTRAINT %I;',
                    r.nspname, r.relname, r.conname);
        END LOOP;
        -- constraints #2: the rest
        FOR r IN (SELECT pns.nspname, pc.relname, pcon.conname
                FROM pg_constraint pcon, pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace AND pc.oid=pcon.conrelid
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pcon.contype<>'f'
            ) LOOP
                EXECUTE format('ALTER TABLE ONLY %I.%I DROP CONSTRAINT %I;',
                    r.nspname, r.relname, r.conname);
        END LOOP;
        -- indicēs
        FOR r IN (SELECT pns.nspname, pc.relname
                FROM pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pc.relkind='i'
            ) LOOP
                EXECUTE format('DROP INDEX %I.%I;',
                    r.nspname, r.relname);
        END LOOP;
        -- normal and materialised views
        FOR r IN (SELECT pns.nspname, pc.relname
                FROM pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pc.relkind IN ('v', 'm')
            ) LOOP
                EXECUTE format('DROP VIEW %I.%I;',
                    r.nspname, r.relname);
        END LOOP;
        -- tables
        FOR r IN (SELECT pns.nspname, pc.relname
                FROM pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pc.relkind='r'
            ) LOOP
                EXECUTE format('DROP TABLE %I.%I;',
                    r.nspname, r.relname);
        END LOOP;
        -- sequences
        FOR r IN (SELECT pns.nspname, pc.relname
                FROM pg_class pc, pg_namespace pns
                WHERE pns.oid=pc.relnamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pc.relkind='S'
            ) LOOP
                EXECUTE format('DROP SEQUENCE %I.%I;',
                    r.nspname, r.relname);
        END LOOP;
        -- functions / procedures
        FOR r IN (SELECT pns.nspname, pp.proname, pp.oid
                FROM pg_proc pp, pg_namespace pns
                WHERE pns.oid=pp.pronamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
            ) LOOP
                EXECUTE format('DROP FUNCTION %I.%I(%s);',
                    r.nspname, r.proname,
                    pg_get_function_identity_arguments(r.oid));
        END LOOP;
        -- nōn-default schemata we own; assume to be run by a not-superuser
        FOR r IN (SELECT pns.nspname
                FROM pg_namespace pns, pg_roles pr
                WHERE pr.oid=pns.nspowner
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast', 'public')
                    AND pr.rolname=current_user
            ) LOOP
                EXECUTE format('DROP SCHEMA %I;', r.nspname);
        END LOOP;
        -- voilà
        RAISE NOTICE 'Database cleared!';
END; $$;

Getestet auf PostgreSQL 9.6 (jessie-backports). Bugfixes und weitere Verbesserungen willkommen!