SQLite - Ændre en tabel

SQLite understøtter et begrænset undersæt af SQL-standarden ALTER TABLE udmelding.

I SQLite er ALTER TABLE kommandoen giver brugeren mulighed for at omdøbe en tabel eller tilføje en ny kolonne til en eksisterende tabel.

Tilføj en kolonne

ADD COLUMN syntaks bruges til at tilføje en ny kolonne til en eksisterende tabel.

Lad os tilføje en kolonne til Kunstnerne tabel:

ALTER TABLE Artists
ADD COLUMN Bio TEXT;

Og tjek derefter tabellen med .schema kommando:

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

Følgende begrænsninger gælder, når du bruger ADD COLUMN syntaks i SQLite:

• Kolonnen har muligvis ikke en PRIMARY KEY eller UNIQUE begrænsning.
• Kolonnen har muligvis ikke en standardværdi på CURRENT_TIME , CURRENT_DATE , CURRENT_TIMESTAMP , eller et udtryk i parentes.
• Hvis en NOT NULL begrænsning er angivet, så skal kolonnen have en anden standardværdi end NULL .
• Hvis fremmednøglebegrænsninger er aktiveret og en kolonne med en REFERENCES klausul tilføjes, skal kolonnen have en standardværdi på NULL .

Omdøb en tabel

RENAME TO syntaks giver dig mulighed for at ændre navnet på en tabel.

Lad os omdøbe et af vores borde:

ALTER TABLE Albums
RENAME TO Albums1;

Og tjek det med en .tables kommando:

sqlite> .tables
Albums1  Artists

Nu skal alle yderligere handlinger bruge det nye navn på tabellen. Så vi kan vælge data som denne:

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                                              

Opdatering eller sletning af kolonner

SQLite understøtter ikke klausuler såsom DROP COLUMN , ALTER COLUMN , og ADD CONSTRAINT , som er en del af SQL-standarden.

Der er dog andre måder at gøre disse ting på med SQLite.

Ændre en kolonne

Lad os sige, at vi vil ændre navnet på Året kolonne til ReleaseDate . Vi ønsker også at fjerne NOT NULL begrænsning.

For at gøre dette kan du oprette en ny tabel (med den nye kolonnedefinition), udfylde tabellen med data fra den gamle tabel og derefter slette den gamle tabel, når den er færdig, og omdøbe den nye for at afspejle det oprindelige navn.

Opret den nye tabel

Først skal du oprette den nye tabel (bemærk ReleaseDate i stedet for 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ølgende tabeller i vores database:

sqlite> .tables
Albums   Albums1  Artists

Indsæt data

Indsæt derefter dataene fra den gamle tabel.

Brug en INSERT sætning, der vælger data fra den gamle tabel og indsætter dem i den nye tabel. Sådan:

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

Bekræft, at dataene blev indsat i den nye tabel:

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        

Slip den gamle tabel

Nu hvor den nye tabel er blevet oprettet og udfyldt med dataene, har vi valget mellem at fjerne den gamle tabel, ændre den eller lade den være som den er.

Lad os lade det ligge indtil videre, vi fjerner det senere.

Slip en kolonne

For at slette en kolonne kan du oprette en tabel fra en SELECT udmelding. I SELECT sætning, udelad den eller de kolonner, du vil have slettet — SQLite vil kun oprette de kolonner, der er inkluderet i SELECT erklæring.

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

Og kontroller derefter, at dataene er blevet indsat i den nye tabel:

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ølgende tabeller i vores database:

sqlite> .tables
Albums   Albums1  Albums2  Artists