SQLite - Een tabel wijzigen

SQLite ondersteunt een beperkte subset van de SQL-standaard ALTER TABLE uitspraak.

In SQLite, de ALTER TABLE Met het commando kan de gebruiker een tabel hernoemen of een nieuwe kolom toevoegen aan een bestaande tabel.

Een kolom toevoegen

De ADD COLUMN syntaxis wordt gebruikt om een nieuwe kolom aan een bestaande tabel toe te voegen.

Laten we een kolom toevoegen aan de Artiesten tafel:

ALTER TABLE Artists
ADD COLUMN Bio TEXT;

En controleer dan de tabel met het .schema commando:

sqlite> .schema Artists
CREATE TABLE Artists(
  ArtistId    INTEGER PRIMARY KEY, 
  ArtistName  TEXT NOT NULL
, Bio TEXT);

De volgende beperkingen zijn van toepassing bij het gebruik van de ADD COLUMN syntaxis in SQLite:

De kolom heeft mogelijk geen PRIMARY KEY of UNIQUE beperking.
De kolom heeft mogelijk geen standaardwaarde van CURRENT_TIME , CURRENT_DATE , CURRENT_TIMESTAMP , of een uitdrukking tussen haakjes.
Als een NOT NULL beperking is opgegeven, moet de kolom een andere standaardwaarde hebben dan NULL .
Als beperkingen voor externe sleutels zijn ingeschakeld en een kolom met een REFERENCES clausule is toegevoegd, moet de kolom de standaardwaarde NULL . hebben .

De naam van een tabel wijzigen

De RENAME TO syntaxis stelt u in staat de naam van een tabel te wijzigen.

Laten we een van onze tabellen hernoemen:

ALTER TABLE Albums
RENAME TO Albums1;

En controleer het met een .tables commando:

sqlite> .tables
Albums1  Artists

Nu moeten alle verdere bewerkingen de nieuwe naam van de tabel gebruiken. Dus we kunnen gegevens als volgt selecteren:

SELECT AlbumName, Year 
FROM Artists AS a INNER JOIN Albums1 AS r
ON a.ArtistId = r.ArtistId
WHERE a.ArtistName = 'Joe Satriani';

AlbumName             Year                                              
--------------------  --------------------------------------------------
Surfing with the Ali  1987                                              
Flying in a Blue Dre  1989                                              
Black Swans and Worm  2010

Kolommen bijwerken of verwijderen

SQLite ondersteunt geen clausules zoals DROP COLUMN , ALTER COLUMN , en ADD CONSTRAINT , die deel uitmaken van de SQL-standaard.

Er zijn echter andere manieren om deze dingen te doen met SQLite.

Een kolom wijzigen

Stel dat we de naam van het Jaar . willen wijzigen kolom naar ReleaseDate . We willen ook de NOT NULL . verwijderen beperking.

Om dit te doen, kunt u een nieuwe tabel maken (met de nieuwe kolomdefinitie), de tabel vullen met de gegevens van de oude tabel, en als u klaar bent, de oude tabel verwijderen en de nieuwe naam wijzigen om de oorspronkelijke naam weer te geven.

Maak de nieuwe tabel

Maak eerst de nieuwe tabel (let op ReleaseDate in plaats van Year ).

CREATE TABLE Albums(
  AlbumId     INTEGER PRIMARY KEY, 
  AlbumName   TEXT NOT NULL,
  ReleaseDate TEXT,
  ArtistId INTEGER NOT NULL,
  FOREIGN KEY(ArtistId) REFERENCES Artists(ArtistId)
);

We hebben nu dus de volgende tabellen in onze database:

sqlite> .tables
Albums   Albums1  Artists

Gegevens invoegen

Voeg vervolgens de gegevens uit de oude tabel in.

Gebruik een INSERT statement dat gegevens uit de oude tabel selecteert en in de nieuwe tabel invoegt. Zoals dit:

INSERT INTO Albums (AlbumId, AlbumName, ReleaseDate, ArtistId)
SELECT AlbumId, AlbumName, Year, ArtistId
FROM Albums1;

Controleer of de gegevens in de nieuwe tabel zijn ingevoegd:

sqlite> SELECT * FROM Albums;
AlbumId   AlbumName                        ReleaseDate  ArtistId  
--------  -------------------------------  -----------  ----------
1         Killers                          1981         7         
2         Powerslave                       1984         7         
3         Surfing with the Alien           1987         1         
4         Heavy as a Really Heavy Thing    1995         11        
5         Yummy Yummy                      1994         17        
6         Out of the Loop                  2007         6         
7         Suck on This                     1989         13        
8         Pork Soda                        1993         13        
9         Sailing the Seas of Cheese       1991         13        
10        Flying in a Blue Dream           1989         1         
11        Black Swans and Wormhole Wizard  2010         1         
12        Somewhere in Time                1986         7         
13        Big Red Car                      1995         17

Laat de oude tafel vallen

Nu de nieuwe tabel is gemaakt en gevuld met de gegevens, hebben we de keuze om de oude tabel te verwijderen, aan te passen of te laten zoals hij is.

Laten we het voor nu laten, we zullen het later verwijderen.

Laat een kolom vallen

Om een kolom neer te zetten, kun je een tabel maken van een SELECT uitspraak. In de SELECT statement, laat de kolom(men) weg die u wilt laten vallen — SQLite zal alleen die kolommen maken die zijn opgenomen in de SELECT verklaring.

CREATE TABLE Albums2 AS 
SELECT AlbumId, AlbumName, ArtistId 
FROM Albums1;

En controleer vervolgens of de gegevens met succes in de nieuwe tabel zijn ingevoegd:

sqlite> select * from Albums2;
AlbumId   AlbumName                        ArtistId  
--------  -------------------------------  ----------
1         Killers                          7         
2         Powerslave                       7         
3         Surfing with the Alien           1         
4         Heavy as a Really Heavy Thing    11        
5         Yummy Yummy                      17        
6         Out of the Loop                  6         
7         Suck on This                     13        
8         Pork Soda                        13        
9         Sailing the Seas of Cheese       13        
10        Flying in a Blue Dream           1         
11        Black Swans and Wormhole Wizard  1         
12        Somewhere in Time                7         
13        Big Red Car                      17

We hebben nu dus de volgende tabellen in onze database:

sqlite> .tables
Albums   Albums1  Albums2  Artists