PyQt5 - Manejo de bases de datos

La biblioteca PyQt5 contiene QtSqlmódulo. Es un elaborado sistema de clases para comunicarse con muchas bases de datos basadas en SQL. SusQSqlDatabaseproporciona acceso a través de un objeto Connection. A continuación se muestra la lista de controladores SQL disponibles actualmente:

No Señor.	Tipo de controlador y descripción
1	QDB2 IBM DB2
2	QIBASE Controlador Borland InterBase
3	QMYSQL Controlador MySQL
4	QOCI Controlador de interfaz de llamada de Oracle
5	QODBC Controlador ODBC (incluye Microsoft SQL Server)
6	QPSQL Controlador PostgreSQL
7	QSQLITE SQLite versión 3 o superior
8	QSQLITE2 SQLite versión 2

Ejemplo

Para este capítulo, se establece una conexión con una base de datos SQLite utilizando el método estático:

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

Otros métodos de la clase QSqlDatabase son los siguientes:

No Señor.	Métodos y descripción
1	setDatabaseName() Establece el nombre de la base de datos con la que se busca la conexión.
2	setHostName() Establece el nombre del host en el que está instalada la base de datos.
3	setUserName() Especifica el nombre de usuario para la conexión.
4	setPassword() Establece la contraseña del objeto de conexión, si la hubiera
5	commit() Confirma las transacciones y devuelve verdadero si tiene éxito
6	rollback() Revierte la transacción de la base de datos
7	close() Cierra la conexión

QSqlQueryLa clase tiene la funcionalidad para ejecutar y manipular comandos SQL. Se pueden ejecutar consultas SQL de tipo DDL y DML. El primer paso es crear una base de datos SQlite usando las siguientes declaraciones:

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

A continuación, obtenga el objeto Consulta con QSqlQuery() y llamar a su método más importante exec_ (), que toma como argumento una cadena que contiene una declaración SQL para ser ejecutada.

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

El siguiente script crea una base de datos de SQLite sports.db con una tabla de deportista poblada con cinco registros.

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

Para confirmar que la base de datos SQLite se crea con los registros anteriores agregados en la tabla de deportistas, use una utilidad SQLite Gui llamada SQLiteStudio.

QSqlTableModelclass en PyQt es una interfaz de alto nivel que proporciona un modelo de datos editable para leer y escribir registros en una sola tabla. Este modelo se utiliza para poblar unQTableViewobjeto. Presenta al usuario una vista desplazable y editable que se puede colocar en cualquier ventana de nivel superior.

Un objeto QSqlTableModel se declara de la siguiente manera:

model = QtSql.QSqlTableModel()

Su estrategia de edición se puede establecer en cualquiera de los siguientes:

QSqlTableModel.OnFieldChange	Todos los cambios se aplicarán inmediatamente.
QSqlTableModel.OnRowChange	Los cambios se aplicarán cuando el usuario seleccione una fila diferente
QSqlTableModel.OnManualSubmit	Todos los cambios se almacenarán en caché hasta que se llame a submitAll () o revertAll ()

Ejemplo

En el siguiente ejemplo, la tabla de deportistas se usa como modelo y la estrategia se establece como:

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

La clase QTableView es parte del marco Model / View en PyQt. El objeto QTableView se crea de la siguiente manera:

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

Este objeto QTableView y dos widgets QPushButton se agregan a la ventana QDialog de nivel superior. La señal pulsada () del botón añadir está conectada a addrow () que realiza insertRow () en la tabla del modelo.

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

La ranura asociada con el botón de eliminar ejecuta una función lambda que elimina una fila, que es seleccionada por el usuario.

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

El código completo es el siguiente:

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

El código anterior produce la siguiente salida:

Intente agregar y eliminar algunos registros y vuelva a SQLiteStudio para confirmar las transacciones.