BANCO DE DADOS PARA ANDROID

SQLite3
Um Banco de dados muito til para qualquer sistema de grande ou pequeno porte, a no ser que seu sistema lida apenas com dados simples, no utilizando de um banco para armazenar informaes.

O Android usa o banco de dados SQLite que open-source, o SQLite muito utilizado em aplicaes populares. Outros exemplo de quem utiliza o SQLite Mozilla Firefox e iPhone.

No Android o banco de dados que voc cria em uma aplicao s acessvel para si mesma, a no ser que voc utiliza um provedor de contedo (assunto a ser discutido em outro post), uma vez criado o banco de dados, ele armazenado no diretrio /data/data/{nome do pacote}/databases/{nome do banco} , alem de gerenciar o banco por cdigo voc pode faze-lo pelo adb(clique para saber mais) utilizando a ferramenta sqlite3. Exemplo:

$ adb -s emulator-5554 shell # sqlite3 /data/data/zarelli.exemplo/databases/banco SQLite version 3.3.12 Enter ".help" for instructions .... enter commands, then quit... # sqlite> .exit

A Aplicao
Vou implementar um exemplo bem simples sem a utilizao de interface, s com visualizao no Log. Primeiro vamos definir nosso banco de dados, vou fazer o SQL em um arquivo (diferente de muitos exemplos) e depois carregar no cdigo, eu prefiro assim pois acredito que tem mais controle e fica mais organizado. Aps sera implementado as classes de controle do banco e por fim vamos utiliza-las.

Defini a estrutura dos pacotes da seguinte maneira (com suas classes):

No arquivo create.sql vamos definir as tabelas de nosso database:

1 CREATE TABLE usuarios_tbl ( 2 id_usuarios INTEGER PRIMARY KEY 3 autoincrement, usuario varchar(45) NOT NULL , 4 senha varchar(45) NOT NULL, 5 nome_completo varchar(45) NOT NULL 6 );
Aps a definio do banco vamos criar a classe de mais baixo nvel, a BancoManager.java. Essa classe vai ser uma classe abstrata responsvel em criar o banco e ter o controle de verso dele, iremos utilizar como classe paiSQLiteOpenHelper.java que nativa do Android e tem a finalidade de gerenciamento.

1 public abstract class BancoManager extends SQLiteOpenHelper { 2 protected Context context; 3 4 public BancoManager(Context context, String nome, int versao) { 5 super(context, nome, null, versao); 6 this.context = context; 7 } 8 public abstract void onCreate(SQLiteDatabase bd); 9 10 public abstract void onUpgrade(SQLiteDatabase bd, int versaoAtual, int 11 versaoNova); 12 13 /** Atravez do id do arquivo sql ser gerado o banco de dados. 14 * * @param fileID 15 * @param bd 16 * @throws IOException 17 */ 18 protected void byFile(int fileID, SQLiteDatabase bd) throws IOException { 19 StringBuilder sql = new StringBuilder(); BufferedReader br = new BufferedReader(new 20 InputStreamReader(context.getResources().openRawResource(fileID))); 21 String line; 22 while ((line = br.readLine()) != null) { 23 line = line.trim(); if (line.length() > 0) { 24

25 26 27 28 29 30 31 } 32 33 34 35

sql.append(line); if (line.endsWith(";")) { bd.execSQL(sql.toString()); sql.delete(0, sql.length()); } } } }

Como vemos essa classe no faz nada se ningum implementar, nela temos um mtodo abstrato onCreate e onUpgrade, ambas precisam ser implementadas para que a coisa toda funcione, o mtodo onCreate ficar responsvel em criar o banco, caso o banco j exista nada ser alterado, o mtodo onUpgrade utilizado para atualizar a base da dados, caso alguma tabela seja alterada, mas nada acontece automaticamente devemos implementa-la de forma correta, esse mtodo ser chamado automaticamente caso a verso que passada no contrutor sej alterada.

Antes de implementar a BancoManager, vamos implementar a classe Banco.java, nela podemos abstrair muita informao, fiz ela o mais simples possvel, mas podemos tratar os insert,update,delete,select nesta classe de uma forma bem abstrata para que haja a melhor orientao possvel. Entenda que essa classe sera responsvel em gerenciar a conexo do banco.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class Banco { private BancoManager bancoManager; private SQLiteDatabase sqld; public Banco(BancoManager bancoManager) { this.bancoManager = bancoManager; } public void open() { sqld = bancoManager.getWritableDatabase(); } public SQLiteDatabase get() { if (sqld != null && sqld.isOpen()) { return sqld; } return null; } public void close() { bancoManager.close(); } }

Vamos usar a BancoManager.java como explicado anteriormente. Criei o BancoUsuarios.java que ir tratar da criao do nosso banco e atualizao.

1 2 3 4 5 6

public class BancoUsuarios extends BancoManager { //nome do banco de dados e verso public static final String NAME = "dBusuarios"; public static final String TAG_LOG = "BancoUsuarios"; public static final int VERSAO = 1;

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public BancoUsuarios(Context context) { //defino pelo contrutor do BancoManager a verso e o nome do banco super(context, NAME, VERSAO); } @Override public void onCreate(SQLiteDatabase bd) { criaTabelas(bd); } /** * Este mtodo chamado automaticamente quando a verso alterada. */ @Override public void onUpgrade(SQLiteDatabase bd, int versaoAtual, int versaoNova) { //realizaa tratamento de upgrade, caso tenha //alterao em tabelas por exemplo. Log.e(TAG_LOG, "V.atual: " + versaoAtual); Log.e(TAG_LOG, "Nova V.: " + versaoNova); //Aqui voc deve fazer o tratamento do update do banco. //no caso estou apagando minha tabela e criando novamente. try { bd.execSQL("drop table usuarios_tbl;"); } catch (Exception e) { Log.e(TAG_LOG, "onUpgrade", e); } criaTabelas(bd); } private void criaTabelas(SQLiteDatabase bd) { try { //crio o banco de dados atravez do arquivo create. byFile(R.raw.create, bd); } catch (Exception e) { Log.e(TAG_LOG, "criaTabelas", e); } } }

Como vimos implementamos tudo que necessrio para a criao e atualizao do banco. Caso algum no saiba a classe Log.java responsvel em escrever no DDMS(aprenda a usar) que nosso gerenciador de log de eventos, ningum que programa em android vive sem o DDMS. Agora que criamos toda nossa estrutura, construmos nosso alicerce, vamos mostrar nossa classe MainActivity.java por partes, definimos a estrutura da seguinte maneira:.

1 2 3 4 5 6 7 8

public class MainActivity extends Activity { public static final String TAG_LOG = "ExemploBanco"; private Banco banco; @Override public void onCreate(Bundle savedInstanceState)...

9 private void insert(String 10 usuario)... 11 private void select()... 12 private void update(String usuario,
String novo)... private void delete(String usuario)... }
Temos nossa tag de log e nosso Banco definido anteriormente. O mtodo onCreate vamos fazer toda chamada, iniciar o banco chamar os mtodos etc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //inicia e abre banco banco = new Banco(new BancoUsuarios(this)); banco.open(); //inicia o exemplo (insert,select,update,delete) Log.d(TAG_LOG, "\nINSERT"); //insiro o usuario insert("gbzarelli"); //insiro o usuario insert("registro_" + System.currentTimeMillis()); select();//busco Log.d(TAG_LOG, "\nUPDATE"); String update = "gbzarelli_" + System.currentTimeMillis(); //atualizo o nome update("gbzarelli", update); select();//busco Log.d(TAG_LOG, "\nDELETE"); delete(update);//deleto o registro select();//busco banco.close();//fecha o banco }

Acredito que at ai no tenha segredo, estamos inserindo dois usurios, um com o parmetro gbzarelli e o outro registro_xxxxxx (esse parmetro vai ser o usurio), aps ter inserido fazemos um update mudando o usurio de gbzarelli para gbzarelli_xxxxxx e por fim fazemos um delete no usurio que foi alterado. Entre essas operaes estamos realizando um select para mostrar as informaes.

O Insert Notamos que utilizamos uma classe chamada ContentValues que serve para linkar a coluna com o registro, essa classe como se fosse um hashmap. Aps o registro ser inserido retornado um long que respectivo ao id primrio da tabela.

1 2 3 4 5 6 7 8

private void insert(String usuario) { //inserir dados ContentValues cv = new ContentValues(); cv.put("usuario", usuario); cv.put("senha", "147147"); cv.put("nome_completo", "Guilherme Biff Zarelli"); long l = banco.get().insert("usuarios_tbl",

9 null, cv);
}

Log.i(TAG_LOG, "id insert: " + l);

O Select - Aqui usamos uma query comum, realizada na mo e passamos os parmetros atravs de um array de string cada posio respectiva com a ordem dos pontos de interrogao. Vemos tambm o uso do Cursor que referente ao ResultSet utilizado no JavaSE.

1 2 3 4 5 6 7 8 9 10 11 12 13

private void select() { //O cursor no android similar ao ResultSet do Java Cursor cursor = banco.get().rawQuery("select * from usuarios_tbl limit ?", new String[]{"5"}); while (cursor.moveToNext()) { Log.i(TAG_LOG, "id: " + cursor.getInt(cursor.getColumnIndex("id_usuarios"))); Log.i(TAG_LOG, "usuario: " + cursor.getString(cursor.getColumnIndex("usuario"))); Log.i(TAG_LOG, "senha: " + cursor.getString(cursor.getColumnIndex("senha"))); Log.i(TAG_LOG, "nomeCompleto: " + cursor.getString(cursor.getColumnIndex("nome_completo"))); Log.i(TAG_LOG, "-------"); } //Nunca esquea de feixar o cursor. cursor.close(); }

O Update Tambm utilizamos o ContentValues e o array de parmetros

1 private void update(String usuario, String novo) { ContentValues cv = new ContentValues(); 2 cv.put("usuario", novo); 3 banco.get().update("usuarios_tbl", cv, 4 "usuario==?", new String[]{usuario}); 5 }
O Delete No delete passamos a tabela e a condio e tambm o array de parmetros.

1 private void delete(String usuario) { banco.get().delete("usuarios_tbl", 2 "usuario==?", new String[]{usuario}); 3 }

Pronto, na implementao podemos notar que existe vrias de maneiras de fazer um select,insert,update ou delete, a classe SQLiteDatabase bem complexa e cheio de mtodos, somente com a prtica podemos criar um controle agradvel e bem usual. Agora basta estudar e ir aprimorando seu cdigo.

Se rodarmos vamos notar no DDMS mais ou menos o seguinte Log:

Caso queiram o projeto segue o link: ProjetoExemploBanco , o projeto foi realizado no NetBeans sobre o Fedora 16 x64 e configurado para a verso 3.2 do Android. Caso queira usar o NetBeans como sua IDE de Android faa os seguintes procedimentos (AQUI).