Python MySQL - Guida rapida

Lo standard Python per le interfacce di database è l'API DB Python. La maggior parte delle interfacce di database Python aderisce a questo standard.

Puoi scegliere il database giusto per la tua applicazione. Python Database API supporta un'ampia gamma di server database come:

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

Ecco l'elenco delle interfacce di database Python disponibili: interfacce di database Python e API . Devi scaricare un modulo API DB separato per ogni database a cui devi accedere. Ad esempio, se è necessario accedere a un database Oracle nonché a un database MySQL, è necessario scaricare sia i moduli di database Oracle che MySQL.

Cos'è mysql-connector-python?

MySQL Python / Connector è un'interfaccia per la connessione a un server di database MySQL da Python. Implementa l'API del database Python e si basa su MySQL.

Come installo mysql-connector-python?

Prima di tutto, devi assicurarti di aver già installato python sulla tua macchina. Per fare ciò, apri il prompt dei comandi e digita python e premi Invio . Se python è già installato nel tuo sistema, questo comando mostrerà la sua versione come mostrato di seguito -

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.
>>>

Ora premi ctrl + z e poi Invio per uscire dalla shell python e creare una cartella (in cui intendi installare il connettore Python-MySQL) denominata Python_MySQL come -

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

Verifica PIP

PIP è un gestore di pacchetti in Python utilizzando il quale è possibile installare vari moduli / pacchetti in Python. Pertanto, per installare Mysql-python mysql-connector-python devi assicurarti di avere PIP installato sul tuo computer e di avere la sua posizione aggiunta al percorso.

Puoi farlo eseguendo il comando pip. Se non avevi PIP nel tuo sistema o, se non hai aggiunto la sua posizione nel filePath variabile d'ambiente, riceverai un messaggio di errore come -

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

Per installare PIP, scarica get-pip.py nella cartella creata sopra e, dal comando , navigalo e installa pip come segue:

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

Installazione di mysql-connector-python

Dopo aver installato Python e PIP, apri il prompt dei comandi e aggiorna pip (opzionale) come mostrato di seguito -

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

Quindi apri il prompt dei comandi in modalità amministratore e installa python MySQL Connect come -

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

Verifica

Per verificare l'installazione del creare uno script Python di esempio con la seguente riga in esso.

import mysql.connector

Se l'installazione ha successo, quando la esegui, non dovresti ricevere alcun errore -

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

Installazione di Python da zero

Semplicemente, se devi installare Python da zero. Visita la home page di Python .

Clicca sul Downloads , verrai reindirizzato alla pagina dei download che fornisce i collegamenti per l'ultima versione di python per varie piattaforme, scegline uno e scaricalo.

Ad esempio, abbiamo scaricato python-3.7.4.exe (per Windows). Avvia il processo di installazione facendo doppio clic sul file .exe scaricato.

Seleziona l'opzione Aggiungi Python 3.7 al percorso e procedi con l'installazione. Dopo il completamento di questo processo, python verrà installato nel tuo sistema.

Per connetterti con MySQL, (un modo è) aprire il prompt dei comandi di MySQL nel tuo sistema come mostrato di seguito -

Chiede la password qui; devi digitare la password che hai impostato come utente predefinito (root) al momento dell'installazione.

Quindi viene stabilita una connessione con MySQL che mostra il seguente messaggio:

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.

Puoi disconnetterti dal database MySQL in qualsiasi momento utilizzando il exitcomando a mysql> prompt.

mysql> exit
Bye

Stabilire una connessione con MySQL usando Python

Prima di stabilire una connessione al database MySQL utilizzando python, presumi:

• Che abbiamo creato un database con il nome mydb.

• Abbiamo creato una tabella EMPLOYEE con le colonne FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

• Le credenziali che utilizziamo per connetterci con MySQL sono nome utente - root, password - password.

È possibile stabilire una connessione utilizzando il costruttore connect () . Accetta nome utente, password, host e nome del database a cui è necessario connettersi (opzionale) e restituisce un oggetto della classe MySQLConnection.

Esempio

Di seguito è riportato l'esempio di connessione con il database 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()

Produzione

All'esecuzione, questo script produce il seguente output:

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

Puoi anche stabilire una connessione a MySQL passando le credenziali (nome utente, password, nome host e nome database) a connection.MySQLConnection() come mostrato di seguito -

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

È possibile creare un database in MYSQL utilizzando la query CREATE DATABASE.

Sintassi

Di seguito è riportata la sintassi della query CREATE DATABASE:

CREATE DATABASE name_of_the_database

Esempio

La seguente istruzione crea un database con il nome mydb in MySQL -

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

Se si osserva l'elenco dei database utilizzando l'istruzione SHOW DATABASES, è possibile osservare il database appena creato al suo interno come mostrato di seguito:

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

Creazione di un database in MySQL utilizzando Python

Dopo aver stabilito la connessione con MySQL, per manipolare i dati in esso è necessario connettersi a un database. Puoi connetterti a un database esistente o crearne uno tuo.

Avresti bisogno di privilegi speciali per creare o eliminare un database MySQL. Quindi, se hai accesso all'utente root, puoi creare qualsiasi database.

Esempio

L'esempio seguente stabilisce la connessione con MYSQL e crea un database al suo interno.

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

Produzione

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

L'istruzione CREATE TABLE viene utilizzata per creare tabelle nel database MYSQL. Qui è necessario specificare il nome della tabella e la definizione (nome e tipo di dati) di ciascuna colonna.

Sintassi

Di seguito è riportata la sintassi per creare una tabella in MySQL:

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

Esempio

La seguente query crea una tabella denominata EMPLOYEE in MySQL con cinque colonne, ovvero FIRST_NAME, LAST_NAME, AGE, SEX e, 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'istruzione DESC fornisce la descrizione della tabella specificata. Usando questo puoi verificare se la tabella è stata creata o meno come mostrato di seguito -

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)

Creazione di una tabella in MySQL utilizzando Python

Il metodo chiamato execute () (invocato sull'oggetto cursore) accetta due variabili -

• Un valore String che rappresenta la query da eseguire.

• Un parametro args facoltativo che può essere una tupla o una lista o un dizionario, che rappresenta i parametri della query (valori dei segnaposto).

Restituisce un valore intero che rappresenta il numero di righe interessate dalla query.

Una volta stabilita una connessione al database, è possibile creare tabelle passando la query CREATE TABLE al file execute() metodo.

In breve, per creare una tabella usando python -

• Importare mysql.connector pacchetto.

• Crea un oggetto connessione usando il mysql.connector.connect() , passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Crea un oggetto cursore richiamando il file cursor() metodo sull'oggetto connessione creato sopra.

• Quindi, eseguire l' istruzione CREATE TABLE passandola come parametro al fileexecute() metodo.

Esempio

L'esempio seguente crea una tabella denominata Employee nel database 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()

Puoi aggiungere nuove righe a una tabella esistente di MySQL utilizzando il INSERT INTOdichiarazione. In questo caso, è necessario specificare il nome della tabella, i nomi delle colonne e i valori (nello stesso ordine dei nomi delle colonne).

Sintassi

Di seguito è riportata la sintassi dell'istruzione INSERT INTO di MySQL.

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

Esempio

La seguente query inserisce un record nella tabella denominata EMPLOYEE.

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

È possibile verificare i record della tabella dopo l'operazione di inserimento utilizzando l'istruzione SELECT come:

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

Non è obbligatorio specificare sempre i nomi delle colonne, se si passano i valori di un record nello stesso ordine delle colonne della tabella è possibile eseguire l'istruzione SELECT senza i nomi delle colonne come segue:

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

Inserimento di dati nella tabella MySQL utilizzando Python

Il execute()(richiamato sull'oggetto cursore) accetta una query come parametro ed esegue la query data. Per inserire i dati, è necessario passare l'istruzione MySQL INSERT come parametro ad esso.

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

Per inserire dati in una tabella in MySQL usando python -

• importare mysql.connector pacchetto.

• Crea un oggetto connessione usando il mysql.connector.connect() , passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Crea un oggetto cursore richiamando il file cursor() metodo sull'oggetto connessione creato sopra.

• Quindi, esegui il file INSERT passandola come parametro al file execute() metodo.

Esempio

L'esempio seguente esegue l' istruzione SQL INSERT per inserire un record nella tabella 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()

Inserimento di valori dinamicamente

Puoi anche usare “%s” invece dei valori in INSERT query di MySQL e passare loro i valori come elenchi come mostrato di seguito -

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

Esempio

L'esempio seguente inserisce dinamicamente un record nella tabella 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.
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()

Produzione

Data inserted

È possibile recuperare / recuperare dati da una tabella in MySQL utilizzando la query SELECT. Questa query / istruzione restituisce il contenuto della tabella specificata in forma tabulare e viene chiamata come set di risultati.

Sintassi

Di seguito è riportata la sintassi della query SELECT:

SELECT column1, column2, columnN FROM table_name;

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome cricketers_data come -

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente query recupera i valori FIRST_NAME e Country dalla tabella.

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)

Puoi anche recuperare tutti i valori di ogni record usando * instated del nome delle colonne come -

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)

Lettura di dati da una tabella MYSQL utilizzando Python

READ Operare su qualsiasi database significa prelevare alcune informazioni utili dal database. Puoi recuperare i dati da MYSQL usando ilfetch() metodo fornito da mysql-connector-python.

La classe cursor.MySQLCursor fornisce tre metodi, vale a direfetchall(), fetchmany() e, fetchone() dove,

• Il fetchall()recupera tutte le righe nel set di risultati di una query e le restituisce come elenco di tuple. (Se lo eseguiamo dopo aver recuperato poche righe, restituisce quelle rimanenti).

• Il fetchone() recupera la riga successiva nel risultato di una query e la restituisce come una tupla.

• Il fetchmany() è simile a fetchone () ma recupera il successivo set di righe nel set di risultati di una query, invece di una singola riga.

Note - Un set di risultati è un oggetto restituito quando un oggetto cursore viene utilizzato per interrogare una tabella.

rowcount - Questo è un attributo di sola lettura e restituisce il numero di righe che sono state influenzate da un metodo execute ().

Esempio

L'esempio seguente recupera tutte le righe della tabella EMPLOYEE utilizzando la query SELECT e dal set di risultati ottenuto inizialmente, stiamo recuperando la prima riga utilizzando il metodo fetchone () e quindi recuperando le righe rimanenti utilizzando il metodo 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()

Produzione

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

L'esempio seguente recupera le prime due righe della tabella EMPLOYEE utilizzando il metodo fetchmany ().

Esempio

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

Produzione

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

Se si desidera recuperare, eliminare o aggiornare particolari righe di una tabella in MySQL, è necessario utilizzare la clausola where per specificare la condizione per filtrare le righe della tabella per l'operazione.

Ad esempio, se si dispone di un'istruzione SELECT con la clausola where, verranno recuperate solo le righe che soddisfano la condizione specificata.

Sintassi

Di seguito è riportata la sintassi della clausola WHERE:

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

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome EMPLOYEES come -

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)

E se abbiamo inserito 4 record in esso utilizzando le istruzioni INSERT come -

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

La seguente dichiarazione MySQL recupera i record dei dipendenti il ​​cui reddito è superiore a 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)

WHERE clausola utilizzando Python

Per recuperare record specifici da una tabella utilizzando il programma python:

• importare mysql.connector pacchetto.

• Crea un oggetto connessione usando il mysql.connector.connect() , passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Crea un oggetto cursore richiamando il file cursor() metodo sull'oggetto connessione creato sopra.

• Quindi, eseguire l' istruzione SELECT con la clausola WHERE , passandola come parametro al fileexecute() metodo.

Esempio

L'esempio seguente crea una tabella denominata Employee e la popola. Quindi, utilizzando la clausola where, recupera i record con un valore di età inferiore a 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()

Produzione

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

Durante il recupero dei dati utilizzando la query SELECT, è possibile ordinare i risultati nell'ordine desiderato (crescente o decrescente) utilizzando la clausola OrderBy. Per impostazione predefinita, questa clausola ordina i risultati in ordine crescente, se è necessario disporli in ordine decrescente è necessario utilizzare esplicitamente "DESC".

Sintassi

Di seguito è riportato l'elenco delle colonne SELEZIONA di sintassi

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

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome EMPLOYEES come -

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)

E se abbiamo inserito 4 record in esso utilizzando le istruzioni INSERT come -

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'istruzione seguente recupera il contenuto della tabella DIPENDENTE in ordine crescente di età.

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)

Puoi anche recuperare i dati in ordine decrescente utilizzando DESC come -

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)

Clausola ORDER BY utilizzando Python

Per recuperare il contenuto di una tabella in un ordine specifico, richiamare il execute() sull'oggetto cursore e passare l'istruzione SELECT insieme alla clausola ORDER BY, come parametro ad essa.

Esempio

Nell'esempio seguente creiamo una tabella con nome e Employee, la popoliamo e ne recuperiamo i record nell'ordine (crescente) della loro età, utilizzando la clausola 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()

Produzione

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

Allo stesso modo è possibile recuperare i dati da una tabella in ordine decrescente utilizzando la clausola ORDER BY.

Esempio

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

Produzione

[
   ('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'operazione su qualsiasi database aggiorna uno o più record, che sono già disponibili nel database. È possibile aggiornare i valori dei record esistenti in MySQL utilizzando l'istruzione UPDATE. Per aggiornare righe specifiche, è necessario utilizzare la clausola WHERE insieme ad essa.

Sintassi

Di seguito è riportata la sintassi dell'istruzione UPDATE in MySQL:

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

È possibile combinare un numero N di condizioni utilizzando gli operatori AND o OR.

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome EMPLOYEES come -

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)

E se abbiamo inserito 4 record in esso utilizzando le istruzioni INSERT come -

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

A seguito della dichiarazione MySQL, l'età di tutti i dipendenti maschi aumenta di un anno -

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

Se recuperi il contenuto della tabella, puoi vedere i valori aggiornati come:

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)

Aggiornare i contenuti di una tabella usando Python

Per aggiornare i record in una tabella in MySQL usando python -

• importare mysql.connector pacchetto.

• Crea un oggetto connessione usando il mysql.connector.connect() , passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Crea un oggetto cursore richiamando il file cursor() metodo sull'oggetto connessione creato sopra.

• Quindi, eseguire l' istruzione UPDATE passandola come parametro al fileexecute() metodo.

Esempio

L'esempio seguente aumenta di un anno l'età di tutti i maschi.

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

Produzione

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

Per eliminare i record da una tabella MySQL, è necessario utilizzare l'estensione DELETE FROMdichiarazione. Per rimuovere record specifici, è necessario utilizzare la clausola WHERE insieme ad essa.

Sintassi

Di seguito è riportata la sintassi della query DELETE in MYSQL:

DELETE FROM table_name [WHERE Clause]

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome EMPLOYEES come -

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)

E se abbiamo inserito 4 record in esso utilizzando le istruzioni INSERT come -

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

La seguente istruzione MySQL cancella il record del dipendente con FIRST_NAME "Mac" .

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

Se recuperi il contenuto della tabella, puoi vedere solo 3 record poiché ne abbiamo eliminato uno.

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)

Se si esegue l'istruzione DELETE senza la clausola WHERE, tutti i record della tabella specificata verranno eliminati.

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

Se recuperi il contenuto della tabella, otterrai un set vuoto come mostrato di seguito -

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

Rimozione dei record di una tabella utilizzando Python

L'operazione DELETE è necessaria quando si desidera eliminare alcuni record dal database.

Per eliminare i record in una tabella:

• importare mysql.connector pacchetto.

• Crea un oggetto connessione usando il mysql.connector.connect() , passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Crea un oggetto cursore invocando il metodo cursor () sull'oggetto connessione creato sopra.

• Quindi, esegui il file DELETE passandola come parametro al file execute() metodo.

Esempio

Il seguente programma elimina tutti i record dal DIPENDENTE la cui ETÀ è superiore a 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()

Produzione

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

Puoi rimuovere un'intera tabella utilizzando il file DROP TABLEdichiarazione. Devi solo specificare il nome della tabella che devi eliminare.

Sintassi

Di seguito è riportata la sintassi dell'istruzione DROP TABLE in MySQL:

DROP TABLE table_name;

Esempio

Prima di eliminare una tabella, ottenere l'elenco delle tabelle utilizzando l'istruzione SHOW TABLES come segue:

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

La seguente istruzione rimuove completamente la tabella denominata sample dal database:

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

Poiché abbiamo cancellato la tabella denominata sample da MySQL, se ottieni nuovamente l'elenco delle tabelle non troverai il nome della tabella sample in essa.

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

Rimuovere una tabella utilizzando Python

È possibile eliminare una tabella ogni volta che è necessario, utilizzando l'istruzione DROP di MYSQL, ma è necessario fare molta attenzione durante l'eliminazione di qualsiasi tabella esistente perché i dati persi non verranno recuperati dopo l'eliminazione di una tabella.

Per eliminare una tabella da un database MYSQL utilizzando python, richiamare il file execute() sull'oggetto cursore e passargli l'istruzione drop come parametro.

Esempio

La tabella seguente elimina una tabella denominata EMPLOYEE dal database.

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

Produzione

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

Elimina tabella solo se esiste

Se si tenta di eliminare una tabella che non esiste nel database, si verifica un errore come:

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

È possibile evitare questo errore verificando se la tabella esiste prima di eliminarla, aggiungendo IF EXISTS all'istruzione 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',)]

Mentre si recuperano i record se si desidera limitarli a un numero particolare, è possibile farlo utilizzando la clausola LIMIT di MYSQL.

Esempio

Supponiamo di aver creato una tabella in MySQL con il nome EMPLOYEES come -

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)

E se abbiamo inserito 4 record in esso utilizzando le istruzioni INSERT come -

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

La seguente istruzione SQL recupera i primi due record della tabella Employee utilizzando la clausola 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)

Clausola limite utilizzando Python

Se invochi il file execute() sull'oggetto cursore passando la query SELECT insieme alla clausola LIMIT, è possibile recuperare il numero di record richiesto.

Esempio

Il seguente esempio di python crea e popola una tabella con nome EMPLOYEE e, utilizzando la clausola LIMIT, ne recupera i primi due record.

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

Produzione

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

LIMIT con OFFSET

Se è necessario limitare i record a partire dall'ennesimo record (non dal primo), è possibile farlo utilizzando OFFSET insieme a 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)]

Dopo aver diviso i dati in due tabelle, è possibile recuperare i record combinati da queste due tabelle utilizzando i join.

Esempio

Supponiamo di aver creato una tabella con il nome EMPLOYEE e di aver inserito i dati in essa come mostrato di seguito -

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

Quindi, se abbiamo creato un'altra tabella e l'abbiamo popolata come -

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

La seguente istruzione recupera i dati combinando i valori in queste due tabelle:

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 utilizzando Python

L'esempio seguente recupera i dati dalle due tabelle precedenti combinate per colonna contatto della tabella EMPLOYEE e colonna ID della tabella CONTATTI.

Esempio

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

Produzione

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

Il MySQLCursor di mysql-connector-python (e librerie simili) viene utilizzato per eseguire istruzioni per comunicare con il database MySQL.

Usando i metodi di esso è possibile eseguire istruzioni SQL, recuperare dati dai set di risultati, chiamare procedure.

Puoi creare Cursor oggetto utilizzando il metodo cursor () dell'oggetto / classe Connection.

Esempio

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

Metodi

Di seguito sono riportati i vari metodi forniti dalla classe / oggetto Cursor.

Suor n	Metodi e descrizione
1	callproc() Questo metodo viene utilizzato per chiamare le procedure esistenti database MySQL.
2	close() Questo metodo viene utilizzato per chiudere l'oggetto cursore corrente.
3	Info() Questo metodo fornisce informazioni sull'ultima query.
4	executemany() Questo metodo accetta una serie di elenchi di elenchi di parametri. Prepara una query MySQL e la esegue con tutti i parametri.
5	execute() Questo metodo accetta una query MySQL come parametro ed esegue la query data.
6	fetchall() Questo metodo recupera tutte le righe nel set di risultati di una query e le restituisce come elenco di tuple. (Se lo eseguiamo dopo aver recuperato poche righe, restituisce quelle rimanenti)
7	fetchone() Questo metodo recupera la riga successiva nel risultato di una query e la restituisce come una tupla.
8	fetchmany() Questo metodo è simile a fetchone () ma recupera la serie successiva di righe nella serie di risultati di una query, invece di una singola riga.
9	fetchwarnings() Questo metodo restituisce gli avvisi generati dall'ultima query eseguita.

Proprietà

Di seguito sono riportate le proprietà della classe Cursor:

Suor n	Proprietà e descrizione
1	column_names Questa è una proprietà di sola lettura che restituisce l'elenco contenente i nomi di colonna di un set di risultati.
2	description Questa è una proprietà di sola lettura che restituisce l'elenco contenente la descrizione delle colonne in un set di risultati.
3	lastrowid Questa è una proprietà di sola lettura, se nella tabella sono presenti colonne con incremento automatico, restituisce il valore generato per quella colonna nell'ultima operazione INSERT o UPDATE.
4	rowcount Restituisce il numero di righe restituite / aggiornate in caso di operazioni SELECT e UPDATE.
5	statement Questa proprietà restituisce l'ultima istruzione eseguita.