Python MySQL - Guide rapide

La norme Python pour les interfaces de base de données est l'API DB Python. La plupart des interfaces de base de données Python adhèrent à cette norme.

Vous pouvez choisir la bonne base de données pour votre application. L'API de base de données Python prend en charge un large éventail de serveurs de base de données tels que -

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

Voici la liste des interfaces de base de données Python disponibles - Interfaces de base de données Python et API . Vous devez télécharger un module DB API distinct pour chaque base de données à laquelle vous devez accéder. Par exemple, si vous avez besoin d'accéder à une base de données Oracle ainsi qu'à une base de données MySQL, vous devez télécharger les modules de base de données Oracle et MySQL.

Qu'est-ce que mysql-connector-python?

MySQL Python / Connector est une interface pour se connecter à un serveur de base de données MySQL depuis Python. Il implémente l'API de base de données Python et est construit sur MySQL.

Comment installer mysql-connector-python?

Tout d'abord, vous devez vous assurer que vous avez déjà installé python sur votre machine. Pour ce faire, ouvrez l'invite de commande et tapez python dedans et appuyez sur Entrée . Si python est déjà installé sur votre système, cette commande affichera sa version comme indiqué ci-dessous -

C:\Users\Tutorialspoint>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Appuyez maintenant sur ctrl + z , puis sur Entrée pour sortir du shell python et créer un dossier (dans lequel vous aviez l'intention d'installer le connecteur Python-MySQL) nommé Python_MySQL comme -

>>> ^Z 
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL

Vérifier PIP

PIP est un gestionnaire de packages en python à l'aide duquel vous pouvez installer divers modules / packages en Python. Par conséquent, pour installer Mysql-python mysql-connector-python, vous devez vous assurer que PIP est installé sur votre ordinateur et que son emplacement est ajouté au chemin.

Vous pouvez le faire en exécutant la commande pip. Si vous n'avez pas de PIP dans votre système ou, si vous n'avez pas ajouté son emplacement dans lePath variable d'environnement, vous obtiendrez un message d'erreur comme -

D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.

Pour installer PIP, téléchargez le get-pip.py dans le dossier créé ci-dessus et, à partir de la commande, parcourez-le et installez pip comme suit -

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
   Downloading
https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
   |████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
   Downloading 
https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

Installer mysql-connector-python

Une fois Python et PIP installés, ouvrez l'invite de commande et mettez à niveau pip (facultatif) comme indiqué ci-dessous -

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
   Using cached 
https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
   Found existing installation: pip 19.0.3
      Uninstalling pip-19.0.3:
         Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

Ensuite, ouvrez l'invite de commande en mode administrateur et installez python MySQL connect en tant que -

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
   Using cached 
https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
   Using cached 
https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
   Using cached 
https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

Vérification

Pour vérifier l'installation du, créez un exemple de script python avec la ligne suivante.

import mysql.connector

Si l'installation réussit, lorsque vous l'exécutez, vous ne devriez obtenir aucune erreur -

D:\Python_MySQL>python test.py
D:\Python_MySQL>

Installer Python à partir de zéro

Simplement, si vous devez installer Python à partir de zéro. Visitez la page d'accueil de Python .

Clique sur le Downloads , vous serez redirigé vers la page de téléchargement qui fournit des liens vers la dernière version de python pour diverses plates-formes, choisissez-en une et téléchargez-la.

Par exemple, nous avons téléchargé python-3.7.4.exe (pour Windows). Démarrez le processus d'installation en double-cliquant sur le fichier .exe téléchargé.

Cochez l'option Ajouter Python 3.7 au chemin et procédez à l'installation. Une fois ce processus terminé, python sera installé sur votre système.

Pour vous connecter à MySQL, (une façon est de) ouvrir l'invite de commande MySQL dans votre système comme indiqué ci-dessous -

Il demande le mot de passe ici; vous devez taper le mot de passe que vous avez défini sur l'utilisateur par défaut (root) au moment de l'installation.

Ensuite, une connexion est établie avec MySQL affichant le message suivant -

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

Vous pouvez vous déconnecter de la base de données MySQL à tout moment en utilisant le exitcommande à l' invite mysql> .

mysql> exit
Bye

Établir une connexion avec MySQL à l'aide de Python

Avant d'établir la connexion à la base de données MySQL à l'aide de python, supposez -

• Que nous avons créé une base de données avec le nom mydb.

• Nous avons créé une table EMPLOYEE avec les colonnes FIRST_NAME, LAST_NAME, AGE, SEX et INCOME.

• Les informations d'identification que nous utilisons pour nous connecter à MySQL sont le nom d'utilisateur - root, mot de passe - password.

Vous pouvez établir une connexion à l'aide du constructeur connect () . Cela accepte le nom d'utilisateur, le mot de passe, l'hôte et le nom de la base de données à laquelle vous devez vous connecter (facultatif) et renvoie un objet de la classe MySQLConnection.

Exemple

Voici l'exemple de connexion avec la base de données MySQL "mydb".

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

#Fetch a single row using fetchone() method.
data = cursor.fetchone()

print("Connection established to: ",data)

#Closing the connection
conn.close()

Production

Lors de l'exécution, ce script produit la sortie suivante -

D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)

Vous pouvez également établir une connexion à MySQL en transmettant les informations d'identification (nom d'utilisateur, mot de passe, nom d'hôte et nom de base de données) à connection.MySQLConnection() comme indiqué ci-dessous -

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Closing the connection
conn.close()

Vous pouvez créer une base de données dans MYSQL à l'aide de la requête CREATE DATABASE.

Syntaxe

Voici la syntaxe de la requête CREATE DATABASE -

CREATE DATABASE name_of_the_database

Exemple

L'instruction suivante crée une base de données avec le nom mydb dans MySQL -

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)

Si vous observez la liste des bases de données à l'aide de l'instruction SHOW DATABASES, vous pouvez y observer la base de données nouvellement créée comme indiqué ci-dessous -

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| logging            |
| mydatabase         |
| mydb               |
| performance_schema |
| students           |
| sys                |
+--------------------+
26 rows in set (0.15 sec)

Créer une base de données dans MySQL à l'aide de Python

Après avoir établi la connexion avec MySQL, pour manipuler les données qu'il contient, vous devez vous connecter à une base de données. Vous pouvez vous connecter à une base de données existante ou créer la vôtre.

Vous auriez besoin de privilèges spéciaux pour créer ou supprimer une base de données MySQL. Donc, si vous avez accès à l'utilisateur root, vous pouvez créer n'importe quelle base de données.

Exemple

L'exemple suivant établit une connexion avec MYSQL et y crée une base de données.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

Production

List of databases:
[
   ('information_schema',), 
   ('dbbug61332',), 
   ('details',), 
   ('exampledatabase',), 
   ('mydatabase',), 
   ('mydb',), 
   ('mysql',), 
   ('performance_schema',)
]

L'instruction CREATE TABLE est utilisée pour créer des tables dans la base de données MYSQL. Ici, vous devez spécifier le nom de la table et la définition (nom et type de données) de chaque colonne.

Syntaxe

Voici la syntaxe pour créer une table dans MySQL -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Exemple

La requête suivante crée une table nommée EMPLOYEE dans MySQL avec cinq colonnes à savoir, FIRST_NAME, LAST_NAME, AGE, SEX et, INCOME.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT);
Query OK, 0 rows affected (0.42 sec)

L'instruction DESC vous donne la description de la table spécifiée. En utilisant cela, vous pouvez vérifier si la table a été créée ou non comme indiqué ci-dessous -

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |  
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

Créer une table dans MySQL à l'aide de Python

La méthode nommée execute () (invoquée sur l'objet curseur) accepte deux variables -

• Une valeur String représentant la requête à exécuter.

• Un paramètre args facultatif qui peut être un tuple ou, une liste ou un dictionnaire, représentant les paramètres de la requête (valeurs des espaces réservés).

Il renvoie une valeur entière représentant le nombre de lignes affectées par la requête.

Une fois la connexion à la base de données établie, vous pouvez créer des tables en transmettant la requête CREATE TABLE au execute() méthode.

En bref, pour créer une table en utilisant python -

• Importer mysql.connector paquet.

• Créez un objet de connexion à l'aide de mysql.connector.connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Créez un objet curseur en invoquant le cursor() méthode sur l'objet de connexion créé ci-dessus.

• Ensuite, exécutez l' instruction CREATE TABLE en la passant comme paramètre à laexecute() méthode.

Exemple

L'exemple suivant crée une table nommée Employee dans la base de données mydb.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

Vous pouvez ajouter de nouvelles lignes à une table existante de MySQL en utilisant le INSERT INTOdéclaration. Dans ce cas, vous devez spécifier le nom de la table, les noms de colonne et les valeurs (dans le même ordre que les noms de colonne).

Syntaxe

Voici la syntaxe de l'instruction INSERT INTO de MySQL.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
   VALUES (value1, value2, value3,...valueN);

Exemple

La requête suivante insère un enregistrement dans la table nommée EMPLOYEE.

INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000);

Vous pouvez vérifier les enregistrements de la table après l'opération d'insertion en utilisant l'instruction SELECT comme -

mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Mac        | Mohan     |    20| M    | 2000   |
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)

Il n'est pas obligatoire de toujours spécifier les noms des colonnes, si vous passez les valeurs d'un enregistrement dans le même ordre que les colonnes de la table, vous pouvez exécuter l'instruction SELECT sans les noms de colonnes comme suit -

INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);

Insérer des données dans une table MySQL à l'aide de Python

le execute()(invoquée sur l'objet curseur) accepte une requête comme paramètre et exécute la requête donnée. Pour insérer des données, vous devez lui transmettre l'instruction MySQL INSERT en tant que paramètre.

cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")

Pour insérer des données dans une table dans MySQL en utilisant python -

• importer mysql.connector paquet.

• Créez un objet de connexion à l'aide de mysql.connector.connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Créez un objet curseur en invoquant le cursor() méthode sur l'objet de connexion créé ci-dessus.

• Ensuite, exécutez le INSERT instruction en la passant comme paramètre au execute() méthode.

Exemple

L'exemple suivant exécute l' instruction SQL INSERT pour insérer un enregistrement dans la table EMPLOYEE -

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Executing the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
# Closing the connection
conn.close()

Insertion dynamique de valeurs

Vous pouvez aussi utiliser “%s” au lieu de valeurs dans le INSERT requête de MySQL et leur transmettre les valeurs sous forme de listes comme indiqué ci-dessous -

cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""", 
   ('Ramya', 'Ramapriya', 25, 'F', 5000))

Exemple

L'exemple suivant insère un enregistrement dans la table Employee de manière dynamique.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)
try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
print("Data inserted")
# Closing the connection
conn.close()

Production

Data inserted

Vous pouvez récupérer / récupérer des données à partir d'une table dans MySQL à l'aide de la requête SELECT. Cette requête / instruction renvoie le contenu de la table spécifiée sous forme de tableau et elle est appelée comme ensemble de résultats.

Syntaxe

Voici la syntaxe de la requête SELECT -

SELECT column1, column2, columnN FROM table_name;

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom cricketers_data comme -

CREATE TABLE cricketers_data(
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Date_Of_Birth date,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

insert into cricketers_data values('Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values('Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values('Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values('Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values('Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

La requête suivante récupère les valeurs FIRST_NAME et Country de la table.

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     | 
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

Vous pouvez également récupérer toutes les valeurs de chaque enregistrement en utilisant * instated du nom des colonnes comme -

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

Lire des données à partir d'une table MYSQL à l'aide de Python

LIRE L'opération sur n'importe quelle base de données signifie récupérer des informations utiles dans la base de données. Vous pouvez récupérer les données de MYSQL en utilisant lefetch() méthode fournie par le mysql-connector-python.

La classe cursor.MySQLCursor fournit trois méthodes à savoirfetchall(), fetchmany() et, fetchone() où,

• le fetchall()La méthode récupère toutes les lignes du jeu de résultats d'une requête et les renvoie sous forme de liste de tuples. (Si nous exécutons ceci après avoir récupéré quelques lignes, il renvoie les autres).

• le fetchone() La méthode récupère la ligne suivante dans le résultat d'une requête et la renvoie sous forme de tuple.

• le fetchmany() est similaire à la méthode fetchone (), mais elle récupère l'ensemble de lignes suivant dans l'ensemble de résultats d'une requête, au lieu d'une seule ligne.

Note - Un jeu de résultats est un objet renvoyé lorsqu'un objet curseur est utilisé pour interroger une table.

rowcount - Il s'agit d'un attribut en lecture seule et renvoie le nombre de lignes affectées par une méthode execute ().

Exemple

L'exemple suivant récupère toutes les lignes de la table EMPLOYEE à l'aide de la requête SELECT et à partir du jeu de résultats obtenu initialement, nous récupérons la première ligne à l'aide de la méthode fetchone (), puis les lignes restantes à l'aide de la méthode fetchall ().

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Production

('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]

L'exemple suivant récupère les deux premières lignes de la table EMPLOYEE à l'aide de la méthode fetchmany ().

Exemple

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

Production

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Si vous souhaitez récupérer, supprimer ou mettre à jour des lignes particulières d'une table dans MySQL, vous devez utiliser la clause where pour spécifier la condition de filtrage des lignes de la table pour l'opération.

Par exemple, si vous avez une instruction SELECT avec la clause where, seules les lignes qui satisfont à la condition spécifiée seront récupérées.

Syntaxe

Voici la syntaxe de la clause WHERE -

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom EMPLOYEES comme -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Et si nous y avons inséré 4 enregistrements en utilisant des instructions INSERT comme -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

L'instruction MySQL suivante récupère les enregistrements des employés dont le revenu est supérieur à 4000.

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Clause WHERE utilisant Python

Pour récupérer des enregistrements spécifiques d'une table à l'aide du programme python -

• importer mysql.connector paquet.

• Créez un objet de connexion à l'aide de mysql.connector.connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Créez un objet curseur en invoquant le cursor() méthode sur l'objet de connexion créé ci-dessus.

• Ensuite, exécutez l' instruction SELECT avec la clause WHERE , en la passant en paramètre auexecute() méthode.

Exemple

L'exemple suivant crée une table nommée Employee et la remplit. Ensuite, à l'aide de la clause where, il récupère les enregistrements dont l'âge est inférieur à 23.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES (%s, %s, %s, %s, %s
)"
data = [
   ('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)
]
cursor.executemany(insert_stmt, data)
conn.commit()
#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

Production

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Lors de la récupération des données à l'aide de la requête SELECT, vous pouvez trier les résultats dans l'ordre souhaité (croissant ou décroissant) à l'aide de la clause OrderBy. Par défaut, cette clause trie les résultats dans l'ordre croissant, si vous devez les organiser par ordre décroissant, vous devez utiliser explicitement «DESC».

Syntaxe

Voici la syntaxe SELECT colonne-liste

FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom EMPLOYEES comme -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT);
Query OK, 0 rows affected (0.36 sec)

Et si nous y avons inséré 4 enregistrements en utilisant des instructions INSERT comme -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

L'instruction suivante récupère le contenu de la table EMPLOYEE dans l'ordre croissant de l'âge.

mysql> SELECT * FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
| Mac        | Mohan     |    26| M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

Vous pouvez également récupérer les données dans l'ordre décroissant en utilisant DESC comme -

mysql> SELECT * FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Mac        | Mohan     |    26| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Clause ORDER BY à l'aide de Python

Pour récupérer le contenu d'une table dans un ordre spécifique, appelez le execute() sur l'objet de curseur et, passez l'instruction SELECT avec la clause ORDER BY en tant que paramètre.

Exemple

Dans l'exemple suivant, nous créons une table avec le nom et l'employé, la remplissons et récupérons ses enregistrements dans l'ordre (croissant) de leur âge, à l'aide de la clause ORDER BY.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE 
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES (%s, %s, %s, %s, %s)"
data = [
   ('Krishna', 'Sharma', 26, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)
]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")

print(cursor.fetchall())

#Closing the connection
conn.close()

Production

[
   ('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]

De la même manière, vous pouvez récupérer les données d'une table dans l'ordre décroissant à l'aide de la clause ORDER BY.

Exemple

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving specific records using the ORDERBY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY INCOME DESC")

print(cursor.fetchall())

#Closing the connection
conn.close()

Production

[
   ('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0)
]

UPDATE L'opération sur n'importe quelle base de données met à jour un ou plusieurs enregistrements, qui sont déjà disponibles dans la base de données. Vous pouvez mettre à jour les valeurs des enregistrements existants dans MySQL à l'aide de l'instruction UPDATE. Pour mettre à jour des lignes spécifiques, vous devez utiliser la clause WHERE avec elle.

Syntaxe

Voici la syntaxe de l'instruction UPDATE dans MySQL -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Vous pouvez combiner N nombre de conditions en utilisant les opérateurs AND ou OR.

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom EMPLOYEES comme -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Et si nous y avons inséré 4 enregistrements en utilisant des instructions INSERT comme -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Suivre la déclaration MySQL augmente l'âge de tous les employés masculins d'un an -

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec) 9. 
Rows matched: 3 Changed: 3 Warnings: 0

Si vous récupérez le contenu de la table, vous pouvez voir les valeurs mises à jour comme -

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    20| M    | 2000   |
| Raj        | Kandukuri |    21| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
| Mac        | Mohan     |    27| M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Mise à jour du contenu d'une table à l'aide de Python

Pour mettre à jour les enregistrements dans une table dans MySQL en utilisant python -

• importer mysql.connector paquet.

• Créez un objet de connexion à l'aide de mysql.connector.connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Créez un objet curseur en invoquant le cursor() méthode sur l'objet de connexion créé ci-dessus.

• Ensuite, exécutez l' instruction UPDATE en la passant en tant que paramètre auexecute() méthode.

Exemple

L'exemple suivant augmente l'âge de tous les hommes d'un an.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''

try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()

#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

Production

[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]

Pour supprimer des enregistrements d'une table MySQL, vous devez utiliser le DELETE FROMdéclaration. Pour supprimer des enregistrements spécifiques, vous devez utiliser la clause WHERE avec elle.

Syntaxe

Voici la syntaxe de la requête DELETE dans MYSQL -

DELETE FROM table_name [WHERE Clause]

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom EMPLOYEES comme -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Et si nous y avons inséré 4 enregistrements en utilisant des instructions INSERT comme -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Suivre une instruction MySQL supprime l'enregistrement de l'employé avec FIRST_NAME «Mac» .

mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)

Si vous récupérez le contenu du tableau, vous ne pouvez voir que 3 enregistrements puisque nous en avons supprimé un.

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    20| M    | 2000   |
| Raj        | Kandukuri |    21| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

Si vous exécutez l'instruction DELETE sans la clause WHERE, tous les enregistrements de la table spécifiée seront supprimés.

mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)

Si vous récupérez le contenu de la table, vous obtiendrez un ensemble vide comme indiqué ci-dessous -

mysql> select * from EMPLOYEE;
Empty set (0.00 sec)

Suppression des enregistrements d'une table à l'aide de Python

L'opération DELETE est requise lorsque vous souhaitez supprimer certains enregistrements de votre base de données.

Pour supprimer les enregistrements dans une table -

• importer mysql.connector paquet.

• Créez un objet de connexion à l'aide de mysql.connector.connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Créez un objet curseur en appelant la méthode cursor () sur l'objet de connexion créé ci-dessus.

• Ensuite, exécutez le DELETE instruction en la passant comme paramètre au execute() méthode.

Exemple

Le programme suivant supprime tous les enregistrements de l'EMPLOYÉ dont l'ÂGE est supérieur à 20 -

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

Production

Contents of the table:
[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0), 
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)
]
Contents of the table after delete operation:
[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0)
]

Vous pouvez supprimer une table entière en utilisant le DROP TABLEdéclaration. Il vous suffit de spécifier le nom de la table à supprimer.

Syntaxe

Voici la syntaxe de l'instruction DROP TABLE dans MySQL -

DROP TABLE table_name;

Exemple

Avant de supprimer une table, obtenez la liste des tables à l'aide de l'instruction SHOW TABLES comme suit -

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| sample          |
| tutorials       |
+-----------------+
5 rows in set (0.00 sec)

L'instruction suivante supprime complètement la table nommée sample de la base de données -

mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)

Puisque nous avons supprimé la table nommée sample de MySQL, si vous obtenez à nouveau la liste des tables, vous n'y trouverez pas l'exemple de nom de table.

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data | 
| employee        |
| tutorials       |
+-----------------+
4 rows in set (0.00 sec)

Supprimer une table à l'aide de Python

Vous pouvez supprimer une table chaque fois que vous en avez besoin, en utilisant l'instruction DROP de MYSQL, mais vous devez être très prudent lors de la suppression d'une table existante car les données perdues ne seront pas récupérées après la suppression d'une table.

Pour supprimer une table d'une base de données MYSQL à l'aide de python, appelez le execute() sur l'objet de curseur et passez l'instruction drop en tant que paramètre.

Exemple

La table suivante supprime une table nommée EMPLOYEE de la base de données.

import mysql.connector
#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method cursor = conn.cursor()

#Retrieving the list of tables print("List of tables in the database: ")   
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute("DROP TABLE EMPLOYEE") 
   print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: "
) 
cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection 
conn.close()

Production

List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]

Supprimer la table uniquement si elle existe

Si vous essayez de supprimer une table qui n'existe pas dans la base de données, une erreur se produit comme -

mysql.connector.errors.ProgrammingError: 1051 (42S02): Unknown table 'mydb.employee'

Vous pouvez éviter cette erreur en vérifiant si la table existe avant la suppression, en ajoutant IF EXISTS à l'instruction DELETE.

Example

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

Output

List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]

Lors de la récupération des enregistrements si vous souhaitez les limiter par un nombre particulier, vous pouvez le faire en utilisant la clause LIMIT de MYSQL.

Exemple

Supposons que nous ayons créé une table dans MySQL avec le nom EMPLOYEES comme -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Et si nous y avons inséré 4 enregistrements en utilisant des instructions INSERT comme -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

L'instruction SQL suivante récupère les deux premiers enregistrements de la table Employee à l'aide de la clause LIMIT.

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Clause de limite à l'aide de Python

Si vous invoquez le execute() sur l'objet curseur en passant la requête SELECT avec la clause LIMIT, vous pouvez récupérer le nombre requis d'enregistrements.

Exemple

L'exemple python suivant crée et remplit une table avec le nom EMPLOYEE et, à l'aide de la clause LIMIT, il récupère les deux premiers enregistrements de celle-ci.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Production

[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

LIMIT avec OFFSET

Si vous avez besoin de limiter les enregistrements à partir du nième enregistrement (et non du 1er), vous pouvez le faire en utilisant OFFSET avec LIMIT.

Example

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Output

[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]

Lorsque vous avez divisé les données en deux tables, vous pouvez extraire des enregistrements combinés de ces deux tables à l'aide des jointures.

Exemple

Supposons que nous ayons créé une table avec le nom EMPLOYEE et y avons rempli des données comme indiqué ci-dessous -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES 
   ('Ramya', 'Rama Priya', 27, 'F', 9000, 101), 
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102), 
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103), 
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104), 
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

Ensuite, si nous avons créé une autre table et l'avons remplie comme -

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai'); 
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

L'instruction suivante récupère les données combinant les valeurs de ces deux tables -

mysql> SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | [email protected] | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | [email protected]    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | [email protected] | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | [email protected]    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

MYSQL JOIN en utilisant Python

L'exemple suivant récupère les données des deux tables ci-dessus combinées par la colonne contact de la table EMPLOYEE et la colonne ID de la table CONTACT.

Exemple

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();

print(result)

#Closing the connection
conn.close()

Production

[
   ('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, '[email protected]', 9848022338, 'Hyderabad'), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'), 
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')
]

Le MySQLCursor de mysql-connector-python (et des bibliothèques similaires) est utilisé pour exécuter des instructions pour communiquer avec la base de données MySQL.

En utilisant les méthodes de celui-ci, vous pouvez exécuter des instructions SQL, extraire des données des ensembles de résultats, appeler des procédures.

Vous pouvez créer Cursor objet en utilisant la méthode cursor () de l'objet / de la classe Connection.

Exemple

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

Méthodes

Voici les différentes méthodes fournies par la classe / objet Cursor.

Sr.Non	Méthodes et description
1	callproc() Cette méthode est utilisée pour appeler les procédures existantes de la base de données MySQL.
2	close() Cette méthode est utilisée pour fermer l'objet curseur actuel.
3	Info() Cette méthode donne des informations sur la dernière requête.
4	executemany() Cette méthode accepte une série de listes de paramètres list. Prépare une requête MySQL et l'exécute avec tous les paramètres.
5	execute() Cette méthode accepte une requête MySQL comme paramètre et exécute la requête donnée.
6	fetchall() Cette méthode récupère toutes les lignes du jeu de résultats d'une requête et les renvoie sous forme de liste de tuples. (Si nous exécutons ceci après avoir récupéré quelques lignes, il renvoie les autres)
sept	fetchone() Cette méthode récupère la ligne suivante dans le résultat d'une requête et la renvoie sous forme de tuple.
8	fetchmany() Cette méthode est similaire à fetchone (), mais elle récupère le jeu de lignes suivant dans le jeu de résultats d'une requête, au lieu d'une seule ligne.
9	fetchwarnings() Cette méthode renvoie les avertissements générés par la dernière requête exécutée.

Propriétés

Voici les propriétés de la classe Cursor -

Sr.Non	Propriété et description
1	column_names Il s'agit d'une propriété en lecture seule qui renvoie la liste contenant les noms de colonne d'un jeu de résultats.
2	description Il s'agit d'une propriété en lecture seule qui renvoie la liste contenant la description des colonnes dans un jeu de résultats.
3	lastrowid Il s'agit d'une propriété en lecture seule, s'il y a des colonnes auto-incrémentées dans la table, cela renvoie la valeur générée pour cette colonne lors de la dernière opération INSERT ou UPDATE.
4	rowcount Cela renvoie le nombre de lignes renvoyées / mises à jour en cas d'opérations SELECT et UPDATE.
5	statement Cette propriété renvoie la dernière instruction exécutée.