PyQt5 - Gerenciamento de banco de dados

A biblioteca PyQt5 contém QtSqlmódulo. É um sistema de classes elaborado para se comunicar com muitos bancos de dados baseados em SQL. EstáQSqlDatabasefornece acesso por meio de um objeto Connection. A seguir está a lista de drivers SQL disponíveis atualmente -

Sr. Não.	Tipo e descrição do driver
1	QDB2 IBM DB2
2	QIBASE Driver Borland InterBase
3	QMYSQL Driver MySQL
4	QOCI Driver de interface de chamada Oracle
5	QODBC Driver ODBC (inclui Microsoft SQL Server)
6	QPSQL Driver PostgreSQL
7	QSQLITE SQLite versão 3 ou superior
8	QSQLITE2 SQLite versão 2

Exemplo

Para este capítulo, uma conexão com um banco de dados SQLite é estabelecida usando o método estático -

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

Outros métodos da classe QSqlDatabase são os seguintes -

Sr. Não.	Métodos e Descrição
1	setDatabaseName() Define o nome do banco de dados com o qual a conexão é buscada
2	setHostName() Define o nome do host no qual o banco de dados está instalado
3	setUserName() Especifica o nome de usuário para conexão
4	setPassword() Define a senha do objeto de conexão, se houver
5	commit() Confirma as transações e retorna verdadeiro se for bem-sucedido
6	rollback() Reverte a transação do banco de dados
7	close() Fecha a conexão

QSqlQueryclasse tem a funcionalidade de executar e manipular comandos SQL. Ambos os tipos DDL e DML de consultas SQL podem ser executados. O primeiro passo é criar banco de dados SQlite usando as seguintes instruções -

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

Em seguida, obtenha o objeto Query com QSqlQuery() método e chama seu método mais importante exec_ (), que toma como argumento uma string contendo a instrução SQL a ser executada.

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

O script a seguir cria um banco de dados SQLite sports.db com uma tabela de esportistas preenchida com 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 o banco de dados SQLite foi criado com os registros acima adicionados à tabela de esportistas, use um utilitário SQLite Gui chamado SQLiteStudio.

QSqlTableModelclasse em PyQt é uma interface de alto nível que fornece modelo de dados editável para leitura e gravação de registros em uma única tabela. Este modelo é usado para preencher umQTableViewobjeto. Ele apresenta ao usuário uma visualização rolável e editável que pode ser colocada em qualquer janela de nível superior.

Um objeto QSqlTableModel é declarado da seguinte maneira -

model = QtSql.QSqlTableModel()

Sua estratégia de edição pode ser definida como qualquer uma das seguintes -

QSqlTableModel.OnFieldChange	Todas as alterações serão aplicadas imediatamente
QSqlTableModel.OnRowChange	As alterações serão aplicadas quando o usuário selecionar uma linha diferente
QSqlTableModel.OnManualSubmit	Todas as alterações serão armazenadas em cache até que submitAll () ou revertAll () seja chamado

Exemplo

No exemplo a seguir, a tabela do esportista é usada como modelo e a estratégia é definida como -

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

A classe QTableView faz parte da estrutura Model / View no PyQt. O objeto QTableView é criado da seguinte maneira -

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

Este objeto QTableView e dois widgets QPushButton são adicionados à janela QDialog de nível superior. O sinal clicado () do botão adicionar é conectado a addrow () que executa insertRow () na tabela do modelo.

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

O Slot associado ao botão de exclusão executa uma função lambda que exclui uma linha, que é selecionada pelo usuário.

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

O código completo é o seguinte -

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

O código acima produz a seguinte saída -

Tente adicionar e excluir alguns registros e voltar ao SQLiteStudio para confirmar as transações.