Inleiding tot Python SQL-bibliotheken

Alle softwareapplicaties werken samen met gegevens , meestal via een databasebeheersysteem (DBMS). Sommige programmeertalen worden geleverd met modules die u kunt gebruiken om te communiceren met een DBMS, terwijl andere het gebruik van pakketten van derden vereisen. In deze zelfstudie verken je de verschillende Python SQL-bibliotheken die u kunt gebruiken. Je ontwikkelt een eenvoudige applicatie voor interactie met SQLite-, MySQL- en PostgreSQL-databases.

In deze zelfstudie leert u hoe u:

• Verbinden naar verschillende databasebeheersystemen met Python SQL-bibliotheken
• Interactie met SQLite-, MySQL- en PostgreSQL-databases
• Uitvoeren veelvoorkomende databasequery's met een Python-toepassing
• Ontwikkelen applicaties in verschillende databases met behulp van een Python-script

Om het meeste uit deze tutorial te halen, moet je kennis hebben van de basis Python, SQL en het werken met databasebeheersystemen. Je moet ook pakketten in Python kunnen downloaden en importeren en weten hoe je verschillende databaseservers lokaal of op afstand moet installeren en uitvoeren.

Gratis pdf-download: Python 3 Cheatsheet

Het databaseschema begrijpen

In deze tutorial ontwikkel je een hele kleine database voor een social media applicatie. De database zal uit vier tabellen bestaan:

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

Een diagram op hoog niveau van het databaseschema wordt hieronder weergegeven:

Beide users en posts zal een een-op-veel-relatie hebben, aangezien één gebruiker veel berichten leuk kan vinden. Evenzo kan één gebruiker veel opmerkingen plaatsen en kan één bericht ook meerdere opmerkingen hebben. Dus beide users en posts zal ook een-op-veel relaties hebben met de comments tafel. Dit geldt ook voor de likes tabel, dus beide users en posts zal een een-op-veel-relatie hebben met de likes tafel.

Python SQL-bibliotheken gebruiken om verbinding te maken met een database

Voordat u met een database communiceert via een Python SQL-bibliotheek, moet u verbinden naar die databank. In dit gedeelte ziet u hoe u vanuit een Python-toepassing verbinding kunt maken met SQLite-, MySQL- en PostgreSQL-databases.

Opmerking: U moet MySQL- en PostgreSQL-servers actief hebben voordat u de scripts in de MySQL- en PostgreSQL-databasesecties uitvoert. Voor een snelle introductie over het starten van een MySQL-server, bekijk de MySQL-sectie van Een Django-project starten. Voor meer informatie over het maken van een database in PostgreSQL, raadpleegt u het gedeelte Een database instellen van SQL-injectieaanvallen voorkomen met Python.

Het wordt aanbevolen dat u drie verschillende Python-bestanden maakt, zodat u er één hebt voor elk van de drie databases. U voert het script voor elke database uit in het bijbehorende bestand.

SQLite

SQLite is waarschijnlijk de meest eenvoudige database om verbinding mee te maken met een Python-toepassing, omdat u hiervoor geen externe Python SQL-modules hoeft te installeren. Uw Python-installatie bevat standaard een Python SQL-bibliotheek met de naam sqlite3 die u kunt gebruiken om te communiceren met een SQLite-database.

Bovendien zijn SQLite-databases serverloos en op zichzelf staand , omdat ze gegevens lezen en schrijven naar een bestand. Dit betekent dat u, in tegenstelling tot MySQL en PostgreSQL, niet eens een SQLite-server hoeft te installeren en uit te voeren om databasebewerkingen uit te voeren!

Zo gebruik je sqlite3 om verbinding te maken met een SQLite-database in 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

Zo werkt deze code:

• Lijn 1 en 2 importeer sqlite3 en de Error . van de module klas.
• Lijn 4 definieert een functie .create_connection() die het pad naar de SQLite-database accepteert.
• Lijn 7 gebruikt .connect() van de sqlite3 module en neemt het SQLite-databasepad als parameter. Als de database op de opgegeven locatie bestaat, wordt een verbinding met de database tot stand gebracht. Anders wordt er een nieuwe database gemaakt op de opgegeven locatie en wordt er een verbinding tot stand gebracht.
• Lijn 8 drukt de status van de succesvolle databaseverbinding af.
• Lijn 9 vangt elke uitzondering op die kan worden gegenereerd als .connect() kan geen verbinding tot stand brengen.
• Lijn 10 geeft het foutbericht weer in de console.

sqlite3.connect(path) retourneert een connection object, dat op zijn beurt wordt geretourneerd door create_connection() . Deze connection object kan worden gebruikt om query's uit te voeren op een SQLite-database. Het volgende script maakt een verbinding met de SQLite-database:

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

Zodra u het bovenstaande script uitvoert, ziet u dat een databasebestand sm_app.sqlite wordt gemaakt in de hoofdmap. Houd er rekening mee dat u de locatie kunt wijzigen zodat deze overeenkomt met uw instellingen.

MySQL

In tegenstelling tot SQLite is er geen standaard Python SQL-module die u kunt gebruiken om verbinding te maken met een MySQL-database. In plaats daarvan moet u een Python SQL-stuurprogramma . installeren voor MySQL om te communiceren met een MySQL-database vanuit een Python-toepassing. Eén zo'n stuurprogramma is mysql-connector-python . Je kunt deze Python SQL-module downloaden met pip :

$ pip install mysql-connector-python

Merk op dat MySQL een servergebaseerd . is databasemanagementsysteem. Eén MySQL-server kan meerdere databases hebben. In tegenstelling tot SQLite, waar het maken van een verbinding gelijk staat aan het maken van een database, heeft een MySQL-database een proces in twee stappen voor het maken van een database:

1. Maak verbinding naar een MySQL-server.
2. Voer een aparte zoekopdracht uit om de database te maken.

Definieer een functie die verbinding maakt met de MySQL-databaseserver en het verbindingsobject retourneert:

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

In het bovenstaande script definieert u een functie create_connection() die drie parameters accepteert:

1. hostnaam
2. gebruikersnaam
3. user_password

De mysql.connector Python SQL-module bevat een methode .connect() die u in regel 7 gebruikt om verbinding te maken met een MySQL-databaseserver. Zodra de verbinding tot stand is gebracht, wordt de connection object wordt teruggestuurd naar de aanroepende functie. Ten slotte roept u in regel 18 create_connection() . aan met de hostnaam, gebruikersnaam en wachtwoord.

Tot nu toe heb je alleen de verbinding tot stand gebracht. De database is nog niet aangemaakt. Om dit te doen, definieert u een andere functie create_database() die twee parameters accepteert:

1. connection is de connection object tegen de databaseserver waarmee u wilt communiceren.
2. query is de query die de database maakt.

Zo ziet deze functie eruit:

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

Om zoekopdrachten uit te voeren, gebruikt u de cursor voorwerp. De query die moet worden uitgevoerd, wordt doorgegeven aan cursor.execute() in tekenreeksformaat.

Maak een database met de naam sm_app voor uw sociale media-app in de MySQL-databaseserver:

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

Nu heb je een database gemaakt sm_app op de databaseserver. Echter, de connection object geretourneerd door de create_connection() is verbonden met de MySQL-databaseserver. Je moet verbinding maken met de sm_app databank. Om dit te doen, kunt u create_connection() . wijzigen als volgt:

 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

Je kunt in regel 8 zien dat create_connection() accepteert nu een extra parameter genaamd db_name . Deze parameter specificeert de naam van de database waarmee u verbinding wilt maken. U kunt de naam doorgeven van de database waarmee u verbinding wilt maken wanneer u deze functie aanroept:

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

Het bovenstaande script roept met succes create_connection() . aan en maakt verbinding met de sm_app database.

PostgreSQL

Net als MySQL is er geen standaard Python SQL-bibliotheek die u kunt gebruiken om te communiceren met een PostgreSQL-database. In plaats daarvan moet u een python SQL-stuurprogramma van derden . installeren om te communiceren met PostgreSQL. Een voorbeeld van zo'n Python SQL-stuurprogramma voor PostgreSQL is psycopg2 . Voer de volgende opdracht uit op uw terminal om de psycopg2 . te installeren Python SQL-module:

$ pip install psycopg2

Net als bij de SQLite- en MySQL-databases, definieert u create_connection() om verbinding te maken met uw 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

U gebruikt psycopg2.connect() om vanuit uw Python-toepassing verbinding te maken met een PostgreSQL-server.

U kunt dan create_connection() . gebruiken om een ​​verbinding met een PostgreSQL-database te maken. Eerst maak je een verbinding met de standaarddatabase postgres door de volgende string te gebruiken:

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

Vervolgens moet u de database sm_app . maken binnen de standaard postgres databank. U kunt een functie definiëren om elke SQL-query in PostgreSQL uit te voeren. Hieronder definieert u create_database() om een ​​nieuwe database aan te maken op de PostgreSQL-databaseserver:

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)

Nadat u het bovenstaande script heeft uitgevoerd, ziet u de sm_app database in uw PostgreSQL-databaseserver.

Voordat u query's uitvoert op de sm_app database, moet u er verbinding mee maken:

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

Zodra u het bovenstaande script uitvoert, wordt er een verbinding tot stand gebracht met de sm_app database in de postgres database server. Hier, 127.0.0.1 verwijst naar het host-IP-adres van de databaseserver, en 5432 verwijst naar het poortnummer van de databaseserver.

Tabellen maken

In het vorige gedeelte hebt u gezien hoe u verbinding kunt maken met SQLite-, MySQL- en PostgreSQL-databaseservers met behulp van verschillende Python SQL-bibliotheken. Je hebt de sm_app . gemaakt database op alle drie de databaseservers. In dit gedeelte ziet u hoe u tabellen maakt binnen deze drie databases.

Zoals eerder besproken, maakt u vier tabellen:

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

Je begint met SQLite.

SQLite

Gebruik cursor.execute() . om queries uit te voeren in SQLite . In deze sectie definieert u een functie execute_query() die deze methode gebruikt. Uw functie accepteert de connection object en een queryreeks, die u doorgeeft aan cursor.execute() .

.execute() kan elke query uitvoeren die eraan wordt doorgegeven in de vorm van een string. U gebruikt deze methode om tabellen in deze sectie te maken. In de komende secties gebruik je dezelfde methode om ook update- en verwijderquery's uit te voeren.

Opmerking: Dit script moet worden uitgevoerd in hetzelfde bestand waarin u de verbinding voor uw SQLite-database hebt gemaakt.

Hier is uw functiedefinitie:

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

Deze code probeert de gegeven query uit te voeren en drukt indien nodig een foutmelding af.

Schrijf vervolgens uw vraag :

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

Dit zegt om een ​​tabel te maken users met de volgende vijf kolommen:

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

Ten slotte roep je execute_query() . aan om de tabel te maken. Je gaat door in de connection object dat u in de vorige sectie hebt gemaakt, samen met de create_users_table tekenreeks die de query voor het maken van een tabel bevat:

execute_query(connection, create_users_table)  

De volgende query wordt gebruikt om de posts . te maken tafel:

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

Aangezien er een een-op-veel-relatie is tussen users en posts , zie je een externe sleutel user_id in de posts tabel die verwijst naar de id kolom in de users tafel. Voer het volgende script uit om de posts . te maken tafel:

execute_query(connection, create_posts_table)

Ten slotte kunt u de comments . maken en likes tabellen met het volgende 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)            

U kunt zien dat tabellen maken in SQLite lijkt erg op het gebruik van onbewerkte SQL. Het enige wat u hoeft te doen is de query op te slaan in een stringvariabele en die variabele vervolgens door te geven aan cursor.execute() .

MySQL

Je gebruikt de mysql-connector-python Python SQL-module om tabellen in MySQL te maken. Net als bij SQLite, moet je je zoekopdracht doorgeven aan cursor.execute() , die wordt geretourneerd door .cursor() . aan te roepen op de connection voorwerp. U kunt een andere functie maken execute_query() die de connection . accepteert en query tekenreeks:

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

In regel 4 geef je de query . door naar cursor.execute() .

Nu kunt u uw users maken tabel met deze functie:

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)

De query voor het implementeren van de externe-sleutelrelatie is iets anders in MySQL in vergelijking met SQLite. Bovendien gebruikt MySQL de AUTO_INCREMENT trefwoord (vergeleken met de SQLite AUTOINCREMENT trefwoord) om kolommen te maken waarin de waarden automatisch worden verhoogd wanneer nieuwe records worden ingevoegd.

Het volgende script maakt de posts tabel, die een refererende sleutel user_id . bevat die verwijst naar de id kolom van de users tafel:

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)

Evenzo, om de comments . te maken en likes tabellen, kunt u de bijbehorende CREATE . doorgeven query's naar execute_query() .

PostgreSQL

Net als bij SQLite- en MySQL-databases, is de connection object dat wordt geretourneerd door psycopg2.connect() bevat een cursor voorwerp. U kunt cursor.execute() . gebruiken om Python SQL-query's uit te voeren op uw PostgreSQL-database.

Definieer een functie 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")

U kunt deze functie gebruiken om tabellen te maken, records in te voegen, records te wijzigen en records te verwijderen in uw PostgreSQL-database.

Maak nu de users tabel in de sm_app databank:

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)

U kunt zien dat de vraag om de users . te maken tabel in PostgreSQL is iets anders dan SQLite en MySQL. Hier, het trefwoord SERIAL wordt gebruikt om kolommen te maken die automatisch worden verhoogd. Bedenk dat MySQL het trefwoord AUTO_INCREMENT . gebruikt .

Bovendien wordt de referentie met refererende sleutels ook anders gespecificeerd, zoals te zien is in het volgende script dat de posts aanmaakt tafel:

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)

Om de comments te maken tabel, moet u een CREATE . schrijven vraag voor de comments tabel en geef het door aan execute_query() . Het proces voor het maken van de likes tafel is hetzelfde. U hoeft alleen de CREATE . aan te passen query om de likes . te maken tabel in plaats van de comments tafel.

Records invoegen

In het vorige gedeelte heb je gezien hoe je tabellen kunt maken in je SQLite-, MySQL- en PostgreSQL-databases met behulp van verschillende Python SQL-modules. In dit gedeelte ziet u hoe u records invoegt in uw tabellen.

SQLite

Om records in uw SQLite-database in te voegen, kunt u dezelfde execute_query() gebruiken functie die u hebt gebruikt om tabellen te maken. Eerst moet u uw INSERT INTO . opslaan vraag in een string. Vervolgens kunt u de connection . doorgeven object en query tekenreeks naar execute_query() . Laten we vijf records invoegen in de users tafel:

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)   

Aangezien u de id . instelt kolom om automatisch te verhogen, hoeft u de waarde van de id niet op te geven kolom voor deze users . De users tabel vult deze vijf records automatisch met id waarden van 1 tot 5 .

Voeg nu zes records toe aan de posts tafel:

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)  

Het is belangrijk om te vermelden dat de user_id kolom van de posts tabel is een buitenlandse sleutel die verwijst naar de id kolom van de users tafel. Dit betekent dat de user_id kolom moet een waarde bevatten die reeds bestaat in de id kolom van de users tafel. Als het niet bestaat, ziet u een fout.

Op dezelfde manier voegt het volgende script records in de comments . in en likes tabellen:

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)  

In beide gevallen bewaart u uw INSERT INTO query als een string en voer het uit met execute_query() .

MySQL

Er zijn twee manieren om vanuit een Python-toepassing records in MySQL-databases in te voegen. De eerste benadering is vergelijkbaar met SQLite. U kunt de INSERT INTO . opslaan query in een string en gebruik dan cursor.execute() om records in te voegen.

Eerder definieerde u een wrapper-functie execute_query() die u hebt gebruikt om records in te voegen. U kunt nu dezelfde functie gebruiken om records in uw MySQL-tabel in te voegen. Het volgende script voegt records toe aan de users tabel met behulp van 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)  

De tweede benadering gebruikt cursor.executemany() , die twee parameters accepteert:

1. De vraag tekenreeks met tijdelijke aanduidingen voor de in te voegen records
2. De lijst van records die u wilt invoegen

Kijk naar het volgende voorbeeld, dat twee records invoegt in de likes tafel:

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

Het is aan u welke benadering u kiest om records in uw MySQL-tabel in te voegen. Als je een expert bent in SQL, dan kun je .execute() . gebruiken . Als u niet zo bekend bent met SQL, is het wellicht eenvoudiger om .executemany() te gebruiken. . Met een van de twee benaderingen kunt u met succes records invoegen in de posts , comments , en likes tabellen.

PostgreSQL

In de vorige sectie zag u twee benaderingen voor het invoegen van records in SQLite-databasetabellen. De eerste gebruikt een SQL-stringquery en de tweede gebruikt .executemany() . psycopg2 volgt deze tweede benadering, hoewel .execute() wordt gebruikt om een ​​op tijdelijke aanduiding gebaseerde zoekopdracht uit te voeren.

U geeft de SQL-query met de tijdelijke aanduidingen en de lijst met records door aan .execute() . Elk record in de lijst is een tuple, waarbij de tuple-waarden overeenkomen met de kolomwaarden in de databasetabel. Zo kunt u gebruikersrecords invoegen in de users tabel in een 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)

Het bovenstaande script maakt een lijst users die vijf gebruikersrecords in de vorm van tupels bevat. Vervolgens maakt u een tijdelijke aanduiding-tekenreeks met vijf tijdelijke aanduiding-elementen (%s ) die overeenkomen met de vijf gebruikersrecords. De tekenreeks voor tijdelijke aanduiding wordt samengevoegd met de query die records invoegt in de users tafel. Ten slotte worden de queryreeks en de gebruikersrecords doorgegeven aan .execute() . Het bovenstaande script voegt met succes vijf records toe aan de users tafel.

Bekijk nog een voorbeeld van het invoegen van records in een PostgreSQL-tabel. Het volgende script voegt records in de posts . in tafel:

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)

U kunt records invoegen in de comments en likes tabellen met dezelfde aanpak.

Records selecteren

In deze sectie ziet u hoe u records selecteert uit databasetabellen met behulp van de verschillende Python SQL-modules. U zult in het bijzonder zien hoe u SELECT . uitvoert query's op uw SQLite-, MySQL- en PostgreSQL-databases.

SQLite

Om records te selecteren met SQLite, kunt u opnieuw cursor.execute() . gebruiken . Nadat u dit heeft gedaan, moet u echter .fetchall() . aanroepen . Deze methode retourneert een lijst met tupels waarbij elke tupel is toegewezen aan de corresponderende rij in de opgehaalde records.

Om het proces te vereenvoudigen, kunt u een functie maken 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")

Deze functie accepteert de connection object en de SELECT query en retourneert de geselecteerde record.

SELECT

Laten we nu alle records selecteren van de users tafel:

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

for user in users:
    print(user)

In het bovenstaande script, de SELECT query selecteert alle gebruikers uit de users tafel. Dit wordt doorgegeven aan de execute_read_query() , die alle records van de users . retourneert tafel. De records worden vervolgens doorgenomen en afgedrukt naar de console.

Opmerking: Het wordt niet aanbevolen om SELECT * . te gebruiken op grote tabellen, aangezien dit kan resulteren in een groot aantal I/O-bewerkingen die het netwerkverkeer vergroten.

De uitvoer van de bovenstaande query ziet er als volgt uit:

(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')

Op dezelfde manier kunt u alle records ophalen uit de posts tabel met het onderstaande script:

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

for post in posts:
    print(post)

De uitvoer ziet er als volgt uit:

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

The result shows all the records in the posts table.

JOIN

You can also execute complex queries involving JOIN operations 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 object. 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.

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.