En algún momento como desarrolladores nos encontraremos con la necesidad de almacenar los datos de nuestras aplicación para su posterior uso, esto incluye aplicaciones web , de escritorio y claro móviles. En este tutorial nos concentraremos en poder almacenar los datos de nuestra aplicación en una base de datos dentro de nuestro dispositivo Android, explicaremos a detalle cada uno de los pasos necesarios para este ejemplo y nos concentraremos en esta ocasión en realizar un CRUD simple.
El gestor de base de datos a utilizar para este ejemplo será el de SQLite.
Una vez que estemos en nuestro proyecto crearemos una nueva clase la cual debe de extender de SQLiteOpenHelper. Esta clase se encuentra en android.database.sqlite así que debemos de importarla, en mi caso la clase se llamará EjemploDB.
Una vez que tenemos nuestra clase heredando de SQLiteOpenHelper necesitaremos agregar dos nuevos métodos:
- El primero un método llamado onCreate el cual recibe como parámetro un objeto SQLIteDatabase.
- El segundo método onUpgrade que recibe como parámetros un objeto SQLiteDatabase y dos enteros (Este método profundizaremos más a detalle en otro post).
Los métodos quedaran de la siguiente manera:
public void onCreate(SQLiteDatabase db) {
}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
}Dentro de nuestra clase crearemos dos nuevas variables estáticas para poder administrar de mejor manera nuestra base de datos:
public static final int DATABASE_VERSION = 1;como podemos observar una variable nos permitirá llevar un control del número de versión correspondiente a nuestra base de datos y la otra almacena el nombre de nuestra base de datos.
public static final String DATABASE_NAME = "nombreDeTuBaseDatos.db";
Para ir concluyendo los preparativos de nuestra clase dentro de nuestro constructor debemos indicarle que espera como parámetro un objeto de tipo Context, dentro de este mismo debemos llamar la constructor de la clase de la cual heredamos (SQLiteOpenHelper ), pasándole como parámetros el contexto, el nombre de nuestra base de datos, un cursor Factory (para este tutorial será null) y una versión, en mi caso quedaría así:
public EjemploDB(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
Lo que corresponde ahora es crear la base de datos y para ellos debemos hacerlo en nuestro método onCreate, sin embargo primero debemos de establecer nuestras columnas de nuestra tabla, para una administración más fácil la documentación de android nos coloca en su ejemplo establecer los nombres de las tablas mediante atributos de una interfaz, por esta ocasión omitiremos esa parte para mantener un nivel bajo de complejidad.
Dentro de nuestra clase (en mi caso EjemploDB ) colocaremos el nombre de nuestra tabla ( o tablas) y los nombres de nuestras columnas mediante variables de tipo String staticas :
public static final String TABLA_NOMBRES = "nombres";
public static final String COLUMNA_ID = "_id";
public static final String COLUMNA_NOMBRE = "nombre";
Con estas tres variables nos podemos dar una idea clara de que tendremos una tabla llamada nombres la cual tendrá dos columnas, una columna _id y una nombre.
Para la creación de nuestra base de datos debemos realizarla mediante una sentencia SQL, de igual forma es recomendable establecer esta sentencia en una variable:
private static final String SQL_CREAR = "create table "
+ TABLA_NOMBRES + "(" + COLUMNA_ID
+ " integer primary key autoincrement, " + COLUMNA_NOMBRE
+ " text not null);";
Ya tenemos el nombre de nuestra tabla, las columnas y la sentencia ahora es el momento de ejecutarlo. A nuestro método onCreate debe quedar de la siguiente manera:
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL_CREAR);
}
Con esto indicamos que nuestra base de datos debe ejecutar una sentencia SQL, que en nuestro caso la encontramos almacenada en la variable SQL_CREAR.
Hasta este punto nuestra clase debe parecerse a esta:
public class EjemploDB extends SQLiteOpenHelper {
public static final int DATABASE_VERSION = 1;
public static final String DATABASE_NAME = "ejemplo.db";
public static final String TABLA_NOMBRES = "nombres";
public static final String COLUMNA_ID = "_id";
public static final String COLUMNA_NOMBRE = "nombre";
private static final String SQL_CREAR = "create table "
+ TABLA_NOMBRES + "(" + COLUMNA_ID
+ " integer primary key autoincrement, " + COLUMNA_NOMBRE
+ " text not null);";
public EjemploDB(Contextcontext) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL_CREAR);
}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
Create:
Para comenzar a utiliza nuestra base de datos vamos a crear un método llamado agregar que recibe como parámetro un objeto String( el nombre ). El método quedaría de la siguiente manera:
public void agregar(Stringnombre){
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(COLUMNA_NOMBRE, nombre);
db.insert(TABLA_NOMBRES, null,values);
db.close();
}
Lo primero que hacemos es indicarle a la clase que vamos a hacer uso de la base de datos, lo segundo es crear un objeto ContentValues el cual nos ayudara a almacenar de manera temporal nuestros datos relacionándolos a la columna a la cual pertenecen (en este caso nombre a la columna nombre), ya por ultimo le indicamos a la base de datos que deseamos insertar un nuevo elemento para ello utilizamos su método insert.
Con este sencillo método ya podemos almacenar datos en nuestra tabla.
Read:
Para poder extraer los datos crearemos otro método, el método lo nombraré obtener. Este método tendrá ciertas peculiaridades que no es necesario que comprendas en estos momentos y son temas que se tocarán en otro momento.
public void obtener(int id){
SQLiteDatabase db = this.getReadableDatabase();
String[] projection = {COLUMNA_ID, COLUMNA_NOMBRE};
Cursor cursor =
db.query(TABLA_NOMBRES,
projection,
" _id = ?",
new String[] { String.valueOf(id) },
null,
null,
null,
null);
if (cursor != null)
cursor.moveToFirst();
System.out.println("El nombre es " + cursor.getString(1) );
db.close();
}
Para este método lo primero que debemos de hacer es indicarle a la clase que vamos a utiliza la base datos (como en el método agregar), para el query de select debemos de tener una proyección (nombre con que lo maneja la documentación) que no es más que una arreglo de todas nuestras columnas con las cuales vamos a trabajar.
El método query recibe como parámetro principalmente el nombre de la tabla a utilizar, la proyección, nuestra condicional para el select, en este caso la columna _id y con que valor debe buscarlo, es por eso que vemos otra arreglo de string como parámetro, los siguiente cuatro parámetros son para realizar un query más complejo.
Para almacenar el resultado de nuestra búsqueda debemos hacer mediante un objeto Cursor.
Para poder visualizar el nombre simplemente mandamos una impresión a consola mediante System, incluso si nosotros así lo deseamos podemos regresar el valor o el cursor.
Prueba:
Bien con esto dos métodos podemos probar si nuestro ejemplo se encuentra funcionando de forma correcta, vamos a modificar nuestro método agregar y colocaremos dos líneas de código más:
long newRowId;
newRowId = db.insert(T…
Con esto vamos a poder conocer el id de nuestro dato almacenado, lo que falta ahora es retornar ese valor, cambiamos nuestro método para regresar el valor (int) y colocamos :
return (int) newRowId;
Bien ahora probemos nuestro ejemplo:
EjemploDB db = new EjemploDB( getApplicationContext() );
int id = db.agregar("Eddard Stark");
System.out.println(id);
db.obtener(id);
Con este sencillo código nos podemos percatar que hasta ahora nuestro ejemplo se encuentra funcionando correctamente ( No es necesario que visualicemos los resultados en consola, podemos apoyarnos de nuestras vistas o de un Toast).
Update:
Para editar debemos de colocar este método:
public void actualizar (String nombre, int id){
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("nombre",nombre);
int i = db.update(TABLA_NOMBRES,
values,
" _id = ?",
new String[] { String.valueOf( id ) });
db.close();
}
Y como ya se nos está haciendo costumbre lo primero que debemos hacer es obtener nuestra base de datos.
Al igual que con el método agregar debemos de almacenar nuestros valores en sus respectivas columnas mediante un objeto ContentValues y con el método update de nuestra base de datos establecemos que tabla queremos utilizar, los valores a cambiar (con el objeto ContentValues) y la condicional para realizar el cambio (Al igual que en el Select)
" _id = ?" nos indica que utilizaremos el campo id como referencia para saber que filas serán actualizadas y con new String[] { String.valueOf( id ) }); indicamos el valor que debe tener la columna.
Probamos el ejemplo:
db.actualizar("CatellyTully", 1);
db.obtener(1);
Con esto ya no obtendremos Eddard Stark si no Catelly Tully con lo cual confirmamos que nuestro método actualizar funciona.
Delete:
Si has estado leyendo el post completamente te podrás intuir cómo será el método de eliminar, pues es muy sencillo y toma partes de cada método utilizado anteriormente:
public boolean eliminar(int id) {
SQLiteDatabase db = this.getWritableDatabase();
try{
db.delete(TABLA_NOMBRES,
" _id = ?",
new String[] { String.valueOf (id ) });
db.close();
return true;
}catch(Exception ex){
return false;
}
}
Aquí simplemente agregamos un Try y un Catch por buenas practicas ( También debemos agregarlo en los otro métodos) y solo para no dejar un return true siempre :P.
Conclusión:
Como podemos observar en este Post el manejo de base de datos en Android no es complicado y hasta cierto punto intuitivo, incluso temas más avanzados en cuanto a base de datos Android nos proporciona una documentación muy bien explicada de cada una de sus clases y métodos.
Espero que este Post les sea de mucha utilidad para sus proyectos y aun que los ejemplo son muy sencillos dejan las bases para poder ser implementados en cualquier proyecto mediado o grande.
Cualquier comentario acerca de este post es bienvenido, así que comenten :D