SQLite Android: Hola SQLite
05 jul 2012
Desde hace unos años nuestra empresa ha ido tomando el camino de la movilidad como una estrategia comercial de futuro y hemos apostado fuerte por ella, sabedores de que en un futuro tendrá el mismo o más peso de lo que hoy tiene la web. No en vano, Viafirma, ha sido la primera plataforma de firma electrónica del mundo en ofrecer firma electrónica móvil avanzada, tanto en sistemas Android como en iOS o RIM (Blackberry).
Hoy no nos vamos a centrar en firmas electrónicas, digitalizadas y demás productos de la suite Viafirma, pero sin embargo sí que queremos introducirnos de un modo más técnico en una importante parte de las soluciones de movilidad: la persistencia de datos a través de SQLite.
SQLite es un motor de base de datos que ya era conocido previamente a la llegada de las plataformas móviles, ya que lo podíamos encontrar en multitud de sistemas como Mozilla Firefox, Adobe Photoshop Elements o Skype. Lo más destacable de SQLite es que no es una base de datos relacional cliente-servidor al uso, de hecho NO tiene una arquitectura cliente-servidor, SQLite se basa en una arquitectura de fichero. Por ejemplo, en Android, nuestra base de datos en SQLite consistirá en un fichero .db almacenado en la carpeta ‘/data/data/packageName/Directorio_DB’.
Las principales características a destacar de SQLite son:
- Open Source.
- Forma parte de la aplicación que lo embebe (NO cliente-servidor).
- Baja latencia de acceso.
- Gestión de datos de hasta 2Terabytes.
Además es importante enumerar los tipos de datos soportados por SQLite, que son:
- NULL El valor es null
- INTEGER Entero con signo que puede ser almacenado en 1,2,4,6 u 8 bytes dependiendo de la magnitud del valor
- REAL El valor es un decimal de punto flotante almacenado en 8 bytes.
- TEXT El valor es una cadena de texto usando el encoding de la base de datos.
- BLOB El valor es un conjunto de datos binarios almacenado exactamente del mismo modo que son enviados.
Para datos de tipo booleano o fechas:
- BOOLEAN Sqlite no soporta este tipo de dato, en su lugar estos valores son almacenados usando tipos INTEGER utilizando 0 (false) ó 1 (true).
- DATE Sqlite tampoco ofrece este tipo de dato, en su lugar su API ofrece funciones que permiten almacenar fechas como TEXT, REAL o INTEGER.
Se puede encontrar más información visitando su sitio web:
Ahora, ¡vamos a la chicha!
Vamos a ver como implementamos esta base de datos en un proyecto Android:
En primer lugar hemos creado un proyecto Android en eclipse y con las dependencias para la versión 2.2 (Froyo). Una vez tenemos creado nuestro proyecto, vamos a necesitar crear una clase que extienda de SQLiteOpenHelper, provista por el API de Android para el manejo de SQLite. Extender de esta clase nos va a obligar a sobrescribir los métodos onCreate (SQLiteDatabase db) y onUpgrade (SQLiteDatabase db, int oldVersion, int newVersion). El método onCreate será llamado la primera vez que se cree la base de datos, mientras que onUpgrade() se llamará cuando la base de datos sea actualizada (habitualmente las operaciones que realiza este método son de migración y adaptación a la nueva estructura de la base de datos).
package org.viafirma;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class SQLiteOpenHelperImpl extends SQLiteOpenHelper{
private static String DATABASE = "holaSql.db";
public SQLiteOpenHelperImpl(Context context, String name, CursorFactory factory, int version) {
super(context, name, factory, version);
}
public SQLiteOpenHelperImpl(Context context) {
super(context, DATABASE, null, 0);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE usuario (_id INTEGER PRIMARY KEY AUTOINCREMENT, nombre TEXT);");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// Por simplicidad unicamente borro la tabla y vuelvo a llamar al onCreate
db.execSQL("DROP TABLE IF EXIST usuario");
onCreate(db);
}
}
Seguidamente, el código del main.xml para que simplemente muestre nuestros registros como texto en un componente TextView, cual ID será ‘textView’:
<?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="fill_parent" /> <TextView android:id="@+id/textView" android:layout_width="fill_parent" android:layout_height="wrap_content" /> </ScrollView>
Por último, modificamos nuestro activity principal para que cargue algunos registros de prueba en la base de datos y después nos muestre la vista main.xml. Es una activity simple, en el metodo onCreate() lo primero que hacemos es asignar la vista que vamos a utilizar, luego insertamos un registro en nuestra base de datos ( método insertar() ), obtenemos el Cursor que nos ayudará a navegar por los resultados dados por una query establecida ( getCursor() ) y por último “seteamos” los registros en un componente de texto de nuestra vista ( mostrarRegistros() ).
package org.viafirma;
import android.app.Activity;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.widget.TextView;
public class SQLiteHolaMundoActivity extends Activity {
private SQLiteOpenHelperImpl sqlHelper;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
sqlHelper = new SQLiteOpenHelperImpl(this);
try{
insertar("Hola SQL!");
insertar("Esto es nuestro segundo registro");
Cursor cursor = getCursor();
mostrarRegistros(cursor);
}finally{
sqlHelper.close();
}
}
//Inserta un registro
private void insertar(String nombreUsuario){
SQLiteDatabase db = sqlHelper.getWritableDatabase();
//Añadimos un nuevo contentValue para cada columna que queramos rellenar
ContentValues contentValues = new ContentValues();
contentValues.put("nombre", nombreUsuario);
//Insertamos en la tabla usuario
db.insertOrThrow("usuario", null, contentValues);
}
//Obtenemos un cursos para una query simple.
//El cursor nos ayudará a navegar a traves de los resultados de la query
private Cursor getCursor(){
SQLiteDatabase db = sqlHelper.getReadableDatabase();
Cursor cursor = db.query("usuario", new String[]{"_id", "nombre"}, null, null, null, null, null);
startManagingCursor(cursor);
return cursor;
}
//Por último metemos los resultados en un String
//para mostrarlo en el componente TextView de nuestra vista
private void mostrarRegistros(Cursor cursor){
String registro = "";
while(cursor.moveToNext()){
long _id = cursor.getLong(0);
String nombre = cursor.getString(1);
registro += _id + " - " + nombre + "\n";
}
TextView text = (TextView) findViewById(R.id.textView);
text.setText(registro);
}
}
Finalmente, si ejecutamos nuestra aplicación deberemos obtener una pantalla tal que así:
Como habréis observado, es realmente fácil implementar una base de datos SQLite en nuestras aplicaciones android, obviamente esto lo podemos complicar/afinar un poco más mediante el uso de ContentProviders o DataBinding, pero hay que ir poco a poco, de momento nos conformamos con haberos explicado el uso simple de SQLite en Android 
