Base De Datos SQLite En Android Con Múltiples Tablas

Anteriormente había creado un tutorial sobre el uso de bases de datos SQLite en Android, donde cubría los aspectos básicos. Sin embargo no expliqué como podrías tratar con múltiples tablas si este caso se te presentara.

Por eso esta vez abordaremos un problema sobre pedidos, productos y clientes el cual contiene varias tablas a relacionar dentro de la base de datos.

Si sigues leyendo, verás cómo:

  • Implementar el CRUD (Create, Read, Update y Delete) de cada entidad propuesta en la base de datos.
  • Usar llaves foráneas y compuestas.
  • Realizar JOINs entre tablas
  • Usar clases de utilidad para SQLite como lo son SQLiteBuilder y DatabaseUtils.

Descargar Proyecto Android Studio De Pedidos

Para desbloquear el link de descarga para el código final del tutorial sigue estas instrucciones:

Base De Datos SQLite De Pedidos

Como te venía diciendo, usaremos uno de los modelos de datos más populares en el mundo del desarrollo de software y las clases universitarias. Se trata de una base de datos que soporta la interacción entre un cliente que realiza pedidos de diferentes productos que posee un establecimiento comercial.

Para llevar a cabo la construcción de la aplicación debes seguir estos pasos:

  1. Diseña modelo de datos para definir la estructura de las tablas y sus relaciones
  2. Crear de nuevo proyecto en Android Studio
    1. Crear clase contrato
    2. Crear manejador SQLiteOpenHelper
    3. Crear clases modelo para las entidades
    4. Generar operaciones de bases de datos necesarias para cada entidad
    5. Probar el funcionamiento

Diseño De Base De Datos Para Pedidos

El diseño de la base de datos no incluye el análisis de requerimientos, ni identificación de temporalidades o especificaciones de triggers, ni levantamiento de restricciones.

Partirás directamente desde el siguiente diagrama entidad-relación:

Nota: Si tienes problemas diseñando bases de datos, te recomiendo mi ebook con un metodología de diseño y plantillas para simplificar el trabajo.

Diagrama ER de pedidos en Android

Este modelo es parecido al que expliqué en el artículo sobre sistemas de facturación, donde de la relación muchos a muchos entre pedidos y productos, se genera una nueva tabla que representa las líneas (detalles, ítems, etc.) del pedido.

El siguiente mini diccionario de datos muestra una explicación de cada tabla y columna:

Entidad Descripción Columnas
CabeceraPedido Representa los datos generales del pedido
  • id: Identificador del pedido
  • id_cliente: Llave foránea de la relación con el cliente
  • fecha: Momento en que se confirmó el pedido
  • id_forma_pago: Llave foránea de la relación con la forma de pago
DetallePedido Es cada uno de los renglones dentro del pedido
  • id_cabecera_pedido: Llave foránea (también es llave parcial) de la relación con CabeceraPedido.
  • secuencia: Llave parcial que indica la posición del detalle en el pedido.
  • id_producto: Llave foránea de la relación con Producto.
  • cantidad: Cantidad de unidades que se compraron de un Producto.
  • precio: Precio del producto en el momento en que se compró.
Producto Artículo que se vende en el establecimiento comercial
  • id: Identificador único del producto.
  • nombre: Nombre descriptivo del producto.
  • precio: Precio actual del producto.
  • existencias: Cantidad de productos que hay en las reservas (stock).
Cliente Persona que acude a comprar productos
  • id: Identificador único del cliente.
  • nombres: Nombre compuesto del cliente.
  • apellidos: Los apellidos del cliente.
  • telefono: Número de teléfono para contactar al cliente.
FormaDePago Cada una de las elecciones financieras que tiene el cliente para pagar un pedido
  •  id: Identificador único de cliente.
  • nombre: Descripción del tipo de pago.

1. Crear Nuevo Proyecto En Android Studio

Si ya entendiste el modelo de datos anterior, entonces es hora de codificar nuestra app Android de ejemplo.

1. Abre Android Studio y crea un nuevo proyecto llamado “Pedidos”. Puedes usar tu paquete personalizado, pero si deseas que cada código que ponga en este tutorial funcione correctamente, entonces usa "com.herprogramacion.pedidos".

2. Añade una actividad en blanco llamada ActividadListaPedidos.java y confirma la creación del proyecto.

3. Crea tres nuevos paquetes haciendo click derecho el paquete java com.herprogramacion.pedidos, luego selecciona New y clickea package. Los nombres de los paquetes son “modelo”, “sqlite” y “ui”.

Android Studio: Crear nuevo paquete Java

Con ello tendrás la siguiente estructura:

Android Studio: Estructura de paquetes Java

2. Crear Clase Contrato

Dentro del paquete sqlite crea una nueva clase llamada ContratoPedidos.java. El propósito de esta es guardar todos los metadatos y componentes auxiliares para definir la estructura general de la base de datos.

Un enfoque práctico para definir las columnas de cada tabla es crear una interfaz por cada una y añadir el nombre estándar. Luego implementas la interfaz en una clase auxiliar que te ayude a la administración de cada tabla.

ContratoPedidos.java

import java.util.UUID;

/**
 * Clase que establece los nombres a usar en la base de datos
 */
public class ContratoPedidos {

    interface ColumnasCabeceraPedido {
        String ID = "id";
        String FECHA = "fecha";
        String ID_CLIENTE = "id_cliente";
        String ID_FORMA_PAGO = "id_forma_pago";
    }

    interface ColumnasDetallePedido {
        String ID = "id";
        String SECUENCIA = "secuencia";
        String ID_PRODUCTO = "id_producto";
        String CANTIDAD = "cantidad";
        String PRECIO = "precio";
    }

    interface ColumnasProducto {
        String ID = "id";
        String NOMBRE = "nombre";
        String PRECIO = "precio";
        String EXISTENCIAS = "existencias";
    }

    interface ColumnasCliente {
        String ID = "id";
        String NOMBRES = "nombres";
        String APELLIDOS = "apellidos";
        String TELEFONO = "telefono";
    }

    interface ColumnasFormaPago {
        String ID = "id";
        String NOMBRE = "nombre";
    }

    public static class CabecerasPedido implements ColumnasCabeceraPedido {
        public static String generarIdCabeceraPedido() {
            return "CP-" + UUID.randomUUID().toString();
        }
    }

    public static class DetallesPedido implements ColumnasDetallePedido {
        // Métodos auxiliares
    }

    public static class Productos implements ColumnasProducto{
        public static String generarIdProducto() {
            return "PRO-" + UUID.randomUUID().toString();
        }
    }

    public static class Clientes implements ColumnasCliente{
        public static String generarIdCliente() {
            return "CLI-" + UUID.randomUUID().toString();
        }
    }

    public static class FormasPago implements ColumnasFormaPago{
        public static String generarIdFormaPago() {
            return "FP-" + UUID.randomUUID().toString();
        }
    }


    private ContratoPedidos() {
    }

}

La mayoría de clases auxiliares tienen un método que genera un identificador basado en la clase UUID, el cuál te servirá al momento de realizar inserciones.

3. Crear Manejador SQLiteOpenHelper

Recuerda que acceder al archivo SQLite que representa tu base de datos requiere de una clase que extienda de SQLiteOpenHelper. En ella debes sobrescribir los controladores onCreate() y onUpgrade() para crear y actualizar tu base de datos.

Al crear este manejador ten en cuenta definir los siguientes ingredientes:

  • El nombre de la base de datos y su versión actual.
  • El nombre de las tablas que crearás.
  • Las referencias de llaves foráneas. Este aspecto solo funciona desde Android Froyo 2.2 con la versión de Sqlite 3.6.19.
  • La sobrescritura del método onOpen() para agregar el soporte de llaves foráneas y las clausulas ON DELETE.
  • Los scripts SQL que usarás para implementar el modelo de datos.
  • Los cambios precisos en las tablas por si deseas actualizar la base de datos.

1. Teniendo en cuenta lo anterior, crea una nueva clase dentro de sqlite llamada BaseDatosPedidos.java y extiéndela de SQLiteOpenHelper.

2. Usa constantes e interfaces para generalizar los elementos descritos arriba con el fin de mejorar la reusabilidad y orden del código.

BaseDatosPedidos.java

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Build;
import android.provider.BaseColumns;

import com.herprogramacion.pedidos.sqlite.ContratoPedidos.CabecerasPedido;
import com.herprogramacion.pedidos.sqlite.ContratoPedidos.DetallesPedido;
import com.herprogramacion.pedidos.sqlite.ContratoPedidos.Productos;
import com.herprogramacion.pedidos.sqlite.ContratoPedidos.Clientes;
import com.herprogramacion.pedidos.sqlite.ContratoPedidos.FormasPago;

/**
 * Clase que administra la conexión de la base de datos y su estructuración
 */
public class BaseDatosPedidos extends SQLiteOpenHelper {

    private static final String NOMBRE_BASE_DATOS = "pedidos.db";

    private static final int VERSION_ACTUAL = 1;

    private final Context contexto;

    interface Tablas {
        String CABECERA_PEDIDO = "cabecera_pedido";
        String DETALLE_PEDIDO = "detalle_pedido";
        String PRODUCTO = "producto";
        String CLIENTE = "cliente";
        String FORMA_PAGO = "forma_pago";
    }

    interface Referencias {

        String ID_CABECERA_PEDIDO = String.format("REFERENCES %s(%s) ON DELETE CASCADE",
                Tablas.CABECERA_PEDIDO, CabecerasPedido.ID_CABECERA_PEDIDO);

        String ID_PRODUCTO = String.format("REFERENCES %s(%s)",
                Tablas.PRODUCTO, Productos.ID_PRODUCTO);

        String ID_CLIENTE = String.format("REFERENCES %s(%s)",
                Tablas.CLIENTE, Clientes.ID_CLIENTE);

        String ID_FORMA_PAGO = String.format("REFERENCES %s(%s)",
                Tablas.FORMA_PAGO, FormasPago.ID_FORMA_PAGO);
    }

    public BaseDatosPedidos(Context contexto) {
        super(contexto, NOMBRE_BASE_DATOS, null, VERSION_ACTUAL);
        this.contexto = contexto;
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        super.onOpen(db);
        if (!db.isReadOnly()) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                db.setForeignKeyConstraintsEnabled(true);
            } else {
                db.execSQL("PRAGMA foreign_keys=ON");
            }
        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(String.format("CREATE TABLE %s (%s INTEGER PRIMARY KEY AUTOINCREMENT," +
                        "%s TEXT UNIQUE NOT NULL,%s DATETIME NOT NULL,%s TEXT NOT NULL %s," +
                        "%s TEXT NOT NULL %s)",
                Tablas.CABECERA_PEDIDO, BaseColumns._ID,
                CabecerasPedido.ID_CABECERA_PEDIDO, CabecerasPedido.FECHA,
                CabecerasPedido.ID_CLIENTE, Referencias.ID_CLIENTE,
                CabecerasPedido.ID_FORMA_PAGO, Referencias.ID_FORMA_PAGO));

        db.execSQL(String.format("CREATE TABLE %s (%s INTEGER PRIMARY KEY AUTOINCREMENT," +
                        "%s TEXT NOT NULL %s,%s INTEGER NOT NULL CHECK (%s>0),%s INTEGER NOT NULL %s," +
                        "%s INTEGER NOT NULL,%s REAL NOT NULL,UNIQUE (%s,%s) )",
                Tablas.DETALLE_PEDIDO, BaseColumns._ID,
                DetallesPedido.ID_CABECERA_PEDIDO, Referencias.ID_CABECERA_PEDIDO,
                DetallesPedido.SECUENCIA, DetallesPedido.SECUENCIA,
                DetallesPedido.ID_PRODUCTO, Referencias.ID_PRODUCTO,
                DetallesPedido.CANTIDAD, DetallesPedido.PRECIO,
                DetallesPedido.ID_CABECERA_PEDIDO, DetallesPedido.SECUENCIA));

        db.execSQL(String.format("CREATE TABLE %s ( %s INTEGER PRIMARY KEY AUTOINCREMENT," +
                        "%s TEXT NOT NULL UNIQUE,%s TEXT NOT NULL,%s REAL NOT NULL," +
                        "%s INTEGER NOT NULL CHECK(%s>=0) )",
                Tablas.PRODUCTO, BaseColumns._ID,
                Productos.ID_PRODUCTO, Productos.NOMBRE, Productos.PRECIO,
                Productos.EXISTENCIAS, Productos.EXISTENCIAS));

        db.execSQL(String.format("CREATE TABLE %s ( %s INTEGER PRIMARY KEY AUTOINCREMENT," +
                        "%s TEXT NOT NULL UNIQUE,%s TEXT NOT NULL,%s TEXT NOT NULL,%s )",
                Tablas.CLIENTE, BaseColumns._ID,
                Clientes.ID_CLIENTE, Clientes.NOMBRES, Clientes.APELLIDOS, Clientes.TELEFONO));

        db.execSQL(String.format("CREATE TABLE %s ( %s INTEGER PRIMARY KEY AUTOINCREMENT," +
                        "%s TEXT NOT NULL UNIQUE,%s TEXT NOT NULL )",
                Tablas.FORMA_PAGO, BaseColumns._ID,
                FormasPago.ID_FORMA_PAGO, FormasPago.NOMBRE));

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

        db.execSQL("DROP TABLE IF EXISTS " + Tablas.CABECERA_PEDIDO);
        db.execSQL("DROP TABLE IF EXISTS " + Tablas.DETALLE_PEDIDO);
        db.execSQL("DROP TABLE IF EXISTS " + Tablas.PRODUCTO);
        db.execSQL("DROP TABLE IF EXISTS " + Tablas.CLIENTE);
        db.execSQL("DROP TABLE IF EXISTS " + Tablas.FORMA_PAGO);

        onCreate(db);
    }


}

Me parece importante destacar el uso de las llaves foráneas a través de la sentencia REFERENCES. La sintaxis funciona como índice al final del comando CREATE:

FOREIGN KEY(columna) REFERENCES otra_tabla(columna_otra_tabla)

o en línea:

columna REFERENCES otra_tabla(columna_otra_tabla)

También puedes agregar la cláusula ON DELETE CASCADE para propagar la eliminación en cascada de los detalles que estén relacionados con una cabecera que se eliminó.

Ahora para el caso de 'detalle_pedido' se usa una llave primaria compuesta. Debido a que '_id' es la clave principal, debes usar la cláusula UNIQUE para satisfacer el rol de índice único. Por lo que puedes especificar ambas columnas así:

UNIQUE (id_cabecera_pedido, secuencia)

Para hacer efectiva las referencias de integridad de las llaves foráneas en SQLite es necesario usar el método setForeignKeyConstraintsEnabled() pasando el valor true dentro de onOpen(). Este método va desde Android Jelly Bean en adelante.

db.setForeignKeyConstraintsEnabled(true);

Para el soporte, puedes habilitar manualmente a través de la sentencia PRAGMA foreign_keys=ON.

db.execSQL("PRAGMA foreign_kets=ON");

4. Crear Modelos Para La Base De Datos

Crear clases modelo permite representar los registros de la base de datos como entidades dentro de la app Android que pueden ayudarte a procesar eventos desde la vista.

1. El primer modelo será el de la cabecera del pedido. Así que crea una nueva clase llamada DetallePedido.java dentro del paquete modelo y agrega los atributos de la siguiente forma.

public class CabeceraPedido {

    public String idCabeceraPedido;

    public String fecha;

    public String idCliente;

    public String idFormaPago;

    public CabeceraPedido(String idCabeceraPedido, String fecha, 
                          String idCliente, String idFormaPago) {
        this.idCabeceraPedido = idCabeceraPedido;
        this.fecha = fecha;
        this.idCliente = idCliente;
        this.idFormaPago = idFormaPago;
    }
}

2. De la misma forma crea una clase con el nombre de DetallePedido.java y escribe los atributos:

DetallePedido.java

public class DetallePedido {

    public String idCabeceraPedido;

    public int secuencia;

    public String idProducto;

    public int cantidad;

    public float precio;

    public DetallePedido(String idCabeceraPedido, int secuencia, 
                         String idProducto, int cantidad, float precio) {
        this.idCabeceraPedido = idCabeceraPedido;
        this.secuencia = secuencia;
        this.idProducto = idProducto;
        this.cantidad = cantidad;
        this.precio = precio;
    }
}

3. Crea una clase llamada Producto.java y añade los atributos visto en el modelo de datos:

Producto.java

public class Producto {

    public String idProducto;

    public String nombre;

    public float precio;

    public int existencias;

    public Producto(String idProducto, String nombre, float precio, int existencias) {
        this.idProducto = idProducto;
        this.nombre = nombre;
        this.precio = precio;
        this.existencias = existencias;
    }
}

4. Ahora es el turno para los clientes. Añade una clase nueva con el nombre de Cliente.java e inserta los respectivos atributos.

Cliente.java

public class Cliente {

    public String idCliente;

    public String nombres;

    public String apellidos;

    public String telefono;

    public Cliente(String idCliente, String nombres, String apellidos, String telefono) {
        this.idCliente = idCliente;
        this.nombres = nombres;
        this.apellidos = apellidos;
        this.telefono = telefono;
    }
}

5. Finalmente termina con la clase FormaPago.java. Recuerda que si necesitas depurar tus elementos puedes sobrescribir el método toString().

FormaPago.java

public class FormaPago {

    public String idFormaPago;

    public String nombre;

    public FormaPago(String idFormaPago, String nombre) {
        this.idFormaPago = idFormaPago;
        this.nombre = nombre;
    }
}

5. CRUD Para La Base De Datos

Ahora es el turno de generar operaciones de lectura, inserción, modificación y eliminación por cada uno de las tablas que tenemos.

Todas las operaciones serán ejecutadas desde una clase auxiliar a la cuál denominarás OperacionesBaseDatos.java. Esta se definirá bajo un patrón singleton que permita propagar el uso de los métodos a través de una sola instancia a lo largo de la app.

5.1 Patrón Singleton Para SQLite

Crea una nueva clase llamada OperacionesBaseDatos.java e implementa un patrón singleton. Esto significa, poner su constructor principal como privado, definir un miembro estático de la clase y generar un método estático que permita la obtención del único miembro.

OperacionesBaseDatos.java

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.herprogramacion.pedidos.modelo.CabeceraPedido;
import com.herprogramacion.pedidos.modelo.Cliente;
import com.herprogramacion.pedidos.modelo.DetallePedido;
import com.herprogramacion.pedidos.modelo.FormaPago;
import com.herprogramacion.pedidos.modelo.Producto;
import com.herprogramacion.pedidos.sqlite.BaseDatosPedidos.Tablas;

/**
 * Clase auxiliar que implementa a {@link BaseDatosPedidos} para llevar a cabo el CRUD
 * sobre las entidades existentes.
 */
public final class OperacionesBaseDatos {

    private static BaseDatosPedidos baseDatos;

    private static OperacionesBaseDatos instancia = new OperacionesBaseDatos();

    private OperacionesBaseDatos() {
    }

    public static OperacionesBaseDatos obtenerInstancia(Context contexto) {
        if (baseDatos == null) {
            baseDatos = new BaseDatosPedidos(contexto);
        }
        return instancia;
    }
}

5.2 CRUD cabeceras de pedido

1. El siguiente método obtendrá todas las cabeceras de pedidos que existan en la base de datos, haciendo un INNER JOIN con 'cliente' y 'forma_pago'. El valor de retorno será Cursor.

public Cursor obtenerCabecerasPedidos() {
        SQLiteDatabase db = baseDatos.getReadableDatabase();

        SQLiteQueryBuilder builder = new SQLiteQueryBuilder();

        builder.setTables(CABECERA_PEDIDO_JOIN_CLIENTE_Y_FORMA_PAGO);

        return builder.query(db, proyCabeceraPedido, null, null, null, null, null);
    }

  private static final String CABECERA_PEDIDO_JOIN_CLIENTE_Y_FORMA_PAGO = "cabecera_pedido " +
            "INNER JOIN cliente " +
            "ON cabecera_pedido.id_cliente = cliente.id " +
            "INNER JOIN forma_pago " +
            "ON cabecera_pedido.id_forma_pago = forma_pago.id";


    private final String[] proyCabeceraPedido = new String[]{
            Tablas.CABECERA_PEDIDO + "." + CabecerasPedido.ID,
            CabecerasPedido.FECHA,
            Clientes.NOMBRES,
            Clientes.APELLIDOS,
            FormasPago.NOMBRE};

Usa clase SQLiteQueryBuilder para fabricar consultas complejas que impliquen joins o uniones. El método setTablets() te permite asociar las tablas necesarias a consultar.

También se liga una proyección de columnas para determinar los datos necesarios a consultar. Recuerda que cómo varias tablas tienen el campo 'id', es necesario anteponer un alias o el mismo nombre de la tabla para no caer en ambigüedades. Por eso la primera columna de la proyección es 'cabecera_pedido.id'.

2. Obtener cabecera de pedido por identificador — Este método es similar al anterior, solo que esta vez se liga una sentencia WHERE para seleccionar solo la cabecera de pedido que tenga el id que viene por parámetro.

public Cursor obtenerCabeceraPorId(String id) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String selection = String.format("%s=?", CabecerasPedido.ID);
    String[] selectionArgs = {id};

    SQLiteQueryBuilder builder = new SQLiteQueryBuilder();
    builder.setTables(CABECERA_PEDIDO_JOIN_CLIENTE_Y_FORMA_PAGO);

    String[] proyeccion = {
            Tablas.CABECERA_PEDIDO + "." + CabecerasPedido.ID,
            CabecerasPedido.FECHA,
            Clientes.NOMBRES,
            Clientes.APELLIDOS,
            FormasPago.NOMBRE};

    return builder.query(db, proyeccion, selection, selectionArgs, null, null, null);
}

3. Insertar cabecera de pedido — Genera un identificador para el pedido, crea una estructura ContentValues para albergar los datos y luego aplica la inserción con insertOrThrow().

public String insertarCabeceraPedido(CabeceraPedido pedido) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    // Generar Pk
    String idCabeceraPedido = CabecerasPedido.generarIdCabeceraPedido();

    ContentValues valores = new ContentValues();
    valores.put(CabecerasPedido.ID_CABECERA_PEDIDO, idCabeceraPedido);
    valores.put(CabecerasPedido.FECHA, pedido.fecha);
    valores.put(CabecerasPedido.ID_CLIENTE, pedido.idCliente);
    valores.put(CabecerasPedido.ID_FORMA_PAGO, pedido.idFormaPago);

    // Insertar cabecera
    db.insertOrThrow(Tablas.CABECERA_PEDIDO, null, valores);

    return idCabeceraPedido;
}

3. Actualizar cabecera de pedido — El siguiente método actualiza los datos de una cabecera cuyo identificador sea igual al entrante. El proceso es similar a la inserción, solo que esta vez debes generar la cláusula de la condición más un parámetro.

public boolean actualizarCabeceraPedido(CabeceraPedido pedidoNuevo) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(CabecerasPedido.FECHA, pedidoNuevo.fecha);
    valores.put(CabecerasPedido.ID_CLIENTE, pedidoNuevo.idCliente);
    valores.put(CabecerasPedido.ID_FORMA_PAGO, pedidoNuevo.idFormaPago);

    String whereClause = String.format("%s=?", CabecerasPedido.ID_CABECERA_PEDIDO);
    String[] whereArgs = {pedidoNuevo.idCabeceraPedido};

    int resultado = db.update(Tablas.CABECERA_PEDIDO, valores, whereClause, whereArgs);

    return resultado > 0;
}

4. Eliminar cabecera de pedido — Usa el método delete() para remover una cabecera de pedido, donde la condición se especifica por el identificador que entra como parámetro al método.

public boolean eliminarCabeceraPedido(String idCabeceraPedido) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String whereClause = CabecerasPedido.ID_CABECERA_PEDIDO + "=?";
    String[] whereArgs = {idCabeceraPedido};

    int resultado = db.delete(Tablas.CABECERA_PEDIDO, whereClause, whereArgs);

    return resultado > 0;
}

No olvides que al eliminar una cabecera, todos sus detalles desaparecerán, debido al activador ON DELETE que pusiste en la creación de la tabla.

5.3 CRUD para detalles de pedido

1. Obtener detalles de pedido — El siguiente método obtendrá todos los detalles de un pedido determinado por el parámetro idDetallePedido.

public Cursor obtenerDetallesPorIdPedido(String idCabeceraPedido) {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format("SELECT * FROM %s WHERE %s=?",
            Tablas.DETALLE_PEDIDO, CabecerasPedido.ID_CABECERA_PEDIDO);

    String[] selectionArgs = {idCabeceraPedido};

    return db.rawQuery(sql, selectionArgs);

}

2. Insertar detalle de pedido — Este método inserta un detalle de pedido a través de una instancia DetallePedido. El retorno es la llave compuesta del nuevo detalle de forma 'idCabeceraPedido#secuencia'.

public String insertarDetallePedido(DetallePedido detalle) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(DetallesPedido.ID_CABECERA_PEDIDO, detalle.idCabeceraPedido);
    valores.put(DetallesPedido.SECUENCIA, detalle.secuencia);
    valores.put(DetallesPedido.ID_PRODUCTO, detalle.idProducto);
    valores.put(DetallesPedido.CANTIDAD, detalle.cantidad);
    valores.put(DetallesPedido.PRECIO, detalle.precio);
    
    db.insertOrThrow(Tablas.DETALLE_PEDIDO, null, valores);
    
    return String.format("%s#%d", detalle.idCabeceraPedido, detalle.secuencia);

}

3. Actualizar un detalle de pedido — Se actualiza el detalle a través de nuevos valores que vienen en una instancia DetallePedido. Esta solo se lleva a cabo si el registro tiene el mismo id de cabecera y número de secuencia.

public boolean actualizarDetallePedido(DetallePedido detalle) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(DetallesPedido.SECUENCIA, detalle.secuencia);
    valores.put(DetallesPedido.CANTIDAD, detalle.cantidad);
    valores.put(DetallesPedido.PRECIO, detalle.precio);

    String selection = String.format("%s=? AND %s=?",
            DetallesPedido.ID_CABECERA_PEDIDO, DetallesPedido.SECUENCIA);
    final String[] whereArgs = {detalle.idCabeceraPedido, String.valueOf(detalle.secuencia)};

    int resultado = db.update(Tablas.DETALLE_PEDIDO, valores, selection, whereArgs);

    return resultado > 0;
}

4. Eliminar un detalle de pedido — Se elimina un registro de la tabla detalle_pedido cuyo id_cabecera_pedido y secuencia concuerden con los parámetros.

public boolean eliminarDetallePedido(String idCabeceraPedido, int secuencia) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String selection = String.format("%s=? AND %s=?",
            DetallesPedido.ID_CABECERA_PEDIDO, DetallesPedido.SECUENCIA);
    String[] whereArgs = {idCabeceraPedido, String.valueOf(secuencia)};

    int resultado = db.delete(Tablas.DETALLE_PEDIDO, selection, whereArgs);

    return resultado > 0;
}

5.4 CRUD de las tablas restantes

Debido a que los demás recursos siguen el mismo patrón para las operaciones, obviaré las explicaciones separadas. Intenta crearlas por ti mismo como práctica para interiorizar los métodos relacionados con bases de datos.

A continuación te dejo la implementación de los recursos faltantes:

// [OPERACIONES_PRODUCTO]
public Cursor obtenerProductos() {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format("SELECT * FROM %s", Tablas.PRODUCTO);

    return db.rawQuery(sql, null);
}

public String insertarProducto(Producto producto) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    // Generar Pk
    String idProducto = Productos.generarIdProducto();
    valores.put(Productos.ID, idProducto);
    valores.put(Productos.NOMBRE, producto.nombre);
    valores.put(Productos.PRECIO, producto.precio);
    valores.put(Productos.EXISTENCIAS, producto.existencias);

    db.insertOrThrow(Tablas.PRODUCTO, null, valores);

    return idProducto;

}

public boolean actualizarProducto(Producto producto) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(Productos.NOMBRE, producto.nombre);
    valores.put(Productos.PRECIO, producto.precio);
    valores.put(Productos.EXISTENCIAS, producto.existencias);

    String whereClause = String.format("%s=?", Productos.ID);
    String[] whereArgs = {producto.idProducto};

    int resultado = db.update(Tablas.PRODUCTO, valores, whereClause, whereArgs);

    return resultado > 0;
}

public boolean eliminarProducto(String idProducto) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String whereClause = String.format("%s=?", Productos.ID);
    String[] whereArgs = {idProducto};

    int resultado = db.delete(Tablas.PRODUCTO, whereClause, whereArgs);

    return resultado > 0;
}
// [/OPERACIONES_PRODUCTO]

// [OPERACIONES_CLIENTE]
public Cursor obtenerClientes() {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format("SELECT * FROM %s", Tablas.CLIENTE);

    return db.rawQuery(sql, null);
}

public String insertarCliente(Cliente cliente) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    // Generar Pk
    String idCliente = Clientes.generarIdCliente();

    ContentValues valores = new ContentValues();
    valores.put(Clientes.ID, idCliente);
    valores.put(Clientes.NOMBRES, cliente.nombres);
    valores.put(Clientes.APELLIDOS, cliente.apellidos);
    valores.put(Clientes.TELEFONO, cliente.telefono);

    return db.insertOrThrow(Tablas.CLIENTE, null, valores) > 0 ? idCliente : null;
}

public boolean actualizarCliente(Cliente cliente) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(Clientes.NOMBRES, cliente.nombres);
    valores.put(Clientes.APELLIDOS, cliente.apellidos);
    valores.put(Clientes.TELEFONO, cliente.telefono);

    String whereClause = String.format("%s=?", Clientes.ID);
    final String[] whereArgs = {cliente.idCliente};

    int resultado = db.update(Tablas.CLIENTE, valores, whereClause, whereArgs);

    return resultado > 0;
}

public boolean eliminarCliente(String idCliente) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String whereClause = String.format("%s=?", Clientes.ID);
    final String[] whereArgs = {idCliente};

    int resultado = db.delete(Tablas.CLIENTE, whereClause, whereArgs);

    return resultado > 0;
}
// [/OPERACIONES_CLIENTE]

// [OPERACIONES_FORMA_PAGO]
public Cursor obtenerFormasPago() {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format("SELECT * FROM %s", Tablas.FORMA_PAGO);

    return db.rawQuery(sql, null);
}

public String insertarFormaPago(FormaPago formaPago) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    // Generar Pk
    String idFormaPago = FormasPago.generarIdFormaPago();

    ContentValues valores = new ContentValues();
    valores.put(FormasPago.ID, idFormaPago);
    valores.put(FormasPago.NOMBRE, formaPago.nombre);

    return db.insertOrThrow(Tablas.FORMA_PAGO, null, valores) > 0 ? idFormaPago : null;
}

public boolean actualizarFormaPago(FormaPago formaPago) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    ContentValues valores = new ContentValues();
    valores.put(FormasPago.NOMBRE, formaPago.nombre);

    String whereClause = String.format("%s=?", FormasPago.ID);
    String[] whereArgs = {formaPago.idFormaPago};

    int resultado = db.update(Tablas.FORMA_PAGO, valores, whereClause, whereArgs);

    return resultado > 0;
}

public boolean eliminarFormaPago(String idFormaPago) {
    SQLiteDatabase db = baseDatos.getWritableDatabase();

    String whereClause = String.format("%s=?", FormasPago.ID);
    String[] whereArgs = {idFormaPago};

    int resultado = db.delete(Tablas.FORMA_PAGO, whereClause, whereArgs);

    return resultado > 0;
}

public SQLiteDatabase getDb() {
    return baseDatos.getWritableDatabase();
}


// [/OPERACIONES_FORMA_PAGO]

Probar Base De Datos SQLite

Abre ActividadListaPedidos.java y crea una tarea asíncrona interna llamada TareaPruebaDatos. El objetivo es ejecutar las operaciones de base de datos dentro de esta para no entorpecer el hilo de UI.

ActividadListaPedidos.java

import android.database.DatabaseUtils;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;

import com.herprogramacion.pedidos.R;
import com.herprogramacion.pedidos.modelo.CabeceraPedido;
import com.herprogramacion.pedidos.modelo.Cliente;
import com.herprogramacion.pedidos.modelo.DetallePedido;
import com.herprogramacion.pedidos.modelo.FormaPago;
import com.herprogramacion.pedidos.modelo.Producto;
import com.herprogramacion.pedidos.sqlite.OperacionesBaseDatos;

import java.util.Calendar;

public class ActividadListaPedidos extends AppCompatActivity {

    OperacionesBaseDatos datos;

    public class TareaPruebaDatos extends AsyncTask<Void, Void, Void> {
        @Override
        protected Void doInBackground(Void... params) {

            // [INSERCIONES]
            String fechaActual = Calendar.getInstance().getTime().toString();

            try {

                datos.getDb().beginTransaction();

                // Inserción Clientes
                String cliente1 = datos.insertarCliente(new Cliente(null, "Veronica", "Del Topo", "4552000"));
                String cliente2 = datos.insertarCliente(new Cliente(null, "Carlos", "Villagran", "4440000"));

                // Inserción Formas de pago
                String formaPago1 = datos.insertarFormaPago(new FormaPago(null, "Efectivo"));
                String formaPago2 = datos.insertarFormaPago(new FormaPago(null, "Crédito"));

                // Inserción Productos
                String producto1 = datos.insertarProducto(new Producto(null, "Manzana unidad", 2, 100));
                String producto2 = datos.insertarProducto(new Producto(null, "Pera unidad", 3, 230));
                String producto3 = datos.insertarProducto(new Producto(null, "Guayaba unidad", 5, 55));
                String producto4 = datos.insertarProducto(new Producto(null, "Maní unidad", 3.6f, 60));

                // Inserción Pedidos
                String pedido1 = datos.insertarCabeceraPedido(
                        new CabeceraPedido(null, fechaActual, cliente1, formaPago1));
                String pedido2 = datos.insertarCabeceraPedido(
                        new CabeceraPedido(null, fechaActual,cliente2, formaPago2));

                // Inserción Detalles
                datos.insertarDetallePedido(new DetallePedido(pedido1, 1, producto1, 5, 2));
                datos.insertarDetallePedido(new DetallePedido(pedido1, 2, producto2, 10, 3));
                datos.insertarDetallePedido(new DetallePedido(pedido2, 1, producto3, 30, 5));
                datos.insertarDetallePedido(new DetallePedido(pedido2, 2, producto4, 20, 3.6f));

                // Eliminación Pedido
                datos.eliminarCabeceraPedido(pedido1);

                // Actualización Cliente
                datos.actualizarCliente(new Cliente(cliente2, "Carlos Alberto", "Villagran", "3333333"));

                datos.getDb().setTransactionSuccessful();
            } finally {
                datos.getDb().endTransaction();
            }

            // [QUERIES]
            Log.d("Clientes","Clientes");
            DatabaseUtils.dumpCursor(datos.obtenerClientes());
            Log.d("Formas de pago", "Formas de pago");
            DatabaseUtils.dumpCursor(datos.obtenerFormasPago());
            Log.d("Productos", "Productos");
            DatabaseUtils.dumpCursor(datos.obtenerProductos());
            Log.d("Cabeceras de pedido", "Cabeceras de pedido");
            DatabaseUtils.dumpCursor(datos.obtenerCabecerasPedidos());
            Log.d("Detalles de pedido", "Detalles de pedido");
            DatabaseUtils.dumpCursor(datos.obtenerDetallesPedido());

            return null;
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.actividad_lista_pedidos);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        getApplicationContext().deleteDatabase("pedidos.db");
        datos = OperacionesBaseDatos
                .obtenerInstancia(getApplicationContext());

        new TareaPruebaDatos().execute();
    }

}

Lo primero que debes hacer es obtener la instancia de OperacionesBaseDatos. Luego dentro de doInBackground() incluye todas las operaciones que vayas a probar dentro de una transacción.

La transacción la inicias con el método beginTransaction(). Luego marcas que fue exitosa con el método setTransactionSuccessful(). Si todo salió bien, la transacción se termina con endTrasaction() y se confirmarán los cambios definitivamente, de lo contrario habrá un rollback para que ninguna operación se haga efectiva.

La clase DatabaseUtils es para concatenar sentencias, ligar parámetros a comandos, construir condiciones para la cláusula WHERE, etc. En mi caso usé le método dumbCursor() para mostrar de forma presentable las filas de los cursores que vaya a loguear.

Por ejemplo, las filas de los clientes insertados arriba se ven así:

DatabaseUtils Android: Log de dumbCursor()

Lo importante es que las pruebas que vayas a realizar se encuentren en la tarea asíncrona y luego loguees el estado de las tablas para observar los cambios realizados.

Conclusión

Con este tutorial ya aprendiste algunas ideas para relacionar varias tablas dentro de una base de datos SQLite y cómo resolver situaciones comunes cómo: llaves compuestas, llaves foráneas, joins, eliminaciones en cascada, etc.

Viste que es posible controlar las referencias de integridad a través de la sentencia REFERENCES para que SQLite maneje por ti las restricciones de integridad.

Solo falta una aplicación que haga uso de estas explicaciones, sin embargo primero quiero explicarte cómo implementar esta base de datos en un Content Provider con múltiples tablas y luego crear la aplicación de pedidos formalmente.

  • Marco Antonio Morales Hernande

    Ola… Yo soy principiante y tengo una duda en esta parte db.execSQL(“PRAGMA foreign_kets=ON”);….. Quisiera saber si es la parte que esta ejecutando con el metodo…. public void onOpen(SQLiteDatabase db)

  • Marco Antonio Morales Hernande

    Ola… Yo soy principiante y tengo una duda en esta parte db.execSQL(“PRAGMA foreign_kets=ON”);….. Quisiera saber si es la parte que esta ejecutando con el metodo…. public void onOpen(SQLiteDatabase db)

  • Fabian Maldonado

    Hermosa programación es lo maximo James, te felicito…. de las mejores cosas que se encuentran en la red….

  • Fabian Maldonado

    Hermosa programación es lo maximo James, te felicito…. de las mejores cosas que se encuentran en la red….

  • Eduardo Viola

    Excelente tutorial. muchas gracias me ha servido de mucho!!
    Saludos.

  • Android Intecap

    Buenas noches donde puedo descargar el codigo completo?

    • Hola compañero, hazlo con el plugin que ves al inicio del artículo. Solo debes compartir el post en una red social para desbloquear el enlace.

  • eRny

    ante nada saludos y gracias por darte el tiempo para compartir tus conocimientos…. me han ayudado de muchos, aunque en esta ocasión debo pedir auxilio, en el tercer paso “crear manejador SQLiteOpenHelper” tengo una gradisima duda UU, en el momento de las interfaces de referencias, son 2..
    1: por que solo “id_cabecera_pedido” tiene el “on delete cascade”?
    y 2: cuando cologo el codigo de las referencias al final mi codigo genera error y no me permite los parametros, puesto que solo me dice que puedo colocar los “generarID….” de los metodos auxiliares…. por favor diganme en que me equivoco o si fue error de ustedes pero mi cabeza no da mas UU

    le e dado DEMASIADAS vueltas al codigo hasta COPIE Y PEGUE literalmente y no logro nada UU
    (adiciono imagen a ver si me explico mejor UU)

    • Emanuel Reniero

      Hola eRny, pudiste solucionar tu problema? Tengo el mismo que vos!

  • Ivan Mendizabal Saravia

    En el punto 5.3 CRUD para detalles de pedido está el siguiente código:

    public Cursor obtenerDetallesPorIdPedido(String idCabeceraPedido) {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format(“SELECT * FROM %s WHERE %s=?”,
    Tablas.DETALLE_PEDIDO, CabecerasPedido.ID_CABECERA_PEDIDO);

    String[] selectionArgs = {idCabeceraPedido};

    return db.rawQuery(sql, selectionArgs);

    }

    Pero al descargar la aplicación el código está como sigue:

    public Cursor obtenerDetallesPorIdPedido() {
    SQLiteDatabase db = baseDatos.getReadableDatabase();

    String sql = String.format(“SELECT * FROM %s WHERE %s=?”,
    Tablas.DETALLE_PEDIDO, ContratoPedidos.CabecerasPedido.ID_CABECERA_PEDIDO);

    String[] selectionArgs = {idCabeceraPedido};

    return db.rawQuery(sql, selectionArgs);

    }

    Diferencias en las siguientes lineas:

    Descarga: public Cursor obtenerDetallesPorIdPedido() {
    Punto 5.3: public Cursor obtenerDetallesPorIdPedido(String idCabeceraPedido) {

    Descarga: Tablas.DETALLE_PEDIDO, CabecerasPedido.ID_CABECERA_PEDIDO);
    Punto 5.3: Tablas.DETALLE_PEDIDO, ContratoPedidos.CabecerasPedido.ID_CABECERA_PEDIDO);

    En el primer caso, pareciera obvio que al corregir la descarga agregándole (String idCabeceraPedido) el error que genera se soluciona, sin embargo al corregirlo se genera un error en ActividadListaPedidos.java ya que la línea que dice:
    DatabaseUtils.dumpCursor(datos.obtenerDetallesPorIdPedido());
    no usa parámetros.

    En el segundo caso, no sé cual de las dos líneas es la correcta.

    Gracias.

  • jeinz

    Buen dia, James estoy siguiendo tu tutorial y he comprado tu ebook Diseño conceptual. Me puedes resolver una duda del punto 5.2 CRUD se debe crear una clase nueva o se debe modificar alguna

    • Hola Jeinz, esos métodos van dentro de la clase de operaciones en la base de datos. Descarga el código completo y verás.

  • victor

    Ostras Jame, no comprendo el código de la creación de tablas con %s y REFERENCES %s(%s), me pierdo, no sé muy bien que es y como lo utilizas, he buscado por google un poco y es como una cadena o algo… Pero sino, ¿puedo crear las tablas manualmente de la forma tipica declarando tabla por tabla? Aunque luego vuelvo a ver que usas el famoso ‘%’ como en el insert: “String.format(“%s#%d”, detalle.idCabeceraPedido, detalle.secuencia);” Estoy perdidillo con este código, ¿qué es esto exactamente? sólo se usa en base de datos? Encuentro cosas de sprintf() y eso, pero me has dejado empanao jajajaja, llevo un rato y no logro pillarlo. Si sabes algún lado que me ayude a comprender este código me ayudaría.

    • victor

      Solucionao! Ya está entendido!

      • ajajaj ok Victor, pero cuéntale a los demás de que se trata.

        • victor

          Claro hombre, realizo un ejemplo por si alguien le viene bien:

          —————————
          // Inicio del ejemplo.
          String nombre = “Víctor”;
          int edad = 23;

          // A partir de un origen o patrón, si tenemos que reutilizarlo
          // una buena forma es dejarlo como una variable, donde ha esta
          // sólo le indicaremos de que tipo es, por ejemplo, si es String %s,
          // o un integer de tipo decimal %d.

          String origen = “Mi nombre es: %s y tengo %d años.”;

          // Finalmente para utilizar la función de String.format(),
          // pasaremos un primer parámetro con el origen o patrón a seguir,
          // y luego de forma consecutiva las variables a sustituir.
          String resultado = String.format(origen ,nombre,edad);

          Log.d(TAG, resultado);
          //Salida-> “Mi nombre es: Víctor y tengo 23 años.”

          //Fin del ejemplo
          —————————
          Espero que les sea de ayuda!

          Gracias por todo James!

          Un saludo!

  • hola amigo excelente tutorial, me podrias ayudar tengo una app con una base de datos en ingles pero la quiero hacer multi lenguaje ya he cambiado todo usando strings-es y esas cosas. pero no se como hacerlo mismo con la carpeta assets y con la base datos? como hacer para que asi como me cambia los nombres de strings a español utilize la base de datos en español y no la de ingles. te lo agradeceria. saludos

  • victor

    Que guayy! Mola mucho, de aquí unos días lo estudio detenidamente este articulo! Igual que el de content provider con diferentes tablas!

    Eres un crack!!

    • Gracias Victor :D, si puedes comparte los artículos con más personas para que el material llegue a todos. Saludos!

      • victor

        Ningún problema!

  • Daniel Exteban Chia Jaime

    si se puede el inner join :D buen tutorial

  • Hola de nuevo compañeros.

    Esta vez traigo este artículo sobre bases de datos SQLite con múltiples tablas. No creé una app compleja, ya que quiero extender este artículo con content providers. Cuando hable sobre ello, entonces podré crear una app de pedidos que use este modelo de datos.

    Recuerden que si encuentran algún error me ayudaría muchísimo si me lo indican. Saludos :) !

    • Diego Giraldo Giraldo

      Reciba un cordial saludo James
      Gracias por enseñarnos como crear una base de datos con multiples tablas en Android, para las personas que tenemos pocos conocimientos de Bases de Datos es muy util.
      Le agradecería, si le es posible, corregir el nombre del archivo “DetallePedido.java” por “CabeceraPedido.java” cuando esta Creando Modelos Para La Base De Datos.
      Nuevamente muchas gracias por el tiempo que nos dedica.

      • Hola Diego, gracias por leer mi blog.

        En que parte debo corregirlo, o por que lo dices compañero?

        • Vicky Vicent

          Hola James, Diego se refiere al punto 4.1 en el que haces referencia a que el codigo siguiente es el de “DetallePedido.java”, cuando en realidad es el de “CabeceraPedido.java”.

          Un saludo y sigue así.