Android – Carregando um database do SQLite

No artigo deste mês continuaremos falando do pequeno e notável Sistema Android junto com o SQLite. Pudemos conferir no mês anterior um exemplo simples de cadastro utilizando uma classe para acesso a dados. Criamos na mesma classe os comandos DML(Data Manipulation Language) e os DDL(Data Definition Language), ou seja, definimos  nossa Base de Dados e manipulamos nossos dados via código.

Neste artigo irei explorar um gerenciador do Banco de Dados SQLite chamado “SQLite Expert Personal” e depois criaremos um projeto para carregar os dados inseridos pelo mesmo. Tenho como objetivo carregar um arquivo .db do SQLite que já está pronto, com suas tabelas definidas e com dados. Isto se faz necessário, pois torna fácil a manipulação e criação de estruturas para o Banco de Dados deixando a parte da programação no Android apenas para comando de Manipulação de Dados.

SQLite Expert Personal

Este gerenciador de Banco de Dados possui várias funções disponíveis suportando visualizações de várias Bases de Dados simultaneamente, permite gerenciar campos de índice e chaves primárias. Possui também ferramentas para criação de gatilhos e visões.

O “SQLite Expert Personal” tem uma interface bem simples e intuitiva para que qualquer pessoa possa utilizá-lo. É interessante informar que a versão “Professional” é paga, portanto com alguns recursos adicionais, mas no nosso caso que não queremos gastar nada utilizaremos a versão “Personal” que pode ser baixada no seguinte endereço:

http://www.sqliteexpert.com/download.html

 

A instalação

 

A instalação é bem fácil e prática, Next, Next, Next e Install, a Figura 01 nos proporciona a conclusão da mesma.

Figura 01: Instalação do SQLite Expert Personal

Criando uma Base de Dados

Veremos como é fácil a manipulação no SQLite Expert Personal, depois de iniciado  clique em File/New database para podermos criar nossa base de Dados, defina as seguintes configurações,

Ver Imagem 02.

Database File: C:\Users\THIAGOO\Desktop\DBTHECLUB
Database Alias: DBTHECLUB
Encoding: UTF-8
Page Size: 1024
Auto Vacuum: 0

Figura 02: Propriedades.

Criando uma Tabela

Para isto clique com o botão direito em cima do “DBTHECLUB” e escolha “New Table”. Em Table Name defina como TB_CLIENTE e no botão ADD adicionaremos os seguintes campos, veja abaixo:

Figura 03: Campos Necessários.

O comando para criar a tabela ficou da seguinte maneira:

CREATE TABLE [TB_CLIENTE] (

[COD_CLI] INT NOT NULL,
[TIP_CLI] VARCHAR(20),
[NOM_CLI] VARCHAR(50),
[END_CLI] VARCHAR(50),
[BAI_CLI] VARCHAR(50),
[CID_CLI] VARCHAR(40),
[EST_CLI] VARCHAR(2),
[CEP_CLI] VARCHAR(15),
CONSTRAINT [] PRIMARY KEY ([COD_CLI]));

Logo em seguida armazenaremos alguns dados para prosseguirmos nosso exemplo prático.

Figura 04: Exemplo de inserção de dados na tabela TB_CLIENTE.

Criando a tabela de Metadados

Para podermos trabalhar com o SQLite precisamos criar uma tabela de controle interno denominada “android_metadata” com o seguinte campo “locale” do tipo TEXT e atribuir um registro “en_US”.

Veja a instrução SQL para isto:

CREATE TABLE android_metadata (locale TEXT);

Figura 05: Exemplo Inserção dados da Tabela android_metadata.

Criando uma Classe para acesso

Para isto precisamos criar um exemplo básico em Android clicando em “File/New/ Android Project” e logo em seguida crie também uma classe e importe alguns pacotes para podermos prosseguir nosso exemplo.

package Pct.BancoDados;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.database.Cursor;

import android.database.SQLException;

import android.database.sqlite.SQLiteDatabase;

import android.database.sqlite.SQLiteException;

import android.database.sqlite.SQLiteOpenHelper;

import android.database.sqlite.SQLiteStatement;

public class Base extends SQLiteOpenHelper

{

}

É interessante lembrar que esta classe herda da SQLiteOpenHelper. Para entendermos melhor, iremos utilizar o arquivo gerado pelo “SQLite Expert Personal”. Copie o arquivo localizado em C:\Users\THIAGOO\Desktop\DBTHECLUB ou no lugar que foi criado e cole no diretório “assets” do nosso exemplo. Neste caso programaremos uma rotina para copiar a base de dados para dentro do exemplo em questão.

Voltando a criação de nossa classe, definiremos logo em seguida alguns atributos para a mesma, veja abaixo o código completo com uma breve explicação de seus métodos para melhores detalhes:

public class DataBaseHelper extends SQLiteOpenHelper

{

private static String DB_PATH="/data/data/Pct.BancoDados/databases/";    private static String DB_NAME = "DBTHECLUB.db";

private SQLiteDatabase dbQuery;

private final Context dbContexto;

O primeiro atributo armazenará o caminho do Banco de Dados, o segundo o Nome e as duas últimas são variáveis para controle interno sendo uma o Cursor de Nossa Classe SQLiteDatabase e outra o nosso Contexto em si.

public DataBaseHelper(Context context)

{

    super(context, DB_NAME, null, 1);

    this.dbContexto = context;

}    

 

Este é o Contrutor de nossa classe DataBaseHelper, ele captura e mantém uma referência do contexto passado para ter acesso aos recursos da aplicação.

public void CriarDataBase() throws IOException

{

   

boolean dbExist = checkDataBase();

if (!dbExist)

{   

       this.getReadableDatabase();

       try

 {

              this.copiarDataBase();

      }

 catch (IOException e)

 {

                  throw new Error("Erro ao copiar o Banco de Dados!");

       }

 }

}

Este Método é responsável por criar nossa Base de Dados, ou seja, utiliza a função copiarDataBase(); para obter os dados que está na nossa pasta “assets” e jogar para nosso Sistema Android. Verifiquem que utilizamos mais uma função para checar se nossa Base de Dados já está criada, denominada checkDataBase() .

Abaixo as duas importantes funções que utilizaremos ao decorrer do artigo.

private void copiarDataBase() throws IOException

{

      InputStream myInput = dbContexto.getAssets().open(DB_NAME);

      String outFileName = DB_PATH + DB_NAME;

      OutputStream myOutput = new FileOutputStream(outFileName);

      byte[] buffer = new byte[1024];

      int length;

      while ((length = myInput.read(buffer))>0)

{

            myOutput.write(buffer, 0, length);

      }

      myOutput.flush();

      myOutput.close();

      myInput.close();

}

private boolean checkDataBase()

{

      SQLiteDatabase checkDB = null;

      try

{

            String myPath = DB_PATH + DB_NAME;

checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);

     }

catch (SQLiteException e)

{}

      if (checkDB != null)

{

            checkDB.close();

     }

      return checkDB != null ? true : false;

}

public void abrirDataBase() throws SQLException

{

      String myPath = DB_PATH + DB_NAME;

dbQuery = SQLiteDatabase.openDatabase(myPath, null,      SQLiteDatabase.OPEN_READONLY);

}

public List<String> selecionaTodos(String NomeTabela, String  OrdemCampo, String...TipoCampos)

{

List<String> list = new ArrayList<String>();

      Cursor cursor = dbQuery.query(NomeTabela, TipoCampos,

      null, null, null, null, OrdemCampo);

            if (cursor.moveToFirst())

{

               do {

list.add(cursor.getString(0) +" - " + cursor.getString(1) + " - "+ cursor.getString(2));

                  }

while (cursor.moveToNext());

            }

            if (cursor != null && !cursor.isClosed())

{

               cursor.close();

            }

            return list;

}

   

@Override

public synchronized void close()

{

     if (dbQuery != null)

     dbQuery.close();

     super.close();

} 

}

O método abrirDataBase() permite que armazenemos todas as informações referentes ao Banco de Dados em uma variável, possibilitando o uso da mesma posteriormente.

Já o Método selecionaTodos() nos devolve uma lista de strings para podemos trabalhar, falaremos um pouco mais deste método quando chamarmos o mesmo pela nossa IDE do Android.

E por final finalizamos nossas variáveis com o método Close().

  

Criando um exemplo Básico

Depois de Criarmos nossa classe de acesso, finalizamos criando um exemplo para selecionar todos os clientes cadastrados no SQLite, adicionamos então apenas um Label em nossa tela principal e definimos sua ID para out_text, Ver Figura 06 e logo abaixo o código fonte.

Figura 06: Tela do Android.

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    >

<TextView 

    android:id="@+id/out_text"

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:text="@string/hello"

    />

</LinearLayout>

No evento OnCreate é onde programaremos nossa rotina para chamar o método SelecionarTodos(), abaixo o código fonte completo para melhores detalhes:

package Pct.BancoDados;

import java.io.IOException;

import android.app.Activity;

import android.os.Bundle;

import android.widget.TextView;

import java.util.List;

public class BancoDadosActivity extends Activity {

   

    TextView output;

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

                       

        output = (TextView) this.findViewById(R.id.out_text);

       

        DataBaseHelper db = new DataBaseHelper(this);

       

        try

        {

                  db.createDataBase();

        }

        catch (IOException e)

        {

                  e.printStackTrace();

        }

           

        db.openDataBase();

List<String> names =   db.selecionaTodos("TB_CLIENTE","COD_CLI",    "COD_CLI", "NOM_CLI", "TIP_CLI");

        StringBuilder sb = new StringBuilder();

        sb.append("Clientes Cadastrados:\n");

        for (String name : names)

        {

           sb.append(name + "\n");

        }

             

        output.setText(sb.toString());

      }

}

Primeiro definimos uma variável para armazenar nosso resultado, denominada “output”, logo em seguida instanciamos nossa classe “DataBaseHelper” criada anteriormente. Utilizaremos o método “criarDatabase()” e depois o abrirDataBase().

O método selecionaTodos() possui os seguinte parâmetros:

Nome da Tabela: TB_CLIENTE
Ordenação: COD_CLI
Campos para Selecionar: COD_CLI, NOM_CLI, TIP_CLI

E por final armazenaremos em uma StringBuilder para podermos jogar em nossa variável “output”.

A Figura 07 Ilustra o resultado final de nosso exemplo.

Figura 07: Exemplo em Run time.

Conclusões

Pudemos aprender neste artigo um pouco da utilização da ferramenta “SQLite Expert Personal”. Vimos que a mesma possibilita a manutenção e a administração tanto da parte de criação quanto na manipulação de dados.

O objetivo deste artigo foi de demonstrar a possibilidade de ter um banco de dados já criado e usá-lo em uma aplicação Android. Percebemos que isto é possível e muito prático em alguns casos específicos e se torna muito viável para o desenvolvedor, pois o Banco de Dados é facilmente manipulado por fora do sistema, se tornando independente da aplicação. A criação de Classes e métodos específicos torna o sistema mais genérico e de uma fácil implementação futura.

Espero que este exemplo básico seja de grande ajuda,

Um forte abraço e até o mês que vem!