Introducción a SQLite

Android hace uso de la base de datos SQLite para el manejo de registros en las aplicaciones. Según Santa Wikipedia define SQLite como:

«SQLite es un sistema de gestión de bases de datos relacional compatible con ACID, contenida en una relativamente pequeña biblioteca escrita en C. «

«SQLite usa un sistema de tipos inusual. En lugar de asignar un tipo a una columna como en la mayor parte de los sistemas de bases de datos SQL, los tipos se asignan a los valores individuales. Por ejemplo, se puede insertar un string en una columna de tipo entero (a pesar de que SQLite tratará en primera instancia de convertir la cadena en un entero). «

Para hacer uso de una base de datos SQLite, android dispone de la clase SQLiteOpenHelper  que tiene los métodos para la creación de base de datos y el control de versiones. Veremos como hacer uso de esa clase en un sencillo proyecto a continuación.

Utilizaremos Eclipse Indigo con Android instalado y configurado.

Proyecto de manejo a base de datos SQLite.

1.Crea un nuevo Application Android Project con la siguiente configuración:

Application Name: SQLite Example

Project Name: SQLiteExample

Package Name: com.tutorial.sqliteexample

Activity: Blank Activity

Activity Name: MainActivity.java

Layout Name: activity_main.xml

2. Crearemos dos clases en el paquete com.tutorial.sqliteexample, estas se llamaran, «SQLiteHelper.java» y «SQLite.java»

3. La clase SQLiteHelper, se extiende de SQLiteOpenHelper y se sobreescriben los métodos onCreate() y onUpgrade().

El método oncreate() sirve para crear la base de datos, android verifica si la aplicación no tiene base de datos, entonces ejecuta este método.

El método onUpgrade(), es utilizada para el manejo y control de versiones, cuando se distribuye una nueva versión de un programa y se desea modificar la base de datos, ya sea con más o menos tablas y campos, quiere decir que  se desea pasar a una «nueva versión» de base de datos, esto se maneja internamente con una variable de tipo entero «versión» y es aquí donde el método onUpgrade() se ejecuta y verifica si una nueva versión de nuestra aplicación hace uso de una nueva «versión» de base de datos o de lo contrario sigue usando la misma.

Clase SQLiteHelper

package com.tutorial.sqliteexample;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

public class SQLiteHelper extends SQLiteOpenHelper {

 //nombre de la base de datos
 private static final String __database__ = "dbTest";
 //versión de la base de datos
 private static final int __version__ = 1;
 //Instrucción SQL para crear las tablas
 private String sql = "CREATE TABLE mi_tabla ( id INTEGER, nombre TEXT, apellido TEXT )";

 /**
 * Constructor de clase
 * */
 public SQLiteHelper(Context context) {  
  super( context, __database__, null, __version__ );  
 }

 @Override
 public void onCreate(SQLiteDatabase db) {  
   db.execSQL( sql );
   Log.i("SQLite", "Se crea la base de datos " + __database__ + " version " + __version__ );
 }

 @Override
 public void onUpgrade( SQLiteDatabase db,  int oldVersion, int newVersion ) {
  Log.i("SQLite", "Control de versiones: Old Version=" + oldVersion + " New Version= " + newVersion  );
  if ( newVersion > oldVersion )
  {
   //elimina tabla
   db.execSQL( "DROP TABLE IF EXISTS mi_tabla" );
   //y luego creamos la nueva tabla
   db.execSQL( sql );   
   Log.i("SQLite", "Se actualiza versión de la base de datos, New version= " + newVersion  );
  }
 }

}

Nuestra base de datos se llama dbTest y consta de una sola tabla con dos campos, es más que suficiente para lo que deseamos hacer en esta oportunidad.

Vemos que se hace uso de una variable «__version__» de tipo entero, esta indica la versión de nuestra base de datos, más adelante veremos como pasar a una segunda versión modificando esta variable.

Nuestro método onUpgrade(), cuando android detecte que existe una nueva versión de base de datos, eliminará la tabla antigua y creara una nueva, esto claro es un ejemplo simple, en la práctica, dependiendo del tamaño de la base de datos y de los cambios que deseemos hacer este método será mucho más trabajado.

4. Una vez que tenemos nuestra clase SQLiteHepler, debemos crear otra clase más que haga uso de la anterior, esta clase es SQLite.java

SQLite.java

package com.tutorial.sqliteexample;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class SQLite {

 SQLiteHelper sqliteHelper;
 SQLiteDatabase db;

 /** Constructor de clase */
 public SQLite(Context context)
 {
  sqliteHelper = new SQLiteHelper( context );
 }

 /** Abre conexion a base de datos */
 public void abrir(){
  Log.i("SQLite", "Se abre conexion a la base de datos " + sqliteHelper.getDatabaseName() );
  db = sqliteHelper.getReadableDatabase(); // solo lectura 
 }

 /** Cierra conexion a la base de datos */
 public void cerrar()
 {
  Log.i("SQLite", "Se cierra conexion a la base de datos " + sqliteHelper.getDatabaseName() );
  sqliteHelper.close();  
 }
}

La clase SQLite.java cuenta con 2 métodos para abrir y cerrar conexiones a la base de datos, por el momento es todo lo que necesitamos. A medida que vayamos necesitando mas funcionalidad en la aplicación ya sea para insertar, eliminar o actualizar registros, estos deberán ser colocados en esta clase.

Tanto en la clase SQLiteHelper y SQLite, hacemos uso de Log.i(), estos logs nos permiten mostrar información, errores, warnings, etc en el LogCat de Eclipse y así poder depurar nuestra aplicación. en este caso Log.i nos permite mostrar información.

5. Para terminar abrimos nuestra clase MainActivity.java e implementamos la clase SQLite.java de la siguiente manera.

package com.tutorial.sqliteexample;

import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.Menu;

public class MainActivity extends Activity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  //
  Log.i("SQLite", "Inicio de aplicación SQLite" );
  SQLite sqlite = new SQLite( this );  
  sqlite.abrir();
  sqlite.cerrar();  
  Log.i("SQLite", "Aplicación SQLite creada correctamente :) " );
  //
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
  // Inflate the menu; this adds items to the action bar if it is present.
  getMenuInflater().inflate(R.menu.main, menu);
  return true;
 }

}

En esta proyecto, no hacemos uso de interfaces XML porque  nuestra aplicación lo único que hará es crear la base de datos, conectarse y desconectarse, en la interfaz del teléfono no veremos nada. Nuestros ojos deberán estar atentos al LogCat.

Ejecutamos por PRIMERA vez y tenemos:

Como es la primera vez que ejecutamos nuestra aplicación, la base de datos NO EXISTE, por tanto se ejecuta el método onCreate() para crear la base de datos.

Ejecutamos por SEGUNDA VEZ, pero antes, debemos cambiar a «2» la variable __version__ de la clase SQLiteHelper.

private static final int __version__ = 2;

En el LogCat tendremos:

Observamos como esta vez, la base de datos ya existe, por tanto no ejecuta el método onCreate(), pero como modificamos la versión de la base de datos a 2, se ejecuta el método onUpgrade(), actualiza a la nueva versión y cierra la conexión.

Eso es todo para comenzar con base de datos de android, más adelante iremos implementados los diferentes métodos de gestión como ser INSERT, DELETE, UPDATE Y SELECT.

Proyecto utilizado en este tutorial AQUI