Neste artigo abordarei um pouco das características do SQLite, junto com alguns exemplos práticos utilizando o Android.
Uma introdução ao SQLite
SQLite é um Banco de Dados Open Source que já vem embutido no Sistema Android. É um Banco de Dados relacional suportando a sintaxe SQL, operações e instruções, requerendo pouca memória em tempo de execução. Sua estrutura está contida em apenas em um único arquivo no sistema e o acesso aos dados é implementado por uma biblioteca de funções escritas em C.
É um gerenciador de banco de dados “auto-suficiente”, ou seja, independente de uma estrutura cliente-servidor. Neste caso ele necessita de um apoio mínimo de bibliotecas externas ou até mesmo do Sistema Operacional, se tornando muito fácil para ser adaptado para o uso de dispositivos embarcados. Isto o torna flexível para muitas plataformas.
É muito utilizado em Dispositivos e sistemas embarcados (telefone celular, PDAs, MP3, entre outros), Aplicações Desktop, Sites com poucos acessos e também pode ser útil para o aprendizado.
Tipos de Campos
Na realidade no SQLite, o tipo de dado de um valor está associado com o valor propriamente dito, diferente de outros Bancos de Dados, se tornando um sistema de tipos dinâmicos.
Um campo de uma tabela em SQLite pode receber qualquer tipo de dado, ignorando o tipo informado no comando CREATE TABLE.
Em poucas palavras, podemos dizer que no SQLite existem classes de armazenamento, veja a seguir para maiores detalhes.
NULL: O campo não deve ser Nulo, característica encontrada como em qualquer outro Banco de Dados.
INTEGER: inteiro com sinal, armazenado em 1, 2, 3, 4, 6 ou 8 bytes dependendo da grandeza do valor.
REAL: valor de ponto flutuante armazenado em 8 bytes.
TEXT: uma string armazenada usando UTF-8, UTF-16BE ou UTF-16LE.
BLOB: armazena campos do tipo Blob.
Como posso utilizar campos do tipo Booleano e Data/Hora?
Na realidade não existe nenhuma classe do tipo Booleana, podemos considerar tipos inteiros 0 e 1, respectivamente como Verdadeiro e Falso.
È o mesmo caso para tipos de campos Data ou Hora, não existem classes para armazenamento destes tipos. O SQLite possui funções capazes de tratar os tipos citados acima.
Funções disponíveis
Date: Retorna a data no formato YYYY-MM-DD.
Time: Retorna a hora no formato HH:MM:SS.
Datetime: retorna data e hora no formato YYYY-MM-DD HH:MM:SS.
Strftime: retorna a data formatada de acordo com o formato especificado.
Exemplos de Utilizações
SELECT date('now') – Retorna a Data Atual.
SELECT time('now') – Retorna a Hora Atual.
SELECT datetime('now') – Retorna a Data/Hora Atual.
Criando um Exemplo Básico
Seguindo os passos do artigo do mês de Novembro, teremos o Eclipse Instalado corretamente com todas as configurações prontas para o nosso exemplo. A intenção será de criar uma tela simples de inserção de dados. Para isto será necessário criar uma classe para manipulação e acesso aos dados.
Abra o Eclipse criando um novo projeto em Android, clique em File/New/Android Project. No meu caso defini como:
Project Name: TheClub_Artigo
Build Target: Android 2.2
Application Name: TheClub_Artigo
Package Name: Pacote. TheClub_Artigo
Create Activity: TheClub_ArtigoActivity
Min SDK Version: 8
Depois de criado nosso Pacote, em Package Explorer escolha o caminho src/Pacote.TheClub e com o botão direito criaremos uma Classe, para isto basta escolher New/Class. Esta classe é responsável por trabalhar com o SQLite.
 |
| Figura 01: Criação da Classe DataHelper. |
Source folder: TheClub/src
Package: Pacote.TheClub
Name: DataHelper
Modifiers: public
Superclass: java.lang.Object
Cheque os itens: “Inherited abstract methods“ e “Generate comments” para podermos herdar os métodos abstratos e gerar comentários respectivamente. Veja abaixo o código gerado:
package Pacote.TheClub;
/**
* @author Thiago
*
*/
public class DataHelper
{
}
Implementando uma Classe de Dados
Nos próximos passos irei criar a classe e darei uma breve explicação do código, Primeiramente utilizaremos o comando “import” para nos dar acesso a algumas classes necessárias para o funcionamento e em seguida definir alguns atributos necessários.
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteStatement;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;
.
.
private static final String DATABASE_NAME = "DB_THECLUB.db";
private static final int DATABASE_VERSION = 1;
private static final String TABLE_NAME = "TB_CLIENTE";
private Context context;
private SQLiteDatabase db;
private SQLiteStatement insertStmt;
private static final String INSERT = "insert into " + TABLE_NAME + "(name) values (?)";
Notem que estes atributos são do tipo “private”, ou seja, são utilizáveis apenas dentro de nossa classe DataHelper.
Logo em seguida programaremos o método Construtor recebendo como parâmetro um Contexto de informações e mais abaixo Implementamos o Método “insert” para inserir dados, “deleteAll” para exclusão, “selectAll” para consultas e por final incluímos uma inner-classe importante que nos dá acesso a um SQLiteOpenHelper.
public DataHelper(Context context)
{
this.context = context;
OpenHelper openHelper = new OpenHelper(this.context);
this.db = openHelper.getWritableDatabase();
this.insertStmt = this.db.compileStatement(INSERT);
}
public long insert(String name)
{
this.insertStmt.bindString(1, name);
return this.insertStmt.executeInsert();
}
public void deleteAll()
{
this.db.delete(TABLE_NAME, null, null);
}
public List<String> selectAll()
{
List<String> list = new ArrayList<String>();
Cursor cursor = this.db.query(TABLE_NAME, new String[] { "cod_cli", "nom_cli" },
null, null, null, null, "cod_cli");
if (cursor.moveToFirst()) {
do {
list.add(cursor.getString(0) +" - " + cursor.getString(1));
} while (cursor.moveToNext());
}
if (cursor != null && !cursor.isClosed()) {
cursor.close();
}
return list;
}
private static class OpenHelper extends SQLiteOpenHelper
{
OpenHelper(Context context)
{
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE " + TABLE_NAME + "(cod_cli INTEGER PRIMARY KEY, nom_cli TEXT)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w("Example", "Upgrading database, this will drop tables and recreate.");
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
}
Uma informação para quem não sabe, Inner Class são classes internas declaradas dentro de outras classes.
Percebam que criamos uma tabela de clientes com apenas dois campos para nosso artigo, mas com certeza este exemplo cobre todos os conceitos básicos de manipulação de dados do Android. Não entraremos em muitos detalhes em relação a esta classe.
Criando um layout de Cadastro
Para isto navegue até o caminho res/layout/main.xml e na Paleta “Form Widgets “ adicione um TextView, um Button e um EditText da paleta “Text Fields”.
Defina suas propriedades em seguida como:
TextView1
Id: @+id/textView1
Text: Nome:
Layout Height: wrap_content
Layout Width: wrap_content
EditText1
Id: @+id/editText1
Input type: textPersonName
Layout Height: wrap_content
Layout Width: wrap_content
Button1
Id: @+id/button1
Text: Inserir
Layout Height: wrap_content
Layout Width: 104dp
 |
| Figura 02: Layout da Tela. |
<?xml version="1.0" encoding="utf-8"?>
<ScrollView
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content">
<LinearLayout xmlns:android=
"http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent" android:layout_height="19dp" android:weightSum="1">
<TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Nome:"></TextView>
<EditText android:layout_height="wrap_content" android:id="@+id/editText1" android:inputType="textPersonName" android:layout_width="300dp">
</EditText>
<Button android:text="Inserir" android:id="@+id/button1" android:layout_height="wrap_content" android:layout_width="104dp"></Button>
<TextView android:id="@+id/out_text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="" />
</LinearLayout>
</ScrollView>
É interessante observar que o trecho do código abaixo foi adicionado para exibir a saída dos dados cadastrados.
.
.
<TextView android:id="@+id/out_text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="" />
A Figura 03 ilustra nossa tela em Run-Time.
 |
| Figura 03: Tela de Cadastro. |
Codificando o Botão Inserir
Primeiramente localize a classe “TheClubActivity” em src/Pacote.TheClub e logo em seguida adicionaremos algumas classes, veja abaixo:
import Pacote.TheClub.DataHelper;
import Pacote.TheClub.R;
import android.app.Activity;
import android.app.AlertDialog;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import java.util.List;
Definimos alguns atributos, como:
TextView saida;
DataHelper db;
Button btn1;
EditText edt1;
E no método OnCreate programaremos o seguinte código
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn1 = (Button) findViewById(R.id.button1);
saida = (TextView) this.findViewById(R.id.out_text);
db = new DataHelper(this);
edt1 = (EditText) findViewById(R.id.editText1);
btn1.setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
db.insert(edt1.getText().toString());
List<String> names = db.selectAll();
StringBuilder sb = new StringBuilder();
sb.append("Clientes Cadastrados:\n");
for (String name : names)
{
sb.append(name + "\n");
}
saida.setText(sb.toString());
}
});
}
No código acima estamos usando o método “findViewById”, que tem como objetivo atribuir o objeto da tela pelo localizado pelo Id a uma variável do mesmo tipo. Desta forma conseguimos manipular toda informação ali trabalhada.
Para utilizar a classe criada anteriormente devemos instanciá-la como um objeto qualquer passando o parâmetro “this” que seria o contexto em geral da aplicação. Veja abaixo novamente:
db = new DataHelper(this);
Utilizamos o Método OnClick do Botão para Inserir os Dados com o método db.Insert e selecioná-los em seguida com o db.SelectAll. A Classe StringBuilder serve para armazenar os registros e mostrá-los na tela.
 |
Figura 04: Dados Inseridos no SQLite. |
Conclusões
Podemos dividir este artigo em duas partes, a primeira como uma teoria destacando informações e dicas referentes ao SQLite do Android e a segunda uma prática com um exemplo simples utilizando a linguagem Java para trabalhar com dados.
A linguagem Java nos proporciona um leque de aprendizado, é um prato cheio para quem está aprendendo Orientação a Objetos pelo fato de ser totalmente desta maneira.
Espero que este artigo proporcione aos senhores um pontapé inicial para trabalhar com a Tecnologia Android.
Um Forte abraço e até o mês que vem!
Referências
Nenhum comentário:
Postar um comentário