Database
 sql >> Database >  >> RDS >> Database

Introduzione alle librerie Python SQL

Tutte le applicazioni software interagiscono con i dati , più comunemente tramite un sistema di gestione di database (DBMS). Alcuni linguaggi di programmazione sono dotati di moduli che puoi utilizzare per interagire con un DBMS, mentre altri richiedono l'uso di pacchetti di terze parti. In questo tutorial esplorerai le diverse librerie Python SQL che puoi usare. Svilupperai un'applicazione semplice per interagire con i database SQLite, MySQL e PostgreSQL.

In questo tutorial imparerai come:

  • Connetti a diversi sistemi di gestione di database con librerie Python SQL
  • Interagisci con database SQLite, MySQL e PostgreSQL
  • Esegui query di database comuni utilizzando un'applicazione Python
  • Sviluppare applicazioni su database diversi utilizzando uno script Python

Per ottenere il massimo da questo tutorial, dovresti avere una conoscenza di base di Python, SQL e lavorare con i sistemi di gestione dei database. Dovresti anche essere in grado di scaricare e importare pacchetti in Python e sapere come installare ed eseguire diversi server di database in locale o in remoto.

Download PDF gratuito: Foglio informativo di Python 3


Comprendere lo schema del database

In questo tutorial, svilupperai un database molto piccolo per un'applicazione di social media. Il database sarà composto da quattro tabelle:

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

Di seguito viene mostrato un diagramma di alto livello dello schema del database:

Entrambi gli users e posts avrà una relazione uno-a-molti poiché un utente può mettere mi piace a molti post. Allo stesso modo, un utente può pubblicare molti commenti e un post può anche avere più commenti. Quindi, entrambi gli users e posts avrà anche relazioni uno-a-molti con i comments tavolo. Questo vale anche per i likes tabella, quindi entrambi users e posts avrà una relazione uno-a-molti con i likes tabella.



Utilizzo delle librerie SQL Python per la connessione a un database

Prima di interagire con qualsiasi database tramite una libreria SQL Python, devi connetterti a quel database. In questa sezione vedrai come connetterti ai database SQLite, MySQL e PostgreSQL dall'interno di un'applicazione Python.

Nota: Avrai bisogno di server MySQL e PostgreSQL attivi e in esecuzione prima di eseguire gli script nelle sezioni del database MySQL e PostgreSQL. Per una rapida introduzione su come avviare un server MySQL, dai un'occhiata alla sezione MySQL di Avvio di un progetto Django. Per informazioni su come creare un database in PostgreSQL, consulta la sezione Configurazione di un database di Prevenzione degli attacchi SQL Injection con Python.

Si consiglia di creare tre diversi file Python, in modo da averne uno per ciascuno dei tre database. Eseguirai lo script per ogni database nel file corrispondente.


SQLite

SQLite è probabilmente il database più semplice a cui connettersi con un'applicazione Python poiché non è necessario installare alcun modulo SQL Python esterno per farlo. Per impostazione predefinita, l'installazione di Python contiene una libreria SQL Python denominata sqlite3 che puoi utilizzare per interagire con un database SQLite.

Inoltre, i database SQLite sono serverless e autonoma , poiché leggono e scrivono dati in un file. Ciò significa che, a differenza di MySQL e PostgreSQL, non è nemmeno necessario installare ed eseguire un server SQLite per eseguire operazioni sul database!

Ecco come usi sqlite3 per connettersi a un database SQLite in Python:

 1import sqlite3
 2from sqlite3 import Error
 3
 4def create_connection(path):
 5    connection = None
 6    try:
 7        connection = sqlite3.connect(path)
 8        print("Connection to SQLite DB successful")
 9    except Error as e:
10        print(f"The error '{e}' occurred")
11
12    return connection

Ecco come funziona questo codice:

  • Righe 1 e 2 importa sqlite3 e l'Error del modulo classe.
  • Riga 4 definisce una funzione .create_connection() che accetta il percorso del database SQLite.
  • Riga 7 utilizza .connect() da sqlite3 modulo e prende il percorso del database SQLite come parametro. Se il database esiste nella posizione specificata, viene stabilita una connessione al database. In caso contrario, viene creato un nuovo database nella posizione specificata e viene stabilita una connessione.
  • Riga 8 stampa lo stato della connessione al database riuscita.
  • Riga 9 rileva qualsiasi eccezione che potrebbe essere generata se .connect() non riesce a stabilire una connessione.
  • Riga 10 visualizza il messaggio di errore nella console.

sqlite3.connect(path) restituisce una connection oggetto, che a sua volta viene restituito da create_connection() . Questa connection oggetto può essere utilizzato per eseguire query su un database SQLite. Il seguente script crea una connessione al database SQLite:

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

Una volta eseguito lo script sopra, vedrai che un file di database sm_app.sqlite viene creato nella directory principale. Tieni presente che puoi modificare la posizione in modo che corrisponda alla tua configurazione.



MySQL

A differenza di SQLite, non esiste un modulo SQL Python predefinito che puoi utilizzare per connetterti a un database MySQL. Dovrai invece installare un driver Python SQL per MySQL per interagire con un database MySQL dall'interno di un'applicazione Python. Uno di questi driver è mysql-connector-python . Puoi scaricare questo modulo Python SQL con pip :

$ pip install mysql-connector-python

Nota che MySQL è un basato su server sistema di gestione della banca dati. Un server MySQL può avere più database. A differenza di SQLite, dove creare una connessione equivale a creare un database, un database MySQL ha un processo in due fasi per la creazione del database:

  1. Crea una connessione a un server MySQL.
  2. Esegui una query separata per creare il database.

Definisci una funzione che si connetta al server del database MySQL e restituisca l'oggetto connessione:

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection(host_name, user_name, user_password):
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect(
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        )
12        print("Connection to MySQL DB successful")
13    except Error as e:
14        print(f"The error '{e}' occurred")
15
16    return connection
17
18connection = create_connection("localhost", "root", "")

Nello script sopra, definisci una funzione create_connection() che accetta tre parametri:

  1. nome_host
  2. nome_utente
  3. password_utente

Il mysql.connector Il modulo Python SQL contiene un metodo .connect() che usi nella riga 7 per connetterti a un server di database MySQL. Una volta stabilita la connessione, il connection l'oggetto viene restituito alla funzione chiamante. Infine, nella riga 18 chiami create_connection() con il nome host, il nome utente e la password.

Finora, hai solo stabilito la connessione. Il database non è ancora stato creato. Per fare ciò, definirai un'altra funzione create_database() che accetta due parametri:

  1. connection è la connection oggetto al server di database con cui vuoi interagire.
  2. query è la query che crea il database.

Ecco come appare questa funzione:

def create_database(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Per eseguire le query, usa il cursor oggetto. La query da eseguire viene passato a cursor.execute() in formato stringa.

Crea un database chiamato sm_app per la tua app di social media nel server di database MySQL:

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

Ora hai creato un database sm_app sul server di database. Tuttavia, la connection oggetto restituito da create_connection() è connesso al server del database MySQL. Devi connetterti a sm_app Banca dati. Per farlo, puoi modificare create_connection() come segue:

 1def create_connection(host_name, user_name, user_password, db_name):
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect(
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        )
10        print("Connection to MySQL DB successful")
11    except Error as e:
12        print(f"The error '{e}' occurred")
13
14    return connection

Puoi vedere nella riga 8 che create_connection() ora accetta un parametro aggiuntivo chiamato db_name . Questo parametro specifica il nome del database a cui ci si vuole connettere. Puoi passare il nome del database a cui vuoi connetterti quando chiami questa funzione:

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

Lo script sopra richiama con successo create_connection() e si connette a sm_app banca dati.



PostgreSQL

Come MySQL, non esiste una libreria Python SQL predefinita che puoi utilizzare per interagire con un database PostgreSQL. Invece, devi installare un driver SQL Python di terze parti per interagire con PostgreSQL. Uno di questi driver Python SQL per PostgreSQL è psycopg2 . Esegui il seguente comando sul tuo terminale per installare psycopg2 Modulo Python SQL:

$ pip install psycopg2

Come con i database SQLite e MySQL, definirai create_connection() per stabilire una connessione con il tuo database PostgreSQL:

import psycopg2
from psycopg2 import OperationalError

def create_connection(db_name, db_user, db_password, db_host, db_port):
    connection = None
    try:
        connection = psycopg2.connect(
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        )
        print("Connection to PostgreSQL DB successful")
    except OperationalError as e:
        print(f"The error '{e}' occurred")
    return connection

Usi psycopg2.connect() per connettersi a un server PostgreSQL dall'interno della tua applicazione Python.

Puoi quindi utilizzare create_connection() per creare una connessione a un database PostgreSQL. Innanzitutto, effettuerai una connessione con il database predefinito postgres utilizzando la seguente stringa:

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

Successivamente, devi creare il database sm_app all'interno del postgres predefinito Banca dati. Puoi definire una funzione per eseguire qualsiasi query SQL in PostgreSQL. Di seguito, definisci create_database() per creare un nuovo database nel server di database PostgreSQL:

def create_database(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

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

Dopo aver eseguito lo script sopra, vedrai sm_app database nel tuo server di database PostgreSQL.

Prima di eseguire query su sm_app database, devi connetterti ad esso:

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

Una volta eseguito lo script precedente, verrà stabilita una connessione con sm_app database situato nel postgres server di database. Qui, 127.0.0.1 fa riferimento all'indirizzo IP dell'host del server di database e 5432 fa riferimento al numero di porta del server di database.




Creazione di tabelle

Nella sezione precedente, hai visto come connetterti ai server di database SQLite, MySQL e PostgreSQL utilizzando diverse librerie Python SQL. Hai creato sm_app database su tutti e tre i server di database. In questa sezione, vedrai come creare tabelle all'interno di questi tre database.

Come discusso in precedenza, creerai quattro tabelle:

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

Inizierai con SQLite.


SQLite

Per eseguire query in SQLite, usa cursor.execute() . In questa sezione definirai una funzione execute_query() che utilizza questo metodo. La tua funzione accetterà la connection oggetto e una stringa di query, che passerai a cursor.execute() .

.execute() può eseguire qualsiasi query passata sotto forma di stringa. Utilizzerai questo metodo per creare tabelle in questa sezione. Nelle prossime sezioni, utilizzerai lo stesso metodo anche per eseguire l'aggiornamento e per eliminare le query.

Nota: Questo script dovrebbe essere eseguito nello stesso file in cui hai creato la connessione per il tuo database SQLite.

Ecco la definizione della tua funzione:

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Questo codice tenta di eseguire la query specificata e stampa un messaggio di errore, se necessario.

Quindi, scrivi la tua query :

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

Questo dice di creare una tabella users con le seguenti cinque colonne:

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

Infine, chiamerai execute_query() per creare la tabella. Passerai la connection oggetto che hai creato nella sezione precedente, insieme a create_users_table stringa che contiene la query di creazione tabella:

execute_query(connection, create_users_table)

La seguente query viene utilizzata per creare i posts tabella:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts(
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id)
);
"""

Poiché esiste una relazione uno-a-molti tra gli users e posts , puoi vedere una chiave esterna user_id nei posts tabella che fa riferimento all'id nella colonna users tavolo. Esegui il seguente script per creare i posts tabella:

execute_query(connection, create_posts_table)

Infine, puoi creare i comments e likes tabelle con il seguente script:

create_comments_table = """
CREATE TABLE IF NOT EXISTS comments (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  text TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  post_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

create_likes_table = """
CREATE TABLE IF NOT EXISTS likes (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  user_id INTEGER NOT NULL, 
  post_id integer NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

execute_query(connection, create_comments_table)  
execute_query(connection, create_likes_table)

Puoi vedere che creazione di tabelle in SQLite è molto simile all'utilizzo di SQL grezzo. Tutto quello che devi fare è memorizzare la query in una variabile stringa e quindi passare quella variabile a cursor.execute() .



MySQL

Utilizzerai mysql-connector-python Modulo Python SQL per creare tabelle in MySQL. Proprio come con SQLite, devi passare la tua query a cursor.execute() , che viene restituito chiamando .cursor() sulla connection oggetto. Puoi creare un'altra funzione execute_query() che accetta la connection e query stringa:

 1def execute_query(connection, query):
 2    cursor = connection.cursor()
 3    try:
 4        cursor.execute(query)
 5        connection.commit()
 6        print("Query executed successfully")
 7    except Error as e:
 8        print(f"The error '{e}' occurred")

Nella riga 4, passi la query a cursor.execute() .

Ora puoi creare i tuoi users tabella utilizzando questa funzione:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INT AUTO_INCREMENT, 
  name TEXT NOT NULL, 
  age INT, 
  gender TEXT, 
  nationality TEXT, 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_users_table)

La query per l'implementazione della relazione di chiave esterna è leggermente diversa in MySQL rispetto a SQLite. Inoltre, MySQL utilizza AUTO_INCREMENT parola chiave (rispetto a SQLite AUTOINCREMENT parola chiave) per creare colonne in cui i valori vengono incrementati automaticamente quando vengono inseriti nuovi record.

Il seguente script crea i posts tabella, che contiene una chiave esterna user_id che fa riferimento all'id colonna degli users tabella:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id INT AUTO_INCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY fk_user_id (user_id) REFERENCES users(id), 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_posts_table)

Allo stesso modo, per creare i comments e likes tabelle, puoi passare il corrispondente CREATE interroga su execute_query() .



PostgreSQL

Come con i database SQLite e MySQL, la connection oggetto restituito da psycopg2.connect() contiene un cursor oggetto. Puoi usare cursor.execute() per eseguire query Python SQL sul tuo database PostgreSQL.

Definisci una funzione execute_query() :

def execute_query(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

Puoi utilizzare questa funzione per creare tabelle, inserire record, modificare record ed eliminare record nel tuo database PostgreSQL.

Ora crea gli users tabella all'interno di sm_app banca dati:

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

execute_query(connection, create_users_table)

Puoi vedere che la query per creare gli users tabella in PostgreSQL è leggermente diversa da SQLite e MySQL. Qui, la parola chiave SERIAL viene utilizzato per creare colonne che si incrementano automaticamente. Ricordiamo che MySQL utilizza la parola chiave AUTO_INCREMENT .

Inoltre, anche il riferimento alla chiave esterna è specificato in modo diverso, come mostrato nello script seguente che crea i posts tabella:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id SERIAL PRIMARY KEY, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER REFERENCES users(id)
)
"""

execute_query(connection, create_posts_table)

Per creare i comments tabella, dovrai scrivere un CREATE interrogare i comments tabella e passalo a execute_query() . Il processo per creare i likes il tavolo è lo stesso. Devi solo modificare il CREATE query per creare i likes tabella invece dei comments tabella.




Inserimento di record

Nella sezione precedente, hai visto come creare tabelle nei tuoi database SQLite, MySQL e PostgreSQL utilizzando diversi moduli Python SQL. In questa sezione vedrai come inserire record nelle tue tabelle.


SQLite

Per inserire record nel tuo database SQLite, puoi utilizzare lo stesso execute_query() funzione utilizzata per creare tabelle. Innanzitutto, devi memorizzare il tuo INSERT INTO interrogare in una stringa. Quindi, puoi passare la connection oggetto e query stringa in execute_query() . Inseriamo cinque record negli users tabella:

create_users = """
INSERT INTO
  users (name, age, gender, nationality)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)

Poiché hai impostato l'id colonna per l'incremento automatico, non è necessario specificare il valore di id colonna per questi users . Gli users la tabella compilerà automaticamente questi cinque record con id valori da 1 a 5 .

Ora inserisci sei record nei posts tabella:

create_posts = """
INSERT INTO
  posts (title, description, user_id)
VALUES
  ("Happy", "I am feeling very happy today", 1),
  ("Hot Weather", "The weather is very hot today", 2),
  ("Help", "I need some help with my work", 2),
  ("Great News", "I am getting married", 1),
  ("Interesting Game", "It was a fantastic game of tennis", 5),
  ("Party", "Anyone up for a late-night party today?", 3);
"""

execute_query(connection, create_posts)

È importante ricordare che user_id colonna dei posts table è una chiave straniera che fa riferimento all'id colonna degli users tavolo. Ciò significa che il user_id la colonna deve contenere un valore che esiste già nel id colonna degli users tavolo. Se non esiste, vedrai un errore.

Allo stesso modo, lo script seguente inserisce i record nei comments e likes tabelle:

create_comments = """
INSERT INTO
  comments (text, user_id, post_id)
VALUES
  ('Count me in', 1, 6),
  ('What sort of help?', 5, 3),
  ('Congrats buddy', 2, 4),
  ('I was rooting for Nadal though', 4, 5),
  ('Help with your thesis?', 2, 3),
  ('Many congratulations', 5, 4);
"""

create_likes = """
INSERT INTO
  likes (user_id, post_id)
VALUES
  (1, 6),
  (2, 3),
  (1, 5),
  (5, 4),
  (2, 4),
  (4, 2),
  (3, 6);
"""

execute_query(connection, create_comments)
execute_query(connection, create_likes)

In entrambi i casi, memorizzi il tuo INSERT INTO interrogare come stringa ed eseguirlo con execute_query() .



MySQL

Esistono due modi per inserire record nei database MySQL da un'applicazione Python. Il primo approccio è simile a SQLite. Puoi memorizzare il INSERT INTO interrogare in una stringa e quindi utilizzare cursor.execute() per inserire i record.

In precedenza, hai definito una funzione wrapper execute_query() che hai usato per inserire i record. Puoi usare questa stessa funzione ora per inserire record nella tua tabella MySQL. Il seguente script inserisce i record negli users tabella usando execute_query() :

create_users = """
INSERT INTO
  `users` (`name`, `age`, `gender`, `nationality`)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)

Il secondo approccio utilizza cursor.executemany() , che accetta due parametri:

  1. La query stringa contenente i segnaposto per i record da inserire
  2. L'elenco di record che vuoi inserire

Guarda il seguente esempio, che inserisce due record nei likes tabella:

sql = "INSERT INTO likes ( user_id, post_id ) VALUES ( %s, %s )"
val = [(4, 5), (3, 4)]

cursor = connection.cursor()
cursor.executemany(sql, val)
connection.commit()

Sta a te decidere quale approccio scegliere per inserire i record nella tua tabella MySQL. Se sei un esperto di SQL, puoi utilizzare .execute() . Se non hai molta dimestichezza con SQL, potrebbe essere più semplice usare .executemany() . Con uno dei due approcci, puoi inserire correttamente i record nei posts , comments e likes tabelle.



PostgreSQL

Nella sezione precedente, hai visto due approcci per l'inserimento di record nelle tabelle del database SQLite. Il primo utilizza una query di stringa SQL e il secondo utilizza .executemany() . psycopg2 segue questo secondo approccio, sebbene .execute() viene utilizzato per eseguire una query basata su segnaposto.

Passi la query SQL con i segnaposto e l'elenco di record a .execute() . Ciascun record nell'elenco sarà una tupla, in cui i valori della tupla corrispondono ai valori delle colonne nella tabella del database. Ecco come puoi inserire record utente in users tabella in un database PostgreSQL:

users = [
    ("James", 25, "male", "USA"),
    ("Leila", 32, "female", "France"),
    ("Brigitte", 35, "female", "England"),
    ("Mike", 40, "male", "Denmark"),
    ("Elizabeth", 21, "female", "Canada"),
]

user_records = ", ".join(["%s"] * len(users))

insert_query = (
    f"INSERT INTO users (name, age, gender, nationality) VALUES {user_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, users)

Lo script sopra crea un elenco di users che contiene cinque record utente sotto forma di tuple. Successivamente, crei una stringa segnaposto con cinque elementi segnaposto (%s ) che corrispondono ai cinque record utente. La stringa segnaposto viene concatenata con la query che inserisce i record negli users tavolo. Infine, la stringa di query ei record utente vengono passati a .execute() . Lo script precedente inserisce correttamente cinque record negli users tabella.

Dai un'occhiata a un altro esempio di inserimento di record in una tabella PostgreSQL. Il seguente script inserisce i record nei posts tabella:

posts = [
    ("Happy", "I am feeling very happy today", 1),
    ("Hot Weather", "The weather is very hot today", 2),
    ("Help", "I need some help with my work", 2),
    ("Great News", "I am getting married", 1),
    ("Interesting Game", "It was a fantastic game of tennis", 5),
    ("Party", "Anyone up for a late-night party today?", 3),
]

post_records = ", ".join(["%s"] * len(posts))

insert_query = (
    f"INSERT INTO posts (title, description, user_id) VALUES {post_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, posts)

Puoi inserire record nei comments e likes tabelle con lo stesso approccio.




Selezione dei record

In questa sezione, vedrai come selezionare i record dalle tabelle del database utilizzando i diversi moduli Python SQL. In particolare, vedrai come eseguire SELECT query sui database SQLite, MySQL e PostgreSQL.


SQLite

Per selezionare i record utilizzando SQLite, puoi nuovamente utilizzare cursor.execute() . Tuttavia, dopo averlo fatto, dovrai chiamare .fetchall() . Questo metodo restituisce un elenco di tuple in cui ogni tupla è mappata alla riga corrispondente nei record recuperati.

Per semplificare il processo, puoi creare una funzione execute_read_query() :

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Questa funzione accetta la connection oggetto e il SELECT interroga e restituisce il record selezionato.


SELECT

Ora selezioniamo tutti i record dagli users tabella:

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

for user in users:
    print(user)

Nello script sopra, il SELECT query seleziona tutti gli utenti da users tavolo. Questo viene passato a execute_read_query() , che restituisce tutti i record degli users tavolo. I record vengono quindi esaminati e stampati sulla console.

Nota: Non è consigliabile utilizzare SELECT * su tabelle di grandi dimensioni poiché può comportare un numero elevato di operazioni di I/O che aumentano il traffico di rete.

L'output della query precedente è simile al seguente:

(1, 'James', 25, 'male', 'USA')
(2, 'Leila', 32, 'female', 'France')
(3, 'Brigitte', 35, 'female', 'England')
(4, 'Mike', 40, 'male', 'Denmark')
(5, 'Elizabeth', 21, 'female', 'Canada')

Allo stesso modo, puoi recuperare tutti i record dai posts tabella con lo script seguente:

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

for post in posts:
    print(post)

L'output è simile a questo:

(1, 'Happy', 'I am feeling very happy today', 1)
(2, 'Hot Weather', 'The weather is very hot today', 2)
(3, 'Help', 'I need some help with my work', 2)
(4, 'Great News', 'I am getting married', 1)
(5, 'Interesting Game', 'It was a fantastic game of tennis', 5)
(6, 'Party', 'Anyone up for a late-night party today?', 3)

Il risultato mostra tutti i record nei posts tabella.



JOIN

Puoi anche eseguire query complesse che coinvolgono JOIN operazioni per recuperare i dati da due tabelle correlate. For instance, the following script returns the user ids and names, along with the description of the posts that these users posted:

select_users_posts = """
SELECT
  users.id,
  users.name,
  posts.description
FROM
  posts
  INNER JOIN users ON users.id = posts.user_id
"""

users_posts = execute_read_query(connection, select_users_posts)

for users_post in users_posts:
    print(users_post)

Here’s the output:

(1, 'James', 'I am feeling very happy today')
(2, 'Leila', 'The weather is very hot today')
(2, 'Leila', 'I need some help with my work')
(1, 'James', 'I am getting married')
(5, 'Elizabeth', 'It was a fantastic game of tennis')
(3, 'Brigitte', 'Anyone up for a late night party today?')

You can also select data from three related tables by implementing multiple JOIN operators . The following script returns all posts, along with the comments on the posts and the names of the users who posted the comments:

select_posts_comments_users = """
SELECT
  posts.description as post,
  text as comment,
  name
FROM
  posts
  INNER JOIN comments ON posts.id = comments.post_id
  INNER JOIN users ON users.id = comments.user_id
"""

posts_comments_users = execute_read_query(
    connection, select_posts_comments_users
)

for posts_comments_user in posts_comments_users:
    print(posts_comments_user)

The output looks like this:

('Anyone up for a late night party today?', 'Count me in', 'James')
('I need some help with my work', 'What sort of help?', 'Elizabeth')
('I am getting married', 'Congrats buddy', 'Leila')
('It was a fantastic game of tennis', 'I was rooting for Nadal though', 'Mike')
('I need some help with my work', 'Help with your thesis?', 'Leila')
('I am getting married', 'Many congratulations', 'Elizabeth')

You can see from the output that the column names are not being returned by .fetchall() . To return column names, you can use the .description attribute of the cursor oggetto. For instance, the following list returns all the column names for the above query:

cursor = connection.cursor()
cursor.execute(select_posts_comments_users)
cursor.fetchall()

column_names = [description[0] for description in cursor.description]
print(column_names)

The output looks like this:

['post', 'comment', 'name']

You can see the names of the columns for the given query.



WHERE

Now you’ll execute a SELECT query that returns the post, along with the total number of likes that the post received:

select_post_likes = """
SELECT
  description as Post,
  COUNT(likes.id) as Likes
FROM
  likes,
  posts
WHERE
  posts.id = likes.post_id
GROUP BY
  likes.post_id
"""

post_likes = execute_read_query(connection, select_post_likes)

for post_like in post_likes:
    print(post_like)

The output is as follows:

('The weather is very hot today', 1)
('I need some help with my work', 1)
('I am getting married', 2)
('It was a fantastic game of tennis', 1)
('Anyone up for a late night party today?', 2)

By using a WHERE clause, you’re able to return more specific results.




MySQL

The process of selecting records in MySQL is absolutely identical to selecting records in SQLite. You can use cursor.execute() followed by .fetchall() . The following script creates a wrapper function execute_read_query() that you can use to select records:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Now select all the records from the users table:

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

for user in users:
    print(user)

The output will be similar to what you saw with SQLite.



PostgreSQL

The process of selecting records from a PostgreSQL table with the psycopg2 Python SQL module is similar to what you did with SQLite and MySQL. Again, you’ll use cursor.execute() followed by .fetchall() to select records from your PostgreSQL table. The following script selects all the records from the users table and prints them to the console:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except OperationalError as e:
        print(f"The error '{e}' occurred")

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

for user in users:
    print(user)

Again, the output will be similar to what you’ve seen before.




Updating Table Records

In the last section, you saw how to select records from SQLite, MySQL, and PostgreSQL databases. In this section, you’ll cover the process for updating records using the Python SQL libraries for SQLite, PostgresSQL, and MySQL.


SQLite

Updating records in SQLite is pretty straightforward. You can again make use of execute_query() . As an example, you can update the description of the post with an id of 2 . First, SELECT the description of this post:

select_post_description = "SELECT description FROM posts WHERE id = 2"

post_description = execute_read_query(connection, select_post_description)

for description in post_description:
    print(description)

You should see the following output:

('The weather is very hot today',)

The following script updates the description:

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Now, if you execute the SELECT query again, you should see the following result:

('The weather has become pleasant now',)

The output has been updated.



MySQL

The process of updating records in MySQL with mysql-connector-python is also a carbon copy of the sqlite3 Python SQL module. You need to pass the string query to cursor.execute() . For example, the following script updates the description of the post with an id of 2 :

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Again, you’ve used your wrapper function execute_query() to update the post description.



PostgreSQL

The update query for PostgreSQL is similar to what you’ve seen with SQLite and MySQL. You can use the above scripts to update records in your PostgreSQL table.




Deleting Table Records

In this section, you’ll see how to delete table records using the Python SQL modules for SQLite, MySQL, and PostgreSQL databases. The process of deleting records is uniform for all three databases since the DELETE query for the three databases is the same.


SQLite

You can again use execute_query() to delete records from YOUR SQLite database. All you have to do is pass the connection object and the string query for the record you want to delete to execute_query() . Then, execute_query() will create a cursor object using the connection and pass the string query to cursor.execute() , which will delete the records.

As an example, try to delete the comment with an id of 5 :

delete_comment = "DELETE FROM comments WHERE id = 5"
execute_query(connection, delete_comment)

Now, if you select all the records from the comments table, you’ll see that the fifth comment has been deleted.



MySQL

The process for deletion in MySQL is also similar to SQLite, as shown in the following example:

delete_comment = "DELETE FROM comments WHERE id = 2"
execute_query(connection, delete_comment)

Here, you delete the second comment from the sm_app database’s comments table in your MySQL database server.



PostgreSQL

The delete query for PostgreSQL is also similar to SQLite and MySQL. You can write a delete query string by using the DELETE keyword and then passing the query and the connection object to execute_query() . This will delete the specified records from your PostgreSQL database.




Conclusion

In this tutorial, you’ve learned how to use three common Python SQL libraries. sqlite3 , mysql-connector-python , and psycopg2 allow you to connect a Python application to SQLite, MySQL, and PostgreSQL databases, respectively.

Now you can:

  • Interact with SQLite, MySQL, or PostgreSQL databases
  • Use three different Python SQL modules
  • Execute SQL queries on various databases from within a Python application

However, this is just the tip of the iceberg! There are also Python SQL libraries for object-relational mapping , such as SQLAlchemy and Django ORM, that automate the task of database interaction in Python. You’ll learn more about these libraries in other tutorials in our Python databases section.