VI.

Bases de Dados
Primeiros passos com SQLite

Nos próximos tópicos deste tutorial de programação Android, vamos nos deter em
describir las distintas opciones de acceso a datos que proporciona la plataforma y en cómo
podemos realizar as tarefas mais habituais dentro deste apartado.

La plataforma Android proporciona dos herramientas principales para el almacenamiento y

consulta de dados estruturados:

Bases de Datos SQLite

Provedores de Conteúdo

Nos próximos tópicos, nos concentraremos na primeira opção, SQLite, que abrangerá
todas las tareas relacionadas con el almacenamiento de los datos propios de nuestra
aplicação. O segundo dos mecanismos, os Content Providers, que trataremos mais
avante, nos facilitarão a tarefa de tornar esses dados visíveis para outras aplicações e, de forma
recíproca, de permitir a consulta de dados publicados por terceiros a partir da nossa aplicação.

SQLiteé um motor de banco de dados muito popular atualmente por oferecer características
tão interessantes quanto o seu pequeno tamanho, não precisar de servidor, exigir pouca configuração,
sertransacionale, claro, ser de código livre.

O Android incorpora de série todas as ferramentas necessárias para a criação e gestão de

bancos de dados SQLite, e entre eles uma API completa para realizar de maneira simples
todas as tarefas necessárias. No entanto, nesta primeira parte sobre bancos de dados em
Android, não vamos entrar em muitos detalhes com esta API. Por enquanto, nos limitaremos a
ver o código necessário para criar um banco de dados, inseriremos alguns dados de teste, e
veremos como podemos comprovar que tudo funciona corretamente.

En Android, la forma típica para crear, actualizar, y conectar con una base de datos SQLite
será através de uma classe auxiliar chamadaSQLiteOpenHelper, ou para ser mais exato, de
una clase propia que derive de ella y que debemos personalizar para adaptarnos a las
necessidades concretas da nossa aplicação.

A classeSQLiteOpenHelpertem apenas um construtor, que normalmente não

precisaremos sobrescrever, e dois métodos abstratos,onCreate()yonUpgrade(), que
devemos personalizar com o código necessário para criar nosso banco de dados e para
atualizar sua estrutura respectivamente.

Como exemplo, nós vamos criar uma base de dados muito simples chamada
BDUsuarios, com uma única tabela chamada Usuários que conterá apenas dois campos: nome
e email. Para eles, vamos criar uma classe derivada deSQLiteOpenHelperque
chamaremosUsuariosSQLiteHelper, onde sobrescreveremos os métodos
onCreate()yonUpgrade()para adaptarlos a la estructura de datos indicada:
package [Link];

importar [Link];
importar [Link];
importar [Link];
import [Link];

public class UsuariosSQLiteHelper extends SQLiteOpenHelper {

//Instrução SQL para criar a tabela de Usuários

String sqlCreate = "CREATE TABLE Usuarios (codigo INTEGER, nombre TEXT)";

public UsuariosSQLiteHelper(Context contexto, String nombre,

CursorFactory factory, int versão) {
super(contexto, nome, fábrica, versão);
}

@Override
public void onCreate(SQLiteDatabase db) {
//Se ejecuta la sentencia SQL de creación de la tabla
[Link](sqlCreate);
}

@Override
public void onUpgrade(SQLiteDatabase db, int versãoAnterior,
int versãoNova) {
//NOTA: Por simplicidade do exemplo aqui utilizamos diretamente
// a opção de eliminar a tabela anterior e criá-la novamente
// vazio com o novo formato.
// No entanto, o normal será que seja necessário migrar dados da
// tabela antiga para a nova, pelo que este método deve
// ser mais elaborado.

//A versão anterior da tabela é eliminada

[Link]("DROP TABLE IF EXISTS Usuarios");

//Uma nova versão da tabela é criada

[Link](sqlCreate);
}
}

A primeira coisa que fazemos é definir uma variável chamadasqlCreateonde armazenamos a

{"texto":"sentença SQL para criar uma tabela chamada Usuários com os campos alfanuméricos nome e"}
email. NOTA: Não é objetivo deste tutorial descrever a sintaxe da linguagem SQL nem as
particularidades do motor de banco de dados SQLite, portanto não entrarei em descrever as
sentenças SQL utilizadas. Para mais informações sobre SQLite, você pode consultar a
documentación oficial o empezar por leer una pequeña introducción que hice en este mismo
blog quando tratei do tema de utilizar SQLite a partir de aplicações .NET

O métodoonCreate()será executado automaticamente pela nossa classe

UsuariosDBHelperquando for necessária a criação da base de dados, ou seja, quando
ainda não exista. As tarefas típicas que devem ser feitas neste método serão a criação de todas
as tabelas necessárias e a inserção dos dados iniciais, se forem necessários. No nosso caso,
sómente vamos a criar a tabela Usuários descrita anteriormente. Para a criação da tabela
utilizaremos a instrução SQL já definida e a executaremos contra o banco de dados utilizando
o método mais simples dos disponíveis na API de SQLite fornecida pelo Android,
chamadoexecSQL()Este método se limita a executar diretamente o código SQL que lhe
pasemos como parâmetro.
Por sua parte, o métodoonUpgrade()será lançado automaticamente quando necessário
uma atualização da estrutura da base de dados ou uma conversão dos dados.

Um exemplo prático: imaginemos que publicamos um aplicativo que utiliza uma tabela com os
campos usuario e email (llamémoslo versión 1 de la base de datos). Más adelante, ampliamos
a funcionalidade da nossa aplicação e precisamos que a tabela também inclua um campo
adicional por exemplo com a idade do usuário (versão 2 da nossa base de dados). Pois bem,
para que tudo funcione corretamente, da primeira vez que executarmos a versão ampliada de
na aplicação, precisaremos modificar a estrutura da tabela Usuários para adicionar o novo
campo idade. Pois este tipo de coisas são as que se encarregará de fazer automaticamente o
métodoonUpgrade()quando tentarmos abrir uma versão concreta do banco de dados
que ainda não exista. Para isso, como parâmetros, recebe a versão atual do banco de dados em
o sistema, e a nova versão à qual se deseja converter. Em função dessa dupla de dados
precisaremos realizar umas ações ou outras. No nosso caso de exemplo, optamos pela
opción más sencilla: borrar la tabla actual y volver a crearla con la nueva estructura, pero
como se indica nos comentários do código, o habitual será que precisemos de algo mais de
lógica para convertir la base de datos de una versión a otra y por supuesto para conservar los
dados registrados até o momento.

Uma vez definida nossa classe helper, a abertura do banco de dados a partir de nossa aplicação
resulta ser algo de lo mais simples. O primeiro será criar um objeto da classe
UsuariosSQLiteHelperao qual passaremos o contexto da aplicação (no exemplo uma
referencia a la actividad principal), el nombre de la base de datos, un objeto
CursorFactoryque tipicamente não será necessário (nesse caso passaremos o valornull),
e por último a versão do banco de dados que precisamos. A simples criação deste objeto
pode ter vários efeitos:

Se a base de dados já existir e sua versão atual coincidir com a solicitada, simplesmente
a conexão com ela será realizada.
Se a base de dados existir mas a sua versão atual for anterior à solicitada, será chamada
automaticamente ao métodoonUpgrade()para converter o banco de dados para a
nova versão e se conectará com o banco de dados convertido.
Se a base de dados não existir, o método onCreate() será chamado automaticamente para
criá-la e ela se conectará com o banco de dados criado.

Uma vez que temos uma referência ao objetoUsuariosSQLiteHelper, chamaremos o seu

métodogetReadableDatabase()ogetWritableDatabase() para obter uma
referência ao banco de dados, dependendo se precisamos apenas consultar os dados ou também
precisamos realizar modificações, respectivamente.

Agora que já conseguimos uma referência ao banco de dados (objeto do tipo

SQLiteDatabase) já podemos realizar todas as ações que quisermos sobre ela. Para
nosso exemplo nos limitaremos a inserir 5 registros de teste, utilizando para isso o
método já comentadoexecSQL()com as sentençasINSERIRcorrespondentes. Por último
cerramos la conexión con la base de datos llamando al método fechar().
pacote [Link];

importar [Link];
importar [Link];
importar [Link];

public class AndroidBaseDatos extends Activity

{
@Override
public void onCreate(Bundle savedInstanceState)
{
[Link](savedInstanceState);
setContentView([Link]);

//Abrimos la base de datos 'DBUsuarios' en modo escritura

UsuariosSQLiteHelper usdbh =
new UsuariosSQLiteHelper(this, "DBUsuarios", null, 1);

SQLiteDatabase db = [Link]();

//Se abrimos corretamente o banco de dados

se(db != null)
{
//Inserimos 5 usuários de exemplo
for(int i=1; i<=5; i++)
{
//Geramos os dados
int codigo = i;
String nome = "Usuário" + i;

//Inserimos os dados na tabela Usuários

[Link]("INSERT INTO Usuarios (codigo, nombre) ")
VALORES (
}

{"text":"Fechamos o banco de dados"}

[Link]();
}
}
}

Ok, e agora o que? Onde está o banco de dados que acabamos de criar? Como podemos
verificar se tudo correu bem e se os registros foram inseridos corretamente? Vamos lá
por partes.

En primer lugar veamos dónde se ha creado nuestra base de datos. Todas las bases de datos
SQLite criadas por aplicativos Android são armazenadas na memória do telefone em um
arquivo com o mesmo nome do banco de dados localizado em um caminho que segue o seguinte
padrão:

/data/data/[Link]/databases/nome_base_dados

No caso do nosso exemplo, o banco de dados seria armazenado no seguinte caminho:

/data/data/[Link]/databases/DBUsuarios

Para comprovar isso, podemos fazer o seguinte. Uma vez executado pela primeira vez desde
Eclipse a aplicação de exemplo no emulador do Android (e, claro, antes de
fechá-lo) podemos ir à perspectiva "DDMS" (Dalvik Debug Monitor Server) do Eclipse e na
Na aba "Explorador de Arquivos", poderemos acessar o sistema de arquivos do emulador, onde
podemos buscar a rota indicada do banco de dados. Podemos ver isso no seguinte
imagen:

Com isso, já verificamos pelo menos que o arquivo do nosso banco de dados foi criado na
rota correta. Já só nos resta verificar que tanto as tabelas criadas quanto os dados
inseridos também foram incluídos corretamente na base de dados. Para isso, podemos
recorrer a dois possíveis métodos:

1. Transferir a base de dados para o nosso PC e consultá-la com qualquer administrador de

bancos de dados SQLite.
2. Aceder diretamente ao console de comandos do emulador do Android e utilizar os
comandos existentes para acessar e consultar o banco de dados SQLite.

O primeiro dos métodos é simples. O arquivo do banco de dados podemos transferi-lo para
nosso PC utilizando o botão de download localizado no canto superior direito do
explorador de arquivos (destacado em vermelho na imagem anterior). Ao lado deste botão
aparecem outros dois para fazer a operação contrária (copiar um arquivo local para o sistema de
arquivos do emulador) e para eliminar arquivos do emulador. Uma vez baixado o arquivo para
nosso sistema local, podemos usar qualquer administrador de SQLite para abrir e
consultar la base de datos, por ejemplo Administrador SQLite(gratuito).

O segundo método utiliza uma estratégia diferente. Em vez de baixar o banco de dados para
nosso sistema local, somos nós que acessamos remotamente o emulador a
através de sua consola de comandos (shell). Para isso, com o emulador de Android ainda aberto,
devemos abrir um console do MS-DOS e utilizar a utilidade [Link] (Android Debug Bridge)
situada na pastaferramentas de plataformado SDK do Android (no meu caso:c:\android-
sdk-windows\ferramentas-da-plataforma\). Em primeiro lugar, consultaremos os identificadores de
todos os emuladores em execução através do comando “dispositivos adb. Isso nos deve
devolver uma única instância se tivermos apenas um emulador aberto, que no meu caso particular se
chamaemulador-5554“.
Após conhecer o identificador do nosso emulador, vamos acessar seu shell através do
comandoadb -s identificador-do-emulador shell. Uma vez conectados, já
podemos acceder a nuestra base de datos utilizando el comando sqlite3passando a rota
do arquivo, para nosso exemplosqlite3 /data/data/[Link]/
bancos de dados/DBUsuarios. Se tudo correu bem, deve aparecer o prompt do SQLite
“sqlite>o que nos indicará que já podemos escrever as consultas SQL necessárias sobre
nossa base de dados. Nós vamos verificar se existe a tabela Usuários e se foram
inseridos os cinco registros de exemplo. Para isso faremos a seguinte consulta: “SELECIONAR *
DE Usuarios;“. Si todo es correcto esta instrucción debe devolvernos los cinco usuarios
existentes en la tabla. En la imagen siguiente se muestra todo el proceso descrito:

Con esto ya hemos comprobado que nuestra base de datos se ha creado correctamente, que
todos os registros de exemplo foram inseridos e tudo funciona como esperado.

Nos seguintes tópicos, comentaremos as diferentes possibilidades que temos na hora

de manipular los datos de la base de datos (insertar, eliminar y modificar datos) y cómo
podemos realizar consultas sobre os mesmos, já que [como sempre] teremos várias
opciones disponibles.

Insertar/Actualizar/Eliminar

Na seção anterior do curso de programação em Android, vimos como criar um banco de

dados para utilizá-la a partir do nosso aplicativo Android. Nesta segunda parte da série
vamos a descrever as possíveis alternativas que a API do Android oferece na hora de
inserir, atualizar e excluir registros do nosso banco de dados SQLite.

A API do SQLite do Android fornece duas alternativas para realizar operações sobre a
base de dados que não retornam resultados (entre elas a inserção/atualização/exclusão
de registros, mas também a criação de tabelas, de índices, etc).
O primeiro deles, que já comentamos brevemente na seção anterior, é o método
execSQL()da classeSQLiteDatabaseEste método permite executar qualquer
sentença SQL sobre a base de dados, desde que esta não retorne resultados. Para isso,
simplesmente aportaremos como parâmetro de entrada deste método a cadeia de texto
correspondente com a sentença SQL. Quando criamos o banco de dados no post anterior já
vimos algum exemplo disso para inserir os registros de teste. Outros exemplos poderiam ser
os seguintes:

//Inserir um registro
[Link]("INSERT INTO Usuarios (usuario,email) VALUES ")
('usu1','usu1@[Link]')

//Eliminar un registro
[Link]("DELETE FROM Usuarios WHERE usuario='usu1' ");

Atualizar um registro
[Link]("UPDATE Usuarios SET email='nuevo@[Link]' WHERE usuario='usu1'")
");

A segunda das alternativas disponíveis na API do Android é utilizar os métodos

inserir(), atualizar()ydeletar()proporcionados também com a classe
SQLiteDatabase. Estes métodos permitem realizar as tarefas de inserção, atualização e
eliminação de registros de uma forma algo mais paramétrica queexecSQL(), separando
tabelas, valores e condições em parâmetros independentes desses métodos.

Comecemos pelo métodoinserir()para inserir novos registros no banco de dados.

Este método recebe três parâmetros, o primeiro deles será o nome da tabela, o terceiro
serão os valores do registro a serem inseridos, e o segundo nós o deixaremos de lado por enquanto, já que tão
sólo se hace necesario en casos muito pontuais (por exemplo para poder inserir registros
completamente vacíos), en cualquier otro caso pasaremos con valor null este segundo
parâmetro.

Os valores a inserir serão passados como elementos de uma coleção do tipo

Valores de Conteúdo. Esta coleção é do tipo dicionário, onde armazenaremos pares de
clave-valor, donde la clave será el nombre de cada campo y el valor será el dato
correspondente a inserir nesse campo.

Vamos ver um exemplo:

//Creamos el registro a insertar como objeto ContentValues

ContentValues novoRegistro = new ContentValues();
[Link]("usuario", "usu10");
[Link]("email","usu10@[Link]");

//Inserimos o registro no banco de dados

[Link]("Usuarios", null, nuevoRegistro);

Os métodosatualizar()ydeletar()serão utilizados de forma muito parecida com esta, com a

salvedad de que receberão um parâmetro adicional com a condiçãoONDEda sentença
SQL. Por exemplo, para atualizar o e-mail do usuário de nome 'usu1' faríamos o seguinte:
//Estabelecemos os campos-valores a atualizar
ContentValues valores = new ContentValues();
[Link]("email","usu1_nuevo@[Link]");

//Atualizamos o registro no banco de dados

[Link]("Usuarios", valores, "usuario='usu1'");

Como podemos ver, como terceiro parâmetro do métodoatualizar()passamos diretamente a

condição doATUALIZAÇÃOtal como faríamos na cláusulaONDEem uma sentença SQL
normal.

O métodoexcluir()se utilizaria de forma análoga. Por exemplo, para eliminar o registro do

usuário 'usu2' faríamos o seguinte:

//Eliminamos el registro del usuario 'usu2'

[Link]("Usuarios", "usuario='usu2'");

Como vemos, volvemos a pasar como primer parámetro el nombre de la tabla y en segundo
lugar a condiçãoONDE. Claro, se não precisássemos de nenhuma condição, poderíamos
deixar comonullneste parâmetro.

Um último detalhe sobre esses métodos. Tanto no caso deexecSQL()como nos casos
deatualizar()odeletar()podemos utilizar argumentos dentro das condições da
sentença SQL. Isto não são mais do que partes variáveis da sentença SQL que forneceremos em
desagrupar valores separados, o que nos evitará passar pela situação típica em que temos
que construir una sentencia SQL concatenando cadenas de texto y variables para formar el
comando SQL final. Esses argumentos SQL serão indicados com o símbolo '?’, e os valores de
esses argumentos devem ser passados no array na mesma ordem em que aparecem na sentença
SQL. Assim, por exemplo, podemos escrever instruções como a seguinte:

//Eliminar un registro con execSQL(), utilizando argumentos

String[] args = new String[]{"usu1"};
[Link]("DELETE FROM Usuarios WHERE usuario=?, args;")

//Atualizar dois registros com update(), utilizando argumentos

ContentValues valores = new ContentValues();
[Link]("email","usu1_nuevo@[Link]");

String[] args = new String[]{"usu1", "usu2"};

[Link]("Usuarios", valores, "usuario=? OU usuario=?", args);

Esta forma de passar para a sentença SQL determinados dados variáveis pode nos ajudar
además a escribir código más limpio y evitar posibles errores.

En el siguiente apartado veremos cómo consultar la base de datos para recuperar registros
de acordo com um determinado critério.

Consultar/Recuperar registros

En el anterior apartado del curso vimos todas las opciones disponibles a la hora de insertar,
actualizar y eliminar datos de una base de datos SQLite en Android. En esta nueva entrega
vamos descrever a última das tarefas importantes de tratamento de dados que nos resta
por ver, a seleção e recuperação de dados.

De forma análoga a lo que vimos para las sentencias de modificación de datos, vamos a tener
duas opções principais para recuperar registros de um banco de dados SQLite no Android. A
a primeira delas utilizando diretamente um comando de seleção SQL, e como segunda
opção utilizando um método específico onde parametrizaremos a consulta ao banco de dados
datos.

Para a primeira opção, utilizaremos o métodorawQuery()da classeSQLiteDatabase.

Este método recebe diretamente como parâmetro um comando SQL completo, onde
indicamos los campos a recuperar y los criterios de selección. El resultado de la consulta lo
obtendremos em forma de cursor, que posteriormente poderemos percorrer para processar os
registros recuperados. Sirva a seguinte consulta a modo de exemplo:

Cursor c = [Link](" SELECT usuario,email FROM Usuarios WHERE ")

usuario='usu1'

Como no caso dos métodos de modificação de dados, também podemos adicionar a este
método uma lista de argumentos variáveis que tenhamos indicado no comando SQL com o
símbolo ' ?‘, por exemplo assim:

String[] args = new String[] {"usu1"};

Cursor c = [Link](" SELECT usuario,email FROM Usuarios WHERE usuario=? ",
args);

Mais adiante nesta seção, veremos como podemos manipular o objeto Cursor para
recuperar os dados obtidos.

Como segunda opción para recuperar datos podemos utilizar el método consulta()da classe
SQLiteDatabaseEste método recebe vários parâmetros: o nome da tabela, um array
com os nomes dos campos a recuperar, a cláusulaONDE, um array com os argumentos
variáveis incluídas noONDE(se houver, nullcaso contrário), a cláusula GROUP BY se
existe, a cláusulaTENDOse existe, e por último a cláusulaORDENAR PORsim existe.
Opcionalmente, pode-se incluir um parâmetro no final indicando o número máximo de
registros que queremos que nos devolva a consulta. Veamos o mesmo exemplo anterior
utilizando o métodoconsulta():

String[] campos = new String[] {"usuario", "email"};

String[] args = new String[] {"usu1"};

Cursor c = [Link]("Usuarios", campos, "usuario=?", args, null, null, null);

Como vemos, os resultados são devolvidos novamente em um objeto Cursor que devemos
recorrer para processar os dados obtidos.
Para percorrer e manipular o cursor retornado por qualquer um dos dois métodos mencionados
temos à nossa disposição vários métodos da classeCursor, entre os quais destacamos
dos dos dedicados a percorrer o cursor de forma sequencial e em ordem natural:

moverParaPrimeiro(): mueve el puntero del cursor al primer registro devuelto.

irParaOProximo()move the cursor pointer to the next returned record.

Os métodosmoverParaPrimeiro()ymoverParaProximo()devolvemVERDADEIROem caso de haver

realizado o movimento correspondente do ponteiro sem erros, ou seja, sempre que exista
um primeiro registro ou um registro seguinte, respectivamente.

Uma vez posicionados em cada registro, poderemos utilizar qualquer um dos métodos.
getXXX(índice_coluna)existentes para cada tipo de dado para recuperar o dado de
cada campo do registro atual do cursor. Assim, se quisermos recuperar, por exemplo, o segundo
columna del registro actual, y ésta contiene un campo alfanumérico, haremos la llamada
getString(1)[NOTA: los índices comienzan por 0, por lo que la segunda columna tiene
índice 1], en caso de contener un dato de tipo real llamaríamos a getDouble(1), e de forma
análoga para todos os tipos de dados existentes. Com tudo isso em mente, vejamos como
poderíamos percorrer o cursor retornado pelo exemplo anterior:

String[] campos = new String[] {"usuario", "email"};

String[] args = new String[] {"usu1"};

Cursor c = [Link]("Usuarios", campos, "usuario=?", args, null, null, null);

Nos certificamos de que existe pelo menos um registro

se ([Link]()) {
//Percorremos o cursor até que não haja mais registros
faça {
String usuario = [Link](0);
String email = [Link](1);
} enquanto([Link]());
}

Além dos métodos comentados da classeCursorexistem muitos mais que nós

podem ser úteis em muitas ocasiões. Por exemplo,getCount()te dirá o número total de
registros devolvidos no cursor,getColumnName(i)devolve o nome da coluna
com índice i,moverParaPosição(i)mova o ponteiro do cursor para o registro com índice i, etc.
Vocês podem consultar a lista completa de métodos disponíveis naclasse Cursorem a
documentación oficial de Android.

Com isso, terminamos a série de tópicos básicos dedicados às tarefas de manutenção

de dados em aplicações Android por meio de bancos de dados SQLite. Estou ciente de que
deixamos de lado alguns temas um pouco mais avançados (como por exemplo o uso de
transações, que tentarei tratar mais adiante), mas com os métodos descritos poderemos
realizar uma porcentagem bastante alta de todas as tarefas necessárias relativas ao tratamento de
dados estruturados em aplicativos Android.