Atenção: esse artigo tem um vídeo complementar. Clique e assista!
Nesse artigo apresentaremos, através de um exemplo completo, a persistência de dados na plataforma Android com SQLite. Ele traz para o mundo mobile a experiência de bancos de dados relacionais tão comuns nos ambientes web e desktop.
Para que serve:
Até aplicações mais simples precisam persistir dados para serem recuperados posteriormente. E com o aumento da complexidade das aplicações mobile, esse recurso é cada vez mais requisitado.
Em que situação o tema é útil:
Diversos tipos de aplicação necessitam salvar e recuperar informações: jogos salvam os recordes do usuário, assim como clientes móveis de sistemas de informação e aplicativos utilitários salvam dados localmente para evitar acesso à rede que pode pesar no bolso do usuário.
Autores: Nelson Glauber de Vasconcelos Leal, Breno Augusto de Melo Menezes e Edilson Mendes Bizerra Junior
O armazenamento de dados é um dos pontos principais que deve ser considerado no desenvolvimento de uma aplicação. Sem ele, os dados ficam disponíveis apenas em tempo de execução, ou seja, após a execução do programa, esses dados são perdidos. Tal prática é inaceitável em grande parte das aplicações. Com isso, faz-se necessário algum mecanismo para persistência dos dados.
Inicialmente, o armazenamento era feito em sistemas de arquivos do sistema operacional e era responsabilidade da aplicação gerenciar esses arquivos, definir localização, controle de permissão, concorrência, etc. Esta responsabilidade introduzia uma complexidade desnecessária e que não fazia parte das regras de negócio da aplicação, afetando diretamente a produtividade dos desenvolvedores.
Estes problemas foram amenizados com o surgimento do Sistema de Gerenciamento de Banco de Dados (SGBD). Um SGBD consiste em um conjunto de programas de computador (softwares) responsáveis pelo gerenciamento de um banco de dados. O principal objetivo é retirar da aplicação cliente a responsabilidade de gerenciar o acesso, manipulação e organização dos dados. O SGBD disponibiliza uma interface (API, Drivers) para que os seus clientes possam incluir, alterar ou consultar dados.
No contexto de aplicações para dispositivos móveis, a escassez de recursos computacionais, tais como memória, capacidade de armazenamento, inerentes a dispositivos móveis pessoais (celulares e PDAs), combinado com a falta de suporte, faz com que os desenvolvedores para estes tipos de dispositivos não desfrutem dos benefícios de um SGBD. Muitas tecnologias para desenvolvimento móvel, assim como no início do desenvolvimento de aplicações desktop, se baseiam em arquivos para armazenar dados. Por exemplo, a plataforma Java ME possui o Record Management System (RMS). O RMS consiste em uma API que dispõe de métodos para manipular registros. Entretanto, a manipulação de dados nessa API não poupa o desenvolvedor de lidar com rotinas de baixo nível para serialização dos dados, já que a API só trabalha com arrays de bytes.
Em contrapartida, a plataforma Android, dentre uma série de inovações e facilidades, trouxe suporte nativo ao SQLite. Uma poderosa biblioteca de banco de dados baseado em SQL (Structured Query Language) que atua como um “mini-SGBD”, capaz de controlar diversos bancos de dados que podem conter diversas tabelas. O desenvolvedor pode criar o banco de dados e as tabelas, assim como manipular seus dados através dos comandos DDL (Data Definition Language) e DML (Data Manipulation Language) do SQL padrão. Isso traz um ganho considerável de produtividade, pois o desenvolvedor agora pode apenas focar nas regras de negócio, tendo em vista que os serviços para persistência de dados são fornecidos pelo SQLite.
No Android, cada aplicação pode criar um ou diversos bancos de dados que ficam localizados no seguinte diretório: /data/data/pacote.da.app/databases. Um banco de dados é visível apenas à aplicação que o criou. Entretanto, o Android oferece uma API, conhecida como Content Providers, que permite compartilhar informações com outras aplicações. Deste modo, elas podem consultar, inserir, alterar e remover informações. Um exemplo clássico é o provedor de conteúdo de Contatos, em que qualquer aplicação pode manipular os contatos cadastrados na agenda do celular.
Para utilizar o SQLite em uma aplicação Android, precisamos criar um banco de dados, e podemos fazê-lo de algumas formas, dentre elas:
• Utilizando a API do Android para SQLite: Além de criar o banco, através da API, é possível criar tabelas e inserir dados através de scripts SQL;
• Usando um cliente do SQLite, tais como SQLite Expert Personal e SQLite Plus (veja como obtê-los na seção Links);
• Utilizando o aplicativo Sqlite3 pelo console do emulador.
Utilizando o sqlite3 pelo console
É possível acessar um banco de dados de uma aplicação a partir da linha de comando usando o comando sqlite3, onde é possível gerenciar os bancos de dados criados por aplicações Android. Para usar o sqlite3, abra uma janela de linha de comando, e dentro do diretório tools onde o SDK do Android está instalado, conecte-se ao emulador executando o comando:
adb shell Caso esteja com mais de um dispositivo Android aberto (emulador ou dispositivo real), podemos passar o parâmetro -s seguido do id do dispositivo.
adb -s emulator-5554 shell Uma vez conectados ao emulador, digite o comando sqlite3. Ao invocar esse comando, é possível especificar o caminho do banco de dados que se deseja explorar. Se o arquivo não existir, um novo será criado automaticamente. Por exemplo:
sqlite3 /data/data/ngvl.android.feira/databases/mercado
mercado
SQLite version 3.5.9
Enter “.help” for instructions Após executar o sqlite3, os comandos podem ser executados no terminal. É possível criar, alterar e remover tabelas e campos e realizar consultas, inserir, atualizar e remover dados da tabela através de comandos SQL. Os comandos abaixo ilustram alguns desses comandos:
sqlite> CREATE TABLE Feira (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,mercado TEXT NOT NULL,data DATE);
sqlite> CREATE TABLE Item (id_feira INTEGER,produto TEXT,qtde DECIMAL,preco DECIMAL); Estes primeiros comandos demonstram a criação das tabelas Feira e Item, respectivamente. Utilizaremos essas tabelas no exemplo que apresentaremos mais adiante.
Após a criação das tabelas, os dados podem ser inseridos por meio do comando SQL insert, como podemos observar a seguir:
sqlite> INSERT INTO Feira (mercado, data) VALUES ('Mercado do Ze', '2010-10-29');
sqlite> INSERT INTO Item (id_feira,produto,qtde,preco) VALUES (1, 'Biscoito', 2, 1.5);
sqlite> INSERT INTO Item (id_feira,produto,qtde,preco) VALUES (1, 'Feijão', 3, 5);
sqlite> INSERT INTO Item (id_feira,produto,qtde,preco) VALUES (1, 'Arroz', 4, 3); Através do insert, foram adicionados dados nas tabelas Feira e Item. Os dados podem ser visualizados através do comando select. Por exemplo:
sqlite> SELECT * FROM Feira;
1|Mercardo do Ze|2010-10-29
sqlite> SELECT * FROM Item WHERE id_feira = 1;
1|Biscoito|2|1.5
1|Feijao|3|5
1|Arroz|4|3 No primeiro comando foram selecionados todos os registros da tabela Feira. Já no segundo, foram selecionados os registros da tabela Item pertencentes à Feira cujo valor do campo id seja igual a 1.
Além dos comandos SQL, existem comandos do sqlite3 que são bastante úteis como: .table, .schema, .dump e .quit. Para obter a relação de todas as tabelas do banco de dados corrente podemos utilizar o comando .table ou realizar uma query na tabela sqlite_master:
sqlite> .tables
Feira Item
sqlite> SELECT * FROM sqlite_master;
table|Feira|Feira|3|CREATE TABLE Feira (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,mercado TEXT NOT NULL,data DATE)
table|Item|Item|5|CREATE TABLE Item (id_feira INTEGER,produto TEXT,qtde DECIMAL,preco DECIMAL) Usando o comando .schema pode-se obter o esquema, ou seja, a estrutura de uma ou de todas as tabelas:
sqlite> .schema
CREATE TABLE Feira (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,mercado TEXT NOT NULL,data DATE);
CREATE TABLE Item (id_feira INTEGER,produto TEXT,qtde DECIMAL,preco DECIMAL);
sqlite> .schema Item
CREATE TABLE Item (id_feira INTEGER,produto TEXT,qtde DECIMAL,preco DECIMAL); Nos bancos de dados as operações de exportação e importação são muito importantes. No sqlite3, o comando .dump é responsável pela exportação da base de dados. A execução desse comando sem nenhum argumento exibe na console todas as regras de criação das tabelas bem como os comandos de inserção de dados nas mesmas, permitindo efetuar a exportação da base de dados. O comando .dump é apresentado abaixo:
sqlite> .dump
BEGIN TRANSACTION;
CREATE TABLE Feira (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,mercado TEXT NOT NULL,data DATE);
INSERT INTO "Feira" VALUES(1,'Mercado do Ze','2010-10-29');
DELETE FROM sqlite_sequence;
INSERT INTO "sqlite_sequence" VALUES('Feira',1);
CREATE TABLE Item (id_feira INTEGER,produto TEXT,qtde DECIMAL,preco DECIMAL);
INSERT INTO "Item" VALUES(1,'Biscoito',2,1.5);
INSERT INTO "Item" VALUES(1,'Feijao',3,5);
INSERT INTO "Item" VALUES(1,'Arroz',4,3);
COMMIT; A saída deste comando pode ser redirecionada para um arquivo. Para isso, utilize o seguinte código:
sqlite3 /data/data/ngvl.android.feira/databases/mercado ".dump" > /sdcard/backup.txt Para importar o conteúdo de uma base de dados ou executar instruções SQL a partir de um arquivo, basta executar .read, como mostra o exemplo a seguir:
sqlite3 /data/data/ngvl.android.feira/databases/mercado ".read /sdcard/backup.txt" O resultado do comando abaixo é semelhante a do .read e pode ser usado como forma alternativa:
sqlite3 / data/data/ngvl.android.feira/databases/mercado < /sdcard/backup.txt Estas foram apenas algumas das opções fornecidas pelo sqlite3. O comando .help apresenta a lista de todos os comandos desse aplicativo. Para sair do sqlite3, execute .quit. É importante ressaltar que esses comandos só estão disponíveis para o emulador. Nos dispositivos reais, normalmente essa aplicação não está habilitada.
Utilizando a Ferramenta SQLite Expert Personal
Como vimos, o Android possui uma ferramenta de linha de comando para gerenciar bases dados SQLite, a ...
