Comparing Hive to other Flutter app database options

In today’s always online world, there are still lots of use cases for storing data offline; especially when it comes to mobile development, but which database should you use?

In Flutter, you have an array of options to pick from if you need an offline database solution. Which option you ultimately go for is up to you, but there are factors that affect this decision (aside from the unique features they might provide) that typically boil down to how simple it is to get started and their speed, both of which we will cover in this article.

In this blog post, we’ll be looking at how the setup works for Hive and other databases, and compare and contrast basic functionalities every database will be expected to feature (specifically CRUD, i.e., create, read, update, delete).

We’ll do some benchmarking to determine how long it takes each database option to perform these operations, so you can have a clear understanding of which database option is right for your Flutter app project, Hive or otherwise.

Let’s get started.

• Hive
• Sembast
• Sqflite
• Isar
• ObjectBox
• Benchmark results
  • iOS (iPhone 12 V15.6)
  • Android (Galaxy A31, Android 11)

CRUD

The CRUD operations referred to previously will be carried out using a User object, i.e., writing n number of user objects to the database, etc. This is what the user object would look like:

class UserModel {
  final int id;
  final DateTime createdAt;
  final String username;
  final String email;
  final int age;

  UserModel(...);

  factory UserModel.fromMap(Map<String, dynamic> map) {
    return UserModel(...);
  }
  Map<String, dynamic> toMap() {
    return {...};
  }
}

To make use of an offline database in an application, the first thing to do is to get the location of the app directory which is where the database will be stored. The Flutter path_provider and path packages can be used to easily retrieve this information:

import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as path;

final dir = await getApplicationDocumentsDirectory();
// For hive, isar and objectbox
final dbPath = dir.path;
// For sembast and sqflite
final dbPath = path.join(dir.path, 'databaseName.db');

Hive

Hive is a key-value database written in pure Dart, with no native dependencies. This makes it truly cross-platform, as it is able to run on all platforms that support the Dart programming language.

Initializing the database is usually done immediately once the application launches. Once you have the path to where the database should be stored, initializing the Hive database is as easy as calling:

Hive.init(dbPath);

To perform CRUD operations using Hive, an instance of a Box is needed.

final box = await Hive.openBox('users');

To add/update a user to the database (Create/Update), you have to provide a unique key and a value to the put() method:

final user = UserModel(...);
await box.put(user.id, user.toMap());

To get a user from the database (Read), you simply request the user using the key provided, like so:

final userMap = box.get(user.id);
return UserModel.fromMap(userMap);

To delete a user from the database (Delete), you pass the key to the delete method.

final user = UserModel(...);
await box.delete(user.id);

Sembast

Sembast is a NoSQL database that makes use of a text document where each entry is a JSON object. Sembast makes it easy to build reactive apps, as you can listen and trigger certain actions when a document changes.

With the database path ready, you can initialize the database by calling:

final db = await databaseFactoryIo.openDatabase(dbPath);

To perform CRUD operations using Sembast, an instance of a StoreRef is needed:

final store = StoreRef('users');

To add/update a user to the database, you have to pass a key to the record function and chain the put method, which takes the database and value as parameters:

final user = UserModel(...);
await store.record(user.id).put(db, user.toMap());

To get a user from the database, you must pass the key to record and chain the get method:

final userMap = await store.record(user.id).get(db);
return UserModel.fromMap(userMap);

To delete a user from the database, you pass the key to record and chain the delete method:

final user = UserModel(...);
await store.record(user.id).delete(db);

Sqflite

Sqflite is a SQL database that provides the ability to write raw SQL commands, which are quite powerful when you know what to do. You also have the option to make use of helper functions.

With the database path ready, initialize the database and create a table to store users by doing the following:

static const String USER_TABLE = "users";
final db = await openDatabase(
      dbPath,
      onCreate: (db, version) async {
        await db.execute(
          'CREATE TABLE $USER_TABLE (id TEXT PRIMARY KEY, createdAt TEXT, 
          username TEXT, email TEXT, age INTEGER)',
        );
      },
      version: 1,
    );

To add/update a user to the database, you have to pass the table name and value to be inserted to the insert or update helper functions.

---

Over 200k developers use LogRocket to create better digital experiences

Learn more →

---

final user = UserModel(...);
await db.insert(USER_TABLE, user.toMap());
// to update the user defined above
await db.update(USER_TABLE, user.toMap(), where: "id = ?", whereArgs: [user.id]);

To get a user from the database, you can use a query string to search it. This will return a list of matches, along with a user ID that is unique; it should return a Map containing only one item:

final users = await db.query(USER_TABLE, where: "id = ?", whereArgs: [user.id]);
return UserModel.fromMap(users.first);

To delete a user from the database, you pass to the delete method, the table name, and a query string to identify the user to be deleted:

final user = UserModel(...);
await db.delete(USER_TABLE, where: "id = ?", whereArgs: [user.id]);

To continue with Isar and ObjectBox, we’ll need more dependencies for the project, as they both use type annotations and code generation, which enables you to read/write Dart objects directly to the database (Hive also provides this as an option).

Isar

Isar is a feature-rich offline database with powerful queries, filters, and sort functionalities.

You can also build very reactive apps with it, as it is able to listen to data changes. With Isar, this is what the dependencies and model classes would look like:

dependencies:
  ...
  isar: $latest
  isar_flutter_libs: $latest
dev_dependencies:
  ...
  build_runner: $latest
  isar_generator: $latest

import 'package:isar/isar.dart';
part 'isar_user.g.dart';

@Collection() // Anotate the user model using Collection()
class UserModel {
  int id;
  ...
  UserModel(...);
}

To get the autogenerated code, simply run flutter pub run build_runner build.

With the database path ready, initialize the database by calling:

final isar = await Isar.open(
        schemas: [UserModelSchema], // A list of anotated collections
        directory: dbPath,
      );

To add/update a user to the database, you have to pass the user model directly to the put method:

final user = UserModel(...);
isar.writeTxn((isar) async {
  await isar.isarUserModels.put(user);
}

To get a user from the database, you use the get method, which takes the id of the user:

final user = await isar.isarUserModels.get(user.id);

To delete a user from the database, you use the delete method, which takes the id of the user:

isar.writeTxn((isar) async {
  await isar.isarUserModels.delete(user.id);
}

ObjectBox

ObjectBox is a NoSQL database written with pure Dart. With ObjectBox, this is what the dependencies and model classes look like:

dependencies:
  ...
  objectbox: $latest
  objectbox_flutter_libs: $latest
dev_dependencies:
  ...
  build_runner: $latest
  objectbox_generator: $latest

@Entity() // Anotate the user model using Entity()
class UserModel {
  int id;
  ...
  UserModel(...);
}

To get the autogenerated code simply run flutter pub run build_runner build, exactly the same as with Isar. With the database path ready, you can initialize the database by calling:

final store = await openStore(directory: dbPath);
final box = store.box<UserModel>();

To add/update a user to the database, you have to pass the UserModel directly to the put method:

final user = UserModel(...);
box.put(user);;

To get a user from the database, you use the get method, which takes the id of the user:

final user = box.get(user.id);

To delete a user from the database, you use the remove method, which takes the id of the user;

box.remove(user.id);

Benchmark results

Firstly, we’ll be looking at how long it takes each database option to perform n number of writes, reads, and deletes.

Secondly, seeing as some of these database options (Hive, Isar, and ObjectBox) have more optimized ways to perform CRUD operations — like writing, reading, or deleting multiple items using a single method — we’ll also look at how long it takes to write, read, and delete n number of users from the database.

final users = [UserModel(...), UserModel(...), UserModel(...)];
// Hive
box.putAll(data), .deleteAll(userIds)
// Isar
isar.isarUserModels.putAll(users), .getAll(userIds), .deleteAll(userIds)
// Objectbox
box.putMany(users), .getMany(userIds), .removeMany(userIds)

Thirdly, because of the variation on different device operating systems, the benchmark will be done on both Android and iOS physical devices, while running in release mode for optimal performance.

iOS v15.6 (iPhone 12)

The following benchmark results were received while running the project in release mode on an iPhone 12 running iOS v15.6.

Below are the results (time in milliseconds) from 10 consecutive runs when 1,000 individual write, read, and delete operations were performed.

Write

Read

Delete

Below are the results (time in milliseconds) from 10 consecutive runs when optimized methods are used (for Hive, Isar, and ObjectBox) to write, read, and delete 1,000 users.

Write

Read

Delete

Android 11 (Galaxy A31)

The following benchmark results were received while running the project in release mode on a physical Samsung Galaxy A31 running Android 11.

Below are the results (time in milliseconds) from 10 consecutive runs when 1,000 individual write, read, and delete operations are performed.

Write

Read

Delete

Below are the results (time in milliseconds) from 10 consecutive runs when optimized methods are used (for Hive, Isar, and ObjectBox) to write, read, and delete 1,000 users.

Write

Read

Delete

Final results

For write operations on iOS, Isar was the fastest. Performing 1,000 individual write operations in an average of 69.7ms and writing 1,000 users in an average of 5.3ms.

On Android, meanwhile, Hive was the fastest with an average of 329.7ms when performing 1,000 individual write operations — though, when optimized, ObjectBox was able to write 1,000 users to the database in 5.5ms, performing better than both Hive (15.3ms) and Isar (8.3ms).

For read operations, Hive was the fastest on both iOS and Android. Performing both 1,000 individual read operations and reading 1,000 users in an average of 0ms (less than 1ms). ObjectBox also read 1,000 users in an average of 0ms on iOS and 1ms on Android, but performed 1,000 individual read operations in an average of 23.3ms on iOS and 19.2ms on Android.

For delete operations, Isar was the fastest on both iOS and Android. Performing 1,000 individual delete operations in an average of 34.7ms on iOS and 346.9 on Android. Hive performed slightly better when deleting 1,000 users (average of 1.3ms) as compared to Isar (average of 1.7ms) on iOS while on Android. ObjectBox was the fastest when deleting 1,000 users from the database, with an average of 2.5ms.

Conclusion

Setup was quite straightforward for all options discussed, so ease of use probably comes down to syntax preference, which in my personal opinion would be Hive. Isar and ObjectBox might require extra setup, but do allow you to read and write Dart objects directly to the database (Hive also provides an option for this, with the same extra setup of annotations and code generation).

Thank you for making it to the bottom of my experiment — I hope this article has helped you come to a decision about which Flutter app database works best for your project. If you would like to run the benchmarks yourself, here’s the link to the project on GitHub for your convenience.

Cut through the noise of traditional error reporting with LogRocket

LogRocket is a digital experience analytics solution that shields you from the hundreds of false-positive errors alerts to just a few truly important items. LogRocket tells you the most impactful bugs and UX issues actually impacting users in your applications.

Then, use session replay with deep technical telemetry to see exactly what the user saw and what caused the problem, as if you were looking over their shoulder.

LogRocket automatically aggregates client side errors, JS exceptions, frontend performance metrics, and user interactions. Then LogRocket uses machine learning to tell you which problems are affecting the most users and provides the context you need to fix it.

Focus on the bugs that matter — try LogRocket today.