El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Introducción

SQLite es una biblioteca de software que proporciona un sistema de gestión de bases de datos relacional. Es una de las bases de datos más utilizadas en aplicaciones móviles debido a su ligereza y eficiencia. En este módulo, aprenderás cómo integrar SQLite en tu aplicación Android para manejar la persistencia de datos.

Objetivos

Entender qué es SQLite y por qué es útil en el desarrollo de aplicaciones Android.
Aprender a crear y gestionar bases de datos SQLite en Android.
Realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) en una base de datos SQLite.

Qué es SQLite

SQLite es una biblioteca de software que implementa un motor de base de datos SQL autónomo, sin servidor y sin configuración. Es una opción popular para aplicaciones móviles debido a su simplicidad y eficiencia.

Ventajas de SQLite

Ligero: No requiere un servidor separado para funcionar.
Integrado: Viene incluido en Android, por lo que no necesitas instalar nada adicional.
Fácil de usar: La API es sencilla y directa.

Configuración inicial

Antes de comenzar a trabajar con SQLite, es importante configurar tu entorno de desarrollo.

Añadir permisos en el archivo AndroidManifest.xml:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

Crear una clase que extienda SQLiteOpenHelper:

public class DatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "example.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // Crear tablas aquí
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // Actualizar la base de datos aquí
    }
}

Creación de una base de datos

Para crear una base de datos, necesitas definir las tablas y sus columnas. Esto se hace en el método onCreate de la clase SQLiteOpenHelper.

Ejemplo de creación de una tabla

@Override
public void onCreate(SQLiteDatabase db) {
    String CREATE_TABLE = "CREATE TABLE users (" +
                          "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
                          "name TEXT, " +
                          "email TEXT)";
    db.execSQL(CREATE_TABLE);
}

Operaciones CRUD

Crear (Insertar)

Para insertar datos en la base de datos, puedes usar el método insert de SQLiteDatabase.

public void addUser(String name, String email) {
    SQLiteDatabase db = this.getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put("name", name);
    values.put("email", email);
    db.insert("users", null, values);
    db.close();
}

Leer (Consultar)

Para leer datos, puedes usar el método query o rawQuery.

public List<User> getAllUsers() {
    List<User> userList = new ArrayList<>();
    String selectQuery = "SELECT * FROM users";
    SQLiteDatabase db = this.getReadableDatabase();
    Cursor cursor = db.rawQuery(selectQuery, null);

    if (cursor.moveToFirst()) {
        do {
            User user = new User();
            user.setId(cursor.getInt(cursor.getColumnIndex("id")));
            user.setName(cursor.getString(cursor.getColumnIndex("name")));
            user.setEmail(cursor.getString(cursor.getColumnIndex("email")));
            userList.add(user);
        } while (cursor.moveToNext());
    }
    cursor.close();
    db.close();
    return userList;
}

Actualizar

Para actualizar datos, puedes usar el método update.

public int updateUser(User user) {
    SQLiteDatabase db = this.getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put("name", user.getName());
    values.put("email", user.getEmail());
    return db.update("users", values, "id = ?", new String[]{String.valueOf(user.getId())});
}

Eliminar

Para eliminar datos, puedes usar el método delete.

public void deleteUser(int id) {
    SQLiteDatabase db = this.getWritableDatabase();
    db.delete("users", "id = ?", new String[]{String.valueOf(id)});
    db.close();
}

Ejercicio práctico

Ejercicio

Crea una aplicación Android que permita al usuario agregar, ver, actualizar y eliminar usuarios.
Implementa una interfaz de usuario simple con botones para cada operación CRUD.
Usa un RecyclerView para mostrar la lista de usuarios.

Solución

Crear la base de datos y las tablas:
- Usa la clase DatabaseHelper para crear la base de datos y la tabla users.
Implementar las operaciones CRUD:
- Usa los métodos addUser, getAllUsers, updateUser y deleteUser en tu actividad principal.
Diseñar la interfaz de usuario:
- Crea un RecyclerView para mostrar la lista de usuarios.
- Añade botones para agregar, actualizar y eliminar usuarios.

Código de ejemplo

public class MainActivity extends AppCompatActivity {
    private DatabaseHelper dbHelper;
    private RecyclerView recyclerView;
    private UserAdapter userAdapter;
    private List<User> userList;

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

        dbHelper = new DatabaseHelper(this);
        recyclerView = findViewById(R.id.recyclerView);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));

        loadUsers();

        findViewById(R.id.btnAddUser).setOnClickListener(v -> {
            // Lógica para agregar usuario
        });

        findViewById(R.id.btnUpdateUser).setOnClickListener(v -> {
            // Lógica para actualizar usuario
        });

        findViewById(R.id.btnDeleteUser).setOnClickListener(v -> {
            // Lógica para eliminar usuario
        });
    }

    private void loadUsers() {
        userList = dbHelper.getAllUsers();
        userAdapter = new UserAdapter(userList);
        recyclerView.setAdapter(userAdapter);
    }
}

Conclusión

En este módulo, has aprendido cómo usar SQLite para manejar la persistencia de datos en una aplicación Android. Has visto cómo crear una base de datos, definir tablas y realizar operaciones CRUD. Estos conocimientos te permitirán gestionar datos de manera eficiente en tus aplicaciones.

Próximos pasos

En el siguiente módulo, aprenderás a usar Room, una biblioteca de persistencia de datos que simplifica el uso de bases de datos SQLite en Android. Room proporciona una capa de abstracción sobre SQLite, facilitando la gestión de bases de datos y mejorando la seguridad y el rendimiento.

Persistencia de datos con SQLite