Hướng dẫn kết nối SQLite sử dụng sqlite3 trong Python

SQLite là một hệ thống quản lý cơ sở dữ liệu quan hệ nhẹ và phẳng. Nó được thiết kế để đơn giản, tiết kiệm và phù hợp cho các ứng dụng nhỏ và trung bình. SQLite không yêu cầu máy chủ riêng biệt và hoạt động trực tiếp trên file cơ sở dữ liệu. Điều này làm cho nó trở thành một lựa chọn tốt cho các ứng dụng như ứng dụng di động, máy tính cá nhân, trình duyệt web, và nhiều ứng dụng nhỏ khác.

SQLite hỗ trợ hầu hết các tính năng của cơ sở dữ liệu SQL chuẩn và có sẵn dưới dạng một thư viện C. Nó được tích hợp trực tiếp vào ứng dụng và không yêu cầu quá trình riêng biệt để quản lý.

Mô-đun sqlite3 trong Python

sqlite3 là một mô-đun trong Python cung cấp các công cụ để làm việc với cơ sở dữ liệu SQLite. Mô-đun này giúp bạn kết nối và tương tác với cơ sở dữ liệu SQLite từ Python một cách dễ dàng.

Bằng cách sử dụng mô-đun sqlite3, bạn có thể thực hiện các thao tác sau trên cơ sở dữ liệu SQLite:

Bài viết này được đăng tại [free tuts .net]

• Kết nối đến cơ sở dữ liệu SQLite.
• Tạo bảng và chỉ định cấu trúc của chúng.
• Thực hiện các truy vấn SQL để truy xuất, cập nhật, và xóa dữ liệu từ bảng.
• Xử lý các ngoại lệ và lỗi liên quan đến cơ sở dữ liệu.

Trong bài viết này, mình sẽ bắt đầu từ cơ bản và tiến thêm vào các khía cạnh phức tạp hơn của SQLite và sqlite3. Hãy cùng tìm hiểu cách thực hiện việc này bước từng bước.

Cài đặt SQLite và Mô-đun sqlite3

Cài đặt SQLite

Trước khi bạn có thể sử dụng cơ sở dữ liệu SQLite và mô-đun sqlite3 trong Python, bạn cần cài đặt SQLite trên hệ thống của mình. Đối với hầu hết các hệ điều hành, bạn có thể làm theo các bước sau để cài đặt SQLite:

Trên Linux (Ubuntu và Debian)

Mở terminal và chạy lệnh sau:

sudo apt-get update
sudo apt-get install sqlite3

Trên macOS (sử dụng Homebrew)

Nếu bạn chưa cài đặt Homebrew, bạn có thể cài đặt nó bằng cách truy cập trang web chính thức của Homebrew và làm theo hướng dẫn.

Sau khi cài đặt Homebrew, mở terminal và chạy lệnh sau để cài đặt SQLite:

brew install sqlite

Trên Windows

Truy cập trang web chính thức của SQLite và tải xuống phiên bản Windows của SQLite (nó sẽ là một file .exe). Sau đó, chạy file tải xuống để cài đặt SQLite trên máy tính của bạn.

Kiểm tra mô-đun sqlite3

Mô-đun sqlite3 là một mô-đun được tích hợp sẵn trong Python, vì vậy bạn không cần cài đặt nó riêng lẻ. Tuy nhiên, để kiểm tra xem mô-đun sqlite3 đã được cài đặt và hoạt động trên hệ thống của bạn, bạn có thể mở Python REPL (Read-Eval-Print Loop) bằng cách chạy lệnh sau trong terminal:

python

Sau đó, bạn có thể kiểm tra xem mô-đun sqlite3 đã được nhập thành công hay chưa bằng cách chạy lệnh sau trong REPL:

import sqlite3

Nếu không có lỗi nào xuất hiện và bạn có thể nhập mô-đun mà không gặp vấn đề gì, điều đó có nghĩa là mô-đun sqlite3 đã được cài đặt và sẵn sàng sử dụng.

Kết nối với SQLite Database

Khi bạn đã cài đặt SQLite và mô-đun sqlite3 trên hệ thống của mình, bạn có thể bắt đầu làm việc với cơ sở dữ liệu SQLite từ Python. Trong phần này, mình sẽ học cách kết nối với cơ sở dữ liệu SQLite sử dụng mô-đun sqlite3, thiết lập kết nối, và xử lý các ngoại lệ kết nối có thể xảy ra.

Import mô-đun sqlite3

Đầu tiên, hãy đảm bảo rằng bạn đã nhập mô-đun sqlite3. Bạn có thể làm điều này bằng cách thêm dòng sau vào mã Python của mình:

import sqlite3

Thiết lập kết nối với cơ sở dữ liệu

Để thiết lập kết nối với cơ sở dữ liệu SQLite, bạn cần sử dụng phương thức connect() của mô-đun sqlite3. Dưới đây là cách bạn có thể làm điều này:

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    # Thay 'mydatabase.db' bằng tên file cơ sở dữ liệu của bạn
    print("Connected to SQLite")
except sqlite3.Error as error:
    print("Error connecting to SQLite:", error)

Trong ví dụ trên, ta đã sử dụng try...except để xử lý ngoại lệ. Nếu có bất kỳ lỗi nào xảy ra trong quá trình kết nối, nó sẽ được xử lý bởi khối except, và bạn có thể in ra thông báo lỗi.

Xử lý ngoại lệ kết nối

Khi làm việc với cơ sở dữ liệu, việc xử lý ngoại lệ là một phần quan trọng để đảm bảo ứng dụng của bạn hoạt động ổn định. Dưới đây là ví dụ về cách xử lý ngoại lệ kết nối trong mô-đun sqlite3:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    # Thay 'mydatabase.db' bằng tên file cơ sở dữ liệu của bạn
    print("Connected to SQLite")
except sqlite3.Error as error:
    print("Error connecting to SQLite:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()
        print("SQLite connection is closed")

Trong ví dụ này, sau khi kết nối thành công hoặc thất bại, mình sử dụng khối finally để đảm bảo rằng kết nối với cơ sở dữ liệu đã được đóng lại. Điều này quan trọng để tránh rò rỉ kết nối và tài nguyên hệ thống.

Thực hiện các thao tác CRUD (Create, Read, Update, Delete)

Cơ sở dữ liệu SQLite cho phép bạn thực hiện các thao tác CRUD cơ bản, tức là tạo (Create), đọc (Read), cập nhật (Update) và xóa (Delete) dữ liệu. Dưới đây là cách thực hiện mỗi thao tác này từ Python sử dụng mô-đun sqlite3.

Chèn dữ liệu vào cơ sở dữ liệu

Để chèn dữ liệu mới vào cơ sở dữ liệu SQLite, bạn cần sử dụng truy vấn SQL INSERT. Dưới đây là ví dụ cách chèn một bản ghi mới vào bảng:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Thực hiện truy vấn INSERT
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data_to_insert = ("John Doe", "john@example.com")
    cursor.execute(insert_query, data_to_insert)

    # Lưu thay đổi
    sqliteConnection.commit()
    print("Data inserted successfully.")

except sqlite3.Error as error:
    print("Error inserting data:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ này, mình đã sử dụng thay thế tham số ? để tránh các vấn đề liên quan đến SQL Injection. Sau khi thực hiện truy vấn INSERT, mình cần gọi commit() để lưu các thay đổi vào cơ sở dữ liệu.

Đọc dữ liệu từ cơ sở dữ liệu

Để đọc dữ liệu từ cơ sở dữ liệu SQLite, bạn cần sử dụng truy vấn SQL SELECT. Dưới đây là ví dụ cách đọc tất cả dữ liệu từ một bảng:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Thực hiện truy vấn SELECT
    select_query = "SELECT * FROM users"
    cursor.execute(select_query)

    # Lấy tất cả dữ liệu
    records = cursor.fetchall()

    # In kết quả
    for record in records:
        print(record)

except sqlite3.Error as error:
    print("Error reading data:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ này, mình đã sử dụng fetchall() để lấy tất cả các dòng từ truy vấn SELECT và sau đó in chúng ra màn hình.

Cập nhật dữ liệu

Để cập nhật dữ liệu trong cơ sở dữ liệu SQLite, bạn cần sử dụng truy vấn SQL UPDATE. Dưới đây là ví dụ cách cập nhật một bản ghi đã tồn tại:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Thực hiện truy vấn UPDATE
    update_query = "UPDATE users SET email = ? WHERE name = ?"
    data_to_update = ("new_email@example.com", "John Doe")
    cursor.execute(update_query, data_to_update)

    # Lưu thay đổi
    sqliteConnection.commit()
    print("Data updated successfully.")

except sqlite3.Error as error:
    print("Error updating data:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ này, mình đã sử dụng truy vấn UPDATE để cập nhật dòng có tên "John Doe" và thay đổi địa chỉ email của nó.

Xóa dữ liệu

Để xóa dữ liệu từ cơ sở dữ liệu SQLite, bạn cần sử dụng truy vấn SQL DELETE. Dưới đây là ví dụ cách xóa một bản ghi:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Thực hiện truy vấn DELETE
    delete_query = "DELETE FROM users WHERE name = ?"
    name_to_delete = ("John Doe",)
    cursor.execute(delete_query, name_to_delete)

    # Lưu thay đổi
    sqliteConnection.commit()
    print("Data deleted successfully.")

except sqlite3.Error as error:
    print("Error deleting data:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ này, mình đã sử dụng truy vấn DELETE để xóa dòng có tên "John Doe" ra khỏi bảng.

Nhớ rằng trước khi thực hiện bất kỳ thay đổi nào vào cơ sở dữ liệu, bạn nên chắc chắn rằng bạn đã sao lưu dữ liệu quan trọng và thực hiện các thao tác CRUD cẩn thận để tránh mất dữ liệu.

Thực thi file SQL và sử dụng tập lệnh thực thi

Trong SQLite, bạn có thể thực thi các file SQL chứa nhiều truy vấn hoặc các tập lệnh SQL bằng cách sử dụng mô-đun sqlite3 trong Python. Dưới đây là cách thực hiện điều này.

Thực thi File SQL

Để thực thi một file SQL từ Python, bạn cần mở file và đọc nội dung của nó, sau đó sử dụng con trỏ execute() để thực thi các truy vấn trong file . Dưới đây là ví dụ:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Đọc nội dung của file SQL
    with open('script.sql', 'r') as sql_file:
        sql_script = sql_file.read()

    # Thực thi file SQL
    cursor.executescript(sql_script)
    print("SQL script executed successfully.")

except sqlite3.Error as error:
    print("Error executing SQL script:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ này, mình mở file SQL bằng with open() và sau đó đọc nội dung của nó vào biến sql_script. Sau đó, ta sử dụng executescript() để thực thi toàn bộ file SQL. Điều này cho phép thực hiện nhiều truy vấn trong một lần thực thi.

Sử dụng tập lệnh thực thi

Tập lệnh SQLite là một tập hợp các truy vấn SQL được lưu trữ trong một file văn bản (.sql). Bạn có thể thực thi toàn bộ tập lệnh bằng cách sử dụng tập lệnh sqlite3 từ dòng lệnh SQLite hoặc từ Python. Dưới đây là ví dụ về cách thực hiện tập lệnh từ Python:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Đọc nội dung của tập lệnh SQL
    with open('script.sql', 'r') as sql_file:
        sql_script = sql_file.read()

    # Thực thi tập lệnh SQL
    cursor.executescript(sql_script)
    print("SQL script executed successfully.")

except sqlite3.Error as error:
    print("Error executing SQL script:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Lưu ý rằng bạn cần phải lưu trữ file tập lệnh SQL (ví dụ: script.sql) trong cùng thư mục với file Python của bạn hoặc cung cấp đường dẫn tới file đó nếu nó nằm ở nơi khác.

Sử dụng tập lệnh SQL và thực thi từ file SQL là cách tiện lợi để quản lý và thực hiện nhiều truy vấn hoặc tác vụ phức tạp trong SQLite.

Làm việc với kiểu dữ liệu đặc biệt

SQLite cho phép bạn lưu trữ nhiều loại dữ liệu đặc biệt như số, văn bản, hình ảnh và file đính kèm trong cơ sở dữ liệu của mình. Dưới đây là cách làm việc với một số kiểu dữ liệu đặc biệt này trong SQLite sử dụng mô-đun sqlite3 của Python.

Lưu trữ số

Để lưu trữ số trong SQLite, bạn có thể sử dụng kiểu dữ liệu INTEGER hoặc REAL. INTEGER được sử dụng cho các số nguyên, trong khi REAL được sử dụng cho các số dấu phẩy động. Dưới đây là ví dụ về cách chèn và đọc số từ SQLite:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Chèn một số nguyên
    cursor.execute("INSERT INTO numbers (integer_column) VALUES (42)")
    sqliteConnection.commit()

    # Đọc số nguyên từ cơ sở dữ liệu
    cursor.execute("SELECT integer_column FROM numbers")
    result = cursor.fetchone()
    if result:
        print("Integer Value:", result[0])

except sqlite3.Error as error:
    print("Error:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Lưu trữ văn bản

Để lưu trữ văn bản trong SQLite, bạn có thể sử dụng kiểu dữ liệu TEXT. Dưới đây là ví dụ về cách chèn và đọc văn bản từ SQLite:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Chèn một chuỗi văn bản
    cursor.execute("INSERT INTO texts (text_column) VALUES ('Hello, SQLite!')")
    sqliteConnection.commit()

    # Đọc chuỗi văn bản từ cơ sở dữ liệu
    cursor.execute("SELECT text_column FROM texts")
    result = cursor.fetchone()
    if result:
        print("Text Value:", result[0])

except sqlite3.Error as error:
    print("Error:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Lưu trữ hình ảnh hoặc file đính kèm

Để lưu trữ hình ảnh hoặc file đính kèm trong SQLite, bạn có thể sử dụng kiểu dữ liệu BLOB (Binary Large Object). Dưới đây là ví dụ về cách chèn và đọc hình ảnh từ SQLite:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Chèn một hình ảnh từ file vào cơ sở dữ liệu
    with open('image.jpg', 'rb') as image_file:
        image_data = image_file.read()
        cursor.execute("INSERT INTO images (image_column) VALUES (?)", (sqlite3.Binary(image_data),))
        sqliteConnection.commit()

    # Đọc hình ảnh từ cơ sở dữ liệu và lưu vào file
    cursor.execute("SELECT image_column FROM images")
    result = cursor.fetchone()
    if result:
        with open('retrieved_image.jpg', 'wb') as retrieved_image_file:
            retrieved_image_file.write(result[0])

except sqlite3.Error as error:
    print("Error:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong ví dụ trên, mình sử dụng kiểu dữ liệu BLOB để lưu trữ hình ảnh và file đính kèm. Để chèn hình ảnh, mình sử dụng sqlite3.Binary(image_data) để đảm bảo rằng dữ liệu hình ảnh được lưu trữ dưới dạng dữ liệu nhị phân.

Lưu ý rằng việc lưu trữ các file đính kèm lớn trong cơ sở dữ liệu có thể làm tăng kích thước cơ sở dữ liệu và làm chậm hiệu suất truy xuất dữ liệu. Nên xem xét cẩn thận việc lưu trữ và quản lý file đính kèm trong SQLite.

Đóng kết nối và quản lý tài nguyên

Khi bạn đã hoàn thành các thao tác với cơ sở dữ liệu SQLite trong Python, quá trình quản lý tài nguyên và đóng kết nối là rất quan trọng để đảm bảo tính ổn định và an toàn của ứng dụng của bạn. Dưới đây là cách đóng kết nối đúng cách và quản lý tài nguyên khi làm việc với SQLite trong Python:

Đóng kết nối đúng cách

Để đảm bảo rằng kết nối đến cơ sở dữ liệu SQLite được đóng đúng cách và tài nguyên được giải phóng, bạn nên sử dụng câu lệnh try...finally hoặc sử dụng lệnh with để quản lý kết nối. Dưới đây là ví dụ về cách đóng kết nối đúng cách:

Sử dụng try...finally:

import sqlite3

sqliteConnection = None

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()

    # Thực hiện các thao tác với cơ sở dữ liệu ở đây

except sqlite3.Error as error:
    print("Error:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Sử dụng lệnh with:

import sqlite3

with sqlite3.connect('mydatabase.db') as sqliteConnection:
    cursor = sqliteConnection.cursor()

    # Thực hiện các thao tác với cơ sở dữ liệu ở đây

Cả hai phương pháp đều đảm bảo rằng kết nối sẽ được đóng khi bạn đã hoàn thành công việc với cơ sở dữ liệu.

Quản lý tài nguyên

Khi làm việc với tài nguyên như file hình ảnh hoặc bất kỳ tài nguyên nào khác trong cơ sở dữ liệu SQLite, bạn nên quản lý chúng cẩn thận. Dưới đây là một số điều cần lưu ý:

• Lưu trữ file ngoài cơ sở dữ liệu: Đối với các file lớn như hình ảnh hoặc file đính kèm, hãy xem xét lưu trữ chúng ở ngoài cơ sở dữ liệu và chỉ lưu trữ đường dẫn hoặc liên kết tới file đó trong cơ sở dữ liệu.

• Xóa tài nguyên không cần thiết: Khi bạn đã sử dụng xong một tài nguyên và không còn cần nữa, hãy xóa nó để giải phóng tài nguyên hệ thống.

• Quản lý bộ nhớ: Khi làm việc với dữ liệu lớn hoặc nhiều tài nguyên, hãy chắc chắn rằng bạn không gây ra lãng phí bộ nhớ bằng cách giải phóng tài nguyên khi chúng không còn cần.

• Sử dụng Context Managers: Đối với việc mở và đóng file hoặc tài nguyên, sử dụng context managers (ví dụ: with statements) để đảm bảo rằng tài nguyên sẽ được giải phóng tự động sau khi bạn đã hoàn thành công việc với chúng.

Khi bạn tuân thủ các nguyên tắc trên, bạn có thể làm việc với SQLite một cách hiệu quả và đảm bảo ứng dụng của bạn hoạt động ổn định và an toàn.

Xử lý lỗi và ngoại lệ SQLite

Khi làm việc với cơ sở dữ liệu SQLite trong Python, quá trình xử lý lỗi và ngoại lệ rất quan trọng để đảm bảo tính ổn định và an toàn cho ứng dụng của bạn. Dưới đây là cách xử lý lỗi và ngoại lệ trong SQLite:

Xử lý lỗi kết nối

Khi bạn thực hiện kết nối đến cơ sở dữ liệu SQLite, có thể xảy ra các lỗi liên quan đến kết nối như không thể kết nối đến cơ sở dữ liệu hoặc sai đường dẫn tới cơ sở dữ liệu. Để xử lý lỗi kết nối, bạn nên sử dụng một khối try...except như sau:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()
    
    # Thực hiện các thao tác với cơ sở dữ liệu ở đây

except sqlite3.Error as error:
    print("Error while connecting to the database:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Trong trường hợp có lỗi kết nối, bạn có thể xử lý và ghi log lỗi hoặc thực hiện các hành động khắc phục tùy thuộc vào tình huống cụ thể.

Xử lý lỗi thao tác dữ liệu

Khi thực hiện các thao tác CRUD (Create, Read, Update, Delete) trên cơ sở dữ liệu SQLite, cũng có thể xảy ra các lỗi thao tác dữ liệu như việc thêm dữ liệu trùng lặp, cố gắng xóa dữ liệu không tồn tại, và nhiều lỗi khác. Để xử lý các lỗi thao tác dữ liệu, bạn nên sử dụng một khối try...except tương tự như sau:

import sqlite3

try:
    sqliteConnection = sqlite3.connect('mydatabase.db')
    cursor = sqliteConnection.cursor()
    
    # Thực hiện các thao tác với cơ sở dữ liệu ở đây, ví dụ: chèn dữ liệu
    sqlite_insert_query = "INSERT INTO mytable (name, age) VALUES (?, ?)"
    data = ('John', 30)
    cursor.execute(sqlite_insert_query, data)
    sqliteConnection.commit()

except sqlite3.Error as error:
    print("Error while performing database operation:", error)
finally:
    if sqliteConnection:
        sqliteConnection.close()

Tương tự như trước, bạn có thể xử lý và ghi log lỗi hoặc thực hiện các hành động khắc phục dựa trên loại lỗi mà bạn nhận được.

Xử lý lỗi và ngoại lệ cơ sở dữ liệu SQLite là một phần quan trọng của việc phát triển ứng dụng đáng tin cậy và an toàn. Bằng cách xử lý lỗi một cách thích hợp, bạn có thể đảm bảo rằng ứng dụng của bạn hoạt động một cách ổn định và không gây ra sự cố không mong muốn cho người dùng.

Kết bài

Trong bài viết này, mình đã tìm hiểu cách kết nối và làm việc với cơ sở dữ liệu SQLite bằng mô-đun sqlite3 trong Python. Ta cũng đã thảo luận về các bước quan trọng từ cài đặt SQLite, tạo và quản lý bảng, thao tác CRUD, thực thi file SQL, làm việc với các kiểu dữ liệu đặc biệt, xử lý lỗi và ngoại lệ, đến các mẹo và thủ thuật để tối ưu hóa hiệu suất và thực hành an toàn theo luồng.

SQLite là một cơ sở dữ liệu nhẹ, linh hoạt và phổ biến, rất thích hợp cho các ứng dụng nhỏ và đơn giản. Việc nắm vững cách làm việc với SQLite trong Python sẽ giúp bạn phát triển các ứng dụng dựa trên dữ liệu một cách hiệu quả và đáng tin cậy. Chúc bạn thành công trong việc làm việc với cơ sở dữ liệu SQLite của mình!