The advantage of using a common database interface is that when the database changes, you only need to modify the initial configuration instead of modifying more corresponding codes.

1. QtSql class

The database operation interface class of the QtSql class includes the following classes:

QSql

QSqlError

QSqlQueryModel

QSqlRelationalTableModel

QSqlDriverCreatorBase

QSqlQuery

QSqlRelationalDelegate

2. Database operation

2.1 Create a database

Connect data through QSqlDataBase, sqlite is stored locally in the form of a file, so set the file name for access, and automatically create a database when the database does not exist.

        self.db = QSqlDatabase.addDatabase("QSQLITE")
        self.db.setDatabaseName(filePath)

2.2 Open the database

Directly call the open() method to open the data, and the return value is a sign of whether the opening is successful or not.

        if not self.db.open():
            print("数据库连接失败！")
            return False
        else:
            print("数据库连接成功！")
            return True

2.3 Create table

Create a table through QSqlQuery, and create a QSqlQuery object directly after the database is opened. When only adding one database, it is the default database, and there is no need to specify a database.

        query = QSqlQuery()
        query.exec(
            'create table test(id int primary key unique, name varchar(15), notes varchar(50))')
        self.db.close()

2.4 Add data

Use sql to directly add data, you need to pay attention to the character type in the sql statement, you need to add double quotes "".

        query.exec(
            f'insert into test values({test.id},"{test.name}","{test.notes}")')
        self.db.close()

2.5 Use model query

Use QSqlTableModel to query and operate data, and directly set the corresponding table name to quickly operate.

        model = QSqlTableModel()
        model.setTable("test")
        model.setEditStrategy(QSqlTableModel.EditStrategy.OnFieldChange)
        model.select()
        model.setHeaderData(0, Qt.Orientation.Horizontal, "ID")
        model.setHeaderData(1, Qt.Orientation.Horizontal, "Name")
        model.setHeaderData(2, Qt.Orientation.Horizontal, "Notes")
        return model

3. Interface display

Add a simple interface to display data and basic operations

3.1 view

from PyQt6.QtWidgets import QMainWindow
from PyQt6.QtWidgets import QWidget
from PyQt6.QtWidgets import QTableView
from PyQt6.QtWidgets import QPushButton
from PyQt6.QtWidgets import QGridLayout
from PyQt6.QtWidgets import QVBoxLayout


class MainWindowView(QMainWindow):
    """Main window view"""

    def __init__(self) -> None:

        super().__init__()
        self.init_ui()

    def init_ui(self):
        """Init ui"""

        self.resize(600, 200)
        self.mainwidget = QWidget()
        self.setCentralWidget(self.mainwidget)
        self.mainlayout = QGridLayout()
        self.mainwidget.setLayout(self.mainlayout)

        self.tv_main = QTableView()
        self.mainlayout.addWidget(self.tv_main, 0, 0)

        self.layout_edit = QVBoxLayout()
        self.mainlayout.addLayout(self.layout_edit, 0, 1)

        self.btn_add = QPushButton("Add")
        self.btn_add.setObjectName("btn_add")
        self.layout_edit.addWidget(self.btn_add)

        self.btn_delete = QPushButton("Delete")
        self.layout_edit.addWidget(self.btn_delete)

3.2 controller

# _*_ coding:utf-8 _*_

from PyQt6.QtCore import QObject
from PyQt6.QtCore import Qt
from PyQt6.QtWidgets import QPushButton
from view.mainview import MainWindowView
from model.sqlitedb import SqliteDB


class MainWindowController(QObject):
    """The controller of main window."""

    def __init__(self) -> None:
        """Init"""

        super().__init__()

        self.mainview = MainWindowView()
        '''主窗体'''
        self.btn_add = self.mainview.findChild(QPushButton, "btn_add", Qt.FindChildOption.FindChildrenRecursively)
        """添加一行按钮"""
        self.btn_add.clicked.connect(self.addrow)
        self.btn_delete = self.mainview.btn_delete
        self.btn_delete.clicked.connect(lambda: self.model_testtable.removeRow(self.tv_main.currentIndex().row()))
        self.tv_main = self.mainview.tv_main
        '''主界面显示TableView'''
        self.tv_main.clicked.connect(self.tableselectedchanged)

        self.init_db()

        self.model_testtable = self.testdb.query_testtable()
        self.tv_main.setModel(self.model_testtable)

        self.mainview.show()

    def init_db(self):
        """Init database"""

        self.testdb = SqliteDB()
        dbpath = r".\zero.sqlite\db\test.db"
        print(dbpath)
        self.testdb.create_db(dbpath)
        self.testdb.create_testtable()

    def addrow(self):
        """添加一行"""

        self.model_testtable.insertRow(self.model_testtable.rowCount())

    def tableselectedchanged(self, item):
        """table selected"""

        self.selecteitem = item
        print("Selected Row:", str(self.selecteitem.row()))

PyQt study notes - use the general database interface QtSql to operate the SQLite database