tutorial - postgresql cascade delete

PostgreSQL: LLAVE EXTRANJERA/ON DELETE CASCADE

Question

Tengo dos mesas como aquí:

DROP TABLE IF EXISTS schemas.book;
DROP TABLE IF EXISTS schemas.category;
DROP SCHEMA IF EXISTS schemas;
CREATE SCHEMA schemas;
CREATE TABLE schemas.category (
id BIGSERIAL PRIMARY KEY,
name VARCHAR NOT NULL,
UNIQUE(name)
);
CREATE TABLE schemas.book (
id BIGSERIAL PRIMARY KEY,
published DATE NOT NULL,
category_id BIGINT NOT NULL REFERENCES schemas.category ON DELETE CASCADE ON UPDATE CASCADE,
author VARCHAR NOT NULL,
name VARCHAR NOT NULL,
UNIQUE(published, author, name),
FOREIGN KEY(category_id) REFERENCES schemas.category (id)
);

Entonces, la lógica es simple: después de que el usuario elimina todos los libros de la categoría x, x se elimina de los gatos, probé el método anterior pero no funciona, después de limpiar el libro de tablas, la categoría de la tabla aún está llena, ¿qué ocurre?

Answer 1

PostgreSQL Forging Key BORRAR, ACTUALIZAR CASCADA

CREATE TABLE apps_user(
user_id SERIAL PRIMARY KEY,
username character varying(30),
userpass character varying(50),
created_on DATE
);
CREATE TABLE apps_profile(
pro_id SERIAL PRIMARY KEY,
user_id INT4 REFERENCES apps_user(user_id) ON DELETE CASCADE ON UPDATE CASCADE,
firstname VARCHAR(30),
lastname VARCHAR(50),
email VARCHAR UNIQUE,
dob DATE
);

Answer 2

En mi humilde experiencia con postgres 9.6, la eliminación en cascada no funciona en la práctica para tablas que crecen por encima de un tamaño trivial.

• Lo que es peor, mientras se lleva a cabo la eliminación de la cascada, las tablas involucradas se bloquean, por lo que esas tablas (y potencialmente toda su base de datos) no se pueden utilizar.
• Peor aún, es difícil hacer que Postgres te diga qué está haciendo durante la eliminación de cascada. Si lleva mucho tiempo, ¿qué tabla o tablas lo hacen lento? Quizás está en algún lugar en la información de pg_stats? Es difícil de contar.

Answer 3

Una clave externa con una eliminación en cascada significa que si se elimina un registro en la tabla principal, entonces los registros correspondientes en la tabla secundaria se eliminarán automáticamente. Esto se llama una eliminación en cascada.

Está diciendo de una manera opuesta, esto no es que cuando elimine de la tabla secundaria, los registros se eliminarán de la tabla principal.

UPDATE 1:

La opción ON DELETE CASCADE es especificar si desea eliminar las filas en una tabla secundaria cuando las filas correspondientes se eliminan en la tabla principal. Si no especifica eliminaciones en cascada, el comportamiento predeterminado del servidor de base de datos le impide eliminar datos de una tabla si otras tablas hacen referencia a ella.

Si especifica esta opción, más adelante, cuando elimine una fila de la tabla principal, el servidor de la base de datos también eliminará las filas asociadas con esa fila (claves externas) en una tabla secundaria. La principal ventaja de la función de eliminación en cascada es que le permite reducir la cantidad de sentencias de SQL que necesita para realizar acciones de eliminación.

Así que todo se trata de lo que sucederá cuando elimines filas de la tabla principal y no de la tabla secundaria.

Entonces, en su caso, cuando el usuario elimine entradas de la tabla CAT, las filas se eliminarán de la tabla de libros. :)

Espero que esto te ayude :)

Answer 4

Extracto de la documentation PostgreSQL:

Las eliminaciones restringidas y en cascada son las dos opciones más comunes. [...] CASCADE especifica que cuando se elimina una fila referenciada, las filas que hacen referencia a ella también deben eliminarse automáticamente.

Esto significa que si elimina una categoría (a la que se hace referencia en los libros), el libro de referencia también se eliminará con ON DELETE CASCADE .

Ejemplo :

CREATE SCHEMA shire;
CREATE TABLE shire.clans (
id serial PRIMARY KEY,
clan varchar
);
CREATE TABLE shire.hobbits (
id serial PRIMARY KEY,
hobbit varchar,
clan_id integer REFERENCES shire.clans (id) ON DELETE CASCADE
);

DELETE FROM clanes CASCADE a hobbits por REFERENCES .

sauron@mordor> psql
sauron=# SELECT * FROM shire.clans;
id | clan
----+------------
1 | Baggins
2 | Gamgi
(2 rows)
sauron=# SELECT * FROM shire.hobbits;
id | hobbit | clan_id
----+----------+---------
1 | Bilbo | 1
2 | Frodo | 1
3 | Samwise | 2
(3 rows)
sauron=# DELETE FROM shire.clans WHERE id = 1 RETURNING *;
id | clan
----+---------
1 | Baggins
(1 row)
DELETE 1
sauron=# SELECT * FROM shire.hobbits;
id | hobbit | clan_id
----+----------+---------
3 | Samwise | 2
(1 row)

Si realmente necesitas lo contrario (verificado por la base de datos), ¡tendrás que escribir un disparador!