PyQt5 - Gestione database

La libreria PyQt5 contiene QtSqlmodulo. È un elaborato sistema di classi per comunicare con molti database basati su SQL. SuoQSqlDatabasefornisce l'accesso tramite un oggetto Connection. Di seguito è riportato l'elenco dei driver SQL attualmente disponibili:

Sr.No.	Tipo e descrizione del driver
1	QDB2 IBM DB2
2	QIBASE Borland InterBase Driver
3	QMYSQL Driver MySQL
4	QOCI Driver dell'interfaccia di chiamata Oracle
5	QODBC Driver ODBC (include Microsoft SQL Server)
6	QPSQL Driver PostgreSQL
7	QSQLITE SQLite versione 3 o successiva
8	QSQLITE2 SQLite versione 2

Esempio

Per questo capitolo, viene stabilita una connessione con un database SQLite utilizzando il metodo statico:

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

Altri metodi della classe QSqlDatabase sono i seguenti:

Sr.No.	Metodi e descrizione
1	setDatabaseName() Imposta il nome del database con il quale viene richiesta la connessione
2	setHostName() Imposta il nome dell'host su cui è installato il database
3	setUserName() Specifica il nome utente per la connessione
4	setPassword() Imposta la password dell'oggetto connessione, se presente
5	commit() Effettua il commit delle transazioni e restituisce true se ha esito positivo
6	rollback() Ripristina la transazione del database
7	close() Chiude la connessione

QSqlQueryclass ha la funzionalità per eseguire e manipolare i comandi SQL. È possibile eseguire query SQL di tipo DDL e DML. Il primo passo è creare il database SQlite utilizzando le seguenti istruzioni:

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

Quindi, ottenere l'oggetto Query con QSqlQuery() e chiama il suo metodo più importante exec_ (), che prende come argomento una stringa contenente un'istruzione SQL da eseguire.

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

Il seguente script crea un database SQLite sports.db con una tabella di sportivi popolata con cinque record.

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

Per confermare che il database SQLite è stato creato con i record sopra aggiunti nella tabella degli sportivi, utilizzare un'utilità SQLite Gui chiamata SQLiteStudio.

QSqlTableModelclass in PyQt è un'interfaccia di alto livello che fornisce un modello di dati modificabile per la lettura e la scrittura di record in una singola tabella. Questo modello viene utilizzato per popolare un fileQTableViewoggetto. Presenta all'utente una visualizzazione scorrevole e modificabile che può essere inserita in qualsiasi finestra di primo livello.

Un oggetto QSqlTableModel viene dichiarato nel modo seguente:

model = QtSql.QSqlTableModel()

La sua strategia di modifica può essere impostata su uno dei seguenti:

QSqlTableModel.OnFieldChange	Tutte le modifiche verranno applicate immediatamente
QSqlTableModel.OnRowChange	Le modifiche verranno applicate quando l'utente seleziona una riga diversa
QSqlTableModel.OnManualSubmit	Tutte le modifiche verranno memorizzate nella cache fino a quando non viene chiamato submitAll () o revertAll ()

Esempio

Nell'esempio seguente, la tabella degli sportivi viene utilizzata come modello e la strategia è impostata come:

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

La classe QTableView fa parte del framework Model / View in PyQt. L'oggetto QTableView viene creato come segue:

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

Questo oggetto QTableView e due widget QPushButton vengono aggiunti alla finestra QDialog di livello superiore. Il segnale cliccato () del pulsante aggiungi è connesso a addrow () che esegue insertRow () sulla tabella del modello.

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

Lo Slot associato al pulsante di eliminazione esegue una funzione lambda che elimina una riga, selezionata dall'utente.

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

Il codice completo è il seguente:

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

Il codice precedente produce il seguente output:

Prova ad aggiungere ed eliminare alcuni record e torna a SQLiteStudio per confermare le transazioni.