Flutter & SQLite: Panduan Database Lokal

Dalam pengembangan aplikasi mobile, kemampuan untuk menyimpan dan mengelola data secara lokal adalah fitur fundamental yang sering dibutuhkan. Flutter, dengan ekosistemnya yang kaya, menyediakan berbagai solusi untuk persistensi data. Salah satu pilihan yang paling populer dan efisien untuk database relasional lokal adalah SQLite. Artikel ini akan memandu Anda langkah demi langkah dalam mengintegrasikan dan menggunakan SQLite di aplikasi Flutter Anda, mulai dari persiapan hingga implementasi operasi CRUD (Create, Read, Update, Delete).

Mengapa Flutter dan SQLite?

SQLite adalah mesin database relasional tertanam yang ringan, tanpa server, tanpa konfigurasi, dan transaksi mandiri yang paling banyak digunakan di dunia. Kombinasinya dengan Flutter menawarkan beberapa keuntungan signifikan:

• Kinerja Optimal: SQLite dirancang untuk kecepatan dan efisiensi, cocok untuk aplikasi mobile yang membutuhkan responsivitas.
• Fleksibilitas Skema: Memberikan kontrol penuh atas skema database Anda, memungkinkan Anda merancang struktur data sesuai kebutuhan aplikasi.
• Dukungan Multi-platform: SQLite mendukung semua platform yang didukung Flutter (Android, iOS, Web, Desktop), memastikan konsistensi data di seluruh perangkat.
• Ukuran Kecil: Dengan footprint memori yang minim, SQLite ideal untuk lingkungan aplikasi mobile yang sumber dayanya terbatas.
• Penggunaan Offline: Memungkinkan aplikasi berfungsi penuh bahkan tanpa koneksi internet, meningkatkan pengalaman pengguna.

Persiapan: Menambahkan Dependensi

Untuk memulai, kita perlu menambahkan paket sqflite dan path_provider ke file pubspec.yaml proyek Flutter Anda. sqflite adalah plugin Flutter untuk SQLite, sedangkan path_provider digunakan untuk menemukan jalur direktori tempat database akan disimpan di perangkat.

# pubspec.yaml
dependencies:
  flutter:
    sdk: flutter
  sqflite: ^2.3.0  # Gunakan versi terbaru
  path_provider: ^2.1.0 # Gunakan versi terbaru

Membuat Model Data

Langkah pertama adalah mendefinisikan model data Anda. Ini adalah representasi objek data yang akan Anda simpan di database. Mari kita buat model sederhana bernama Item.

// lib/models/item.dart
class Item {
  int? id;
  String name;
  String description;

  Item({this.id, required this.name, required this.description});

  Map toMap() {
    return {
      'id': id,
      'name': name,
      'description': description,
    };
  }

  factory Item.fromMap(Map map) {
    return Item(
      id: map['id'],
      name: map['name'],
      description: map['description'],
    );
  }
}

Membangun Database Helper (DBHelper)

Untuk mengelola interaksi dengan database SQLite, praktik terbaik adalah membuat kelas DatabaseHelper (atau DbService). Kelas ini akan bertanggung jawab atas inisialisasi database, membuat tabel, dan menyediakan metode untuk operasi CRUD.

• Singleton Pattern: Menggunakan pola Singleton memastikan hanya ada satu instance database helper di seluruh aplikasi, menghindari masalah konkurensi.
• Inisialisasi Database: Fungsi _initDatabase akan membuka atau membuat database. Ini menggunakan path_provider untuk mendapatkan direktori dokumen aplikasi dan path untuk menggabungkan jalur file database.
• onCreate: Fungsi ini dipanggil hanya sekali saat database pertama kali dibuat. Di sinilah Anda akan mendefinisikan skema tabel Anda menggunakan perintah SQL CREATE TABLE.
• Operasi CRUD: Metode insert, queryAllItems, queryItem, update, dan delete akan berinteraksi langsung dengan database untuk melakukan operasi yang sesuai.

// lib/database_helper.dart
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'dart:io';
import 'package:your_app_name/models/item.dart'; // Sesuaikan path sesuai proyek Anda

class DatabaseHelper {
  static final _databaseName = "MyDatabase.db";
  static final _databaseVersion = 1;

  static final itemTable = 'items';
  static final columnId = 'id';
  static final columnName = 'name';
  static final columnDescription = 'description';

  // Make this a singleton class
  DatabaseHelper._privateConstructor();
  static final DatabaseHelper instance = DatabaseHelper._privateConstructor();

  static Database? _database;
  Future get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }

  // Open the database or create it if it doesn't exist
  _initDatabase() async {
    Directory documentsDirectory = await getApplicationDocumentsDirectory();
    String path = join(documentsDirectory.path, _databaseName);
    return await openDatabase(path,
        version: _databaseVersion,
        onCreate: _onCreate);
  }

  // SQL code to create the database table
  Future _onCreate(Database db, int version) async {
    await db.execute('''
          CREATE TABLE $itemTable (
            $columnId INTEGER PRIMARY KEY AUTOINCREMENT,
            $columnName TEXT NOT NULL,
            $columnDescription TEXT NOT NULL
          )
          ''');
  }

  // --- CRUD Operations ---

  // Insert an item
  Future insert(Item item) async {
    Database db = await instance.database;
    return await db.insert(itemTable, item.toMap());
  }

  // Query all items
  Future> queryAllItems() async {
    Database db = await instance.database;
    final List> maps = await db.query(itemTable);
    return List.generate(maps.length, (i) {
      return Item.fromMap(maps[i]);
    });
  }

  // Query a single item by ID
  Future queryItem(int id) async {
    Database db = await instance.database;
    List> maps = await db.query(
      itemTable,
      where: '$columnId = ?',
      whereArgs: [id],
    );
    if (maps.isNotEmpty) {
      return Item.fromMap(maps.first);
    }
    return null;
  }

  // Update an item
  Future update(Item item) async {
    Database db = await instance.database;
    return await db.update(
      itemTable,
      item.toMap(),
      where: '$columnId = ?',
      whereArgs: [item.id],
    );
  }

  // Delete an item
  Future delete(int id) async {
    Database db = await instance.database;
    return await db.delete(
      itemTable,
      where: '$columnId = ?',
      whereArgs: [id],
    );
  }
}

Mengintegrasikan dengan Aplikasi Flutter

Setelah DatabaseHelper siap, Anda dapat mengintegrasikannya ke dalam UI Flutter Anda. Berikut adalah contoh sederhana yang menunjukkan cara melakukan operasi CRUD dasar dan menampilkan data dalam ListView.

// lib/main.dart (contoh penggunaan sederhana)
import 'package:flutter/material.dart';
import 'package:your_app_name/database_helper.dart'; // Sesuaikan path
import 'package:your_app_name/models/item.dart';     // Sesuaikan path

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter SQLite Demo',
      debugShowCheckedModeBanner: false,
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State {
  final dbHelper = DatabaseHelper.instance;
  List _items = [];

  @override
  void initState() {
    super.initState();
    _refreshItems();
  }

  void _refreshItems() async {
    final data = await dbHelper.queryAllItems();
    setState(() {
      _items = data;
    });
  }

  void _addItem() async {
    // Generate a unique name for demonstration purposes
    String uniqueName = 'Item Barux ${DateTime.now().millisecondsSinceEpoch}';
    Item newItem = Item(name: uniqueName, description: 'Deskripsi untuk $uniqueName');
    await dbHelper.insert(newItem);
    _refreshItems(); // Refresh the list after adding
  }

  void _updateItem(Item item) async {
    item.name = '${item.name} (Diperbarui)';
    item.description = '${item.description} (Diperbarui pada ${DateTime.now().toLocal().toString().substring(0, 19)})';
    await dbHelper.update(item);
    _refreshItems(); // Refresh the list after updating
  }

  void _deleteItem(int id) async {
    await dbHelper.delete(id);
    _refreshItems(); // Refresh the list after deleting
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Daftar Item SQLite')),
      body: _items.isEmpty
          ? const Center(child: Text('Tidak ada item. Tambahkan satu!'))
          : ListView.builder(
              itemCount: _items.length,
              itemBuilder: (context, index) {
                final item = _items[index];
                return Card(
                  margin: const EdgeInsets.all(8),
                  child: ListTile(
                    title: Text(item.name),
                    subtitle: Text(item.description),
                    trailing: Row(
                      mainAxisSize: MainAxisSize.min,
                      children: [
                        IconButton(
                          icon: const Icon(Icons.edit),
                          onPressed: () => _updateItem(item),
                        ),
                        IconButton(
                          icon: const Icon(Icons.delete),
                          onPressed: () => _deleteItem(item.id!),
                        ),
                      ],
                    ),
                  ),
                );
              },
            ),
      floatingActionButton: FloatingActionButton(
        onPressed: _addItem,
        child: const Icon(Icons.add),
      ),
    );
  }
}

Praktik Terbaik dan Pertimbangan

• Operasi Asinkron: Semua operasi database di sqflite adalah asinkron. Pastikan Anda menggunakan async/await untuk menangani operasi ini dengan benar dan menghindari memblokir UI.
• Penanganan Error: Implementasikan penanganan error (misalnya, dengan blok try-catch) untuk operasi database untuk mengelola skenario seperti database tidak dapat diakses atau query gagal.
• Migrasi Database: Saat aplikasi Anda berkembang, Anda mungkin perlu mengubah skema database (misalnya, menambahkan kolom baru). sqflite mendukung migrasi database dengan memperbarui nomor versi database dan menyediakan fungsi onUpgrade.
• Pembaruan UI: Setelah melakukan operasi CRUD, pastikan untuk memanggil setState() atau menggunakan state management solution (seperti Provider, BLoC, Riverpod) untuk memperbarui UI aplikasi Anda agar mencerminkan perubahan data.
• Keamanan: SQLite bukan solusi yang aman untuk menyimpan data sensitif tanpa enkripsi tambahan. Untuk data yang sangat sensitif, pertimbangkan solusi seperti sembast atau plugin enkripsi database khusus.

Kesimpulan

Mengintegrasikan SQLite ke dalam aplikasi Flutter adalah cara yang efektif dan andal untuk mengelola data lokal. Dengan sqflite dan path_provider, Anda dapat dengan mudah membangun sistem persistensi data yang kuat, meningkatkan fungsionalitas offline dan kinerja aplikasi Anda. Dengan mengikuti panduan ini dan menerapkan praktik terbaik, Anda siap untuk membuat aplikasi Flutter yang lebih canggih dengan kapabilitas database lokal yang solid.