SQLite - Ändra en tabell

SQLite stöder en begränsad delmängd av SQL-standarden ALTER TABLE påstående.

I SQLite, ALTER TABLE kommandot låter användaren byta namn på en tabell eller lägga till en ny kolumn i en befintlig tabell.

Lägg till en kolumn

ADD COLUMN syntax används för att lägga till en ny kolumn i en befintlig tabell.

Låt oss lägga till en kolumn till Artister tabell:

ALTER TABLE Artists
ADD COLUMN Bio TEXT;

Och kontrollera sedan tabellen med .schema kommando:

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

Följande begränsningar gäller när du använder ADD COLUMN syntax i SQLite:

• Kolumnen kanske inte har en PRIMARY KEY eller UNIQUE begränsning.
• Kolumnen kanske inte har ett standardvärde på CURRENT_TIME , CURRENT_DATE , CURRENT_TIMESTAMP , eller ett uttryck inom parentes.
• Om en NOT NULL begränsning anges, måste kolumnen ha ett annat standardvärde än NULL .
• Om begränsningar för främmande nyckel är aktiverade och en kolumn med REFERENCES sats läggs till måste kolumnen ha ett standardvärde på NULL .

Byt namn på en tabell

RENAME TO syntax låter dig ändra namnet på en tabell.

Låt oss byta namn på ett av våra bord:

ALTER TABLE Albums
RENAME TO Albums1;

Och kontrollera det med en .tables kommando:

sqlite> .tables
Albums1  Artists

Nu kommer alla ytterligare operationer att behöva använda det nya namnet på tabellen. Så vi kan välja data så här:

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                                              

Uppdatera eller släppa kolumner

SQLite stöder inte satser som DROP COLUMN , ALTER COLUMN och ADD CONSTRAINT , som är en del av SQL-standarden.

Det finns dock andra sätt att göra dessa saker med SQLite.

Ändra en kolumn

Säg att vi vill ändra namnet på Året kolumnen till ReleaseDate . Vi vill också ta bort NOT NULL begränsning.

För att göra detta kan du skapa en ny tabell (med den nya kolumndefinitionen), fylla i tabellen med data från den gamla tabellen, sedan när du är klar, ta bort den gamla tabellen och byta namn på den nya för att återspegla det ursprungliga namnet.

Skapa den nya tabellen

Skapa först den nya tabellen (notera ReleaseDate istället för Year ).

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

Så vi har nu följande tabeller i vår databas:

sqlite> .tables
Albums   Albums1  Artists

Infoga data

Infoga sedan data från den gamla tabellen.

Använd en INSERT uttalande som väljer data från den gamla tabellen och infogar den i den nya tabellen. Så här:

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

Verifiera att data har infogats i den nya tabellen:

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        

Släpp den gamla tabellen

Nu när den nya tabellen har skapats och fyllts i med data kan vi välja att ta bort den gamla tabellen, ändra den eller lämna den som den är.

Låt oss lämna det tills vidare, vi tar bort det senare.

Släpp en kolumn

För att ta bort en kolumn kan du skapa en tabell från en SELECT påstående. I SELECT sats, utelämna kolumnen/kolumnerna som du vill ta bort — SQLite skapar endast de kolumner som ingår i SELECT uttalande.

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

Och kontrollera sedan att data har infogats i den nya tabellen:

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        

Så vi har nu följande tabeller i vår databas:

sqlite> .tables
Albums   Albums1  Albums2  Artists