bbolt VS sqlite

Based on this [GitHub document](https://github.com/etcd-io/bbolt) for BBoltDB, we can understand that Go Code be used to create a BBoltDB database on the system. The key-values added & operations done on them in that Go Code are stored in the BBoltDB database.

A Locker is a store on your file system (built on top of the amazing bbolt).

- bbolt for storage on disk. In order to get the smallest db file size possible make sure you insert the keys in order and set:

I'm wanting to store some wasm modules (as []byte) in BoltDB. Right now the modules are <1MB, but eventually, they could be 10-50MB in size. Is this going to reduce the performance of BoltDB all around, if the size of a value is this large? If it makes a difference, I'm using the Storm toolkit for querying.

bbolt - An embedded key/value database for Go.

For learning goroutines and channels, I usually recommend writing a program that reads from files and writes the data in a dummy database with something like https://github.com/etcd-io/bbolt. It's relatively simple and you're more likely to run into common manifestations of concurrency issues running disk operations.

If you would like to explore usage of channels, I highly recommend writing a program that reads from files and writes the data in a dummy database with something like https://github.com/etcd-io/bbolt.

No transactions, no consistency guarantees, no benchmarks, global locks in the storage implementation, a collection is copied in its entirety on every insertion to it...I realize it's not for the same use case as MySQL or MongoDB, but a more obvious comparison here is e.g. https://github.com/etcd-io/bbolt. So why should someone use this over bbolt?

use go-sqlite3 to work with sqlite3 is one choice.

https://github.com/etcd-io/bbolt is another pure go option.

cznic seems like an alternative to bbolt. nice to have some options.

> You can get substantially better performance out of sqlite by using the lower level https://github.com/crawshaw/sqlite, turning on WAL etc, using a connection per goroutine for reads, and sending batches of writes over a buffered channel / queue to a dedicated writer thread. That way you can turn off SQLite’s built in per-connection mutex but still be thread safe since each connection is only used on a single thread at a time.

Would this protect against a row update in the middle of a read? e.g. would a row at least be internally consistent at the time it was read?

The default go sqlite driver is https://github.com/mattn/go-sqlite3, which is quite lovely, but I ran into issues with concurrency on read only databases.

I'm now using https://github.com/crawshaw/sqlite and it seems to address those issues (but I haven't gotten around to setting up a proper test to confirm). It may be worth perusing if you do run into performance problems. It does come with the caveat of not being a database/sql driver though.

crawshaw/sqlite - Low-level Go interface to SQLite

crawshaw/sqlite actually uses CGo -- it's a wrapper around the C version of SQLite. For example, see https://github.com/crawshaw/sqlite/blob/23d646f8ac00d9dd2390...

zombiezen/go-sqlite uses cznic's pure Go converted version of SQLite, so avoids CGo. It's explicitly stated to be "a fork of crawshaw.io/sqlite that uses modernc.org/sqlite, a CGo-free SQLite package. It aims to be a mostly drop-in replacement for crawshaw.io/sqlite."

The second well known driver is https://github.com/crawshaw/sqlite