Introduktion till Python SQL-bibliotek

Alla program interagerar med data , oftast via ett databashanteringssystem (DBMS). Vissa programmeringsspråk kommer med moduler som du kan använda för att interagera med ett DBMS, medan andra kräver användning av tredjepartspaket. I den här handledningen kommer du att utforska de olika Python SQL-biblioteken som du kan använda. Du kommer att utveckla en enkel applikation för att interagera med SQLite-, MySQL- och PostgreSQL-databaser.

I den här självstudien får du lära dig hur du:

• Anslut till olika databashanteringssystem med Python SQL-bibliotek
• Interagera med SQLite-, MySQL- och PostgreSQL-databaser
• Utför vanliga databasfrågor med en Python-applikation
• Utveckla applikationer över olika databaser med ett Python-skript

För att få ut det mesta av den här handledningen bör du ha kunskap om grundläggande Python, SQL och att arbeta med databashanteringssystem. Du bör också kunna ladda ner och importera paket i Python och veta hur du installerar och kör olika databasservrar lokalt eller på distans.

Gratis PDF-nedladdning: Python 3 Cheat Sheet

Förstå databasschemat

I den här handledningen kommer du att utveckla en mycket liten databas för en applikation för sociala medier. Databasen kommer att bestå av fyra tabeller:

1. users
2. posts
3. comments
4. likes

Ett högnivådiagram över databasschemat visas nedan:

Båda users och posts kommer att ha en en-till-många-relation eftersom en användare kan gilla många inlägg. På samma sätt kan en användare skicka många kommentarer, och ett inlägg kan också ha flera kommentarer. Så båda users och posts kommer också att ha en-till-många-relationer med comments tabell. Detta gäller även för likes tabell, så båda users och posts kommer att ha en en-till-många-relation med likes bord.

Använda Python SQL-bibliotek för att ansluta till en databas

Innan du interagerar med någon databas genom ett Python SQL-bibliotek måste du ansluta till den databasen. I det här avsnittet kommer du att se hur du ansluter till SQLite-, MySQL- och PostgreSQL-databaser från en Python-applikation.

Obs! Du behöver MySQL- och PostgreSQL-servrar igång innan du kör skripten i MySQL- och PostgreSQL-databassektionerna. För en snabb introduktion om hur man startar en MySQL-server, kolla in MySQL-delen av Starta ett Django-projekt. För att lära dig hur du skapar en databas i PostgreSQL, kolla in avsnittet Konfigurera en databas i Förhindra SQL-injektionsattacker med Python.

Det rekommenderas att du skapar tre olika Python-filer, så att du har en för var och en av de tre databaserna. Du kommer att köra skriptet för varje databas i dess motsvarande fil.

SQLite

SQLite är förmodligen den enklaste databasen att ansluta till med en Python-applikation eftersom du inte behöver installera några externa Python SQL-moduler för att göra det. Som standard innehåller din Python-installation ett Python SQL-bibliotek med namnet sqlite3 som du kan använda för att interagera med en SQLite-databas.

Dessutom är SQLite-databaser serverlösa och fristående , eftersom de läser och skriver data till en fil. Detta innebär att du, till skillnad från med MySQL och PostgreSQL, inte ens behöver installera och köra en SQLite-server för att utföra databasoperationer!

Så här använder du sqlite3 för att ansluta till en SQLite-databas i Python:

 1import sqlite3
 2from sqlite3 import Error
 3
 4def create_connection(path):
 5    connection = None
 6    try:
 7        connection = sqlite3.connect(path)
 8        print("Connection to SQLite DB successful")
 9    except Error as e:
10        print(f"The error '{e}' occurred")
11
12    return connection

Så här fungerar den här koden:

• Rad 1 och 2 importera sqlite3 och modulens Error klass.
• Rad 4 definierar en funktion .create_connection() som accepterar sökvägen till SQLite-databasen.
• Rad 7 använder .connect() från sqlite3 modul och tar SQLite-databassökvägen som en parameter. Om databasen finns på den angivna platsen upprättas en anslutning till databasen. Annars skapas en ny databas på den angivna platsen och en anslutning upprättas.
• Rad 8 skriver ut statusen för den lyckade databasanslutningen.
• Rad 9 fångar alla undantag som kan skapas om .connect() misslyckas med att upprätta en anslutning.
• Rad 10 visar felmeddelandet i konsolen.

sqlite3.connect(path) returnerar en connection objekt, som i sin tur returneras av create_connection() . Denna connection objekt kan användas för att köra frågor på en SQLite-databas. Följande skript skapar en anslutning till SQLite-databasen:

connection = create_connection("E:\\sm_app.sqlite")

När du kört skriptet ovan ser du att en databasfil sm_app.sqlite skapas i rotkatalogen. Observera att du kan ändra platsen så att den matchar din inställning.

MySQL

Till skillnad från SQLite finns det ingen standard Python SQL-modul som du kan använda för att ansluta till en MySQL-databas. Istället måste du installera en Python SQL-drivrutin för MySQL för att interagera med en MySQL-databas från en Python-applikation. En sådan drivrutin är mysql-connector-python . Du kan ladda ner denna Python SQL-modul med pip :

$ pip install mysql-connector-python

Observera att MySQL är en serverbaserad databashanteringssystem. En MySQL-server kan ha flera databaser. Till skillnad från SQLite, där att skapa en anslutning är liktydigt med att skapa en databas, har en MySQL-databas en tvåstegsprocess för att skapa databas:

1. Skapa en anslutning till en MySQL-server.
2. Kör en separat fråga för att skapa databasen.

Definiera en funktion som ansluter till MySQL-databasservern och returnerar anslutningsobjektet:

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection(host_name, user_name, user_password):
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect(
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        )
12        print("Connection to MySQL DB successful")
13    except Error as e:
14        print(f"The error '{e}' occurred")
15
16    return connection
17
18connection = create_connection("localhost", "root", "")

I skriptet ovan definierar du en funktion create_connection() som accepterar tre parametrar:

1. värdnamn
2. användarnamn
3. användarlösenord

mysql.connector Python SQL-modulen innehåller en metod .connect() som du använder i rad 7 för att ansluta till en MySQL-databasserver. När anslutningen har upprättats visas connection objektet returneras till den anropande funktionen. Slutligen, på rad 18 anropar du create_connection() med värdnamn, användarnamn och lösenord.

Hittills har du bara upprättat anslutningen. Databasen är inte skapad ännu. För att göra detta kommer du att definiera en annan funktion create_database() som accepterar två parametrar:

1. connection är connection objekt mot databasservern som du vill interagera med.
2. query är frågan som skapar databasen.

Så här ser den här funktionen ut:

def create_database(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

För att utföra frågor använder du cursor objekt. query som ska köras skickas till cursor.execute() i strängformat.

Skapa en databas med namnet sm_app för din sociala media-app i MySQL-databasservern:

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

Nu har du skapat en databas sm_app på databasservern. Men connection objekt som returneras av create_connection() är ansluten till MySQL-databasservern. Du måste ansluta till sm_app databas. För att göra det kan du ändra create_connection() enligt följande:

 1def create_connection(host_name, user_name, user_password, db_name):
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect(
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        )
10        print("Connection to MySQL DB successful")
11    except Error as e:
12        print(f"The error '{e}' occurred")
13
14    return connection

Du kan se på rad 8 att create_connection() accepterar nu ytterligare en parameter som heter db_name . Den här parametern anger namnet på databasen som du vill ansluta till. Du kan skicka in namnet på databasen du vill ansluta till när du anropar den här funktionen:

connection = create_connection("localhost", "root", "", "sm_app")

Ovanstående skript anropar framgångsrikt create_connection() och ansluter till sm_app databas.

PostgreSQL

Precis som MySQL finns det inget standard Python SQL-bibliotek som du kan använda för att interagera med en PostgreSQL-databas. Istället måste du installera en tredjeparts Python SQL-drivrutin att interagera med PostgreSQL. En sådan Python SQL-drivrutin för PostgreSQL är psycopg2 . Utför följande kommando på din terminal för att installera psycopg2 Python SQL-modul:

$ pip install psycopg2

Precis som med SQLite- och MySQL-databaserna kommer du att definiera create_connection() för att skapa en anslutning till din PostgreSQL-databas:

import psycopg2
from psycopg2 import OperationalError

def create_connection(db_name, db_user, db_password, db_host, db_port):
    connection = None
    try:
        connection = psycopg2.connect(
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        )
        print("Connection to PostgreSQL DB successful")
    except OperationalError as e:
        print(f"The error '{e}' occurred")
    return connection

Du använder psycopg2.connect() för att ansluta till en PostgreSQL-server från din Python-applikation.

Du kan sedan använda create_connection() för att skapa en anslutning till en PostgreSQL-databas. Först gör du en anslutning till standarddatabasen postgres genom att använda följande sträng:

connection = create_connection(
    "postgres", "postgres", "abc123", "127.0.0.1", "5432"
)

Därefter måste du skapa databasen sm_app inuti standard postgres databas. Du kan definiera en funktion för att köra valfri SQL-fråga i PostgreSQL. Nedan definierar du create_database() för att skapa en ny databas i PostgreSQL-databasservern:

def create_database(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

När du kör skriptet ovan ser du sm_app databas i din PostgreSQL-databasserver.

Innan du kör frågor på sm_app databas måste du ansluta till den:

connection = create_connection(
    "sm_app", "postgres", "abc123", "127.0.0.1", "5432"
)

När du kört skriptet ovan kommer en anslutning att upprättas med sm_app databas som finns i postgres databasserver. Här, 127.0.0.1 hänvisar till databasserverns värd-IP-adress och 5432 hänvisar till portnumret för databasservern.

Skapa tabeller

I föregående avsnitt såg du hur du ansluter till SQLite-, MySQL- och PostgreSQL-databasservrar med olika Python SQL-bibliotek. Du skapade sm_app databas på alla tre databasservrarna. I det här avsnittet ser du hur du skapar tabeller i dessa tre databaser.

Som diskuterats tidigare kommer du att skapa fyra tabeller:

1. users
2. posts
3. comments
4. likes

Du börjar med SQLite.

SQLite

För att köra frågor i SQLite, använd cursor.execute() . I det här avsnittet kommer du att definiera en funktion execute_query() som använder denna metod. Din funktion accepterar connection objekt och en frågesträng, som du skickar till cursor.execute() .

.execute() kan exekvera vilken fråga som helst som skickas till den i form av en sträng. Du kommer att använda den här metoden för att skapa tabeller i det här avsnittet. I de kommande avsnitten kommer du att använda samma metod för att utföra uppdateringar och radera frågor också.

Obs! Detta skript bör köras i samma fil som du skapade anslutningen för din SQLite-databas.

Här är din funktionsdefinition:

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Den här koden försöker köra den givna query och skriver ut ett felmeddelande om det behövs.

Skriv sedan din fråga :

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  age INTEGER,
  gender TEXT,
  nationality TEXT
);
"""

Detta säger att skapa en tabell users med följande fem kolumner:

1. id
2. name
3. age
4. gender
5. nationality

Slutligen ska du anropa execute_query() för att skapa tabellen. Du skickar in connection objekt som du skapade i föregående avsnitt, tillsammans med create_users_table sträng som innehåller skapa tabellfrågan:

execute_query(connection, create_users_table)  

Följande fråga används för att skapa posts tabell:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts(
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id)
);
"""

Eftersom det finns en en-till-många-relation mellan users och posts , kan du se en främmande nyckel user_id i posts tabell som refererar till id kolumnen i users tabell. Kör följande skript för att skapa posts tabell:

execute_query(connection, create_posts_table)

Slutligen kan du skapa comments och likes tabeller med följande skript:

create_comments_table = """
CREATE TABLE IF NOT EXISTS comments (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  text TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  post_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

create_likes_table = """
CREATE TABLE IF NOT EXISTS likes (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  user_id INTEGER NOT NULL, 
  post_id integer NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

execute_query(connection, create_comments_table)  
execute_query(connection, create_likes_table)            

Du kan se att skapa tabeller i SQLite är mycket likt att använda rå SQL. Allt du behöver göra är att lagra frågan i en strängvariabel och sedan skicka den variabeln till cursor.execute() .

MySQL

Du använder mysql-connector-python Python SQL-modul för att skapa tabeller i MySQL. Precis som med SQLite måste du skicka din fråga till cursor.execute() , som returneras genom att anropa .cursor() på connection objekt. Du kan skapa en annan funktion execute_query() som accepterar connection och query sträng:

 1def execute_query(connection, query):
 2    cursor = connection.cursor()
 3    try:
 4        cursor.execute(query)
 5        connection.commit()
 6        print("Query executed successfully")
 7    except Error as e:
 8        print(f"The error '{e}' occurred")

På rad 4 skickar du query till cursor.execute() .

Nu kan du skapa dina users tabell med denna funktion:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INT AUTO_INCREMENT, 
  name TEXT NOT NULL, 
  age INT, 
  gender TEXT, 
  nationality TEXT, 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_users_table)

Frågan för att implementera den främmande nyckelrelationen är något annorlunda i MySQL jämfört med SQLite. Dessutom använder MySQL AUTO_INCREMENT nyckelord (jämfört med SQLite AUTOINCREMENT nyckelord) för att skapa kolumner där värdena automatiskt ökas när nya poster infogas.

Följande skript skapar posts tabell, som innehåller en främmande nyckel user_id som refererar till id kolumnen för users tabell:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id INT AUTO_INCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY fk_user_id (user_id) REFERENCES users(id), 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_posts_table)

På samma sätt för att skapa comments och likes tabeller kan du skicka motsvarande CREATE frågor till execute_query() .

PostgreSQL

Som med SQLite och MySQL-databaser, connection objekt som returneras av psycopg2.connect() innehåller en cursor objekt. Du kan använda cursor.execute() för att köra Python SQL-frågor på din PostgreSQL-databas.

Definiera en funktion execute_query() :

def execute_query(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

Du kan använda den här funktionen för att skapa tabeller, infoga poster, ändra poster och ta bort poster i din PostgreSQL-databas.

Skapa nu users tabell i sm_app databas:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL, 
  age INTEGER,
  gender TEXT,
  nationality TEXT
)
"""

execute_query(connection, create_users_table)

Du kan se att frågan för att skapa users Tabell i PostgreSQL är något annorlunda än SQLite och MySQL. Här är nyckelordet SERIAL används för att skapa kolumner som ökar automatiskt. Kom ihåg att MySQL använder nyckelordet AUTO_INCREMENT .

Dessutom specificeras även referenser för främmande nycklar annorlunda, som visas i följande skript som skapar posts tabell:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id SERIAL PRIMARY KEY, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER REFERENCES users(id)
)
"""

execute_query(connection, create_posts_table)

För att skapa comments tabell måste du skriva en CREATE fråga efter comments tabell och skicka den till execute_query() . Processen för att skapa likes tabellen är densamma. Du behöver bara ändra CREATE fråga för att skapa likes tabellen istället för comments bord.

Infoga poster

I föregående avsnitt såg du hur du skapar tabeller i dina SQLite-, MySQL- och PostgreSQL-databaser genom att använda olika Python SQL-moduler. I det här avsnittet ser du hur du infogar poster i dina tabeller.

SQLite

För att infoga poster i din SQLite-databas kan du använda samma execute_query() funktion som du använde för att skapa tabeller. Först måste du lagra din INSERT INTO fråga i en sträng. Sedan kan du skicka connection objekt och query sträng till execute_query() . Låt oss infoga fem poster i users tabell:

create_users = """
INSERT INTO
  users (name, age, gender, nationality)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)   

Eftersom du ställt in id för att automatiskt öka, behöver du inte ange värdet på id kolumn för dessa users . users tabell kommer att fylla i dessa fem poster automatiskt med id värden från 1 till 5 .

Infoga nu sex poster i posts tabell:

create_posts = """
INSERT INTO
  posts (title, description, user_id)
VALUES
  ("Happy", "I am feeling very happy today", 1),
  ("Hot Weather", "The weather is very hot today", 2),
  ("Help", "I need some help with my work", 2),
  ("Great News", "I am getting married", 1),
  ("Interesting Game", "It was a fantastic game of tennis", 5),
  ("Party", "Anyone up for a late-night party today?", 3);
"""

execute_query(connection, create_posts)  

Det är viktigt att nämna att user_id kolumnen i posts tabellen är en främmande nyckel som refererar till id kolumnen för users tabell. Det betyder att user_id kolumnen måste innehålla ett värde som redan finns i id kolumnen för users tabell. Om det inte finns, kommer du att se ett felmeddelande.

På liknande sätt infogar följande skript poster i comments och likes tabeller:

create_comments = """
INSERT INTO
  comments (text, user_id, post_id)
VALUES
  ('Count me in', 1, 6),
  ('What sort of help?', 5, 3),
  ('Congrats buddy', 2, 4),
  ('I was rooting for Nadal though', 4, 5),
  ('Help with your thesis?', 2, 3),
  ('Many congratulations', 5, 4);
"""

create_likes = """
INSERT INTO
  likes (user_id, post_id)
VALUES
  (1, 6),
  (2, 3),
  (1, 5),
  (5, 4),
  (2, 4),
  (4, 2),
  (3, 6);
"""

execute_query(connection, create_comments)
execute_query(connection, create_likes)  

I båda fallen lagrar du din INSERT INTO fråga som en sträng och kör den med execute_query() .

MySQL

Det finns två sätt att infoga poster i MySQL-databaser från en Python-applikation. Det första tillvägagångssättet liknar SQLite. Du kan lagra INSERT INTO fråga i en sträng och använd sedan cursor.execute() för att infoga poster.

Tidigare definierade du en omslagsfunktion execute_query() som du använde för att infoga poster. Du kan använda samma funktion nu för att infoga poster i din MySQL-tabell. Följande skript infogar poster i users tabell med execute_query() :

create_users = """
INSERT INTO
  `users` (`name`, `age`, `gender`, `nationality`)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)  

Den andra metoden använder cursor.executemany() , som accepterar två parametrar:

1. Frågan sträng som innehåller platshållare för posterna som ska infogas
2. Listan över poster som du vill infoga

Titta på följande exempel, som infogar två poster i likes tabell:

sql = "INSERT INTO likes ( user_id, post_id ) VALUES ( %s, %s )"
val = [(4, 5), (3, 4)]

cursor = connection.cursor()
cursor.executemany(sql, val)
connection.commit()

Det är upp till dig vilken metod du väljer för att infoga poster i din MySQL-tabell. Om du är expert på SQL kan du använda .execute() . Om du inte är så bekant med SQL kan det vara enklare för dig att använda .executemany() . Med någon av de två metoderna kan du infoga poster i posts , comments och likes tabeller.

PostgreSQL

I föregående avsnitt såg du två metoder för att infoga poster i SQLite-databastabeller. Den första använder en SQL-strängfråga, och den andra använder .executemany() . psycopg2 följer detta andra tillvägagångssätt, även om .execute() används för att köra en platshållarbaserad fråga.

Du skickar SQL-frågan med platshållarna och listan med poster till .execute() . Varje post i listan kommer att vara en tuppel, där tuppelvärdena motsvarar kolumnvärdena i databastabellen. Så här kan du infoga användarposter i users tabell i en PostgreSQL-databas:

users = [
    ("James", 25, "male", "USA"),
    ("Leila", 32, "female", "France"),
    ("Brigitte", 35, "female", "England"),
    ("Mike", 40, "male", "Denmark"),
    ("Elizabeth", 21, "female", "Canada"),
]

user_records = ", ".join(["%s"] * len(users))

insert_query = (
    f"INSERT INTO users (name, age, gender, nationality) VALUES {user_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, users)

Skriptet ovan skapar en lista över users som innehåller fem användarposter i form av tupler. Därefter skapar du en platshållarsträng med fem platshållarelement (%s ) som motsvarar de fem användarposterna. Platshållarsträngen är sammanlänkad med frågan som infogar poster i users tabell. Slutligen skickas frågesträngen och användarposterna till .execute() . Skriptet ovan infogar framgångsrikt fem poster i users bord.

Ta en titt på ett annat exempel på att infoga poster i en PostgreSQL-tabell. Följande skript infogar poster i posts tabell:

posts = [
    ("Happy", "I am feeling very happy today", 1),
    ("Hot Weather", "The weather is very hot today", 2),
    ("Help", "I need some help with my work", 2),
    ("Great News", "I am getting married", 1),
    ("Interesting Game", "It was a fantastic game of tennis", 5),
    ("Party", "Anyone up for a late-night party today?", 3),
]

post_records = ", ".join(["%s"] * len(posts))

insert_query = (
    f"INSERT INTO posts (title, description, user_id) VALUES {post_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, posts)

Du kan infoga poster i comments och likes tabeller med samma tillvägagångssätt.

Välja poster

I det här avsnittet kommer du att se hur du väljer poster från databastabeller med de olika Python SQL-modulerna. I synnerhet kommer du att se hur du utför SELECT frågor på dina SQLite-, MySQL- och PostgreSQL-databaser.

SQLite

För att välja poster med SQLite kan du återigen använda cursor.execute() . Men efter att du har gjort detta måste du anropa .fetchall() . Den här metoden returnerar en lista med tupler där varje tuppel är mappad till motsvarande rad i de hämtade posterna.

För att förenkla processen kan du skapa en funktion execute_read_query() :

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Den här funktionen accepterar connection objektet och SELECT fråga och returnerar den valda posten.

SELECT

Låt oss nu välja alla poster från users tabell:

select_users = "SELECT * from users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

I skriptet ovan, SELECT query väljer alla användare från users tabell. Detta skickas till execute_read_query() , som returnerar alla poster från users tabell. Posterna går sedan igenom och skrivs ut till konsolen.

Obs: Det rekommenderas inte att använda SELECT * på stora tabeller eftersom det kan resultera i ett stort antal I/O-operationer som ökar nätverkstrafiken.

Utdata från ovanstående fråga ser ut så här:

(1, 'James', 25, 'male', 'USA')
(2, 'Leila', 32, 'female', 'France')
(3, 'Brigitte', 35, 'female', 'England')
(4, 'Mike', 40, 'male', 'Denmark')
(5, 'Elizabeth', 21, 'female', 'Canada')

På samma sätt kan du hämta alla poster från posts tabell med skriptet nedan:

select_posts = "SELECT * FROM posts"
posts = execute_read_query(connection, select_posts)

for post in posts:
    print(post)

Utdatan ser ut så här:

(1, 'Happy', 'I am feeling very happy today', 1)
(2, 'Hot Weather', 'The weather is very hot today', 2)
(3, 'Help', 'I need some help with my work', 2)
(4, 'Great News', 'I am getting married', 1)
(5, 'Interesting Game', 'It was a fantastic game of tennis', 5)
(6, 'Party', 'Anyone up for a late-night party today?', 3)

Resultatet visar alla poster i posts bord.

JOIN

Du kan också köra komplexa frågor som involverar JOIN verksamhet to retrieve data from two related tables. For instance, the following script returns the user ids and names, along with the description of the posts that these users posted:

select_users_posts = """
SELECT
  users.id,
  users.name,
  posts.description
FROM
  posts
  INNER JOIN users ON users.id = posts.user_id
"""

users_posts = execute_read_query(connection, select_users_posts)

for users_post in users_posts:
    print(users_post)

Here’s the output:

(1, 'James', 'I am feeling very happy today')
(2, 'Leila', 'The weather is very hot today')
(2, 'Leila', 'I need some help with my work')
(1, 'James', 'I am getting married')
(5, 'Elizabeth', 'It was a fantastic game of tennis')
(3, 'Brigitte', 'Anyone up for a late night party today?')

You can also select data from three related tables by implementing multiple JOIN operators . The following script returns all posts, along with the comments on the posts and the names of the users who posted the comments:

select_posts_comments_users = """
SELECT
  posts.description as post,
  text as comment,
  name
FROM
  posts
  INNER JOIN comments ON posts.id = comments.post_id
  INNER JOIN users ON users.id = comments.user_id
"""

posts_comments_users = execute_read_query(
    connection, select_posts_comments_users
)

for posts_comments_user in posts_comments_users:
    print(posts_comments_user)

The output looks like this:

('Anyone up for a late night party today?', 'Count me in', 'James')
('I need some help with my work', 'What sort of help?', 'Elizabeth')
('I am getting married', 'Congrats buddy', 'Leila')
('It was a fantastic game of tennis', 'I was rooting for Nadal though', 'Mike')
('I need some help with my work', 'Help with your thesis?', 'Leila')
('I am getting married', 'Many congratulations', 'Elizabeth')

You can see from the output that the column names are not being returned by .fetchall() . To return column names, you can use the .description attribute of the cursor objekt. For instance, the following list returns all the column names for the above query:

cursor = connection.cursor()
cursor.execute(select_posts_comments_users)
cursor.fetchall()

column_names = [description[0] for description in cursor.description]
print(column_names)

The output looks like this:

['post', 'comment', 'name']

You can see the names of the columns for the given query.

WHERE

Now you’ll execute a SELECT query that returns the post, along with the total number of likes that the post received:

select_post_likes = """
SELECT
  description as Post,
  COUNT(likes.id) as Likes
FROM
  likes,
  posts
WHERE
  posts.id = likes.post_id
GROUP BY
  likes.post_id
"""

post_likes = execute_read_query(connection, select_post_likes)

for post_like in post_likes:
    print(post_like)

The output is as follows:

('The weather is very hot today', 1)
('I need some help with my work', 1)
('I am getting married', 2)
('It was a fantastic game of tennis', 1)
('Anyone up for a late night party today?', 2)

By using a WHERE clause, you’re able to return more specific results.

MySQL

The process of selecting records in MySQL is absolutely identical to selecting records in SQLite. You can use cursor.execute() followed by .fetchall() . The following script creates a wrapper function execute_read_query() that you can use to select records:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Now select all the records from the users table:

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

The output will be similar to what you saw with SQLite.

PostgreSQL

The process of selecting records from a PostgreSQL table with the psycopg2 Python SQL module is similar to what you did with SQLite and MySQL. Again, you’ll use cursor.execute() followed by .fetchall() to select records from your PostgreSQL table. The following script selects all the records from the users table and prints them to the console:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except OperationalError as e:
        print(f"The error '{e}' occurred")

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

Again, the output will be similar to what you’ve seen before.

Updating Table Records

In the last section, you saw how to select records from SQLite, MySQL, and PostgreSQL databases. In this section, you’ll cover the process for updating records using the Python SQL libraries for SQLite, PostgresSQL, and MySQL.

SQLite

Updating records in SQLite is pretty straightforward. You can again make use of execute_query() . As an example, you can update the description of the post with an id of 2 . First, SELECT the description of this post:

select_post_description = "SELECT description FROM posts WHERE id = 2"

post_description = execute_read_query(connection, select_post_description)

for description in post_description:
    print(description)

You should see the following output:

('The weather is very hot today',)

The following script updates the description:

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Now, if you execute the SELECT query again, you should see the following result:

('The weather has become pleasant now',)

The output has been updated.

MySQL

The process of updating records in MySQL with mysql-connector-python is also a carbon copy of the sqlite3 Python SQL module. You need to pass the string query to cursor.execute() . For example, the following script updates the description of the post with an id of 2 :

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Again, you’ve used your wrapper function execute_query() to update the post description.

PostgreSQL

The update query for PostgreSQL is similar to what you’ve seen with SQLite and MySQL. You can use the above scripts to update records in your PostgreSQL table.

Deleting Table Records

In this section, you’ll see how to delete table records using the Python SQL modules for SQLite, MySQL, and PostgreSQL databases. The process of deleting records is uniform for all three databases since the DELETE query for the three databases is the same.

SQLite

You can again use execute_query() to delete records from YOUR SQLite database. All you have to do is pass the connection object and the string query for the record you want to delete to execute_query() . Then, execute_query() will create a cursor object using the connection and pass the string query to cursor.execute() , which will delete the records.

As an example, try to delete the comment with an id of 5 :

delete_comment = "DELETE FROM comments WHERE id = 5"
execute_query(connection, delete_comment)

Now, if you select all the records from the comments table, you’ll see that the fifth comment has been deleted.

MySQL

The process for deletion in MySQL is also similar to SQLite, as shown in the following example:

delete_comment = "DELETE FROM comments WHERE id = 2"
execute_query(connection, delete_comment)

Here, you delete the second comment from the sm_app database’s comments table in your MySQL database server.

PostgreSQL

The delete query for PostgreSQL is also similar to SQLite and MySQL. You can write a delete query string by using the DELETE keyword and then passing the query and the connection object to execute_query() . This will delete the specified records from your PostgreSQL database.

Slutsats

In this tutorial, you’ve learned how to use three common Python SQL libraries. sqlite3 , mysql-connector-python , and psycopg2 allow you to connect a Python application to SQLite, MySQL, and PostgreSQL databases, respectively.

Now you can:

• Interact with SQLite, MySQL, or PostgreSQL databases
• Use three different Python SQL modules
• Execute SQL queries on various databases from within a Python application

However, this is just the tip of the iceberg! There are also Python SQL libraries for object-relational mapping , such as SQLAlchemy and Django ORM, that automate the task of database interaction in Python. You’ll learn more about these libraries in other tutorials in our Python databases section.