SQLITE
Es un ligero motor de bases de datos de código abierto.
No requiere el soporte de un servidor
No necesita configuración
Usa un archivo para el esquema
Es de Código Abierto
PASO 1
Alternativa 1. Se crea una clase public class LawyersContract {
Crear una clase llamada Contract Class, la cual public static abstract class LawyerEntry implements
guarda como constantes todas las características BaseColumns {
de la base de datos. public static final String TABLE_NAME ="lawyer";
Se crea un POJO y una clase Contrac para el
POJO. public static final String ID = "id";
public static final String NAME = "name";
Creamos la clase interna Entry para guardar el public static final String SPECIALTY = "specialty";
nombre de las columnas de la tabla. public static final String PHONE_NUMBER =
"phoneNumber";
Se implementó la interfaz BaseColumns con el fin public static final String AVATAR_URI = "avatarUri";
de agregar una columna extra que se recomienda public static final String BIO = "bio";
tenga toda tabla. }
}
Alternativa 2
Crear directamente La clase que nos permitirá public class AdminSQLiteOpenHelper extends SQLiteOpenHelper {
public AdminSQLiteOpenHelper(Context context, String name,
comunicar nuestra aplicación con la base de datos. SQLiteDatabase.CursorFactory factory, int version) {
Esta clase extiende de “SQLiteOpenHelper”. Se trata super(context, name, factory, version);
de una clase abstracta que nos provee los }
mecanismos básicos para la relación entre la
@Override
aplicación Android y la información. public void onCreate(SQLiteDatabase db) {
db.execSQL("create table articulos(codigo int primary key,descripcion
text, precio real)");
}
Crear una clase que extienda de
SQLiteOpenHelper @Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Configurar un constructor apropiado
}
Sobrescribir los métodos onCreate() y onUpgrade() }
public class LawyersDbHelper extends Context context: Contexto de acción para el helper. String
SQLiteOpenHelper { name: Nombre del archivo con extensión .db, donde se
almacenará la base de datos, que a su vez corresponde al
public static final int DATABASE_VERSION nombre de la base de datos.
= 1;
public static final String DATABASE_NAME CursorFactory factory: Asignamos null, por ahora no es
= "Lawyers.db"; necesario comprender el funcionamiento de este
parámetro.
public LawyersDbHelper(Context context)
{ int version: Entero que representa la versión de la base de
datos. Su valor inicial por defecto es 1. Si en algún momento
super(context, DATABASE_NAME, null, la versión es mayor se llama al método onUpgrade() para
DATABASE_VERSION); actualizar la base de datos a la nueva versión. Si es menor,
se llama a downUpgrade() para volver a una versión previa.
}
/data/data/<paquete>/databases/<nombre-de-la-bd>.db
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// No hay operaciones
}
SQLiteDatabase db: Manejador de la base de datos.
int oldVersion: Se trata de un entero que indica la versión antigua de la base de datos.
int newVersion: Entero que se refiere a la versión nueva de la base de datos.
Ejemplo
@Override
public void onCreate(SQLiteDatabase sqLiteDatabase) {
sqLiteDatabase.execSQL("CREATE TABLE " + LawyerEntry.TABLE_NAME + " ("
+ LawyerEntry._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
+ LawyerEntry.ID + " TEXT NOT NULL,"
db.execSQL("create table articulos(codigo int primary
+ LawyerEntry.NAME + " TEXT NOT NULL," key,descripcion text, precio real)");
+ LawyerEntry.SPECIALTY + " TEXT NOT NULL,"
+ LawyerEntry.PHONE_NUMBER + " TEXT NOT NULL,"
+ LawyerEntry.BIO + " TEXT NOT NULL,"
+ LawyerEntry.AVATAR_URI + " TEXT,"
+ "UNIQUE (" + LawyerEntry.ID + "))");
}
Es recomendable que la llave primaria sea BaseColumns._ID, ya que el framework de Android
usa esta referencia internamente en varios procesos.
Sin embargo puedes usar tu propio ID y añadirle un índice UNIQUE para mantener la unicidad
de tus filas según tus reglas de negocio.
Agregar Datos
Crea un objeto del tipo ContentValues. Este permite
almacenar las columnas del registro en pares clave-valor SQLiteDatabase bd = admin.getWritableDatabase();
Añade los pares con el método put() ContentValues registro = new ContentValues();
registro.put("codigo", cod);
Invoca a insert() a través de la instancia de la base de
registro.put("descripcion", descri);
datos
registro.put("precio", pre);
String table: Nombre de la tabla donde se insertará la bd.insert("articulos", null, registro);
info. bd.close();
String nullColumnHack: Nombre de una columna que
acepta valores NULL y de la cual no se proveen pares
clave-valor en values.
ContentValues values: Conjunto de pares clave-valor
para las columnas.
Ejemplo-Agregar Datos
// Contenedor de valores
ContentValues values = new ContentValues();
// Pares clave-valor
values.put(LawyerEntry.ID, "L-001");
values.put(LawyerEntry.NAME, "Carlos solarte");
values.put(LawyerEntry.SPECIALTY, "Abogado penalista");
values.put(LawyerEntry.PHONE_NUMBER, "300 200 1111");
values.put(LawyerEntry.BIO, "Carlos es una profesional con 5 años de trayectoria...");
values.put(LawyerEntry.AVATAR_URI, "carlos_solarte.jpg");
// Insertar...
db.insert(LawyerEntry.TABLE_NAME, null, values);
}
Consultas - usando Query
Estructura de la función Query
query (String table,
String[] columns,
String selection,
String[] selectionArgs,
String groupBy,
String having,
String orderBy)
String table: Nombre de la tabla a consultar
String[] columns: Lista de nombres de las columnas que se van a consultar. Si deseas obtener todas
las columnas usas null.
String selection: Es el cuerpo de la sentencia WHERE con las columnas a condicionar. Es posible
usar el placeholder '?' para generalizar la condición.
String[] selectionArgs: Es una lista de los valores que se usaran para reemplazar las incógnitas de
selection en el WHERE.
String groupBy: Aquí puedes establecer cómo se vería la cláusula GROUP BY, si es que la necesitas.
String having: Establece la sentencia HAVING para condicionar a groupBy.
String orderBy: Reordena las filas de la consulta a través de ORDER BY.
Consulta usando rawQuery()
db.rawQuery("select * from " + LawyerEntry.TABLE_NAME, null);
Cursor fila = bd.rawQuery(
"select descripcion,precio from articulos where codigo=" + cod, null);
Cursor
Emplea el método booleano moveToNext() para avanzar al siguiente registro. Este retorna true si
fue posible o false si ya no existen más elementos.
while(c.moveToNext()){
String name = c.getString(c.getColumnIndex(LawyerEntry.NAME));
// Acciones...
}
Ejemplo
fila.moveToFirst()
Usa métodos get*() para obtener el valor de cada columna a través del índice según su tipo de
dato. Es decir, obtienes enteros con getInt(), flotantes con getFloat(), etc.
El índice de la columna se obtiene con getColumnsIndex().
Borrar
Para borrar uno o más registros la clase SQLiteDatabase tiene un método que le pasamos en el
primer parámetro el nombre de la tabla y en el segundo la condición que debe cumplirse para
que se borre la fila de la tabla. El método delete retorna un entero que indica la cantidad de
registros borrados
int cant = bd.delete("articulos", "codigo=" + cod, null);
