¿Dejar caer todas las tablas en PostgreSQL?

¿Cómo puedo eliminar todas las tablas en PostgreSQL, trabajando desde la línea de comando?

No quiero dejar la base de datos en sí, solo todas las tablas y todos los datos en ellas.

Si todas sus tablas están en un único esquema, este enfoque podría funcionar (debajo del código se supone que el nombre de su esquema es public )

 DROP SCHEMA public CASCADE; CREATE SCHEMA public; 

Si está utilizando PostgreSQL 9.3 o superior, es posible que también deba restaurar las concesiones predeterminadas.

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

Puede escribir una consulta para generar un script SQL como este:

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

O:

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

En caso de que algunas tablas se eliminen automáticamente debido a la opción de cascada en una oración anterior.

Además, como se indica en los comentarios, es posible que desee filtrar las tablas que desea colocar por nombre de esquema:

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

Y luego ejecutarlo.

Glorious COPY + PASTE también funcionará.

La respuesta más aceptada a partir de este escrito (enero de 2014) es:

 drop schema public cascade; create schema public; 

Esto funciona, sin embargo, si su intención es restaurar el esquema público a su estado virgen, esto no completa la tarea. En pgAdmin III para PostgreSQL 9.3.1, si hace clic en el esquema “público” creado de esta manera y mira en el “panel de SQL”, verá lo siguiente:

 -- Schema: public -- DROP SCHEMA public; CREATE SCHEMA public AUTHORIZATION postgres; 

Sin embargo, por el contrario, una nueva base de datos tendrá lo siguiente:

 -- 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 mí, el uso de un marco web python que crea tablas de base de datos (web2py), utilizando el anterior causó problemas:

  no schema has been selected to create in 

Entonces, en mi opinión, la respuesta correcta es:

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

(También tenga en cuenta que para ejecutar estos comandos desde pgAdmin III, fui a Plugins-> PSQL Console)

Puede soltar todas las tablas con

 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 esto es mejor que drop schema public , porque no necesita recrear el schema y restaurar todas las concesiones.

Bono adicional que esto no requiere lenguaje de scripting externo, ni copia y pegado de SQL generado de vuelta al intérprete.

Como Pablo arriba, para simplemente caer de un esquema específico, con respecto a la caja:

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

Si todo lo que desea eliminar pertenece al mismo usuario, puede usar:

 drop owned by the_user; 

Tienes que reemplazar the_user con el nombre de usuario real, actualmente no hay opción para dejar todo para “el usuario actual”. La próxima versión 9.5 tendrá la opción drop owned by current_user .

Esto también eliminará vistas materializadas, vistas, secuencias, disparadores, esquemas, funciones, tipos, agregados, operadores, dominios, etc. (= todo ) que posee el the_user (= creado).

Más detalles en el manual: http://www.postgresql.org/docs/current/static/sql-drop-owned.html

 drop schema public cascade; 

debería hacer el truco.

Siguiendo a Pablo y LenW, aquí hay una línea que lo hace a la vez preparando y luego ejecutando:

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

NB: configure o reemplace $PGUSER y $PGDB con los valores que desee

Si tiene instalado el lenguaje de procedimientos PL / PGSQL, puede usar lo siguiente para eliminar todo sin un 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(); 

En lugar de escribir esto en el indicador “psql”, le sugiero que lo copie en un archivo y luego pase el archivo como entrada a psql usando las opciones “–file” o “-f”:

 psql -f clean_all_pg.sql 

Crédito por el cual se debe crédito: escribí la función, pero creo que las consultas (o la primera al menos) vinieron de alguien en una de las listas de correo de pgsql hace años. No recuerdo exactamente cuándo o cuál.

Modifiqué ligeramente la respuesta de Pablo por la conveniencia de que los comandos SQL generados se devolvieran como una sola cadena:

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

Por si acaso … Script de Python simple que limpia la base de datos 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] 

Asegúrese de que, después de copiarlo, la sangría sea la correcta, ya que Python confía en ella.

Puede usar la función string_agg para hacer una lista separada por comas, perfecta para DROP TABLE. Desde 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" 

Debes eliminar tablas y secuencias, aquí está lo que funcionó para mí

 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 ejecutar el comando, es posible que necesite sudo / su para el usuario de postgres o (exportar los detalles de la conexión PGHOST , PGPORT , PGUSER y PGPASSWORD ) y luego export PGDATABASE=yourdatabase

Use esta secuencia de comandos en 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; $$ 

Tarea Rake para Rails para destruir todas las tablas en la base de datos actual

 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 

Si desea eliminar datos (no eliminar la tabla):

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

O si desea colocar la tabla puede usar este sql:

 -- For tables SELECT 'DROP TABLE "' || table_schema || '"."' || table_name || '" CASCADE;' FROM information_schema.tables WHERE table_catalog = '' AND table_schema = ''; -- For sequences SELECT 'DROP SEQUENCE d_a_seq "' || sequence_schema || '"."' || sequence_name || '";' FROM information_schema.sequences WHERE sequence_catalog = '' AND sequence_schema = ''; 

Mejoré el método bash de Jamie ocupándome de las vistas porque solo respeta el tipo de tabla “tabla base” que es el valor predeterminado.

El siguiente código bash borra las vistas primero y luego todo el 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" 

en un archivo por lotes de 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 ) 

bueno, ya que me gusta trabajar desde la línea de comando …

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

-c '\dt' invocará el comando list tables.

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

cut -d ' ' -f 4 ahora, canalice su salida para tomar el 4to campo (cuando usa el espacio como separador), que es la tabla.

sed se usa para prefijar una drop table y sufijo ; separador de comando

| egrep '_d_' | egrep '_d_' – Pipe it into grep poco más y puede ser más selectivo acerca de qué tablas | egrep '_d_' caer.

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

Nota: según lo escrito, esto generará filas falsas para la salida de los comandos \dt de los encabezados de las columnas y las filas totales al final. Lo evito cazando, pero podrías usar head y tail .