Como posso soltar todas as tabelas em um banco de dados PostgreSQL?

Como posso eliminar todas as tabelas no PostgreSQL, trabalhando na linha de comando?

Eu não quero largar o próprio banco de dados, apenas a todas as tabelas e todos os dados em si.

Se todas as suas tabelas estiverem em um único esquema, essa abordagem poderá funcionar (o código abaixo assume que o nome do seu esquema é public)

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;

Se você estiver usando o PostgreSQL 9.3 ou superior, também poderá ser necessário restaurar as concessões padrão.

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

Você pode escrever uma consulta para gerar um script SQL como este:

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

Ou:

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

Caso algumas tabelas sejam eliminadas automaticamente devido à opção em cascata em uma frase anterior.

Além disso, conforme indicado nos comentários, convém filtrar as tabelas que deseja excluir pelo nome do esquema:

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

E depois execute.

Glorioso COPY + PASTE também funcionará.

A resposta mais aceita até o momento em que este artigo foi escrito (janeiro de 2014) é:

drop schema public cascade;
create schema public;

Isso funciona, no entanto, se sua intenção é restaurar o esquema público para seu estado virgem, isso não realiza completamente a tarefa. No pgAdmin III para PostgreSQL 9.3.1, se você clicar no esquema "público" criado dessa maneira e procurar no "painel SQL", verá o seguinte:

-- Schema: public

-- DROP SCHEMA public;

CREATE SCHEMA public
  AUTHORIZATION postgres;

No entanto, por outro lado, um novo banco de dados terá o seguinte:

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

Para mim, usando um framework web python que cria tabelas de banco de dados (web2py), o uso dos primeiros causou problemas:

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

Então, na minha opinião, a resposta totalmente correta é:

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

Observe também que para emitir esses comandos no pgAdmin III, usei a ferramenta Query (ícone da lupa "Executar consultas SQL abritrárias") ou você pode usar Plugins-> PSQL Console

Nota

Se você tiver alguma extensão instalada, ela será descartada quando você soltar o esquema; portanto, anote o que você precisa instalar e execute as instruções conforme necessário. Por exemplo

CREATE EXTENSION postgis;

Você pode soltar todas as tabelas com

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

Para a IMO, é melhor que isso drop schema public, porque você não precisa recriar schemae restaurar todas as concessões.

Bônus adicional por não exigir linguagem de script externa nem copiar e colar o SQL gerado de volta ao intérprete.

Se tudo o que você deseja soltar pertence ao mesmo usuário, você pode usar:

drop owned by the_user;

Isso descartará tudo o que o usuário possui.

Isso inclui visualizações materializadas, visualizações, sequências, gatilhos, esquemas, funções, tipos, agregados, operadores, domínios e assim por diante (então, realmente: tudo ) que the_userpossui (= criado).

Você precisa substituir the_userpelo nome de usuário real. Atualmente, não há opção de descartar tudo para "o usuário atual". A próxima versão 9.5 terá a opção drop owned by current_user.

Mais detalhes no manual: http://www.postgresql.org/docs/current/static/sql-drop-owned.html

Conforme Pablo acima, para sair apenas de um esquema específico, com relação ao caso:

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

drop schema public cascade;

deve fazer o truque.

Seguindo Pablo e LenW, aqui está uma lista que faz tudo ao mesmo tempo preparando e executando:

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

NB: defina ou substitua $PGUSERe $PGDBcom os valores desejados

Se você tiver a linguagem procedural PL / PGSQL instalada, poderá usar o seguinte para remover tudo sem um script externo 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();

Em vez de digitar isso no prompt "psql", sugiro que você o copie para um arquivo e depois passe o arquivo como entrada para o psql usando as opções "--file" ou "-f":

psql -f clean_all_pg.sql

Crédito onde o crédito é devido: eu escrevi a função, mas acho que as consultas (ou a primeira pelo menos) vieram de alguém de uma das listas de discussão do pgsql anos atrás. Não lembro exatamente quando ou qual.

Se você quiser destruir todas as tabelas de qualquer maneira, poderá dispensar detalhes, como CASCADE, colocando todas as tabelas em uma única instrução. Isso também torna a execução mais rápida.

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

Executando-o diretamente:

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

Substitua TRUNCATEpor DROPconforme aplicável.

Modifiquei ligeiramente a resposta de Pablo para a conveniência de ter os comandos SQL gerados retornados como uma única sequência:

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

Use este script no 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; $$

Apenas no caso ... Script Python simples que limpa o banco de dados 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]

Certifique-se de que, após copiá-lo, o recuo esteja correto, pois o Python depende dele.

Você pode usar a função string_agg para criar uma lista separada por vírgulas, perfeita para DROP TABLE. Em um 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"

Se você deseja excluir dados (não excluir tabela):

-- 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, se você quiser soltar a tabela, poderá usar este 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>';

Nota: minha resposta é sobre realmente excluir as tabelas e outros objetos de banco de dados; para apagar todos os dados em tabelas, ou seja truncar todas as tabelas , Endre Ambos forneceu uma declaração similarily bem executado (execução direta), um mês depois.

Para os casos em que você não pode simplesmente DROP SCHEMA public CASCADE;, DROP OWNED BY current_user;ou algo assim, aqui está um script SQL independente que eu escrevi, que é seguro para transações (ou seja, você pode colocá-lo entre BEGIN;e ROLLBACK;apenas para testá-lo ou COMMIT;realmente fazer a ação) e limpa “todos” os objetos do banco de dados ... bem, todos aqueles usados ​​no banco de dados que nosso aplicativo usa ou eu poderia acrescentar sensatamente, que é:

• gatilhos nas tabelas
• restrições de tabela (FK, PK, CHECK, UNIQUE)
• indicações
• VIEWs (normal ou materializado)
• mesas
• sequências
• rotinas (funções agregadas, funções, procedimentos)
• todos os esquemas não padrão (por exemplo, não publicou internos ao banco de dados) "nós" possuímos: o script é útil quando executado como "não um superusuário de banco de dados"; um superusuário pode eliminar todos os esquemas (os realmente importantes ainda são explicitamente excluídos)
• extensões (contribuídas pelo usuário, mas normalmente as deixo deliberadamente)

Não são descartados (alguns deliberados; outros apenas porque eu não tinha exemplo em nosso banco de dados):

• o publicesquema (por exemplo, para itens fornecidos por extensão)
• colações e outras coisas de localidade
• gatilhos de evento
• pesquisa de texto,… (veja aqui outras informações que eu poderia ter perdido)
• funções ou outras configurações de segurança
• tipos compostos
• mesas de brinde
• FDW e tabelas estrangeiras

Isso é realmente útil para os casos em que o dump que você deseja restaurar é de uma versão de esquema de banco de dados diferente (por exemplo, com Debian dbconfig-common, Flyway ou Liquibase / DB-Manul) do que o banco de dados no qual você deseja restaurá-lo.

Eu também tenho uma versão que exclui "tudo, exceto duas tabelas e o que lhes pertence" (uma sequência, testada manualmente, desculpe, eu sei, chata) no caso de alguém estar interessado; o diff é pequeno. Entre em contato comigo ou consulte este repositório, se estiver interessado.

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

Testado, exceto adições posteriores ( extensionscontribuído por Clément Prévost ), no PostgreSQL 9.6 ( jessie-backports). Remoção agregada testada em 9.6 e 12.2, remoção de procedimento testada em 12.2 também. Correções de bugs e melhorias adicionais são bem-vindas!

Essa é uma pergunta realmente interessante, e você poderá fazer isso de várias maneiras. Espero que isso seja útil para você.

1. Eliminando e recriando o esquema atual

Aqui, em geral, temos um publicesquema por padrão. Então, eu estou usando isso como uma instância.

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

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

Se você estiver usando o PostgreSQL 9.3 ou superior, também poderá ser necessário restaurar as concessões padrão.

Prós:

Isso limpará um esquema inteiro e o recriará como um novo.

Contras:

Você vai perder outras entidades também como Functions, Views, Materialized views, etc.

2. Usando a busca de todos os nomes de pg_tablestabela da tabela.

O PostgreSQL armazena todas as tabelas em sua tabela de registro denominada pg_table.

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

Como você pode ver, pelo uso da subconsulta, podemos remover todas as tabelas do esquema.

Prós:

Quando as outras entidades de dados são importantes e você deseja excluir apenas as tabelas do esquema, essa abordagem será realmente útil para você.

Você precisa soltar tabelas e sequências, eis o que funcionou para mim

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

antes de executar o comando que você pode precisar sudo / su aos postgresusuários ou (detalhes de conexão de exportação PGHOST, PGPORT, PGUSERe PGPASSWORD) e, em seguida,export PGDATABASE=yourdatabase

Tarefa Rake para Rails para destruir todas as tabelas no banco de dados atual

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

As etapas a seguir podem ser úteis (para usuários Linux):

1. Primeiro, digite o postgresprompt de comando, seguindo o comando:

   sudo -u postgres psql

2. Digite o banco de dados por este comando (o nome do meu banco de dados é maoss:):

   \c maoss

3. Agora digite o comando para descartar todas as tabelas:

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

Aprimorei o método bash de jamie cuidando das visualizações, porque ele só respeita o tipo de tabela "tabela base", que é o padrão.

O seguinte código bash exclui as visualizações primeiro e depois todo o resto

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

em um arquivo em lotes do 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
)

bem, desde que eu gosto de trabalhar na linha de comando ...

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

-c '\dt' chamará o comando list tables.

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

cut -d ' ' -f 4 agora, canalize sua saída para pegar o quarto campo (ao usar o espaço como separador), que é a tabela.

sedé então utilizado como prefixo a drop tablee sufixo o ;separador de comandos.

| egrep '_d_'- Coloque um greppouco mais e você poderá ser mais seletivo sobre as tabelas que você solta.

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

Nota: conforme escrito, isso gerará linhas falsas para a \dtsaída dos comandos dos cabeçalhos das colunas e o total de linhas no final. Evito isso grepping, mas você pode usar heade tail.

A maneira mais fácil é abandonar o esquema público, como outros sugeriram nas respostas anteriores. No entanto, este não é um bom caminho. Você nunca sabe o que foi feito com o esquema público que foi esquecido e não foi documentado. Você também não sabe se isso funcionará da mesma maneira no futuro. Na V9, teria sido bom, mas na V10 todos os usuários perderiam o acesso ao esquema e devem ter acesso concedido novamente, caso contrário, seu aplicativo será interrompido. Eu não verifiquei a V11, mas o ponto é que você nunca sabe o que será interrompido ao passar de máquina para máquina, site para site ou versão para versão. Isso também não pode ser feito se você for um usuário que tenha acesso ao banco de dados, mas não ao esquema.

Se você precisar fazer isso de forma programática, as outras respostas acima abordarão isso, mas uma coisa que as respostas acima não consideram é fazer com que o Postgres faça o trabalho para você. Se você usar pg_dump com a opção -c como abaixo:

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

Isso criará um script de restauração do banco de dados com instruções sql que excluirá todas as tabelas.

Se o único objetivo ao fazer a pergunta era excluir as tabelas antes da restauração, sua restauração fará o trabalho por você.

No entanto, se você precisar de algo mais, poderá simplesmente copiar as instruções drop do script sql.