Persistir datos con SQLite en Flutter

SQLite es una base de datos informática de código abierto, se utiliza para producir una pieza de información, realizar operaciones completamente diferentes como agregar, eliminar y quitar datos. SQLite no necesita un servidor o un código de back-end, toda la información se guarda en un archivo de computadora dentro del dispositivo, o diremos que es nativo del almacenamiento. 

Instalación del complemento SQLite en Flutter

Para poder usar SQLite en Flutter, desea presentar el complemento SQLite. por lo tanto, para mostrarlo, desea navegar hasta el archivo pubspec.yaml,

 

Y agregue la dependencia de ruta y SQLite.

dependencies:
  cupertino_icons: ^1.0.2
  flutter:
    sdk: flutter
  path: ^1.8.0
  sqflite: ^2.0.0+4

¡Ahora puedes comenzar a usar SQLite en el proyecto Flutter!

Definición del modelo de planeta

Definición de la clase de modelo en la que se deben almacenar los datos. Nuestra clase de modelo tiene la identificación, el nombre, la edad, la distancia del sol y un constructor que inicializa los miembros de datos.

class Planets {
  late final int id;
  late final String name;
  late final int age;
  late final int distancefromsun;
  
  Planets({
    required this.id,
    required this.name,
    required this.age,
    required this.distancefromsun,
  });
   
  Planets.fromMap(Map<String, dynamic> result)
      : id = result["id"],
        name = result["name"],
        age = result["age"],
        distancefromsun = result["distancefromsun"];
  Map<String, Object> toMap() {
    return {
      'id': id,
      'name': name,
      'age': age,
      'distancefromsun': distancefromsun
    };
  }
}

Definición de la clase de base de datos

En la clase de base de datos tenemos todas las funciones implementadas aquí, la clase de base de datos tiene los siguientes métodos

• initializedDB que en realidad obtiene la ruta de datos predeterminada utilizando el método getDatabasePath de SQLite, abre la base de datos utilizando el método openDatabase de SQLite y luego crea los planetas de la tabla.
• El método insertPlanets toma la lista de planetas y los inserta en la tabla uno por uno.
• retrievePlanets devuelve la lista de planetas.
• deletePlanets elimina el planeta de la base de datos utilizando la identificación de la clave principal.

import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';
import 'model.dart';
  
class DataBase {
  Future<Database> initializedDB() async {
    String path = await getDatabasesPath();
    return openDatabase(
      join(path, 'planets.db'),
      version: 1,
      onCreate: (Database db, int version) async {
        await db.execute(
          "CREATE TABLE planets(id INTEGER PRIMARY KEY , name TEXT NOT NULL,age INTEGER NOT NULL,distancefromsun INTEGER NOT NULL)",
        );
      },
    );
  }
  
  // insert data
  Future<int> insertPlanets(List<Planets> planets) async {
    int result = 0;
    final Database db = await initializedDB();
    for (var planet in planets) {
      result = await db.insert('planets', planet.toMap(),
          conflictAlgorithm: ConflictAlgorithm.replace);
    }
  
    return result;
  }
  
  // retrieve data
  Future<List<Planets>> retrievePlanets() async {
    final Database db = await initializedDB();
    final List<Map<String, Object?>> queryResult = await db.query('planets');
    return queryResult.map((e) => Planets.fromMap(e)).toList();
  }
  
  // delete user
  Future<void> deletePlanet(int id) async {
    final db = await initializedDB();
    await db.delete(
      'planets',
      where: "id = ?",
      whereArgs: [id],
    );
  }
}

Definición del archivo principal

• En el archivo principal, en realidad llamamos a la Función principal y ejecutamos la aplicación runApp.
• El método initState agrega los datos y llama al método insertPlanets .
• y luego simplemente mostramos los datos en la pantalla del usuario.

import 'package:flutter/material.dart';
import 'package:sqliteimplementation/model.dart';
import 'package:sqliteimplementation/service.dart';
  
void main() {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(Home());
}
  
class Home extends StatefulWidget {
  Home({Key? key}) : super(key: key);
  
  @override
  State<Home> createState() => _HomeState();
}
  
class _HomeState extends State<Home> {
  late DataBase handler;
  Future<int> addPlanets() async {
    Planets firstPlanet =
        Planets(name: "Mercury", age: 24, id: 1, distancefromsun: 10);
    Planets secondPlanet =
        Planets(name: "Venus", age: 31, id: 2, distancefromsun: 20);
    Planets thirdPlanet =
        Planets(id: 3, name: 'Earth', age: 4, distancefromsun: 30);
     Planets fourthPlanet =
        Planets(id: 4, name: 'Mars', age: 5, distancefromsun: 40);
  
    List<Planets> planets = [firstPlanet, secondPlanet,thirdPlanet,fourthPlanet];
    return await handler.insertPlanets(planets);
  }
  
  @override
  void initState() {
    super.initState();
    handler = DataBase();
    handler.initializedDB().whenComplete(() async {
      await addPlanets();
      setState(() {});
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: FutureBuilder(
          future: handler.retrievePlanets(),
          builder:
              (BuildContext context, AsyncSnapshot<List<Planets>> snapshot) {
            if (snapshot.hasData) {
              return ListView.builder(
                itemCount: snapshot.data?.length,
                itemBuilder: (BuildContext context, int index) {
                  return Card(
                    child: ListTile(
                      contentPadding: const EdgeInsets.all(8.0),
                      title: Text(snapshot.data![index].name),
                      subtitle: Text(snapshot.data![index].age.toString()),
                    ),
                  );
                },
              );
            } else {
              return const Center(child: CircularProgressIndicator());
            }
          },
        ),
      ),
    );
  }
}

Producción: