Esse artigo mostrará como criar você pode integrar recursos do SQLite a sua aplicação usando a arquitetura modelo/visão em uma aplicação-exemplo de gerenciamento de contatos.
Introdução
Um recursos importante do Qt é o suporte a SQL. Usando a arquitetura modelo/visão do Qt e um mínimo de conhecimento em SQL é possível criar poderosas aplicações baseadas em banco de dados. Se você for um iniciante em SQL pode encontrar bons materiais introdutórios sobre SQL pesquisando na web. O SQL é considerada a linguagem mais usada nos sistemas de gerenciamento de banco de dados e parte de qualquer cursos de ciência da computação. Em especial, o SQLite é útil para aplicações móveis já que é um banco de dados SQL transacional, que necessita de configuração zero, não dependente de servidor e auto-contido. O SQLite tem sido usado em vários projetos grandes como Mozilla Firefoz, smartphones Symbian, Solaris, PHP, MAc OS, entre outros, e é provavelmente o banco de dados SQL mais largamente usado. No Qt, o SQLite está disponível para desktop, Meego e Symbian.
Nesse artigo será demonstrado como vocÊ pode integrar os recursos do SQLite a sua aplicação usando a arquitetura modelo/visão em uma aplicação de gerenciamento de contatos. O Nokia Qt SDK foi usado nesse exemplo.
Se estiver usando dispositivos Maemo como o N900, é necessário instalar o SQLite para Qt antes de testar essa aplicação em seu dispositivo. Abra a aplicação X Terminal e digite os seguintes comandos:
sudo gainroot apt-get install libqt4-sql-sqlite
sudo gainroot permite que você execute comandos em seu telefone como administrador e precisa ser usado com cuidado.
Para usuários Symbian, a aplicação sqlite3.sis é necessário. Pode ser encontrado junto com o Nokia Qt SDK em \NokiaQtSDK\Symbian\sis\sqlite3.sis ou pronto para instalação a partir do menu Iniciar (Nokia Qt SDK -> Symbian -> Install SQLite to Symbian).
Se não quiser usar um dispositivo real, umaalternativa é usar o simulador do Qt, disponível no Nokia Qt SDK. Nenhuma instalação adicional é necessária nesse caso.
Classes Qt para acessar o SQLite
Usando Qt, as classes SQL são divididas em três camadas:
- Camada de Driver: Um conjunto de classes úteis para quem quiser criar o seu próprio driver de banco de dados e adicionar personalizações aos recursos existentes.
- Camada da API SQL: Acesso básico ao banco de dados, como conexões, erros, manipulação de campos e assim em diante.
- Camada da interface com o usuário: Um conjunto de classes para ser usadas com a arquitetura modelo/visão do Qt.
Apenas as camadas dois e três serão usadas nesse artigo, e são representadas pelas seguintes classes disponíveis na arquitetura modelo/visão:
- QSqlDatabase: O conector com o banco de dados (fonte de dados, nessa arquitetura). Como o SQLite é mapeado em um arquivo, a conexão é direta. Para banco de dados mais sofisticados, parâmetros como login, senha e porta podem ser fornecidos.
- QSqlTableModel: usado como modelo, fornece uma interface de alto nível para acesso ao banco de dados.
- QTreeView: o objeto da visão usado para exibir os registros do banco de dados
Conectando o banco de dados SQLite a arquitetura modelo/visão do Qt
Como os banco de dados do SQLite são mapeados em arquivos, a conexão ao banco de dados consiste apenas de especificar o arquivo a ser usado. Naturalmente, o caminho para o arquivo pode variar se você estiver programando para MeeGo ou Symbian e você deve cuidar dessa situação com sentenças #ifdef Q_OS_SYMBIAN. Além disso, você precisa criar a estrutura do banco de dados dentro desse arquivo antes de usa-lo para armazenar os registros.
In the following code snippet the database connector is created and the database opened. If the database structure does not exist yet it will be created.
// using SQLITE driver
QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("path_to_database_file");
if (db.open()) {
// Try to locate the contacts database.
// If it is not available create it.
if (db.tables().indexOf("contacts") == -1) {
QSqlQuery query(db);
query.prepare("CREATE TABLE contacts (name VARCHAR(32), phone VARCHAR(16))");
if (!query.exec())
qCritical() << query.lastError();
}
} else {
qCritical() << db.lastError();
}
O próximo passo é associar esse banco de dados a arquitetura modelo/visão. Os métodos setTable() (da classe modelo) e setModel() (da classe visão) são usados para cumprir essa tarefa. É necessário chamar select() para popular o modelo com dados da tabela e o programador pode escolher sua estratégia de edição chamando o método setEditEstrategy(). Nesse caso, usando QSqlTableModel::OnFieldChange, qualquer alteração será aplicada imediatamente ao banco de dados.
// create a new model and use the contacts table
QSqlTableModel *model = new QSqlTableModel(this, db);
model->setTable("contacts");
// All changes to the model will be applied immediately to the database
model->setEditStrategy(QSqlTableModel::OnFieldChange);
// Populate the model with data from table
model->select();
// creating the model/view association
ui->view->setModel(model);
Agora sua aplicação está pronta para ser iniciada e todos os dados do banco de dados estarão disponíveis ao usuário através do componente. Adicionalmente, sua aplicação tem suporte a persistência de dados sem qualquer linha de código, todos os registros são mantidos durante as sucessivas execuções do programa.
Adicionando registros
Quando os registros puderem ser visualizados, sua próxima tarefa é criar uma caixa de diálogo para disponibilizar os dados aos usuários. O designer do formulário do Qt Creator torna essa tarefa muito fácil. Uma caixa de diálogo simples com apenas dois campos (nome e telefone) é necessária para essa aplicação exemplo. Crie essa caixa de diálogo e as classes relacionadas e adicione-as ao seu projeto, adicionando métodos para os botões Cancel e Ok. Para mostrar a caixa de diálogo, você precisa usar o método exec(). Depois que essa caixa de diálogo é fechada, você pode verificar se tem algum dado válido e assim adicionar esses dados ao seu banco de dados como um novo registro. O método record() (do modelo) retornará um registro SQL de acordo com a especificação do banco de dados e você pode preencher esse registro usando o método sertValue(). As propriedades do Qt são usadas na classe da caixa de diálogo para nos ajudar a coletar os dados necessários e o método do modelo insertRecord() adicionará esse registro ao banco de dados.
// Create a new empty dialog and show it using exec()
NewContact dlg(this);
dlg.resetName();
dlg.resetPhone();
if(dlg.exec() == QDialog::Accepted && dlg.name().length() > 0) {
// create a record from the current model
QSqlRecord rec = model->record();
rec.setValue("name", dlg.name());
rec.setValue("phone", dlg.phone());
// insert a new record (-1)
model->insertRecord(-1,rec);
}
Apagando registro
O apagamento de registros é simples já que você tem o indice de registro. Obtenha o indice como um objeto QModelIndex pesquisando o componente da visão e usando-o como um parâmetro para a chamada a removeRow() (do modelo).
// get the current index, if any
QModelIndex sample = ui->view->currentIndex();
if (sample.row() >= 0) {
QMessageBox::StandardButton reply;
reply = QMessageBox::question(this, tr("Remove contact"),
QString(tr("Remove contact ?")),
QMessageBox::Yes | QMessageBox::No);
if(reply == QMessageBox::Yes)
model->removeRow(sample.row()); // remove the current index
}
Modificando registros
Depois de criar os métodos addRegister() e deleteRecord(), é fácil codificar o método editRecord(). Obtenha o indice do registro e preencha a caixa de diálogo usando as informações do registro. Depois apresente essa caixa de diálogo ao usuário e salve as alterações.
// get the current index, if any
QModelIndex sample = ui->view->currentIndex();
if (sample.row() >= 0 ) {
// copy the current record
QSqlRecord rec = model->record(sample.row());
NewContact dlg(this);
dlg.setName(rec.value("name").toString());
dlg.setPhone(rec.value("phone").toString());
if (dlg.exec() == QDialog::Accepted) {
rec.setValue("name",dlg.name());
rec.setValue("phone",dlg.phone());
// save modified data
model->setRecord(sample.row(),rec);
}
}
Conclusão
Como o Qt é possível criar programas consisos que usam persistência de dados com SQL usando poucas linhas de código. Em especial, a abstração do SQLite fornecida pelo Qt é realmente direta quando usada junto com a arquitetura modelo/visão do Qt.
Código-fonte
Esse programa exemplo foi testado no Maemo, Linux e Windows sem modificações. Você pode baixar todo o código fonte nesse link.