SQLite
 sql >> Database >  >> RDS >> SQLite

Crea una chiave esterna in SQLite

Quando crei una tabella in SQLite, puoi anche creare una chiave esterna per stabilire una relazione con un'altra tabella.

Questo articolo fornisce un esempio di creazione di una chiave esterna durante la creazione di una tabella in SQLite.

Abilita supporto chiave esterna

La prima cosa che dovremmo fare è abilitare il supporto della chiave esterna (se non è già stato fatto).

Supponendo che la tua libreria SQLite non lo sia stato compilato con SQLITE_OMIT_FOREIGN_KEY o SQLITE_OMIT_TRIGGER definito, sarà comunque necessario abilitare il supporto della chiave esterna in fase di esecuzione.

Per fare ciò, esegui la seguente istruzione:

PRAGMA foreign_keys = ON;

Ciò consentirà l'applicazione della chiave esterna per la connessione al database.

Se apri un'altra connessione, dovrai eseguire la stessa istruzione per quella connessione.

Tieni presente che questa impostazione non è richiesta per la creazione chiavi esterne, ma è necessario per l'imposizione chiavi esterne.

Ora che abbiamo abilitato il supporto della chiave esterna, andiamo avanti e creiamo una chiave esterna.

Esempio

Immagina di volere due tabelle con i seguenti dati.

Tabella denominata Animali domestici :

PetId       PetName     TypeId    
----------  ----------  ----------
1           Brush       3         
2           Tweet       3         
3           Yelp        1         
4           Woofer      1         
5           Fluff       2         

Tabella denominata Tipo s:

TypeId      Type      
----------  ----------
1           Dog       
2           Cat       
3           Parakeet  
4           Hamster   

E vogliamo il TypeId colonna degli Animali domestici tabella per fare riferimento a TypeId colonna dei Tipi tavolo.

In altre parole, vogliamo creare Pets.TypeId la chiave figlio (con un vincolo di chiave esterna) e Types.TypeId la chiave padre (con un vincolo di chiave primaria).

Sebbene le chiavi padre siano in genere anche la chiave primaria per la tabella, questo in realtà non è un requisito. In questo esempio ne faremo la chiave primaria.

Possiamo usare il codice seguente per creare queste due tabelle.

CREATE TABLE Types( 
    TypeId INTEGER PRIMARY KEY, 
    Type
);

CREATE TABLE Pets( 
    PetId INTEGER PRIMARY KEY, 
    PetName,
    TypeId,
    FOREIGN KEY(TypeId) REFERENCES Types(TypeId)
);

La parte che crea la chiave esterna è questa:

FOREIGN KEY(TypeId) REFERENCES Types(TypeId)

La FOREIGN KEY(TypeId) parte dichiara Pets.TypeId come chiave esterna.

Sebbene non abbia qualificato il nome della colonna con il nome della tabella, sappiamo che è Pets.TypeId (e non Types.TypeId ) perché lo stiamo eseguendo in CREATE TABLE dichiarazione per Animali domestici .

I REFERENCES Types(TypeId) specifica la colonna a cui farà riferimento la nostra chiave esterna. In questo caso farà riferimento a TypeId colonna dei Tipi tabella.

Ora che le nostre tabelle sono state create con la chiave esterna appropriata, possiamo aggiungere dati.

INSERT INTO Types VALUES 
    ( NULL, 'Dog' ),
    ( NULL, 'Cat' ),
    ( NULL, 'Parakeet' ),
    ( NULL, 'Hamster' );

INSERT INTO Pets VALUES 
    ( NULL, 'Brush', 3 ),
    ( NULL, 'Tweet', 3 ),
    ( NULL, 'Yelp', 1 ),
    ( NULL, 'Woofer', 1 ),
    ( NULL, 'Fluff', 2 );

Le tabelle ora contengono i dati mostrati sopra.

sqlite> SELECT * FROM Pets;
PetId       PetName     TypeId    
----------  ----------  ----------
1           Brush       3         
2           Tweet       3         
3           Yelp        1         
4           Woofer      1         
5           Fluff       2         
sqlite> SELECT * FROM Types;
TypeId      Type      
----------  ----------
1           Dog       
2           Cat       
3           Parakeet  
4           Hamster   

Violazione di chiavi straniere

Ma ora proviamo a inserire i dati che violano la chiave esterna.

Proviamo ad aggiungere un animale domestico che utilizza un TypeID inesistente (ovvero un TypeId valore che non esiste nei Tipi colonna).

INSERT INTO Pets VALUES 
    ( NULL, 'Homer', 5 );

Risultato:

Error: FOREIGN KEY constraint failed

Quindi la nostra chiave esterna ha impedito con successo l'ingresso di dati errati nel database. Ci ha quindi aiutato a mantenere l'integrità dei dati.

Se non ricevi questo errore e i dati sono stati inseriti correttamente, non hai abilitato il supporto della chiave esterna. Come accennato, dovrai abilitare il supporto della chiave esterna prima che le tue chiavi esterne vengano applicate.

Aggiunta di una chiave esterna a una tabella esistente

Il ALTER TABLE L'istruzione in SQLite è molto limitata e non consente di aggiungere una chiave esterna a una tabella esistente.

Pertanto, se devi aggiungere una chiave esterna a una tabella esistente, dovrai eliminare la tabella e crearla di nuovo con il vincolo di chiave esterna.

Se la tabella contiene dati che desideri conservare, puoi trasferire tali dati in un'altra tabella, prima di trasferirli nuovamente dopo aver creato la nuova tabella con il vincolo di chiave esterna.