PyQt5 - Datenbankverarbeitung

PyQt5-Bibliothek enthält QtSqlModul. Es ist ein ausgeklügeltes Klassensystem zur Kommunikation mit vielen SQL-basierten Datenbanken. Es istQSqlDatabaseBietet Zugriff über ein Verbindungsobjekt. Im Folgenden finden Sie eine Liste der derzeit verfügbaren SQL-Treiber:

Sr.Nr.	Fahrertyp & Beschreibung
1	QDB2 IBM DB2
2	QIBASE Borland InterBase-Treiber
3	QMYSQL MySQL-Treiber
4	QOCI Oracle Call Interface-Treiber
5	QODBC ODBC-Treiber (einschließlich Microsoft SQL Server)
6	QPSQL PostgreSQL-Treiber
7	QSQLITE SQLite Version 3 oder höher
8	QSQLITE2 SQLite Version 2

Beispiel

In diesem Kapitel wird mithilfe der statischen Methode eine Verbindung mit einer SQLite-Datenbank hergestellt.

db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sports.db')

Andere Methoden der QSqlDatabase-Klasse sind wie folgt:

Sr.Nr.	Methoden & Beschreibung
1	setDatabaseName() Legt den Namen der Datenbank fest, mit der eine Verbindung gesucht wird
2	setHostName() Legt den Namen des Hosts fest, auf dem die Datenbank installiert ist
3	setUserName() Gibt den Benutzernamen für die Verbindung an
4	setPassword() Legt das Kennwort des Verbindungsobjekts fest, falls vorhanden
5	commit() Übernimmt die Transaktionen und gibt bei Erfolg true zurück
6	rollback() Setzt die Datenbanktransaktion zurück
7	close() Schließt die Verbindung

QSqlQueryKlasse verfügt über die Funktionalität zum Ausführen und Bearbeiten von SQL-Befehlen. Es können SQL-Abfragen vom Typ DDL und DML ausgeführt werden. Der erste Schritt besteht darin, eine SQlite-Datenbank mit den folgenden Anweisungen zu erstellen:

db = QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sportsdatabase.db')

Als nächstes erhalten Sie das Abfrageobjekt mit QSqlQuery() Methode und rufen Sie die wichtigste Methode exec_ () auf, die als Argument eine Zeichenfolge mit der auszuführenden SQL-Anweisung verwendet.

query = QtSql.QSqlQuery()
query.exec_("create table sportsmen(id int primary key, " "firstname varchar(20), lastname varchar(20))")

Das folgende Skript erstellt eine SQLite-Datenbank sports.db mit einer Tabelle von Sportlern, die mit fünf Datensätzen gefüllt ist.

import sys
from PyQt5.QtSql import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def createDB():
   db = QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sportsdatabase.db')

   if not db.open():
      msg = QMessageBox()
      msg.setIcon(QMessageBox.Critical)
      msg.setText("Error in Database Creation")
      retval = msg.exec_()
      return False
   query = QSqlQuery()

   query.exec_("create table sportsmen(
      id int primary key, ""firstname varchar(20), lastname varchar(20))")

   query.exec_("insert into sportsmen values(101, 'Roger', 'Federer')")
   query.exec_("insert into sportsmen values(102, 'Christiano', 'Ronaldo')")
   query.exec_("insert into sportsmen values(103, 'Ussain', 'Bolt')")
   query.exec_("insert into sportsmen values(104, 'Sachin', 'Tendulkar')")
   query.exec_("insert into sportsmen values(105, 'Saina', 'Nehwal')")
   return True

if __name__ == '__main__':
   app = QApplication(sys.argv)
   createDB()

Verwenden Sie ein SQLite Gui-Dienstprogramm namens, um zu bestätigen, dass die SQLite-Datenbank mit den oben in der Sportsmen-Tabelle hinzugefügten Datensätzen erstellt wurde SQLiteStudio.

QSqlTableModelclass in PyQt ist eine übergeordnete Schnittstelle, die ein bearbeitbares Datenmodell zum Lesen und Schreiben von Datensätzen in einer einzelnen Tabelle bereitstellt. Dieses Modell wird zum Auffüllen von a verwendetQTableViewObjekt. Es bietet dem Benutzer eine scrollbare und bearbeitbare Ansicht, die in jedes Fenster der obersten Ebene eingefügt werden kann.

Ein QSqlTableModel-Objekt wird folgendermaßen deklariert:

model = QtSql.QSqlTableModel()

Die Bearbeitungsstrategie kann auf eine der folgenden Optionen eingestellt werden:

QSqlTableModel.OnFieldChange	Alle Änderungen werden sofort übernommen
QSqlTableModel.OnRowChange	Änderungen werden übernommen, wenn der Benutzer eine andere Zeile auswählt
QSqlTableModel.OnManualSubmit	Alle Änderungen werden zwischengespeichert, bis entweder submitAll () oder revertAll () aufgerufen wird

Beispiel

Im folgenden Beispiel wird die Sportertabelle als Modell verwendet und die Strategie wie folgt festgelegt:

model.setTable('sportsmen') 
model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)
   model.select()

Die QTableView-Klasse ist Teil des Model / View-Frameworks in PyQt. Das QTableView-Objekt wird wie folgt erstellt:

view = QtGui.QTableView()
view.setModel(model)
view.setWindowTitle(title)
return view

Dieses QTableView-Objekt und zwei QPushButton-Widgets werden dem QDialog-Fenster der obersten Ebene hinzugefügt. Das angeklickte () Signal der Schaltfläche zum Hinzufügen ist mit addrow () verbunden, das insertRow () für die Modelltabelle ausführt.

button.clicked.connect(addrow)
def addrow():
   print model.rowCount()
   ret = model.insertRows(model.rowCount(), 1)
   print ret

Der der Schaltfläche Löschen zugeordnete Steckplatz führt eine Lambda-Funktion aus, die eine vom Benutzer ausgewählte Zeile löscht.

btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))

Der vollständige Code lautet wie folgt:

import sys
from PyQt5.QtSql import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def initializeModel(model):
   model.setTable('sportsmen')
   model.setEditStrategy(QSqlTableModel.OnFieldChange)
   model.select()
   model.setHeaderData(0, Qt.Horizontal, "ID")
   model.setHeaderData(1, Qt.Horizontal, "First name")
   model.setHeaderData(2, Qt.Horizontal, "Last name")

def createView(title, model):
   view = QTableView()
   view.setModel(model)
   view.setWindowTitle(title)
   return view

def addrow():
   print (model.rowCount())
   ret = model.insertRows(model.rowCount(), 1)
   print (ret)

def findrow(i):
   delrow = i.row()

if __name__ == '__main__':
   app = QApplication(sys.argv)
   db = QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sportsdatabase.db')
   model = QSqlTableModel()
   delrow = -1
   initializeModel(model)

   view1 = createView("Table Model (View 1)", model)
   view1.clicked.connect(findrow)

   dlg = QDialog()
   layout = QVBoxLayout()
   layout.addWidget(view1)

   button = QPushButton("Add a row")
   button.clicked.connect(addrow)
   layout.addWidget(button)

   btn1 = QPushButton("del a row")
   btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))
   layout.addWidget(btn1)

   dlg.setLayout(layout)
   dlg.setWindowTitle("Database Demo")
   dlg.show()
   sys.exit(app.exec_())

Der obige Code erzeugt die folgende Ausgabe -

Versuchen Sie, einige Datensätze hinzuzufügen und zu löschen, und kehren Sie zu SQLiteStudio zurück, um die Transaktionen zu bestätigen.