You are on page 1of 7

BANCO DE DADOS PARA ANDROID

SQLite3
Um Banco de dados é muito útil para qualquer sistema de grande ou pequeno porte, a não ser que seu sistema lida apenas com dados simples, não utilizando de um banco para armazenar informações.

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

No Android o banco de dados que você cria em uma aplicação só é acessível para si mesma, a não ser que você utiliza um provedor de conteúdo (assunto a ser discutido em outro post), uma vez criado o banco de dados, ele é armazenado no diretório “/data/data/{nome do pacote}/databases/{nome do banco}” , alem de gerenciar o banco por código 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 Aplicação
Vou implementar um exemplo bem simples sem a utilização de interface, só com visualização no Log. Primeiro vamos definir nosso banco de dados, vou fazer o SQL em um arquivo (diferente de muitos exemplos) e depois carregar no código, eu prefiro assim pois acredito que tem mais controle e fica mais organizado. Após 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):

iremos utilizar como classe paiSQLiteOpenHelper.length() > 0) { 24 . 3 4 public BancoManager(Context context. String nome. Essa classe vai ser uma classe abstrata responsável em criar o banco e ter o controle de versão dele.trim(). 21 String line. int versaoAtual.sql vamos definir as tabelas de nosso database: 1 CREATE TABLE usuarios_tbl ( 2 id_usuarios INTEGER PRIMARY KEY 3 autoincrement. 14 * * @param fileID 15 * @param bd 16 * @throws IOException 17 */ 18 protected void byFile(int fileID.getResources(). versao). 5 nome_completo varchar(45) NOT NULL 6 ). 12 13 /** Atravez do id do arquivo sql será gerado o banco de dados.openRawResource(fileID))). if (line. 7 } 8 public abstract void onCreate(SQLiteDatabase bd).context = context. 6 this.java. null. 4 senha varchar(45) NOT NULL. Após a definição do banco vamos criar a classe de mais baixo nível. int versao) { 5 super(context. nome. SQLiteDatabase bd) throws IOException { 19 StringBuilder sql = new StringBuilder(). 22 while ((line = br.java que é nativa do Android e tem a finalidade de gerenciamento. int 11 versaoNova).No arquivo create.readLine()) != null) { 23 line = line. BufferedReader br = new BufferedReader(new 20 InputStreamReader(context. 9 10 public abstract void onUpgrade(SQLiteDatabase bd. a BancoManager. usuario varchar(45) NOT NULL . 1 public abstract class BancoManager extends SQLiteOpenHelper { 2 protected Context context.

isOpen()) { return sqld.bancoManager = bancoManager. nela temos um método abstrato onCreate e onUpgrade. public static final String TAG_LOG = "BancoUsuarios". Antes de implementar a BancoManager. } public SQLiteDatabase get() { if (sqld != null && sqld. private SQLiteDatabase sqld. Criei o BancoUsuarios. } return null.getWritableDatabase(). } } } } Como vemos essa classe não faz nada se ninguém implementar. nela podemos abstrair muita informação.update. o método onCreate ficará responsável em criar o banco. sql.delete(0.endsWith(". caso alguma tabela seja alterada. o método onUpgrade é utilizado para atualizar a base da dados. public Banco(BancoManager bancoManager) { this. } public void open() { sqld = bancoManager. 1 2 3 4 5 6 public class BancoUsuarios extends BancoManager { //nome do banco de dados e versão public static final String NAME = "dBusuarios". .java que irá tratar da criação do nosso banco e atualização.append(line).java como explicado anteriormente. mas nada acontece automaticamente devemos implementa-la de forma correta.execSQL(sql.close().")) { bd.25 26 27 28 29 30 31 } 32 33 34 35 sql. Entenda que essa classe sera responsável em gerenciar a conexão do banco. caso o banco já exista nada será alterado. if (line. sql.length()).delete. esse método será chamado automaticamente caso a versão que é passada no contrutor sejá alterada.java.select nesta classe de uma forma bem abstrata para que haja a melhor orientação possível. ambas precisam ser implementadas para que a coisa toda funcione. mas podemos tratar os insert. vamos implementar a classe 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. } } Vamos usar a BancoManager. public static final int VERSAO = 1. fiz ela o mais simples possível. } public void close() { bancoManager.toString()).

try { bd. Caso alguém não saiba a classe Log. . } private void criaTabelas(SQLiteDatabase bd) { try { //crio o banco de dados atravez do arquivo create. "Nova V.raw. //Aqui você deve fazer o tratamento do update do banco. e). } /** * Este método é chamado automaticamente quando a versão é alterada. byFile(R. */ @Override public void onUpgrade(SQLiteDatabase bd. bd). caso tenha //alteração em tabelas por exemplo. } catch (Exception e) { Log.: " + versaoNova). //no caso estou apagando minha tabela e criando novamente.e(TAG_LOG. } } } Como vimos implementamos tudo que é necessário para a criação e atualização do banco..java é responsável em escrever no DDMS(aprenda a usar) que é nosso gerenciador de log de eventos. VERSAO).e(TAG_LOG. } criaTabelas(bd).e(TAG_LOG. Agora que criamos toda nossa estrutura. e).create.e(TAG_LOG. NAME. "criaTabelas". construímos nosso alicerce.. ninguém que programa em android vive sem o DDMS.atual: " + versaoAtual). Log. Log.java por partes. vamos mostrar nossa classe MainActivity. definimos a estrutura da seguinte maneira:.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 versão e o nome do banco super(context. private Banco banco. 1 2 3 4 5 6 7 8 public class MainActivity extends Activity { public static final String TAG_LOG = "ExemploBanco". "onUpgrade". } @Override public void onCreate(SQLiteDatabase bd) { criaTabelas(bd). int versaoNova) { //realizaa tratamento de upgrade. "V. @Override public void onCreate(Bundle savedInstanceState). int versaoAtual.").execSQL("drop table usuarios_tbl. } catch (Exception e) { Log.

essa classe é como se fosse um hashmap. 12 private void update(String usuario. "\nINSERT"). //inicia e abre banco banco = new Banco(new BancoUsuarios(this)).d(TAG_LOG. Entre essas operações estamos realizando um select para mostrar as informações. estamos inserindo dois usuários.onCreate(savedInstanceState)..//busco Log. cv. String novo). O Insert – Notamos que utilizamos uma classe chamada ContentValues que serve para linkar a coluna com o registro..currentTimeMillis().update.insert("usuarios_tbl".open(). banco. select(). "\nDELETE"). "Guilherme Biff Zarelli"). select(). 11 private void select(). //atualizo o nome update("gbzarelli".currentTimeMillis()). O método onCreate vamos fazer toda chamada.//busco Log. } Temos nossa tag de log e nosso Banco definido anteriormente. private void delete(String usuario). um com o parâmetro “gbzarelli” e o outro “registro_xxxxxx” (esse parâmetro vai ser o usuário).. update).delete) Log. "147147").put("nome_completo".... após ter inserido fazemos um update mudando o usuário de “gbzarelli” para “gbzarelli_xxxxxx” e por fim fazemos um delete no usuário que foi alterado.select. //inicia o exemplo (insert.close().d(TAG_LOG. iniciar o banco chamar os métodos 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. String update = "gbzarelli_" + System.put("usuario". long l = banco. usuario). //insiro o usuario insert("registro_" + System.get(). Após o registro ser inserido é retornado um long que é respectivo ao id primário da tabela. cv.//fecha o banco } Acredito que até ai não tenha segredo. "\nUPDATE"). //insiro o usuario insert("gbzarelli").9 private void insert(String 10 usuario). .//deleto o registro select()..//busco banco.d(TAG_LOG..put("senha". cv. 1 2 3 4 5 6 7 8 private void insert(String usuario) { //inserir dados ContentValues cv = new ContentValues(). delete(update).

4 "usuario==?". O Select .get(). novo). "senha: " + cursor. } O Update – Também utilizamos o ContentValues e o array de parâmetros 1 private void update(String usuario.getString(cursor. } Log. cv. cursor.Aqui usamos uma query comum. 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.put("usuario". 3 } Pronto.getColumnIndex("id_usuarios"))). "id: " + cursor. Agora basta estudar e ir aprimorando seu código. "-------"). .close(). Log. 5 } O Delete – No delete passamos a tabela e a condição e também o array de parâmetros.getColumnIndex("usuario"))). new String[]{"5"}).i(TAG_LOG.insert. } //Nunca esqueça de feixar o cursor.i(TAG_LOG. Log.moveToNext()) { Log.rawQuery("select * from usuarios_tbl limit ?".update ou delete.i(TAG_LOG.getString(cursor. 2 "usuario==?". "id insert: " + l). "usuario: " + cursor. 2 cv. na implementação podemos notar que existe várias de maneiras de fazer um select. somente com a prática podemos criar um controle agradável e bem usual.get(). Log. new String[]{usuario}).update("usuarios_tbl". cv). "nomeCompleto: " + cursor. while (cursor.getString(cursor.i(TAG_LOG.getColumnIndex("senha"))).9 null.i(TAG_LOG. new String[]{usuario}). 1 private void delete(String usuario) { banco.delete("usuarios_tbl".getColumnIndex("nome_completo"))).i(TAG_LOG. realizada na mão e passamos os parâmetros através de um array de string cada posição é respectiva com a ordem dos pontos de interrogação.getInt(cursor. String novo) { ContentValues cv = new ContentValues(). a classe SQLiteDatabase é bem complexa e cheio de métodos. Log.get(). Vemos também o uso do Cursor que é referente ao ResultSet utilizado no JavaSE. 3 banco.

o projeto foi realizado no NetBeans sobre o Fedora 16 x64 e configurado para a versão 3.2 do Android. .Se rodarmos vamos notar no DDMS mais ou menos o seguinte Log: Caso queiram o projeto segue o link: ProjetoExemploBanco . Caso queira usar o NetBeans como sua IDE de Android faça os seguintes procedimentos (AQUI).