Giới thiệu về Thư viện SQL Python

Tất cả các ứng dụng phần mềm tương tác với dữ liệu , phổ biến nhất là thông qua hệ thống quản lý cơ sở dữ liệu (DBMS). Một số ngôn ngữ lập trình đi kèm với các mô-đun mà bạn có thể sử dụng để tương tác với DBMS, trong khi những ngôn ngữ khác yêu cầu sử dụng các gói của bên thứ ba. Trong hướng dẫn này, bạn sẽ khám phá các thư viện Python SQL khác nhau mà bạn có thể sử dụng. Bạn sẽ phát triển một ứng dụng đơn giản để tương tác với cơ sở dữ liệu SQLite, MySQL và PostgreSQL.

Trong hướng dẫn này, bạn sẽ học cách:

• Kết nối tới các hệ thống quản lý cơ sở dữ liệu khác nhau với thư viện Python SQL
• Tương tác với cơ sở dữ liệu SQLite, MySQL và PostgreSQL
• Thực hiện các truy vấn cơ sở dữ liệu phổ biến bằng ứng dụng Python
• Phát triển ứng dụng trên các cơ sở dữ liệu khác nhau bằng cách sử dụng tập lệnh Python

Để tận dụng tối đa hướng dẫn này, bạn nên có kiến ​​thức về Python, SQL cơ bản và làm việc với các hệ quản trị cơ sở dữ liệu. Bạn cũng có thể tải xuống và nhập các gói bằng Python và biết cách cài đặt và chạy các máy chủ cơ sở dữ liệu khác nhau tại chỗ hoặc từ xa.

Tải xuống PDF miễn phí: Bảng lừa đảo Python 3

Hiểu lược đồ cơ sở dữ liệu

Trong hướng dẫn này, bạn sẽ phát triển một cơ sở dữ liệu rất nhỏ cho một ứng dụng mạng xã hội. Cơ sở dữ liệu sẽ bao gồm bốn bảng:

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

Sơ đồ cấp cao của lược đồ cơ sở dữ liệu được hiển thị bên dưới:

Cả users và posts sẽ có mối quan hệ một-nhiều vì một người dùng có thể thích nhiều bài đăng. Tương tự, một người dùng có thể đăng nhiều bình luận và một bài đăng cũng có thể có nhiều bình luận. Vì vậy, cả users và posts cũng sẽ có mối quan hệ một-nhiều với comments bàn. Điều này cũng áp dụng cho likes bảng, vì vậy cả users và posts sẽ có mối quan hệ một-nhiều với likes bảng.

Sử dụng thư viện SQL Python để kết nối với cơ sở dữ liệu

Trước khi bạn tương tác với bất kỳ cơ sở dữ liệu nào thông qua Thư viện SQL Python, bạn phải kết nối vào cơ sở dữ liệu đó. Trong phần này, bạn sẽ thấy cách kết nối với cơ sở dữ liệu SQLite, MySQL và PostgreSQL từ bên trong ứng dụng Python.

Lưu ý: Bạn sẽ cần thiết lập và chạy các máy chủ MySQL và PostgreSQL trước khi thực thi các tập lệnh trong phần cơ sở dữ liệu MySQL và PostgreSQL. Để có phần giới thiệu nhanh về cách khởi động máy chủ MySQL, hãy xem phần MySQL của Khởi động dự án Django. Để tìm hiểu cách tạo cơ sở dữ liệu trong PostgreSQL, hãy xem phần Thiết lập cơ sở dữ liệu của Ngăn chặn tấn công SQL Injection với Python.

Bạn nên tạo ba tệp Python khác nhau để bạn có một tệp cho mỗi trong ba cơ sở dữ liệu. Bạn sẽ thực thi tập lệnh cho từng cơ sở dữ liệu trong tệp tương ứng của nó.

SQLite

SQLite có lẽ là cơ sở dữ liệu đơn giản nhất để kết nối với ứng dụng Python vì bạn không cần cài đặt bất kỳ mô-đun SQL Python bên ngoài nào để làm như vậy. Theo mặc định, cài đặt Python của bạn chứa thư viện Python SQL có tên sqlite3 mà bạn có thể sử dụng để tương tác với cơ sở dữ liệu SQLite.

Hơn nữa, cơ sở dữ liệu SQLite không có máy chủ và khép kín , vì chúng đọc và ghi dữ liệu vào một tệp. Điều này có nghĩa là, không giống như MySQL và PostgreSQL, bạn thậm chí không cần cài đặt và chạy máy chủ SQLite để thực hiện các hoạt động cơ sở dữ liệu!

Đây là cách bạn sử dụng sqlite3 để kết nối với cơ sở dữ liệu SQLite bằng 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

Đây là cách mã này hoạt động:

• Dòng 1 và 2 nhập sqlite3 và Error của mô-đun lớp học.
• Dòng 4 định nghĩa một hàm .create_connection() chấp nhận đường dẫn đến cơ sở dữ liệu SQLite.
• Dòng 7 sử dụng .connect() từ sqlite3 và lấy đường dẫn cơ sở dữ liệu SQLite làm tham số. Nếu cơ sở dữ liệu tồn tại ở vị trí được chỉ định, thì một kết nối với cơ sở dữ liệu sẽ được thiết lập. Nếu không, cơ sở dữ liệu mới sẽ được tạo tại vị trí đã chỉ định và kết nối được thiết lập.
• Dòng 8 in trạng thái của kết nối cơ sở dữ liệu thành công.
• Dòng 9 bắt bất kỳ ngoại lệ nào có thể được ném ra nếu .connect() không thiết lập được kết nối.
• Dòng 10 hiển thị thông báo lỗi trong bảng điều khiển.

sqlite3.connect(path) trả về một kết nối connection đối tượng này lần lượt được trả về bởi create_connection() . connection này đối tượng có thể được sử dụng để thực thi các truy vấn trên cơ sở dữ liệu SQLite. Tập lệnh sau tạo kết nối đến cơ sở dữ liệu SQLite:

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

Sau khi thực thi tập lệnh trên, bạn sẽ thấy rằng một tệp cơ sở dữ liệu sm_app.sqlite được tạo trong thư mục gốc. Lưu ý rằng bạn có thể thay đổi vị trí để phù hợp với thiết lập của mình.

MySQL

Không giống như SQLite, không có mô-đun Python SQL mặc định nào mà bạn có thể sử dụng để kết nối với cơ sở dữ liệu MySQL. Thay vào đó, bạn sẽ cần cài đặt Trình điều khiển SQL Python cho MySQL để tương tác với cơ sở dữ liệu MySQL từ bên trong ứng dụng Python. Một trong những trình điều khiển như vậy là mysql-connector-python . Bạn có thể tải xuống mô-đun SQL Python này bằng pip :

$ pip install mysql-connector-python

Lưu ý rằng MySQL là một dựa trên máy chủ hệ quản trị cơ sở dữ liệu. Một máy chủ MySQL có thể có nhiều cơ sở dữ liệu. Không giống như SQLite, nơi tạo kết nối tương đương với việc tạo cơ sở dữ liệu, cơ sở dữ liệu MySQL có quy trình hai bước để tạo cơ sở dữ liệu:

1. Tạo kết nối tới máy chủ MySQL.
2. Thực thi một truy vấn riêng biệt để tạo cơ sở dữ liệu.

Xác định một hàm kết nối với máy chủ cơ sở dữ liệu MySQL và trả về đối tượng kết nối:

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

Trong đoạn mã trên, bạn xác định một hàm create_connection() chấp nhận ba tham số:

1. host_name
2. user_name
3. user_password

mysql.connector Mô-đun SQL trong Python chứa một phương thức .connect() mà bạn sử dụng trong dòng 7 để kết nối với máy chủ cơ sở dữ liệu MySQL. Sau khi kết nối được thiết lập, connection đối tượng được trả về chức năng gọi. Cuối cùng, ở dòng 18, bạn gọi create_connection() với tên máy chủ, tên người dùng và mật khẩu.

Cho đến nay, bạn chỉ mới thiết lập kết nối. Cơ sở dữ liệu chưa được tạo. Để thực hiện việc này, bạn sẽ xác định một hàm khác create_database() chấp nhận hai tham số:

1. connection là connection phản đối máy chủ cơ sở dữ liệu mà bạn muốn tương tác.
2. query là truy vấn tạo cơ sở dữ liệu.

Đây là chức năng này trông như thế nào:

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

Để thực hiện các truy vấn, bạn sử dụng cursor vật. Truy vấn connection được thực thi được chuyển tới cursor.execute() ở định dạng chuỗi.

Tạo cơ sở dữ liệu có tên sm_app cho ứng dụng truyền thông xã hội của bạn trong máy chủ cơ sở dữ liệu MySQL:

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

Bây giờ bạn đã tạo cơ sở dữ liệu sm_app trên máy chủ cơ sở dữ liệu. Tuy nhiên, connection đối tượng được trả về bởi create_connection() được kết nối với máy chủ cơ sở dữ liệu MySQL. Bạn cần kết nối với sm_app cơ sở dữ liệu. Để làm như vậy, bạn có thể sửa đổi create_connection() như sau:

 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

Bạn có thể thấy trong dòng 8 rằng create_connection() bây giờ chấp nhận một tham số bổ sung được gọi là db_name . Tham số này chỉ định tên của cơ sở dữ liệu mà bạn muốn kết nối. Bạn có thể chuyển vào tên của cơ sở dữ liệu bạn muốn kết nối khi bạn gọi hàm này:

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

Tập lệnh trên gọi thành công create_connection() và kết nối với sm_app cơ sở dữ liệu.

PostgreSQL

Giống như MySQL, không có thư viện Python SQL mặc định nào mà bạn có thể sử dụng để tương tác với cơ sở dữ liệu PostgreSQL. Thay vào đó, bạn cần cài đặt trình điều khiển SQL Python bên thứ ba để tương tác với PostgreSQL. Một trình điều khiển Python SQL như vậy cho PostgreSQL là psycopg2 . Thực thi lệnh sau trên thiết bị đầu cuối của bạn để cài đặt psycopg2 Mô-đun SQL Python:

$ pip install psycopg2

Giống như với cơ sở dữ liệu SQLite và MySQL, bạn sẽ xác định create_connection() để tạo kết nối với cơ sở dữ liệu PostgreSQL của bạn:

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

Bạn sử dụng psycopg2.connect() để kết nối với máy chủ PostgreSQL từ trong ứng dụng Python của bạn.

Sau đó, bạn có thể sử dụng create_connection() để tạo kết nối đến cơ sở dữ liệu PostgreSQL. Trước tiên, bạn sẽ tạo kết nối với cơ sở dữ liệu mặc định postgres bằng cách sử dụng chuỗi sau:

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

Tiếp theo, bạn phải tạo cơ sở dữ liệu sm_app bên trong postgres mặc định cơ sở dữ liệu. Bạn có thể xác định một hàm để thực thi bất kỳ truy vấn SQL nào trong PostgreSQL. Dưới đây, bạn xác định create_database() để tạo cơ sở dữ liệu mới trong máy chủ cơ sở dữ liệu 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)

Sau khi chạy tập lệnh ở trên, bạn sẽ thấy sm_app cơ sở dữ liệu trong máy chủ cơ sở dữ liệu PostgreSQL của bạn.

Trước khi bạn thực hiện các truy vấn trên sm_app cơ sở dữ liệu, bạn cần kết nối với nó:

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

Khi bạn thực thi tập lệnh trên, kết nối sẽ được thiết lập với sm_app cơ sở dữ liệu nằm trong postgres máy chủ cơ sở dữ liệu. Đây, 127.0.0.1 đề cập đến địa chỉ IP của máy chủ cơ sở dữ liệu và 5432 đề cập đến số cổng của máy chủ cơ sở dữ liệu.

Tạo bảng

Trong phần trước, bạn đã biết cách kết nối với máy chủ cơ sở dữ liệu SQLite, MySQL và PostgreSQL bằng cách sử dụng các thư viện Python SQL khác nhau. Bạn đã tạo sm_app cơ sở dữ liệu trên cả ba máy chủ cơ sở dữ liệu. Trong phần này, bạn sẽ thấy cách tạo bảng bên trong ba cơ sở dữ liệu này.

Như đã thảo luận trước đó, bạn sẽ tạo bốn bảng:

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

Bạn sẽ bắt đầu với SQLite.

SQLite

Để thực thi các truy vấn trong SQLite, hãy sử dụng cursor.execute() . Trong phần này, bạn sẽ xác định một hàm execute_query() sử dụng phương pháp này. Hàm của bạn sẽ chấp nhận kết nối connection đối tượng và một chuỗi truy vấn mà bạn sẽ chuyển tới cursor.execute() .

.execute() có thể thực hiện bất kỳ truy vấn nào được chuyển tới nó dưới dạng chuỗi. Bạn sẽ sử dụng phương pháp này để tạo bảng trong phần này. Trong các phần sắp tới, bạn cũng sẽ sử dụng phương pháp này để thực hiện cập nhật và xóa các truy vấn.

Lưu ý: Tập lệnh này phải được thực thi trong cùng một tệp mà bạn đã tạo kết nối cho cơ sở dữ liệu SQLite của mình.

Đây là định nghĩa chức năng của bạn:

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

Mã này cố gắng thực thi query đã cho và in thông báo lỗi nếu cần.

Tiếp theo, viết truy vấn của bạn :

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

Điều này nói để tạo một bảng users với năm cột sau:

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

Cuối cùng, bạn sẽ gọi execute_query() để tạo bảng. Bạn sẽ sử dụng connection đối tượng mà bạn đã tạo trong phần trước, cùng với create_users_table chuỗi chứa truy vấn tạo bảng:

execute_query(connection, create_users_table)  

Truy vấn sau được sử dụng để tạo posts bảng:

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

Vì có mối quan hệ một-nhiều giữa users và posts , bạn có thể thấy một khóa ngoại user_id trong posts bảng tham chiếu đến id trong users bàn. Thực thi tập lệnh sau để tạo posts bảng:

execute_query(connection, create_posts_table)

Cuối cùng, bạn có thể tạo comments và likes bảng có tập lệnh sau:

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)            

Bạn có thể thấy rằng tạo bảng trong SQLite rất giống với việc sử dụng SQL thô. Tất cả những gì bạn phải làm là lưu trữ truy vấn trong một biến chuỗi và sau đó chuyển biến đó vào cursor.execute() .

MySQL

Bạn sẽ sử dụng mysql-connector-python Mô-đun Python SQL để tạo bảng trong MySQL. Cũng giống như với SQLite, bạn cần chuyển truy vấn của mình tới cursor.execute() , được trả về bằng cách gọi .cursor() trên kết nối connection vật. Bạn có thể tạo một hàm khác execute_query() chấp nhận kết nối connection và query chuỗi:

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

Trong dòng 4, bạn chuyển query thành cursor.execute() .

Bây giờ bạn có thể tạo users của mình bảng sử dụng chức năng này:

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)

Truy vấn triển khai quan hệ khóa ngoại trong MySQL hơi khác so với SQLite. Hơn nữa, MySQL sử dụng AUTO_INCREMENT từ khóa (so với AUTOINCREMENT của SQLite từ khóa) để tạo các cột trong đó các giá trị được tự động tăng lên khi các bản ghi mới được chèn vào.

Tập lệnh sau tạo posts bảng chứa khóa ngoại user_id tham chiếu đến id cột của users bảng:

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)

Tương tự, để tạo comments và likes bảng, bạn có thể chuyển CREATE tương ứng truy vấn tới execute_query() .

PostgreSQL

Giống như với cơ sở dữ liệu SQLite và MySQL, kết nối connection đối tượng được trả về bởi psycopg2.connect() chứa cursor vật. Bạn có thể sử dụng cursor.execute() để thực thi các truy vấn Python SQL trên cơ sở dữ liệu PostgreSQL của bạn.

Xác định một hàm 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")

Bạn có thể sử dụng chức năng này để tạo bảng, chèn bản ghi, sửa đổi bản ghi và xóa bản ghi trong cơ sở dữ liệu PostgreSQL của mình.

Bây giờ, hãy tạo users bảng bên trong sm_app cơ sở dữ liệu:

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)

Bạn có thể thấy rằng truy vấn để tạo users bảng trong PostgreSQL hơi khác so với SQLite và MySQL. Đây, từ khóa SERIAL được sử dụng để tạo các cột tự động tăng dần. Nhớ lại rằng MySQL sử dụng từ khóa AUTO_INCREMENT .

Ngoài ra, tham chiếu khóa ngoại cũng được chỉ định khác nhau, như được hiển thị trong tập lệnh sau tạo ra posts bảng:

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)

Để tạo comments bảng, bạn sẽ phải viết CREATE truy vấn cho comments bảng và chuyển nó vào execute_query() . Quy trình tạo likes bảng giống nhau. Bạn chỉ phải sửa đổi CREATE truy vấn để tạo likes bảng thay vì comments bảng.

Chèn bản ghi

Trong phần trước, bạn đã biết cách tạo bảng trong cơ sở dữ liệu SQLite, MySQL và PostgreSQL bằng cách sử dụng các mô-đun Python SQL khác nhau. Trong phần này, bạn sẽ thấy cách chèn bản ghi vào các bảng của bạn.

SQLite

Để chèn các bản ghi vào cơ sở dữ liệu SQLite của bạn, bạn có thể sử dụng cùng một execute_query() mà bạn đã sử dụng để tạo bảng. Đầu tiên, bạn phải lưu trữ INSERT INTO của mình truy vấn trong một chuỗi. Sau đó, bạn có thể chuyển connection đối tượng và query chuỗi thành execute_query() . Hãy chèn năm bản ghi vào users bảng:

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)   

Vì bạn đặt id để tự động tăng dần, bạn không cần chỉ định giá trị của id cột cho users này . Người dùng connection bảng sẽ tự động điền năm bản ghi này với id các giá trị từ 1 thành 5 .

Bây giờ hãy chèn sáu bản ghi vào posts bảng:

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)  

Điều quan trọng cần đề cập là user_id cột của posts bảng là một khóa ngoại tham chiếu đến id cột của users bàn. Điều này có nghĩa là user_id cột phải chứa một giá trị đã tồn tại trong id cột của users bàn. Nếu nó không tồn tại, thì bạn sẽ thấy lỗi.

Tương tự, tập lệnh sau sẽ chèn các bản ghi vào comments và likes bảng:

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)  

Trong cả hai trường hợp, bạn lưu trữ INSERT INTO của mình truy vấn dưới dạng một chuỗi và thực thi nó với execute_query() .

MySQL

Có hai cách để chèn bản ghi vào cơ sở dữ liệu MySQL từ một ứng dụng Python. Cách tiếp cận đầu tiên tương tự như SQLite. Bạn có thể lưu trữ INSERT INTO truy vấn trong một chuỗi và sau đó sử dụng cursor.execute() để chèn bản ghi.

Trước đó, bạn đã xác định một hàm trình bao bọc execute_query() mà bạn đã sử dụng để chèn bản ghi. Bạn có thể sử dụng cùng một chức năng này ngay bây giờ để chèn các bản ghi vào bảng MySQL của mình. Tập lệnh sau sẽ chèn các bản ghi vào users bảng sử dụng 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)  

Cách tiếp cận thứ hai sử dụng cursor.executemany() , chấp nhận hai tham số:

1. Truy vấn chuỗi chứa trình giữ chỗ để chèn các bản ghi
2. Danh sách trong số các bản ghi mà bạn muốn chèn

Hãy xem ví dụ sau, ví dụ này sẽ chèn hai bản ghi vào likes bảng:

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

Việc chèn bản ghi vào bảng MySQL của bạn là tùy thuộc vào bạn. Nếu bạn là một chuyên gia về SQL, thì bạn có thể sử dụng .execute() . Nếu bạn không quen thuộc nhiều với SQL, thì bạn có thể dễ dàng sử dụng .executemany() . Với một trong hai cách tiếp cận, bạn có thể chèn thành công các bản ghi vào posts , comments và likes bảng.

PostgreSQL

Trong phần trước, bạn đã thấy hai cách tiếp cận để chèn bản ghi vào bảng cơ sở dữ liệu SQLite. Đầu tiên sử dụng truy vấn chuỗi SQL và truy vấn thứ hai sử dụng .executemany() . psycopg2 theo cách tiếp cận thứ hai này, mặc dù .execute() được sử dụng để thực thi một truy vấn dựa trên trình giữ chỗ.

Bạn chuyển truy vấn SQL với trình giữ chỗ và danh sách các bản ghi tới .execute() . Mỗi bản ghi trong danh sách sẽ là một bộ, trong đó các giá trị của bộ tương ứng với các giá trị cột trong bảng cơ sở dữ liệu. Đây là cách bạn có thể chèn bản ghi người dùng vào users bảng trong cơ sở dữ liệu 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)

Tập lệnh trên tạo danh sách users chứa năm bản ghi người dùng ở dạng bộ giá trị. Tiếp theo, bạn tạo một chuỗi giữ chỗ với năm phần tử giữ chỗ (%s ) tương ứng với năm bản ghi người dùng. Chuỗi trình giữ chỗ được nối với truy vấn chèn bản ghi vào users bàn. Cuối cùng, chuỗi truy vấn và các bản ghi người dùng được chuyển đến .execute() . Tập lệnh trên chèn thành công năm bản ghi vào users bảng.

Hãy xem một ví dụ khác về chèn bản ghi vào bảng PostgreSQL. Tập lệnh sau sẽ chèn các bản ghi vào posts bảng:

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)

Bạn có thể chèn các bản ghi vào comments và likes các bảng có cùng cách tiếp cận.

Chọn bản ghi

Trong phần này, bạn sẽ thấy cách chọn bản ghi từ các bảng cơ sở dữ liệu bằng cách sử dụng các mô-đun Python SQL khác nhau. Đặc biệt, bạn sẽ thấy cách thực hiện SELECT truy vấn trên cơ sở dữ liệu SQLite, MySQL và PostgreSQL của bạn.

SQLite

Để chọn bản ghi bằng SQLite, bạn có thể sử dụng lại cursor.execute() . Tuy nhiên, sau khi thực hiện xong việc này, bạn cần gọi .fetchall() . Phương thức này trả về một danh sách các bộ trong đó mỗi bộ được ánh xạ tới hàng tương ứng trong các bản ghi được truy xuất.

Để đơn giản hóa quy trình, bạn có thể tạo một hàm 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")

Hàm này chấp nhận kết nối connection đối tượng và SELECT truy vấn và trả về bản ghi đã chọn.

SELECT

Bây giờ chúng ta hãy chọn tất cả các bản ghi từ users bảng:

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

for user in users:
    print(user)

Trong tập lệnh trên, SELECT truy vấn chọn tất cả người dùng từ users bàn. Điều này được chuyển đến execute_read_query() , trả về tất cả các bản ghi từ users bàn. Sau đó, các bản ghi sẽ được duyệt và in ra bảng điều khiển.

Lưu ý: Bạn không nên sử dụng SELECT * trên các bảng lớn vì nó có thể dẫn đến một số lượng lớn các hoạt động I / O làm tăng lưu lượng mạng.

Đầu ra của truy vấn trên trông giống như sau:

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

Theo cách tương tự, bạn có thể truy xuất tất cả các bản ghi từ posts bảng với tập lệnh bên dưới:

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

for post in posts:
    print(post)

Đầu ra trông giống như sau:

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

Kết quả hiển thị tất cả các bản ghi trong posts bảng.

JOIN

Bạn cũng có thể thực hiện các truy vấn phức tạp liên quan đến JOIN hoạt động để lấy dữ liệu từ hai bảng có liên quan. Ví dụ:tập lệnh sau trả về id và tên người dùng, cùng với mô tả về các bài đăng mà những người dùng này đã đăng:

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 vật. 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 bảng:

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.