Ejemplo SQLite

Configuración del proyecto:

1. Agregar la dependencia: En tu archivo pubspec.yaml, agrega la siguiente dependencia:

   YAML

   dependencies:
     sqflite: ^3.0.0
   

   Luego, ejecuta flutter pub get para instalar el paquete.

2. Crear un modelo de datos: Define una clase que represente la estructura de los datos que deseas almacenar en la base de datos. Por ejemplo, si quieres almacenar usuarios, puedes crear una clase User:

class User { 

  final int id; final String name; final int age;

  User({required this.id, required this.name, required this.age});   

 Map<String, dynamic> toMap() {
   return {
     'id': id,
     'name': name,
     'age': age,
   };
 }

 factory User.fromMap(Map<String, dynamic> map) {
   return User(
     id: map['id'],
     name: map['name'],
     age: map['age'],   
   );
 }
}

**Permisos:**

SQLite almacena los datos localmente en el dispositivo, por lo que **no requiere permisos especiales**. Los datos se guardan en un archivo dentro de la aplicación y son accesibles solo por esa aplicación.

**Código para crear y usar la base de datos:**

```dart
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

class DatabaseHelper {
static const _databaseName = 'my_database.db';
static const _databaseVersion = 1;

static const table    = 'users';
static const columnId = '_id';
static const columnName = 'name';
static const columnAge    = 'age';

// Singleton pattern to ensure only one database instance
static final DatabaseHelper _instance = DatabaseHelper._private();
Database? _database;

DatabaseHelper._private();

Future<Database> get database async {
 if (_database != null) return _database!;

 // Get a location using the `path` package
 final databasesPath = await getDatabasesPath();
 final path = join(databasesPath, _databaseName);

 // open the database
 _database = await openDatabase(
   path,
   version: _databaseVersion,
   onCreate: _onCreate,
 );
 return _database!;
}

// SQL code to create the table
Future<void> _onCreate(Database db, int version) async {
 await db.execute('''
           CREATE TABLE $table (
             $columnId INTEGER PRIMARY KEY AUTOINCREMENT,
             $columnName TEXT,
             $columnAge    INTEGER
           )
           ''');
}

// Insert a user
Future<int> insert(User user) async {
 Database db = await instance;
 return await db.insert(table, user.toMap());
}

// Get all users
Future<List<User>> queryAllUsers() async {
 Database db = await instance;
 List<Map<String, dynamic>> maps = await db.query(table);

 return List.generate(maps.length, (i) {
   return User.fromMap(maps[i]);
 });
}

 Future<int> update(User user) async {
    Database db = await instance;
    return await db.update(
      table,
      user.toMap(),
      where: '$columnId = ?',
      whereArgs: [user.id],
    );
 }

 Future<int> delete(int id) async {
    Database db = await instance;
    return await db.delete(
      table,
      where: '$columnId = ?',
      whereArgs: [id],
    );
 }
}

Explicación:

• Singleton: Se utiliza un patrón singleton para garantizar que solo haya una instancia de la base de datos.
• Creación de la base de datos: Se crea la base de datos y la tabla especificada.
• Inserción de datos: Se inserta un nuevo usuario en la tabla.
• Consulta de datos: Se obtienen todos los usuarios de la tabla.

Uso en tu aplicación:

Dart

// ...
DatabaseHelper databaseHelper = DatabaseHelper();

// Insertar un usuario
User user = User(id: 1, name: 'John Doe', age: 30);
await databaseHelper.insert(user);

// Obtener todos los usuarios
List<User> users = await databaseHelper.queryAllUsers();

Consideraciones adicionales:

• Migraciones: Si cambias la estructura de la tabla, tendrás que implementar migraciones para actualizar la base de datos.
• Rendimiento: Para grandes cantidades de datos, considera optimizar las consultas y utilizar índices.
• Seguridad: Si estás almacenando datos sensibles, considera encriptar los datos antes de guardarlos.