In SQLite, puoi eliminare una tabella con DROP TABLE dichiarazione.
Puoi opzionalmente aggiungere il IF EXISTS clausola per eliminare eventuali errori che potrebbero verificarsi se la tabella non esiste.
Inoltre, se la tabella è referenziata da una chiave esterna, ci sono alcune cose da tenere a mente.
Esempio
Ecco un esempio per dimostrare il modo più semplice per eliminare una tabella in SQLite:
DROP TABLE t1;
Questo elimina la tabella chiamata t1 .
È possibile opzionalmente anteporre al nome della tabella il nome dello schema.
Utilizzando il IF EXISTS Clausola
Puoi usare il IF EXISTS clausola per eliminare eventuali errori che potrebbero verificarsi nel caso in cui la tabella non esiste.
DROP TABLE IF EXISTS t2;
Se rimuoviamo IF EXISTS ed eseguirlo di nuovo, otteniamo un errore.
Esempio:
DROP TABLE t2;Risultato:
Error: no such table: t2
Chiave straniera e dipendenze vista
SQLite non supporta CASCADE e RESTRICT parole chiave, che sono incluse nello standard SQL e sono supportate da altri RDBMS (come PostgreSQL). Queste parole chiave sono progettate per specificare cosa fare quando la tabella di destinazione ha dipendenze (come una vista o una chiave esterna che fa riferimento alla tabella).
Dato che SQLite non supporta queste parole chiave, ecco come SQLite gestisce le viste e le chiavi esterne quando tenti di eliminare una tabella.
SQLite ignora qualsiasi vista dipendente. In altre parole, va avanti e lascia cadere la tabella, anche se c'è una vista che vi fa riferimento.
Per quanto riguarda le chiavi esterne...
Innanzitutto, le chiavi esterne sono disabilitate per impostazione predefinita in SQLite. Quindi, a meno che non le abiliti, tutte le chiavi esterne che fanno riferimento alla tabella di destinazione non avranno alcun impatto sull'eliminazione della tabella di destinazione. In altre parole, la tabella verrà eliminata.
Se le chiavi esterne sono abilitate nella tua sessione, impediranno l'eliminazione della tabella solo se sono presenti dati che violeranno quella chiave esterna. Se la tabella figlio non contiene dati, la tabella padre verrà eliminata senza errori. Se la tabella figlio contiene dati (presumibilmente inclusi dati che fanno riferimento alla chiave primaria della tabella padre), ciò risulterà in un errore e la tabella non verrà eliminata.
In questo modo:
PRAGMA foreign_keys = ON;
DROP TABLE t1;Risultato:
Error: FOREIGN KEY constraint failed
Il motivo per cui funziona in questo modo è perché SQLite esegue un implicito DELETE FROM operazione prima di far cadere il tavolo. Se il DELETE FROM l'operazione provoca una violazione della chiave esterna, quindi otteniamo l'errore. Ma se non ci sono dati nella tabella, allora qualsiasi DELETE FROM l'operazione non comporterà una violazione della chiave esterna e la tabella può essere eliminata.
In breve, non è il DROP TABLE operazione che causa qualsiasi violazione della chiave esterna, è l'implicito DELETE FROM operazione.
Quando la chiave esterna utilizza ON DELETE CASCADE
Tuttavia, se il vincolo di chiave esterna è definito con ON DELETE CASCADE , la tabella padre verrà eliminata e tutte le righe che fanno riferimento alla colonna della chiave primaria di quella tabella verranno eliminate nella tabella figlio.
Ecco un esempio.
Crea tabelle e inserisci dati:
CREATE TABLE t11 (
c1 integer PRIMARY KEY AUTOINCREMENT
);
CREATE TABLE t12 (
c1 integer PRIMARY KEY AUTOINCREMENT,
c2 integer REFERENCES t11 (c1) ON DELETE CASCADE
);
INSERT INTO t11 VALUES (1);
INSERT INTO t12 VALUES (1, 1);
Seleziona i dati:
sqlite> SELECT * FROM t11;
c1
--
1
sqlite> SELECT * FROM t12;
c1 c2
-- --
1 1 Rilascia la tabella principale ed esamina tutte le tabelle:
sqlite> DROP TABLE t11;
sqlite> .tables
t12
Possiamo vedere che t11 non esiste più, ma t12 esiste ancora.
Controlla la chiave esterna su t12 :
sqlite> PRAGMA foreign_key_list(t12);
id seq table from to on_update on_delete match
-- --- ----- ---- -- --------- --------- -----
0 0 t11 c2 c1 NO ACTION CASCADE NONE
Sì, esiste ancora e possiamo confermare che ha ON DELETE CASCADE .
Seleziona i dati da t12 :
sqlite> SELECT * FROM t12;
sqlite>
Non vengono restituite righe. Questo perché ON DELETE CASCADE opzione sulla chiave esterna assicurava che la riga fosse eliminata quando la tabella padre (t11 ) è stato eliminato (o più precisamente, quando i suoi dati sono stati eliminati tramite l'implicito DELETE FROM operazione prima della caduta).
Eliminazione di una chiave esterna
SQLite in realtà non supporta l'eliminazione di chiavi esterne. Normalmente in SQL si eliminano le chiavi esterne con il ALTER TABLE istruzione, ma ALTER TABLE di SQLite l'implementazione non consente di eliminare i vincoli.
C'è un modo per affrontare questa situazione però. Vedi Come eliminare una chiave esterna in SQLite per un esempio.
