SQLite DROP TABELL

I SQLite kan du släppa en tabell med DROP TABLE uttalande.

Du kan valfritt lägga till IF EXISTS klausul för att undertrycka eventuella fel som kan uppstå om tabellen inte finns.

Dessutom, om tabellen refereras av en främmande nyckel, finns det några saker att vara medveten om.

Exempel

Här är ett exempel för att visa det enklaste sättet att släppa en tabell i SQLite:

DROP TABLE t1;

Detta tar bort tabellen som heter t1 .

Du kan valfritt prefix tabellnamnet med schemanamnet.

Använda IF EXISTS Klausul

Du kan använda koden IF EXISTS klausul för att undertrycka eventuella fel som kan uppstå i händelse av att tabellen inte existerar.

DROP TABLE IF EXISTS t2;

Om vi ​​tar bort IF EXISTS och kör den igen får vi ett felmeddelande.

Exempel:

DROP TABLE t2;

Resultat:

Error: no such table: t2 

Förändrade nyckel- och vyberoenden

SQLite stöder inte CASCADE och RESTRICT nyckelord, som ingår i SQL-standarden, och som stöds av vissa andra RDBMS (som PostgreSQL). Dessa nyckelord är utformade för att specificera vad som ska göras när måltabellen har beroenden (som en vy eller främmande nyckel som refererar till tabellen).

Eftersom SQLite inte stöder dessa nyckelord, så här hanterar SQLite vyer och främmande nycklar när du försöker släppa en tabell.

SQLite ignorerar alla beroende vyer. Med andra ord, det går vidare och släpper tabellen, även om det finns en vy som refererar till det.

När det gäller främmande nycklar...

För det första är främmande nycklar inaktiverade som standard i SQLite. Så om du inte aktiverar dem kommer alla främmande nycklar som refererar till måltabellen inte att ha någon inverkan på att måltabellen tas bort. Med andra ord kommer tabellen att tas bort.

Om främmande nycklar är aktiverade i din session kommer de bara att förhindra att tabellen släpps om det finns data som bryter mot den främmande nyckeln. Om din underordnade tabell inte innehåller några data, kommer den överordnade tabellen att tas bort utan fel. Om den underordnade tabellen innehåller data (förmodligen inklusive data som refererar till den överordnade tabellens primärnyckel), kommer detta att resultera i ett fel och tabellen kommer inte att tas bort.

Så här:

PRAGMA foreign_keys = ON;
DROP TABLE t1;

Resultat:

Error: FOREIGN KEY constraint failed 

Anledningen till att det fungerar så här är att SQLite utför en implicit DELETE FROM operation innan du släpper bordet. Om DELETE FROM operation resulterar i ett brott mot främmande nyckel, då får vi felet. Men om det inte finns några data i tabellen, då någon DELETE FROM operation kommer inte att resultera i ett brott mot främmande nyckel, och tabellen kan släppas.

Kort sagt, det är inte DROP TABLE operation som orsakar överträdelser av främmande nyckel, det är den implicita DELETE FROM operation.

När den främmande nyckeln använder ON DELETE CASCADE

Men om den främmande nyckeln är definierad med ON DELETE CASCADE , kommer den överordnade tabellen att tas bort, och alla rader som refererar till tabellens primärnyckelkolumn kommer att tas bort i den underordnade tabellen.

Här är ett exempel.

Skapa tabeller och infoga data:

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

Välj data:

sqlite> SELECT * FROM t11;
c1
--
1 
sqlite> SELECT * FROM t12;
c1  c2
--  --
1   1 

Släpp den överordnade tabellen och granska alla tabeller:

sqlite> DROP TABLE t11;
sqlite> .tables
t12

Vi kan se att t11 finns inte längre, men t12 finns fortfarande.

Kontrollera den främmande nyckeln på 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 

Ja, det finns fortfarande, och vi kan bekräfta att det har ON DELETE CASCADE .

Välj data från t12 :

sqlite> SELECT * FROM t12;
sqlite> 

Inga rader returneras. Detta beror på att ON DELETE CASCADE alternativet på den främmande nyckeln säkerställde att raden raderades när den överordnade tabellen (t11 ) togs bort (eller mer exakt, när dess data raderades via den implicita DELETE FROM operation innan den tappas).

Släpp en främmande nyckel

SQLite stöder faktiskt inte borttagning av främmande nycklar. Normalt i SQL släpper du främmande nycklar med ALTER TABLE sats, men SQLites ALTER TABLE implementering tillåter inte att begränsningar tas bort.

Det finns dock ett sätt att hantera den här situationen. Se Hur man släpper en främmande nyckel i SQLite för ett exempel.