Använda SQLite-databaser

Mål

Efter lektionen ska du kunna...

• förklara vad SQLite och en relationsdatabas är
• skapa en databasfil och en tabell
• lägga till data med INSERT INTO
• hämta data med SELECT
• använda databasresultat i Python

Från textfil

Varför använda en databas?

Pannkakor|mjölk,ägg,mjöl
Tomatsoppa|tomater,lök,vatten

En textfil fungerar för enkel lagring.

Det blir svårare att söka, sortera och uppdatera enskilda poster.

En databas organiserar informationen i tabeller.

SQLite

Databasen är fortfarande en fil

recept.db

• SQLite kräver ingen separat databasserver.
• Tabeller och data sparas i en databasfil.
• Det passar bra för mindre program och lokala projekt.

Relationstabell

Rader och kolumner

Tabell: recept

id | namn       | ingredienser
1  | Pannkakor  | mjölk, mjöl, ägg
2  | Tomatsoppa | tomater, lök, vatten

Varje rad är ett recept.

Varje kolumn beskriver en egenskap hos receptet.

VS Code

Visa databasen med SQLite Viewer

Installera tillägget SQLite Viewer av Florian Klampfer i VS Code.

1. Öppna Extensions i VS Code.
2. Sök efter SQLite Viewer.
3. Kontrollera att publisher är Florian Klampfer.
4. Installera tillägget.
5. Öppna sedan filen recept.db för att se tabeller och rader.

Tillägget gör databasen lättare att inspektera, men Pythonkoden fungerar även utan det.

Begrepp

SQLite, SQL och sqlite3

• SQLite: databassystemet som sparar data i en fil.
• SQL: språket som används för att skicka kommandon till databasen.
• sqlite3: Pythons inbyggda bibliotek för SQLite.

import sqlite3

Arbetsflöde

Samma fem steg återkommer

1. connect() öppnar databasen.
2. cursor() skapar ett cursor-objekt.
3. execute() kör SQL.
4. commit() sparar ändringar.
5. close() stänger anslutningen.

Anslutning

Öppna eller skapa databasen

conn = sqlite3.connect("recept.db")

Om filen finns öppnas den.

Om filen saknas skapar SQLite den.

conn representerar anslutningen till databasen.

Cursor

Objektet som kör SQL

cursor = conn.cursor()

cursor.execute("SELECT * FROM recept")

cursor skickar SQL-kommandon genom anslutningen.

execute() kör ett SQL-kommando.

Skapa tabell

Hela SQL-kommandot

cursor.execute("""
CREATE TABLE IF NOT EXISTS recept (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    namn TEXT NOT NULL,
    ingredienser TEXT
)
""")

Trippelcitat gör att SQL-kommandot kan skrivas på flera rader.

CREATE TABLE

Läs kommandot del för del

• CREATE TABLE skapar en tabell.
• IF NOT EXISTS undviker fel om tabellen redan finns.
• recept är tabellens namn.
• Innehållet mellan parenteserna beskriver kolumnerna.

Kolumner

Datatyper och regler

id INTEGER PRIMARY KEY AUTOINCREMENT

namn TEXT NOT NULL

ingredienser TEXT

Spara och stäng

commit() och close()

conn.commit()
conn.close()

commit() sparar genomförda ändringar i databasfilen.

close() avslutar anslutningen.

Lägga till

INSERT INTO

namn = "Pannkakor"
ingredienser = "mjölk, mjöl, ägg"

cursor.execute(
    "INSERT INTO recept (namn, ingredienser) VALUES (?, ?)",
    (namn, ingredienser)
)

Platshållare

Varför används ??

VALUES (?, ?)
(namn, ingredienser)

Frågetecknen markerar var värden ska placeras.

Värdena skickas separat i en tuple.

sqlite3 hanterar värdena säkert utan att vi bygger SQL genom att klistra ihop strängar.

Viktigt

INSERT behöver commit()

cursor.execute(
    "INSERT INTO recept (namn, ingredienser) VALUES (?, ?)",
    (namn, ingredienser)
)

conn.commit()

execute() utför kommandot.

commit() gör ändringen bestående i filen.

Hämta data

SELECT och fetchall()

cursor.execute("SELECT * FROM recept")
rader = cursor.fetchall()

SELECT * väljer alla kolumner.

FROM recept anger tabellen.

fetchall() hämtar alla rader som frågan hittade.

Resultat

Varje databasrad blir en tuple

rad = (1, "Pannkakor", "mjölk, mjöl, ägg")

• rad[0] är id.
• rad[1] är namn.
• rad[2] är ingredienser.

Visa data

Loopa genom resultatet

for rad in rader:
    print(f"Recept: {rad[1]}")
    print(f"Ingredienser: {rad[2]}")

Recept: Pannkakor
Ingredienser: mjölk, mjöl, ägg

CRUD

Fyra vanliga databasoperationer

• Create: skapa eller lägga till data.
• Read: läsa data.
• Update: ändra befintlig data.
• Delete: ta bort data.

I detta kapitel arbetar vi främst med Create och Read.

Programstruktur

Dela upp databasansvaret

skapa_databas_och_tabell()
lägg_till_recept(namn, ingredienser)
visa_alla_recept()
main()

Varje funktion öppnar databasen, gör sin uppgift och stänger anslutningen.

Skapa databasen

Första funktionen

def skapa_databas_och_tabell():
    conn = sqlite3.connect(DB_NAMN)
    cursor = conn.cursor()
    cursor.execute("""
    CREATE TABLE IF NOT EXISTS recept (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        namn TEXT NOT NULL,
        ingredienser TEXT
    )
    """)
    conn.commit()
    conn.close()

Lägg till

Andra funktionen

def lägg_till_recept(namn, ingredienser):
    conn = sqlite3.connect(DB_NAMN)
    cursor = conn.cursor()
    cursor.execute(
        "INSERT INTO recept (namn, ingredienser) VALUES (?, ?)",
        (namn, ingredienser)
    )
    conn.commit()
    conn.close()

Visa alla

Tredje funktionen

def visa_alla_recept():
    conn = sqlite3.connect(DB_NAMN)
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM recept")
    rader = cursor.fetchall()

    for rad in rader:
        print(rad[1], rad[2])

    conn.close()

main()

Starta i rätt ordning

def main():
    skapa_databas_och_tabell()

    while True:
        # Visa meny och läs användarens val.
        ...

if __name__ == "__main__":
    main()

Tabellen skapas innan menyn börjar användas.

Öva

Mini-receptregister

1. Skapa databasfilen och tabellen.
2. Skapa en funktion som lägger till recept.
3. Skapa en funktion som visar alla recept.
4. Bygg en meny som anropar funktionerna.
5. Kör programmet flera gånger och kontrollera att datan finns kvar.

Sammanfattning

Kom ihåg

• SQLite sparar en strukturerad databas i en fil.
• sqlite3 kopplar Python till SQLite.
• execute() kör SQL-kommandon.
• commit() sparar ändringar.
• SELECT och fetchall() hämtar rader.
• Platshållare gör SQL-frågor tydligare och säkrare.