Comment supprimer toutes les tables d'une base de données PostgreSQL?

Comment puis-je supprimer toutes les tables dans PostgreSQL, à partir de la ligne de commande?

Je ne veux pas supprimer la base de données elle-même, juste toutes les tables et toutes les données qu'elles contiennent .

Si toutes vos tables sont dans un seul schéma, cette approche pourrait fonctionner (le code ci-dessous suppose que le nom de votre schéma est public)

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;

Si vous utilisez PostgreSQL 9.3 ou supérieur, vous devrez peut-être également restaurer les autorisations par défaut.

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

Vous pouvez écrire une requête pour générer un script SQL comme celui-ci:

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

Ou:

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

Dans le cas où certaines tables sont automatiquement supprimées en raison de l'option en cascade dans une phrase précédente.

En outre, comme indiqué dans les commentaires, vous souhaiterez peut-être filtrer les tables que vous souhaitez supprimer par nom de schéma:

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

Et puis lancez-le.

Glorious COPY + PASTE fonctionnera également.

La réponse la plus acceptée à ce jour (janvier 2014) est:

drop schema public cascade;
create schema public;

Cela fonctionne, cependant, si votre intention est de restaurer le schéma public à son état vierge, cela n'accomplit pas entièrement la tâche. Sous pgAdmin III pour PostgreSQL 9.3.1, si vous cliquez sur le schéma "public" créé de cette façon et regardez dans le "volet SQL", vous verrez ce qui suit:

-- Schema: public

-- DROP SCHEMA public;

CREATE SCHEMA public
  AUTHORIZATION postgres;

Cependant, en revanche, une nouvelle base de données aura les éléments suivants:

-- 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';

Pour moi, en utilisant un framework web python qui crée des tables de base de données (web2py), en utilisant les premiers problèmes causés:

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

Donc, à mon avis, la réponse entièrement correcte est:

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';

Notez également que pour émettre ces commandes dans pgAdmin III, j'ai utilisé l'outil de requête (icône de la loupe "Exécuter des requêtes SQL abritairs") ou vous pouvez utiliser des plugins-> PSQL Console

Remarque

Si des extensions sont installées, elles seront supprimées lorsque vous supprimerez le schéma, vous devez donc prendre note de ce que vous devez installer, puis exécuter des instructions si nécessaire. Par exemple

CREATE EXTENSION postgis;

Vous pouvez supprimer toutes les tables avec

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 $$;

OMI, c'est mieux que drop schema public, car vous n'avez pas besoin de recréer le schemaet de restaurer toutes les subventions.

Bonus supplémentaire qui ne nécessite pas de langage de script externe, ni de copier-coller du SQL généré vers l'interpréteur.

Si tout ce que vous souhaitez supprimer appartient au même utilisateur, vous pouvez utiliser:

drop owned by the_user;

Cela supprimera tout ce que l'utilisateur possède.

Cela inclut les vues matérialisées, les vues, les séquences, les déclencheurs, les schémas, les fonctions, les types, les agrégats, les opérateurs, les domaines, etc. (donc, vraiment: tout ) qui the_userappartient (= créé).

Vous devez remplacer the_userpar le nom d'utilisateur réel, actuellement il n'y a pas d'option pour tout supprimer pour "l'utilisateur actuel". La prochaine version 9.5 aura l'option drop owned by current_user.

Plus de détails dans le manuel: http://www.postgresql.org/docs/current/static/sql-drop-OWN.html

Comme par Pablo ci-dessus, pour simplement passer d'un schéma spécifique, par rapport à la casse:

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

drop schema public cascade;

devrait faire l'affaire.

Après Pablo et LenW, voici un one-liner qui fait tout à la fois la préparation et l'exécution:

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

NB: définissez ou remplacez $PGUSERet $PGDBavec les valeurs que vous souhaitez

Si le langage procédural PL / PGSQL est installé, vous pouvez utiliser ce qui suit pour tout supprimer sans script externe shell / Perl.

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();

Plutôt que de taper ceci à l'invite "psql", je vous suggère de le copier dans un fichier, puis de passer le fichier en entrée à psql en utilisant les options "--file" ou "-f":

psql -f clean_all_pg.sql

Crédit à qui le crédit est dû: j'ai écrit la fonction, mais je pense que les requêtes (ou la première au moins) sont venues de quelqu'un sur l'une des listes de diffusion pgsql il y a des années. Je ne me souviens pas exactement quand ni lequel.

Si vous souhaitez de toute façon supprimer toutes les tables, vous pouvez vous passer de subtilités telles que CASCADE en mettant toutes les tables dans une seule instruction. Cela rend également l'exécution plus rapide.

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

L'exécuter directement:

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

Remplacez TRUNCATEpar DROPle cas échéant.

J'ai légèrement modifié la réponse de Pablo pour la commodité d'avoir les commandes SQL générées renvoyées en une seule chaîne:

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

Utilisez ce script dans 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; $$

Juste au cas où ... Script Python simple qui nettoie la base de données Postgresql

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]

Assurez-vous qu'après l'avoir copié, l'indentation est correcte car Python s'appuie dessus.

Vous pouvez utiliser la fonction string_agg pour créer une liste séparée par des virgules, parfaite pour DROP TABLE. À partir d'un script bash:

#!/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"

C'est une question vraiment intéressante, et vous y arriverez de plusieurs manières. J'espère que cela vous sera utile.

1. En supprimant et en recréant le schéma actuel

Ici, en général, nous avons un publicschéma par défaut. Donc, je l'utilise comme instance.

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

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

Si vous utilisez PostgreSQL 9.3 ou supérieur, vous devrez peut-être également restaurer les autorisations par défaut.

Avantages:

Cela nettoiera tout un schéma et le recréera comme un nouveau.

Les inconvénients:

Vous perdrez d' autres entités aussi comme Functions, Views, Materialized views, etc.

2. En utilisant l'extraction de tous les noms de pg_tablestable de la table.

PostgreSQL stocke toutes les tables sur sa table d'enregistrement nommée pg_table.

SELECT
  'DROP TABLE IF EXISTS "' || tablename || '" CASCADE;' 
from
  pg_tables WHERE schemaname = 'public';

Comme vous pouvez le voir, en utilisant la sous-requête, nous pouvons supprimer l'intégralité des tables du schéma.

Avantages:

Lorsque les autres entités de données sont importantes et que vous souhaitez simplement supprimer uniquement les tables du schéma, cette approche vous sera vraiment utile.

Si vous souhaitez supprimer des données (pas supprimer la table):

-- 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>';

Ou si vous voulez déposer une table, vous pouvez utiliser ce sql:

-- 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>';

Remarque: ma réponse consiste à supprimer réellement les tables et autres objets de base de données; pour la suppression de toutes les données dans les tableaux, à savoir tronquer toutes les tables , Endre deux a fourni une déclaration (exécution directe) Similairement bien exécuté un mois plus tard.

Pour les cas où vous ne pouvez pas simplement DROP SCHEMA public CASCADE;, DROP OWNED BY current_user;ou quelque chose comme ça, voici un script SQL autonome que j'ai écrit, qui est sûr pour les transactions (c'est-à-dire que vous pouvez le mettre entre BEGIN;et soit le ROLLBACK;tester simplement, soit COMMIT;faire l'acte) et nettoie «tous» les objets de la base de données… enfin, tous ceux utilisés dans la base de données que notre application utilise ou je pourrais raisonnablement ajouter, ce qui est:

• déclencheurs sur les tables
• les contraintes sur les tables (FK, PK, CHECK,UNIQUE )
• indicēs
• VIEWs (normal ou matérialisé)
• les tables
• séquences
• routines (fonctions agrégées, fonctions, procédures)
• tous les schémas nōn par défaut (c'est-à-dire non publicou internes à la base de données) «que nous» possédons: le script est utile lorsqu'il est exécuté en tant que «pas un superutilisateur de base de données»; un superutilisateur peut tout laisser tomber schémas (les plus importants sont cependant explicitement exclus)
• extensions (fournies par l'utilisateur, mais je les laisse normalement délibérément)

Non abandonnés sont (certains délibérés; certains uniquement parce que je n'avais aucun exemple dans notre DB):

• le public schéma (par exemple pour les éléments fournis par l'extension)
• des classements et d'autres trucs locaux
• déclencheurs d'événements
• recherche de texte,… (voir ici pour d'autres choses que j'aurais pu manquer)
• rôles ou autres paramètres de sécurité
• types composites
• tables de toast
• FDW et tables étrangères

Ceci est vraiment utile dans les cas où le vidage que vous souhaitez restaurer est d'une version de schéma de base de données différente (par exemple avec Debiandbconfig-common , Flyway ou Liquibase / DB-Manul) que la base de données dans laquelle vous souhaitez le restaurer.

J'ai également une version qui supprime «tout sauf deux tables et ce qui leur appartient» (une séquence, testée manuellement, désolé, je sais, ennuyeuse) au cas où quelqu'un serait intéressé; le diff est petit. Contactez-moi ou consultez ce repo si vous intéressé.

SQL

-- Copyright © 2019, 2020
--      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
        q TEXT;
        r RECORD;
BEGIN
        -- triggers
        FOR r IN (SELECT pns.nspname, pc.relname, pt.tgname
                FROM pg_catalog.pg_trigger pt, pg_catalog.pg_class pc, pg_catalog.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_catalog.pg_constraint pcon, pg_catalog.pg_class pc, pg_catalog.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_catalog.pg_constraint pcon, pg_catalog.pg_class pc, pg_catalog.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_catalog.pg_class pc, pg_catalog.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_catalog.pg_class pc, pg_catalog.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_catalog.pg_class pc, pg_catalog.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_catalog.pg_class pc, pg_catalog.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;
        -- extensions (only if necessary; keep them normally)
        FOR r IN (SELECT pns.nspname, pe.extname
                FROM pg_catalog.pg_extension pe, pg_catalog.pg_namespace pns
                WHERE pns.oid=pe.extnamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
            ) LOOP
                EXECUTE format('DROP EXTENSION %I;', r.extname);
        END LOOP;
        -- aggregate functions first (because they depend on other functions)
        FOR r IN (SELECT pns.nspname, pp.proname, pp.oid
                FROM pg_catalog.pg_proc pp, pg_catalog.pg_namespace pns, pg_catalog.pg_aggregate pagg
                WHERE pns.oid=pp.pronamespace
                    AND pns.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
                    AND pagg.aggfnoid=pp.oid
            ) LOOP
                EXECUTE format('DROP AGGREGATE %I.%I(%s);',
                    r.nspname, r.proname,
                    pg_get_function_identity_arguments(r.oid));
        END LOOP;
        -- routines (functions, aggregate functions, procedures, window functions)
        IF EXISTS (SELECT * FROM pg_catalog.pg_attribute
                WHERE attrelid='pg_catalog.pg_proc'::regclass
                    AND attname='prokind' -- PostgreSQL 11+
            ) THEN
                q := 'CASE pp.prokind
                        WHEN ''p'' THEN ''PROCEDURE''
                        WHEN ''a'' THEN ''AGGREGATE''
                        ELSE ''FUNCTION''
                    END';
        ELSIF EXISTS (SELECT * FROM pg_catalog.pg_attribute
                WHERE attrelid='pg_catalog.pg_proc'::regclass
                    AND attname='proisagg' -- PostgreSQL ≤10
            ) THEN
                q := 'CASE pp.proisagg
                        WHEN true THEN ''AGGREGATE''
                        ELSE ''FUNCTION''
                    END';
        ELSE
                q := '''FUNCTION''';
        END IF;
        FOR r IN EXECUTE 'SELECT pns.nspname, pp.proname, pp.oid, ' || q || ' AS pt
                FROM pg_catalog.pg_proc pp, pg_catalog.pg_namespace pns
                WHERE pns.oid=pp.pronamespace
                    AND pns.nspname NOT IN (''information_schema'', ''pg_catalog'', ''pg_toast'')
            ' LOOP
                EXECUTE format('DROP %s %I.%I(%s);', r.pt,
                    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_catalog.pg_namespace pns, pg_catalog.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; $$;

Testé, sauf ajouts ultérieurs ( extensionscontribution de Clément Prévost ), sur PostgreSQL 9.6 ( jessie-backports). Suppression d'agrégats testée sur 9.6 et 12.2, retrait de procédure également testé sur 12.2. Les corrections de bugs et autres améliorations sont les bienvenues!

Vous devez supprimer des tableaux et des séquences, voici ce qui a fonctionné pour moi

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

avant d'exécuter la commande que vous pourriez avoir besoin de Sudo / su à l' postgresutilisateur ou (détails connexion à l'exportation PGHOST, PGPORT, PGUSERet PGPASSWORD) puisexport PGDATABASE=yourdatabase

Rake task for Rails for destroy all tables in current database

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

Les étapes suivantes peuvent être utiles (pour les utilisateurs de Linux):

1. Entrez d'abord l' postgresinvite de commande en suivant la commande:

   sudo -u postgres psql

2. Entrez la base de données par cette commande (mon nom de base de données est:) maoss:

   \c maoss

3. Entrez maintenant la commande pour supprimer toutes les tables:

   DROP SCHEMA public CASCADE;
   CREATE SCHEMA public;
   
   GRANT ALL ON SCHEMA public TO postgres;
   GRANT ALL ON SCHEMA public TO public;

J'ai amélioré la méthode bash de jamie en prenant soin des vues car la sienne ne respecte que le type de table "table de base" qui est la valeur par défaut.

le code bash suivant supprime d'abord les vues, puis tout le reste

#!/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"

dans un fichier batch Windows:

@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
)

bien, puisque j'aime travailler depuis la ligne de commande ...

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

-c '\dt' invoquera la commande list tables.

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

cut -d ' ' -f 4 maintenant, dirigez sa sortie pour saisir le 4ème champ (lorsque vous utilisez l'espace comme séparateur), qui est la table.

sedest ensuite utilisé pour préfixer a drop tableet suffixer le ;séparateur de commandes.

| egrep '_d_'- Ajoutez-en grepplus et vous pouvez être plus sélectif sur les tables que vous supprimez.

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

Remarque: tel qu'écrit, cela générera de fausses lignes pour la \dtsortie des commandes des en-têtes de colonne et le total des lignes à la fin. J'évite cela en applaudissant, mais vous pouvez utiliser headet tail.

Le moyen le plus simple consiste à supprimer le schéma public comme d'autres l'ont suggéré dans les réponses précédentes. Cependant, ce n'est PAS un bon moyen. Vous ne savez jamais ce qui a été fait au schéma public qui a depuis été oublié et n'a pas été documenté. Vous ne savez pas non plus si cela fonctionnera de la même manière à l'avenir. Dans la version 9, cela aurait été bien, mais dans la version 10, tous vos utilisateurs perdraient l'accès au schéma et ils devraient à nouveau y accéder, sinon votre application se briserait. Je n'ai pas vérifié la V11, mais le fait est que vous ne savez jamais ce qui se cassera lorsque vous passez d'une machine à l'autre, d'un site à l'autre ou d'une version à une autre. Cela ne peut pas non plus être fait si vous êtes un utilisateur qui a accès à la base de données, mais pas au schéma.

Si vous devez le faire par programme, les autres réponses ci-dessus couvrent cela, mais une chose que les réponses ci-dessus ne prennent pas en compte est de demander à Postgres de faire le travail pour vous. Si vous utilisez pg_dump avec l'option -c comme ci-dessous:

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

Cela créera un script de restauration de base de données avec des instructions sql qui supprimera toutes les tables.

Si le seul but en posant la question était de supprimer les tables avant la restauration, votre restauration fera le travail pour vous.

Cependant, si vous en avez besoin pour autre chose, vous pouvez simplement copier les instructions drop du script sql.