Hive: ano ito, NoSQL imbakan at pag-develop nang walang native code

Ano ang Hive?

Hive — ay isang NoSQL database na ganap na nakasulat sa Dart at hindi nangangailangan ng native na library. Ito ay nilikha ni Simon Leiter noong 2019 bilang alternatibo sa SQLite para sa Flutter projects. Ang Hive ay nag-iimbak ng data sa binary format .hive, na na-optimize para sa mabilis na pagbasa at pagsulat sa mga mobile device. Ang .hive format ay gumagamit ng custom na serialization scheme kung saan ang bawat uri ng data ay may sariling byte prefix, na nagpapahintulot sa pagbasa ng file nang walang paunang kaalaman sa scheme — hindi tulad ng Protocol Buffers o FlatBuffers.

Ang pangunahing ideya ng Hive — maximum na pagiging simple. Ang database ay hindi nangangailangan ng initialization ng native engines, hindi naglalaman ng SQL parser at hindi gumagamit ng reflection. Lahat ng operasyon ay direktang tawag sa Dart functions na may binary serialization sa pamamagitan ng WriteBuffer at ReadBuffer.

Ayon sa survey ng Flutter Community (2023), ang Hive ay nasa top 5 ng pinakaginagamit na packages para sa pag-iimbak ng data sa Flutter, pangalawa lamang sa shared_preferences sa kasikatan, ngunit nahihigitan ito sa functionality at bilis.

Arkitektura ng Hive

Hive ay gumagamit ng konsepto ng Box — analogo ng table sa relational databases. Ang bawat Box ay isang file sa disk na may set ng key-value pairs. Ang key ay maaaring int o String, ang value — anumang primitive type, listahan, Map o custom na object sa pamamagitan ng TypeAdapter. Ang mga Box ay hiwalay sa isa't isa at binubuksan nang independyente.

Mga bentahe kumpara sa native na solusyon

Hive ay hindi nangangailangan ng platform channels. Ibig sabihin nito ay pareho itong gumagana sa Android, iOS, Web, macOS, Windows at Linux nang walang karagdagang configuration. Para sa mga project na naka-target sa web compilation, ang Hive ay nananatiling tanging magaan na NoSQL solution — ang SQLite ay hindi gumagana sa browser. Kasabay nito, ang Hive ay gumagamit ng IndexedDB bilang backend para sa web, na tinitiyak ang data persistence kahit sa browser environment.

Paano gumagana ang Hive?

Hive ay nagse-serialize ng data sa binary format kapag nagsusulat at nagde-deserialize kapag nagbabasa. Ang internal mechanism ay nakabatay sa BinaryWriter at BinaryReader, na nagpa-pack ng data sa mga compact byte arrays. Ang laki ng imbakan sa disk ay average na 2–3 beses na mas maliit kaysa sa JSON representation ng parehong data.

Kapag binubuksan ang Box, nilo-load ng Hive ang buong file sa RAM. Ito ay nagbibigay ng mataas na bilis ng pagbasa (microseconds), ngunit nagpapataw ng limitasyon sa laki ng data: inirerekomenda na mag-imbak ng hindi hihigit sa 50–100 MB bawat Box. Para sa mas malalaking volume, gamitin ang LazyBox — lazy loading ng records mula sa disk.

Mga transaksyon at concurrency

Hive ay gumagana nang single-threaded sa isolation ng Dart-isolate. Ang mga write operation ay isinasagawa nang synchronously na may file locking. Para sa asynchronous access, gamitin ang Hive.openBox() na may await. Ang concurrent access mula sa maraming isolates ay hindi direktang suportado — para dito kailangan ng hiwalay na synchronization mechanism.

Hive vs SharedPreferences at vs SQLite

Hive ay nasa pagitan ng SharedPreferences at SQLite. Ito ay mas kumplikado kaysa sa SharedPreferences (sumusuporta sa custom na object), ngunit mas simple kaysa sa SQLite (hindi nangangailangan ng SQL queries). Ihambing natin ang mga pangunahing katangian.

Kailan pumili ng Hive

Hive ay optimal para sa maliit na volume ng data: app settings, cache ng API responses, lokal na synchronization queue, favorites at browsing history. Kung ang data ay hindi lalampas sa 50 MB at hindi nangangailangan ng relational queries — ang Hive ay mas mabilis at mas simple kaysa sa SQLite.

Kailan hindi angkop ang Hive

Hive ay hindi sumusuporta sa queries na may filtering sa maraming field, JOIN, aggregate functions. Kung kailangan mo ng complex queries tulad ng “piliin lahat ng tasks ngayong araw na may priority na higit sa 3” — gamitin ang SQLite na may drift o floor. Ang Hive ay hindi rin angkop para sa pag-iimbak ng higit sa 100 MB ng data dahil sa pag-load sa memory.

Mga halimbawa ng code sa Hive

Hive ay nagsisimula sa initialization at pagbubukas ng Box. Sa ibaba ay ang mga basic operation para sa tipikal na scenario — pag-iimbak ng listahan ng tasks sa Flutter app. Lahat ng halimbawa ay gumagana nang walang native platform calls.

Initialization at pagbubukas ng Box

Bago gamitin ang Hive, dapat tawagin ang Hive.initFlutter() sa main function. Pagkatapos buksan ang Box sa pamamagitan ng Hive.openBox() — ang resulta ay isang Box instance na handa para sa pagbasa at pagsulat.

import 'package:hive/hive.dart';
import 'package:hive_flutter/hive_flutter.dart';

void async main() {
    await Hive.initFlutter();
    final settingsBox = await Hive.openBox('settings');
    runApp(MyApp());
}

CRUD operations

Box ay nagbibigay ng mga method na put, get, delete at naglalaman ng iterator para sa pag-ikot sa lahat ng records. Ang mga key at value ay tina-type sa pamamagitan ng generics — bilang default, ang Box<dynamic> ay pumapayag sa anumang uri, ngunit inirerekomenda na tukuyin ang specific na uri.

// Pagsulat ng data
final box = await Hive.openBox<String>('tasks');
await box.put('task_1', 'Bumili ng produkto');

// Pagbasa
final task = box.get('task_1');

// Lahat ng key
final allTasks = box.values.toList();

// Pag-delete
await box.delete('task_1');

// Paglinis ng Box
await box.clear();

Reactive observation sa pamamagitan ng WatchBox

WatchBox — extension ng Box na nag-aabiso sa mga subscriber tungkol sa mga pagbabago. Sa Flutter, ito ay nag-i-integrate sa ValueListenableBuilder: kapag nagbago ang anumang value sa Box, ang widget ay awtomatikong nagre-rebuild nang hindi tumatawag ng setState.

final watchBox = await Hive.openBox('settings');

// Sa widget
ValueListenableBuilder(
    valueListenable: watchBox.listenable(),
    builder: (context, box, _) {
        final counter = box.get('counter') ?? 0;
        return Text('Counter: $counter');
    },
)

TypeAdapter at custom na object

TypeAdapter — mekanismo ng Hive para sa serialization ng custom na Dart objects. Inilalarawan ng adapter kung paano i-convert ang object sa binary format (write) at pabalik (read). Hindi tulad ng json_serializable, ang TypeAdapter ay hindi nangangailangan ng reflection at mas mabilis gumana.

Paglikha ng TypeAdapter

Ang adapter ay nag-i-implement ng interface na TypeAdapter na may dalawang method: read at write. Ang class ay nirehistro sa pamamagitan ng Hive.registerAdapter() bago buksan ang Box. Bawat adapter ay binibigyan ng numeric ID — naka-save sa file para sa type identification.

// Modelo ng data
class Task {
    final String title;
    final bool isCompleted;
    Task({required this.title, this.isCompleted = false});
}

// TypeAdapter
class TaskAdapter extends TypeAdapter<Task> {
    @override
    final int typeId = 0;

    @override
    Task read(BinaryReader reader) {
        return Task(
            title: reader.readString(),
            isCompleted: reader.readBool(),
        );
    }

    @override
    void write(BinaryWriter writer, Task obj) {
        writer.writeString(obj.title);
        writer.writeBool(obj.isCompleted);
    }
}

Pag-generate ng adapters sa pamamagitan ng code generation

Para sa mga project na may maraming modelo, ang Hive ay nagbibigay ng hive_generator at build_runner. Ang annotation na @HiveType sa class at @HiveField sa fields ay awtomatikong nagge-generate ng adapter. Ito ay maginhawa kapag ang modelo ay naglalaman ng 10+ fields — ang manual na pagsulat ng read/write ay nagiging labor-intensive.

Optimization ng performance ng Hive

Hive ay nagsasagawa ng pagbasa mula sa memory, hindi mula sa disk, na nagbibigay ng bilis hanggang 30 000 operations bawat segundo. Para sa optimization: buksan ang Box nang isang beses at gamitin muli sa buong app, huwag tawaging muli ang openBox. Gamitin ang Hive.box() (synchronous getter) pagkatapos ng initialization — nagbabalik ng nakabukas nang Box nang hindi gumagawa ng bagong instance.

Hive kasama ang Provider at Riverpod

Hive ay madaling nag-i-integrate sa mga sikat na Flutter state managers. Para sa Provider, gamitin ang ChangeNotifierProvider na nagbabasa ng data mula sa Box sa initialization at nag-a-update sa pamamagitan ng listenable. Para sa Riverpod, ang StreamProvider na naka-subscribe sa WatchBox ay angkop. Ang ganitong kombinasyon ay nagbibigay ng reactive UI updates sa bawat pagbabago ng data sa Hive nang walang manual na setState call. Sa tipikal na Flutter project, ang ganitong arkitektura ay nagpapahintulot ng synchronization ng state sa pagitan ng screens nang walang global singleton.