Introduktion til Python SQL-biblioteker

Alle softwareapplikationer interagerer med data , oftest gennem et databasestyringssystem (DBMS). Nogle programmeringssprog kommer med moduler, som du kan bruge til at interagere med et DBMS, mens andre kræver brug af tredjepartspakker. I denne øvelse vil du udforske de forskellige Python SQL-biblioteker som du kan bruge. Du vil udvikle en ligetil applikation til at interagere med SQLite-, MySQL- og PostgreSQL-databaser.

I dette selvstudie lærer du, hvordan du:

• Opret forbindelse til forskellige databasestyringssystemer med Python SQL-biblioteker
• Interager med SQLite-, MySQL- og PostgreSQL-databaser
• Udfør almindelige databaseforespørgsler ved hjælp af et Python-program
• Udvikle applikationer på tværs af forskellige databaser ved hjælp af et Python-script

For at få mest muligt ud af denne tutorial, bør du have kendskab til grundlæggende Python, SQL og arbejde med databasestyringssystemer. Du bør også være i stand til at downloade og importere pakker i Python og vide, hvordan du installerer og kører forskellige databaseservere lokalt eller eksternt.

Gratis PDF-download: Python 3 snydeark

Forståelse af databaseskemaet

I denne vejledning vil du udvikle en meget lille database til en social medieapplikation. Databasen vil bestå af fire tabeller:

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

Et diagram på højt niveau af databaseskemaet er vist nedenfor:

Begge users og posts vil have et en-til-mange forhold, da én bruger kan like mange indlæg. På samme måde kan én bruger skrive mange kommentarer, og et indlæg kan også have flere kommentarer. Så begge users og posts vil også have en-til-mange relationer med comments bord. Dette gælder også for likes tabel, så begge users og posts vil have et en-til-mange forhold til likes tabel.

Brug af Python SQL-biblioteker til at oprette forbindelse til en database

Før du interagerer med en database gennem et Python SQL-bibliotek, skal du oprette forbindelse til den database. I dette afsnit kan du se, hvordan du opretter forbindelse til SQLite-, MySQL- og PostgreSQL-databaser fra en Python-applikation.

Bemærk: Du skal bruge MySQL- og PostgreSQL-servere til at køre, før du udfører scripts i MySQL- og PostgreSQL-databasesektionerne. For en hurtig introduktion til, hvordan man starter en MySQL-server, tjek MySQL-sektionen af ​​Starting a Django Project. For at lære, hvordan du opretter en database i PostgreSQL, tjek afsnittet Opsætning af en database i Forebyggelse af SQL-injektionsangreb med Python.

Det anbefales, at du opretter tre forskellige Python-filer, så du har en til hver af de tre databaser. Du skal udføre scriptet for hver database i dens tilsvarende fil.

SQLite

SQLite er sandsynligvis den mest ligetil database at oprette forbindelse til med en Python-applikation, da du ikke behøver at installere nogen eksterne Python SQL-moduler for at gøre det. Som standard indeholder din Python-installation et Python SQL-bibliotek ved navn sqlite3 som du kan bruge til at interagere med en SQLite-database.

Hvad mere er, SQLite-databaser er serverløse og uafhængig , da de læser og skriver data til en fil. Dette betyder, at du i modsætning til MySQL og PostgreSQL ikke engang behøver at installere og køre en SQLite-server for at udføre databaseoperationer!

Sådan bruger du sqlite3 for at oprette forbindelse til en SQLite-database 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ådan fungerer denne kode:

• Linje 1 og 2 importer sqlite3 og modulets Error klasse.
• Linje 4 definerer en funktion .create_connection() der accepterer stien til SQLite-databasen.
• Linje 7 bruger .connect() fra sqlite3 modul og tager SQLite-databasestien som en parameter. Hvis databasen findes på den angivne placering, oprettes en forbindelse til databasen. Ellers oprettes en ny database på den angivne placering, og en forbindelse etableres.
• Linje 8 udskriver status for den vellykkede databaseforbindelse.
• Linje 9 fanger enhver undtagelse, der kan opstå, hvis .connect() kan ikke oprette forbindelse.
• Linje 10 viser fejlmeddelelsen i konsollen.

sqlite3.connect(path) returnerer en connection objekt, som igen returneres af create_connection() . Denne connection objekt kan bruges til at udføre forespørgsler på en SQLite-database. Følgende script opretter en forbindelse til SQLite-databasen:

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

Når du har udført ovenstående script, vil du se, at en databasefil sm_app.sqlite oprettes i rodmappen. Bemærk, at du kan ændre placeringen, så den passer til din opsætning.

MySQL

I modsætning til SQLite er der ikke noget standard Python SQL-modul, som du kan bruge til at oprette forbindelse til en MySQL-database. I stedet skal du installere en Python SQL-driver for MySQL for at interagere med en MySQL-database fra en Python-applikation. En sådan driver er mysql-connector-python . Du kan downloade dette Python SQL-modul med pip :

$ pip install mysql-connector-python

Bemærk, at MySQL er en serverbaseret databasestyringssystem. En MySQL-server kan have flere databaser. I modsætning til SQLite, hvor oprettelse af en forbindelse er ensbetydende med oprettelse af en database, har en MySQL-database en to-trins-proces til databaseoprettelse:

1. Opret en forbindelse til en MySQL-server.
2. Udfør en separat forespørgsel for at oprette databasen.

Definer en funktion, der forbinder til MySQL-databaseserveren og returnerer forbindelsesobjektet:

 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 ovenstående script definerer du en funktion create_connection() der accepterer tre parametre:

1. værtsnavn
2. brugernavn
3. brugeradgangskode

mysql.connector Python SQL-modulet indeholder en metode .connect() som du bruger i linje 7 til at oprette forbindelse til en MySQL-databaseserver. Når forbindelsen er etableret, vises connection objektet returneres til den kaldende funktion. Til sidst kalder du i linje 18 create_connection() med værtsnavnet, brugernavnet og adgangskoden.

Indtil videre har du kun etableret forbindelsen. Databasen er endnu ikke oprettet. For at gøre dette skal du definere en anden funktion create_database() der accepterer to parametre:

1. connection er connection objekt til databaseserveren, som du vil interagere med.
2. query er den forespørgsel, der opretter databasen.

Sådan ser denne funktion ud:

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")

For at udføre forespørgsler bruger du cursor objekt. query der skal udføres, sendes til cursor.execute() i strengformat.

Opret en database med navnet sm_app til din sociale medie-app i MySQL-databaseserveren:

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

Nu har du oprettet en database sm_app på databaseserveren. Men connection objekt returneret af create_connection() er forbundet til MySQL-databaseserveren. Du skal oprette forbindelse til sm_app database. For at gøre det kan du ændre create_connection() som følger:

 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 i linje 8, at create_connection() accepterer nu en ekstra parameter kaldet db_name . Denne parameter angiver navnet på den database, du vil oprette forbindelse til. Du kan indtaste navnet på den database, du vil oprette forbindelse til, når du kalder denne funktion:

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

Ovenstående script kalder create_connection() og opretter forbindelse til sm_app database.

PostgreSQL

Ligesom MySQL er der ikke noget standard Python SQL-bibliotek, som du kan bruge til at interagere med en PostgreSQL-database. I stedet skal du installere en tredjeparts Python SQL-driver at interagere med PostgreSQL. En sådan Python SQL-driver til PostgreSQL er psycopg2 . Udfør følgende kommando på din terminal for at installere psycopg2 Python SQL-modul:

$ pip install psycopg2

Ligesom med SQLite- og MySQL-databaserne, vil du definere create_connection() for at oprette forbindelse til din PostgreSQL-database:

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 bruger psycopg2.connect() for at oprette forbindelse til en PostgreSQL-server fra din Python-applikation.

Du kan derefter bruge create_connection() at oprette en forbindelse til en PostgreSQL-database. Først skal du oprette forbindelse til standarddatabasen postgres ved at bruge følgende streng:

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

Dernæst skal du oprette databasen sm_app inde i standard postgres database. Du kan definere en funktion til at udføre enhver SQL-forespørgsel i PostgreSQL. Nedenfor definerer du create_database() for at oprette en ny database i PostgreSQL-databaseserveren:

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 har kørt scriptet ovenfor, vil du se sm_app database i din PostgreSQL-databaseserver.

Før du udfører forespørgsler på sm_app database, skal du oprette forbindelse til den:

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

Når du udfører ovenstående script, oprettes en forbindelse med sm_app database placeret i postgres database server. Her 127.0.0.1 refererer til databaseserverens værts IP-adresse og 5432 henviser til portnummeret på databaseserveren.

Oprettelse af tabeller

I det forrige afsnit så du, hvordan du opretter forbindelse til SQLite-, MySQL- og PostgreSQL-databaseservere ved hjælp af forskellige Python SQL-biblioteker. Du har oprettet sm_app database på alle tre databaseservere. I dette afsnit kan du se, hvordan du opretter tabeller inde i disse tre databaser.

Som diskuteret tidligere, vil du oprette fire tabeller:

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

Du starter med SQLite.

SQLite

For at udføre forespørgsler i SQLite, brug cursor.execute() . I dette afsnit skal du definere en funktion execute_query() der bruger denne metode. Din funktion vil acceptere connection objekt og en forespørgselsstreng, som du sender til cursor.execute() .

.execute() kan udføre enhver forespørgsel sendt til den i form af streng. Du skal bruge denne metode til at oprette tabeller i dette afsnit. I de kommende sektioner vil du også bruge den samme metode til at udføre opdatering og slette forespørgsler.

Bemærk: Dette script skal udføres i den samme fil, hvor du oprettede forbindelsen til din SQLite-database.

Her er 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")

Denne kode forsøger at udføre den givne query og udskriver en fejlmeddelelse, hvis det er nødvendigt.

Skriv derefter din forespørgsel :

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

Dette siger at oprette en tabel users med følgende fem kolonner:

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

Til sidst skal du kalde execute_query() at oprette bordet. Du sender connection ind objekt, som du oprettede i det foregående afsnit, sammen med create_users_table streng, der indeholder opret tabelforespørgslen:

execute_query(connection, create_users_table)  

Følgende forespørgsel bruges til at oprette posts tabel:

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)
);
"""

Da der er et en-til-mange forhold mellem users og posts , kan du se en fremmednøgle user_id i posts tabel, der refererer til id kolonnen i users bord. Udfør følgende script for at oprette posts tabel:

execute_query(connection, create_posts_table)

Til sidst kan du oprette comments og likes tabeller med følgende script:

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, at opretter tabeller i SQLite ligner meget at bruge rå SQL. Alt du skal gøre er at gemme forespørgslen i en strengvariabel og derefter videregive denne variabel til cursor.execute() .

MySQL

Du skal bruge mysql-connector-python Python SQL-modul til at oprette tabeller i MySQL. Ligesom med SQLite skal du sende din forespørgsel til cursor.execute() , som returneres ved at kalde .cursor() på connection objekt. Du kan oprette en anden funktion execute_query() der accepterer connection og query streng:

 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")

I linje 4 sender du query til cursor.execute() .

Nu kan du oprette dine users tabel ved hjælp af denne 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)

Forespørgslen til implementering af den fremmede nøglerelation er lidt anderledes i MySQL sammenlignet med SQLite. Hvad mere er, MySQL bruger AUTO_INCREMENT nøgleord (sammenlignet med SQLite AUTOINCREMENT søgeord) for at oprette kolonner, hvor værdierne automatisk øges når nye poster indsættes.

Følgende script opretter posts tabel, som indeholder en fremmednøgle user_id der refererer til id kolonne af users tabel:

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å samme måde for at oprette comments og likes tabeller, kan du sende den tilsvarende CREATE forespørgsler til execute_query() .

PostgreSQL

Ligesom med SQLite- og MySQL-databaser, connection objekt, der returneres af psycopg2.connect() indeholder en cursor objekt. Du kan bruge cursor.execute() for at udføre Python SQL-forespørgsler på din PostgreSQL-database.

Definer 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 bruge denne funktion til at oprette tabeller, indsætte poster, ændre poster og slette poster i din PostgreSQL-database.

Opret nu users tabel inde i sm_app database:

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, at forespørgslen om at oprette users tabel i PostgreSQL er lidt anderledes end SQLite og MySQL. Her er søgeordet SERIAL bruges til at oprette kolonner, der øges automatisk. Husk, at MySQL bruger søgeordet AUTO_INCREMENT .

Derudover er fremmednøglehenvisning også specificeret anderledes, som vist i følgende script, der opretter posts tabel:

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)

For at oprette comments tabel, skal du skrive en CREATE forespørgsel efter comments tabel og send den til execute_query() . Processen til at oprette likes bordet er det samme. Du skal kun ændre CREATE forespørgsel for at oprette likes tabel i stedet for comments tabel.

Indsættelse af poster

I det foregående afsnit så du, hvordan du opretter tabeller i dine SQLite-, MySQL- og PostgreSQL-databaser ved at bruge forskellige Python SQL-moduler. I dette afsnit kan du se, hvordan du indsætter poster ind i dine tabeller.

SQLite

For at indsætte poster i din SQLite-database kan du bruge den samme execute_query() funktion, som du brugte til at oprette tabeller. Først skal du gemme din INSERT INTO forespørgsel i en streng. Derefter kan du videregive connection objekt og query streng til execute_query() . Lad os indsætte fem poster i users tabel:

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)   

Siden du indstillede id kolonne til automatisk stigning, behøver du ikke angive værdien af ​​id kolonne for disse users . users tabel vil automatisk udfylde disse fem poster med id værdier fra 1 til 5 .

Indsæt nu seks poster i posts tabel:

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 er vigtigt at nævne, at user_id kolonne i posts tabel er en fremmednøgle der refererer til id kolonne af users bord. Det betyder, at user_id kolonne skal indeholde en værdi, der allerede findes i id kolonne af users bord. Hvis det ikke eksisterer, vil du se en fejl.

På samme måde indsætter følgende script poster i comments og 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 begge tilfælde gemmer du din INSERT INTO forespørgsel som en streng og udfør den med execute_query() .

MySQL

Der er to måder at indsætte poster i MySQL-databaser fra en Python-applikation. Den første tilgang ligner SQLite. Du kan gemme INSERT INTO forespørg i en streng, og brug derefter cursor.execute() for at indsætte poster.

Tidligere definerede du en indpakningsfunktion execute_query() som du brugte til at indsætte poster. Du kan bruge den samme funktion nu til at indsætte poster i din MySQL-tabel. Følgende script indsætter poster i users tabel ved hjælp af 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 anden tilgang bruger cursor.executemany() , som accepterer to parametre:

1. Forespørgslen streng, der indeholder pladsholdere for de poster, der skal indsættes
2. Listen af poster, som du vil indsætte

Se på følgende eksempel, som indsætter to poster i likes tabel:

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 er op til dig, hvilken tilgang du vælger til at indsætte poster i din MySQL-tabel. Hvis du er ekspert i SQL, så kan du bruge .execute() . Hvis du ikke er meget fortrolig med SQL, så kan det være mere ligetil for dig at bruge .executemany() . Med en af ​​de to tilgange kan du indsætte poster i posts , comments , og likes tabeller.

PostgreSQL

I det foregående afsnit så du to metoder til at indsætte poster i SQLite-databasetabeller. Den første bruger en SQL-strengforespørgsel, og den anden bruger .executemany() . psycopg2 følger denne anden tilgang, selvom .execute() bruges til at udføre en pladsholder-baseret forespørgsel.

Du sender SQL-forespørgslen med pladsholderne og listen over poster til .execute() . Hver post på listen vil være en tupel, hvor tupelværdier svarer til kolonneværdierne i databasetabellen. Sådan kan du indsætte brugerregistreringer i users tabel i en PostgreSQL-database:

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)

Scriptet ovenfor opretter en liste over users der indeholder fem brugerposter i form af tuples. Derefter opretter du en pladsholderstreng med fem pladsholderelementer (%s ), der svarer til de fem brugerregistreringer. Pladsholderstrengen er sammenkædet med forespørgslen, der indsætter poster i users bord. Til sidst sendes forespørgselsstrengen og brugerregistreringerne til .execute() . Ovenstående script indsætter med succes fem poster i users tabel.

Tag et kig på et andet eksempel på indsættelse af poster i en PostgreSQL-tabel. Følgende script indsætter poster i posts tabel:

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 indsætte poster i comments og likes tabeller med samme tilgang.

Valg af poster

I dette afsnit kan du se, hvordan du vælger poster fra databasetabeller ved hjælp af de forskellige Python SQL-moduler. Du vil især se, hvordan du udfører SELECT forespørgsler på dine SQLite-, MySQL- og PostgreSQL-databaser.

SQLite

For at vælge poster ved hjælp af SQLite kan du igen bruge cursor.execute() . Men når du har gjort dette, skal du ringe til .fetchall() . Denne metode returnerer en liste over tupler, hvor hver tuple er knyttet til den tilsvarende række i de hentede poster.

For at forenkle processen kan du oprette 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")

Denne funktion accepterer connection objektet og SELECT forespørg og returnerer den valgte post.

SELECT

Lad os nu vælge alle posterne fra users tabel:

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

for user in users:
    print(user)

I ovenstående script er SELECT forespørgsel vælger alle brugere fra users bord. Dette sendes til execute_read_query() , som returnerer alle poster fra users bord. Optegnelserne gennemløbes derefter og udskrives til konsollen.

Bemærk: Det anbefales ikke at bruge SELECT * på store borde, da det kan resultere i et stort antal I/O-operationer, der øger netværkstrafikken.

Outputtet af ovenstående forespørgsel ser sådan ud:

(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å samme måde kan du hente alle posterne fra posts tabel med nedenstående script:

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

for post in posts:
    print(post)

Outputtet ser sådan ud:

(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 viser alle posterne i posts tabel.

JOIN

Du kan også udføre komplekse forespørgsler, der involverer JOIN operationer at hente data fra to relaterede tabeller. For eksempel returnerer følgende script bruger-id'er og navne sammen med beskrivelsen af ​​de indlæg, som disse brugere har postet:

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 tabel:

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.

Conclusion

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.