postgresql - example - tables postgres

¿Deseas eliminar todas las tablas en PostgreSQL?

Question

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

No quiero eliminar la base de datos, solo todas las tablas y todos los datos que contienen.

Answer 1

Bueno, ya que me gusta trabajar desde la línea de comandos ...

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

-c ''/dt'' invocará el comando de tablas de listas.

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 use el espacio como separador), que es la tabla.

sed se usa entonces para prefijar una drop table y el sufijo ; separador de comandos.

| egrep ''_d_'' | egrep ''_d_'' : | egrep ''_d_'' en grep poco más y puede ser más selectivo sobre las tablas que suelta.

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

Nota: como está escrito, esto generará filas falsas para la salida de los comandos /dt de los encabezados de columna y las filas totales al final. Evito eso al grepping, pero podrías usar head y tail .

Answer 2

De acuerdo con Pablo arriba, para simplemente abandonar un esquema específico, con respecto al caso:

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

Answer 3

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 cumple completamente 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 SQL" verá lo siguiente:

-- Schema: public

-- DROP SCHEMA public;

CREATE SCHEMA public
  AUTHORIZATION postgres;

Sin embargo, en contraste, 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í, usar un marco web de Python que crea tablas de base de datos (web2py), usando los problemas causados ​​anteriormente:

<class ''psycopg2.ProgrammingError''> 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 emitir estos comandos desde pgAdmin III, fui a Plugins-> PSQL Console)

Answer 4

Mejoré el método de bash de jamie cuidando las vistas porque solo respeta el tipo de tabla "tabla base", que es el valor predeterminado.

El siguiente código de bash elimina primero las vistas y luego todas las demás.

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

Answer 5

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

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

Answer 6

Necesitas eliminar tablas y secuencias, esto es 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 postgres o (exportar detalles de conexión PGHOST , PGPORT , PGUSER y PGPASSWORD ) y luego export PGDATABASE=yourdatabase

Answer 7

Por si acaso ... Sencillo script Python 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 se basa en ella.

Answer 8

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

Answer 9

Puedes caer todas las mesas 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 $$;

En mi opinión, esto es mejor que drop schema public , ya que no es necesario volver a crear el schema y restaurar todas las concesiones.

Bonificación adicional de que esto no requiere lenguaje de scripting externo, ni copiar y pegar de nuevo el SQL generado al intérprete.

Answer 10

Puedes 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.

La gloriosa COPY + PASTE también funcionará.

Answer 11

Rake task for 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

Answer 12

Si desea eliminar datos (no borrar tabla):

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

O si quieres drop table puedes 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>'';

Answer 13

Si tiene installed lenguaje de procedimientos PL / PGSQL, puede usar lo siguiente para eliminar todo sin un script shell / Perl externo.

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 mensaje "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 al que se debe el crédito: escribí la función, pero creo que las consultas (o la primera al menos) provinieron de alguien en una de las listas de correo de pgsql hace años. No recuerdo exactamente cuándo o cuál.

Answer 14

Si todas sus tablas están en un solo esquema, este enfoque podría funcionar (el código a continuación asume 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;

Answer 15

Si todo lo que quieres soltar es propiedad del mismo usuario, entonces puedes usar:

drop owned by the_user;

Esto eliminará todo lo que el usuario posee.

Eso incluye vistas materializadas, vistas, secuencias, disparadores, esquemas, funciones, tipos, agregados, operadores, dominios, etc. (así, realmente: todo ) que posee el the_user (= creado).

the_user 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 .

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

Answer 16

Siguiendo a Pablo y LenW, aquí hay una sola línea que hace todo 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

Answer 17

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

Answer 18

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
)

Answer 19

drop schema public cascade;

debe hacer el truco