Database
 sql >> Base de données >  >> RDS >> Database

Introduction aux bibliothèques Python SQL

Toutes les applications logicielles interagissent avec les données , le plus souvent via un système de gestion de base de données (SGBD). Certains langages de programmation sont livrés avec des modules que vous pouvez utiliser pour interagir avec un SGBD, tandis que d'autres nécessitent l'utilisation de packages tiers. Dans ce tutoriel, vous allez explorer les différentes bibliothèques SQL Python que vous pouvez utiliser. Vous développerez une application simple pour interagir avec les bases de données SQLite, MySQL et PostgreSQL.

Dans ce didacticiel, vous apprendrez à :

  • Se connecter à différents systèmes de gestion de bases de données avec les bibliothèques Python SQL
  • Interagir avec les bases de données SQLite, MySQL et PostgreSQL
  • Performer requêtes de base de données courantes à l'aide d'une application Python
  • Développer applications sur différentes bases de données à l'aide d'un script Python

Pour tirer le meilleur parti de ce didacticiel, vous devez avoir des connaissances de base en Python, SQL et travailler avec des systèmes de gestion de base de données. Vous devez également être capable de télécharger et d'importer des packages en Python et savoir comment installer et exécuter différents serveurs de base de données localement ou à distance.

Téléchargement PDF gratuit : Aide-mémoire Python 3


Comprendre le schéma de la base de données

Dans ce didacticiel, vous allez développer une très petite base de données pour une application de médias sociaux. La base de données sera composée de quatre tables :

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

Un schéma de haut niveau du schéma de la base de données est présenté ci-dessous :

Les deux users et posts aura une relation un-à-plusieurs puisqu'un utilisateur peut aimer plusieurs publications. De même, un utilisateur peut publier de nombreux commentaires, et un message peut également avoir plusieurs commentaires. Ainsi, les deux users et posts aura également des relations un-à-plusieurs avec les comments table. Ceci s'applique également aux likes table, donc les deux users et posts aura une relation un-à-plusieurs avec les likes tableau.



Utilisation des bibliothèques SQL Python pour se connecter à une base de données

Avant d'interagir avec une base de données via une bibliothèque SQL Python, vous devez vous connecter à cette base de données. Dans cette section, vous verrez comment vous connecter aux bases de données SQLite, MySQL et PostgreSQL à partir d'une application Python.

Remarque : Vous aurez besoin de serveurs MySQL et PostgreSQL opérationnels avant d'exécuter les scripts dans les sections de base de données MySQL et PostgreSQL. Pour une introduction rapide sur la façon de démarrer un serveur MySQL, consultez la section MySQL de Démarrer un projet Django. Pour savoir comment créer une base de données dans PostgreSQL, consultez la section Configurer une base de données de Prévenir les attaques par injection SQL avec Python.

Il est recommandé de créer trois fichiers Python différents, afin d'en avoir un pour chacune des trois bases de données. Vous exécuterez le script pour chaque base de données dans son fichier correspondant.


SQLite

SQLite est probablement la base de données la plus simple à laquelle se connecter avec une application Python puisque vous n'avez pas besoin d'installer de modules Python SQL externes pour le faire. Par défaut, votre installation Python contient une bibliothèque Python SQL nommée sqlite3 que vous pouvez utiliser pour interagir avec une base de données SQLite.

De plus, les bases de données SQLite sont sans serveur et autonome , car ils lisent et écrivent des données dans un fichier. Cela signifie que, contrairement à MySQL et PostgreSQL, vous n'avez même pas besoin d'installer et d'exécuter un serveur SQLite pour effectuer des opérations de base de données !

Voici comment utiliser sqlite3 pour se connecter à une base de données SQLite en 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

Voici comment fonctionne ce code :

  • Lignes 1 et 2 importer sqlite3 et l'Error du module classe.
  • Ligne 4 définit une fonction .create_connection() qui accepte le chemin vers la base de données SQLite.
  • Ligne 7 utilise .connect() depuis le sqlite3 module et prend le chemin de la base de données SQLite comme paramètre. Si la base de données existe à l'emplacement spécifié, une connexion à la base de données est établie. Sinon, une nouvelle base de données est créée à l'emplacement spécifié et une connexion est établie.
  • Ligne 8 affiche l'état de la connexion réussie à la base de données.
  • Ligne 9 intercepte toute exception qui pourrait être levée si .connect() ne parvient pas à établir une connexion.
  • Ligne 10 affiche le message d'erreur dans la console.

sqlite3.connect(path) renvoie une connection objet, qui est à son tour renvoyé par create_connection() . Cette connection L'objet peut être utilisé pour exécuter des requêtes sur une base de données SQLite. Le script suivant crée une connexion à la base de données SQLite :

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

Une fois que vous avez exécuté le script ci-dessus, vous verrez qu'un fichier de base de données sm_app.sqlite est créé dans le répertoire racine. Notez que vous pouvez modifier l'emplacement pour qu'il corresponde à votre configuration.



MySQL

Contrairement à SQLite, il n'y a pas de module Python SQL par défaut que vous pouvez utiliser pour vous connecter à une base de données MySQL. Au lieu de cela, vous devrez installer un pilote Python SQL pour MySQL afin d'interagir avec une base de données MySQL depuis une application Python. Un de ces pilotes est mysql-connector-python . Vous pouvez télécharger ce module Python SQL avec pip :

$ pip install mysql-connector-python

Notez que MySQL est un basé sur un serveur système de gestion de base de données. Un serveur MySQL peut avoir plusieurs bases de données. Contrairement à SQLite, où la création d'une connexion équivaut à la création d'une base de données, une base de données MySQL comporte un processus en deux étapes pour la création de la base de données :

  1. Établir une connexion à un serveur MySQL.
  2. Exécuter une requête distincte pour créer la base de données.

Définissez une fonction qui se connecte au serveur de base de données MySQL et renvoie l'objet de connexion :

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

Dans le script ci-dessus, vous définissez une fonction create_connection() qui accepte trois paramètres :

  1. nom_hôte
  2. nom_utilisateur
  3. user_password

Le mysql.connector Le module Python SQL contient une méthode .connect() que vous utilisez à la ligne 7 pour vous connecter à un serveur de base de données MySQL. Une fois la connexion établie, la connection L'objet est renvoyé à la fonction appelante. Enfin, à la ligne 18, vous appelez create_connection() avec le nom d'hôte, le nom d'utilisateur et le mot de passe.

Jusqu'à présent, vous avez seulement établi la connexion. La base de données n'est pas encore créée. Pour ce faire, vous allez définir une autre fonction create_database() qui accepte deux paramètres :

  1. connection est la connection objet au serveur de base de données avec lequel vous souhaitez interagir.
  2. query est la requête qui crée la base de données.

Voici à quoi ressemble cette fonction :

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

Pour exécuter des requêtes, vous utilisez le cursor objet. La query à exécuter est passé à cursor.execute() au format chaîne.

Créez une base de données nommée sm_app pour votre application de médias sociaux dans le serveur de base de données MySQL :

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

Vous avez maintenant créé une base de données sm_app sur le serveur de base de données. Cependant, la connection objet renvoyé par create_connection() est connecté au serveur de base de données MySQL. Vous devez vous connecter à sm_app base de données. Pour ce faire, vous pouvez modifier create_connection() comme suit :

 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

Vous pouvez voir à la ligne 8 que create_connection() accepte désormais un paramètre supplémentaire appelé db_name . Ce paramètre spécifie le nom de la base de données à laquelle vous souhaitez vous connecter. Vous pouvez transmettre le nom de la base de données à laquelle vous souhaitez vous connecter lorsque vous appelez cette fonction :

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

Le script ci-dessus appelle avec succès create_connection() et se connecte à la sm_app base de données.



PostgreSQL

Comme MySQL, il n'y a pas de bibliothèque Python SQL par défaut que vous pouvez utiliser pour interagir avec une base de données PostgreSQL. Au lieu de cela, vous devez installer un pilote Python SQL tiers pour interagir avec PostgreSQL. Un tel pilote Python SQL pour PostgreSQL est psycopg2 . Exécutez la commande suivante sur votre terminal pour installer le psycopg2 Module SQL Python :

$ pip install psycopg2

Comme avec les bases de données SQLite et MySQL, vous définirez create_connection() pour établir une connexion avec votre base de données PostgreSQL :

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

Vous utilisez psycopg2.connect() pour vous connecter à un serveur PostgreSQL depuis votre application Python.

Vous pouvez ensuite utiliser create_connection() pour créer une connexion à une base de données PostgreSQL. Tout d'abord, vous allez établir une connexion avec la base de données par défaut postgres en utilisant la chaîne suivante :

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

Ensuite, vous devez créer la base de données sm_app à l'intérieur du postgres par défaut base de données. Vous pouvez définir une fonction pour exécuter n'importe quelle requête SQL dans PostgreSQL. Ci-dessous, vous définissez create_database() pour créer une nouvelle base de données dans le serveur de base de données PostgreSQL :

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)

Une fois que vous avez exécuté le script ci-dessus, vous verrez le sm_app base de données dans votre serveur de base de données PostgreSQL.

Avant d'exécuter des requêtes sur sm_app base de données, vous devez vous y connecter :

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

Une fois que vous avez exécuté le script ci-dessus, une connexion sera établie avec le sm_app base de données située dans postgres serveur de base de données. Ici, 127.0.0.1 fait référence à l'adresse IP de l'hôte du serveur de base de données et 5432 fait référence au numéro de port du serveur de base de données.




Créer des tableaux

Dans la section précédente, vous avez vu comment vous connecter aux serveurs de bases de données SQLite, MySQL et PostgreSQL à l'aide de différentes bibliothèques Python SQL. Vous avez créé la sm_app base de données sur les trois serveurs de base de données. Dans cette section, vous verrez comment créer des tableaux à l'intérieur de ces trois bases de données.

Comme indiqué précédemment, vous allez créer quatre tables :

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

Vous commencerez avec SQLite.


SQLite

Pour exécuter des requêtes dans SQLite, utilisez cursor.execute() . Dans cette section, vous allez définir une fonction execute_query() qui utilise cette méthode. Votre fonction acceptera la connection objet et une chaîne de requête, que vous passerez à cursor.execute() .

.execute() peut exécuter toute requête qui lui est transmise sous forme de chaîne. Vous utiliserez cette méthode pour créer des tableaux dans cette section. Dans les sections à venir, vous utiliserez cette même méthode pour exécuter également les requêtes de mise à jour et de suppression.

Remarque : Ce script doit être exécuté dans le même fichier où vous avez créé la connexion pour votre base de données SQLite.

Voici la définition de votre fonction :

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

Ce code essaie d'exécuter la query donnée et imprime un message d'erreur si nécessaire.

Ensuite, rédigez votre requête :

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

Cela dit de créer une table users avec les cinq colonnes suivantes :

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

Enfin, vous appellerez execute_query() pour créer le tableau. Vous passerez la connection objet que vous avez créé dans la section précédente, avec la create_users_table chaîne contenant la requête de création de table :

execute_query(connection, create_users_table)

La requête suivante est utilisée pour créer les posts tableau :

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

Puisqu'il existe une relation un-à-plusieurs entre les users et posts , vous pouvez voir une clé étrangère user_id dans les posts table qui fait référence à l'id colonne dans la colonne users table. Exécutez le script suivant pour créer les posts tableau :

execute_query(connection, create_posts_table)

Enfin, vous pouvez créer les comments et likes tables avec le script suivant :

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)

Vous pouvez voir que la création de tableaux dans SQLite est très similaire à l'utilisation de SQL brut. Tout ce que vous avez à faire est de stocker la requête dans une variable de chaîne, puis de passer cette variable à cursor.execute() .



MySQL

Vous utiliserez le mysql-connector-python Module Python SQL pour créer des tables dans MySQL. Tout comme avec SQLite, vous devez transmettre votre requête à cursor.execute() , qui est retourné en appelant .cursor() sur la connection objet. Vous pouvez créer une autre fonction execute_query() qui accepte la connection et query chaîne :

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

A la ligne 4, vous passez la query à cursor.execute() .

Vous pouvez maintenant créer vos users table en utilisant cette fonction :

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)

La requête pour implémenter la relation de clé étrangère est légèrement différente dans MySQL par rapport à SQLite. De plus, MySQL utilise le AUTO_INCREMENT mot clé (par rapport au SQLite AUTOINCREMENT mot-clé) pour créer des colonnes où les valeurs sont incrémentées automatiquement lorsque de nouveaux enregistrements sont insérés.

Le script suivant crée les posts table, qui contient une clé étrangère user_id qui référence le id colonne des users tableau :

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)

De même, pour créer les comments et likes tables, vous pouvez passer le CREATE correspondant requêtes à execute_query() .



PostgreSQL

Comme avec les bases de données SQLite et MySQL, la connection objet renvoyé par psycopg2.connect() contient un cursor objet. Vous pouvez utiliser cursor.execute() pour exécuter des requêtes Python SQL sur votre base de données PostgreSQL.

Définir une fonction 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")

Vous pouvez utiliser cette fonction pour créer des tables, insérer des enregistrements, modifier des enregistrements et supprimer des enregistrements dans votre base de données PostgreSQL.

Créez maintenant les users table à l'intérieur du sm_app base de données :

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)

Vous pouvez voir que la requête pour créer les users table dans PostgreSQL est légèrement différent de SQLite et MySQL. Ici, le mot clé SERIAL est utilisé pour créer des colonnes qui s'incrémentent automatiquement. Rappelons que MySQL utilise le mot clé AUTO_INCREMENT .

De plus, le référencement de clé étrangère est également spécifié différemment, comme indiqué dans le script suivant qui crée les posts tableau :

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)

Pour créer les comments table, vous devrez écrire un CREATE requête pour les comments table et transmettez-la à execute_query() . Le processus de création des likes le tableau est le même. Vous n'avez qu'à modifier le CREATE requête pour créer les likes table au lieu des comments tableau.




Insérer des enregistrements

Dans la section précédente, vous avez vu comment créer des tables dans vos bases de données SQLite, MySQL et PostgreSQL en utilisant différents modules Python SQL. Dans cette section, vous verrez comment insérer des enregistrements dans vos tableaux.


SQLite

Pour insérer des enregistrements dans votre base de données SQLite, vous pouvez utiliser le même execute_query() fonction que vous avez utilisée pour créer des tables. Tout d'abord, vous devez stocker votre INSERT INTO requête dans une chaîne. Ensuite, vous pouvez passer la connection objet et query chaîne vers execute_query() . Insérons cinq enregistrements dans les users tableau :

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)

Depuis que vous avez défini l'id colonne à auto-incrémenter, vous n'avez pas besoin de spécifier la valeur de l'id colonne pour ces users . Les users table remplira automatiquement ces cinq enregistrements avec id valeurs de 1 à 5 .

Insérez maintenant six enregistrements dans les posts tableau :

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)

Il est important de mentionner que le user_id colonne des posts la table est une clé étrangère qui référence le id colonne des users table. Cela signifie que le user_id la colonne doit contenir une valeur qui existe déjà dans l'id colonne des users table. S'il n'existe pas, vous verrez une erreur.

De même, le script suivant insère des enregistrements dans les comments et likes tableaux :

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)

Dans les deux cas, vous stockez votre INSERT INTO requête sous forme de chaîne et exécutez-la avec execute_query() .



MySQL

Il existe deux façons d'insérer des enregistrements dans des bases de données MySQL à partir d'une application Python. La première approche est similaire à SQLite. Vous pouvez stocker le INSERT INTO requête dans une chaîne puis utilisez cursor.execute() pour insérer des enregistrements.

Précédemment, vous avez défini une fonction wrapper execute_query() que vous avez utilisé pour insérer des enregistrements. Vous pouvez utiliser cette même fonction maintenant pour insérer des enregistrements dans votre table MySQL. Le script suivant insère des enregistrements dans les users table en utilisant 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)

La deuxième approche utilise cursor.executemany() , qui accepte deux paramètres :

  1. La requête chaîne contenant des espaces réservés pour les enregistrements à insérer
  2. La liste d'enregistrements que vous souhaitez insérer

Regardez l'exemple suivant, qui insère deux enregistrements dans le likes tableau :

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

C'est à vous de choisir l'approche que vous choisissez pour insérer des enregistrements dans votre table MySQL. Si vous êtes un expert en SQL, vous pouvez utiliser .execute() . Si vous n'êtes pas très familier avec SQL, il peut être plus simple pour vous d'utiliser .executemany() . Avec l'une ou l'autre des deux approches, vous pouvez insérer avec succès des enregistrements dans les posts , comments , et likes tableaux.



PostgreSQL

Dans la section précédente, vous avez vu deux approches pour insérer des enregistrements dans des tables de base de données SQLite. Le premier utilise une requête de chaîne SQL et le second utilise .executemany() . psycopg2 suit cette deuxième approche, bien que .execute() est utilisé pour exécuter une requête basée sur un espace réservé.

Vous passez la requête SQL avec les espaces réservés et la liste des enregistrements à .execute() . Chaque enregistrement de la liste sera un tuple, où les valeurs de tuple correspondent aux valeurs de colonne dans la table de base de données. Voici comment vous pouvez insérer des enregistrements d'utilisateurs dans les users table dans une base de données PostgreSQL :

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)

Le script ci-dessus crée une liste users qui contient cinq enregistrements d'utilisateur sous la forme de tuples. Ensuite, vous créez une chaîne d'espace réservé avec cinq éléments d'espace réservé (%s ) qui correspondent aux cinq enregistrements d'utilisateur. La chaîne d'espace réservé est concaténée avec la requête qui insère des enregistrements dans les users table. Enfin, la chaîne de requête et les enregistrements d'utilisateur sont passés à .execute() . Le script ci-dessus insère avec succès cinq enregistrements dans les users tableau.

Jetez un œil à un autre exemple d'insertion d'enregistrements dans une table PostgreSQL. Le script suivant insère des enregistrements dans les posts tableau :

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)

Vous pouvez insérer des enregistrements dans les comments et likes tables avec la même approche.




Sélectionner des enregistrements

Dans cette section, vous verrez comment sélectionner des enregistrements dans des tables de base de données à l'aide des différents modules Python SQL. En particulier, vous verrez comment effectuer SELECT requêtes sur vos bases de données SQLite, MySQL et PostgreSQL.


SQLite

Pour sélectionner des enregistrements à l'aide de SQLite, vous pouvez à nouveau utiliser cursor.execute() . Cependant, après avoir fait cela, vous devrez appeler .fetchall() . Cette méthode renvoie une liste de tuples où chaque tuple est mappé à la ligne correspondante dans les enregistrements récupérés.

Pour simplifier le processus, vous pouvez créer une fonction 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")

Cette fonction accepte la connection objet et le SELECT requête et renvoie l'enregistrement sélectionné.


SELECT

Sélectionnons maintenant tous les enregistrements des users tableau :

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

for user in users:
    print(user)

Dans le script ci-dessus, le SELECT la requête sélectionne tous les utilisateurs parmi les users table. Ceci est passé au execute_read_query() , qui renvoie tous les enregistrements des users table. Les enregistrements sont ensuite parcourus et imprimés sur la console.

Remarque : Il n'est pas recommandé d'utiliser SELECT * sur de grandes tables car cela peut entraîner un grand nombre d'opérations d'E/S qui augmentent le trafic réseau.

Le résultat de la requête ci-dessus ressemble à ceci :

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

De la même manière, vous pouvez récupérer tous les enregistrements des posts tableau avec le script ci-dessous :

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

for post in posts:
    print(post)

La sortie ressemble à ceci :

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

Le résultat affiche tous les enregistrements dans les posts tableau.



JOIN

Vous pouvez également exécuter des requêtes complexes impliquant JOIN opérations pour récupérer les données de deux tables liées. 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 objet. 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 tableau :

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.