Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/amit-davidson/LibraDB
LibraDB is a simple, persistent key/value store written in pure Go in less than 1000 lines for learning purposes.
https://github.com/amit-davidson/LibraDB
data-structures database go golang
Last synced: about 2 months ago
JSON representation
LibraDB is a simple, persistent key/value store written in pure Go in less than 1000 lines for learning purposes.
- Host: GitHub
- URL: https://github.com/amit-davidson/LibraDB
- Owner: amit-davidson
- License: gpl-3.0
- Created: 2021-08-28T17:02:46.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2024-04-11T18:39:36.000Z (9 months ago)
- Last Synced: 2024-04-22T13:31:55.500Z (8 months ago)
- Topics: data-structures, database, go, golang
- Language: Go
- Homepage:
- Size: 90.8 KB
- Stars: 147
- Watchers: 5
- Forks: 17
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go - libradb - LibraDB is a simple database with less than 1000 lines of code for learning. (Database / Databases Implemented in Go)
README
# LibraDB
[](http://golang.org)
[](http://golang.org)
[](https://lbesson.mit-license.org/)
[](http://makeapullrequest.com)
[](https://app.circleci.com/pipelines/github/amit-davidson/LibraDB)
LibraDB is a simple, persistent key/value store written in pure Go. The project aims to provide a working yet simple
example of a working database. If you're interested in databases, I encourage you to start here.
This database accompanies my [blog post](https://betterprogramming.pub/build-a-nosql-database-from-the-scratch-in-1000-lines-of-code-8ed1c15ed924) on how to write a database from scratch.
## Installing
To start using LibraDB, install Go and run `go get`:
```sh
go get -u github.com/amit-davidson/LibraDB
```
## Basic usage
```go
package main
import "github.com/amit-davidson/LibraDB"
func main() {
path := "libra.db"
db, _ := LibraDB.Open(path, LibraDB.DefaultOptions)
tx := db.WriteTx()
name := []byte("test")
collection, _ := tx.CreateCollection(name)
key, value := []byte("key1"), []byte("value1")
_ = collection.Put(key, value)
_ = tx.Commit()
}
```
## Transactions
Read-only and read-write transactions are supported. LibraDB allows multiple read transactions or one read-write
transaction at the same time. Transactions are goroutine-safe.
LibraDB has an isolation level: [Serializable](https://en.wikipedia.org/wiki/Isolation_(database_systems)#Serializable).
In simpler words, transactions are executed one after another and not at the same time.This is the highest isolation level.
### Read-write transactions
```go
tx := db.WriteTx()
...
if err := tx.Commit(); err != nil {
return err
}
```
### Read-only transactions
```go
tx := db.ReadTx()
...
if err := tx.Commit(); err != nil {
return err
}
```
## Collections
Collections are a grouping of key-value pairs. Collections are used to organize and quickly access data as each
collection is B-Tree by itself. All keys in a collection must be unique.
```go
tx := db.WriteTx()
collection, err := tx.CreateCollection([]byte("test"))
if err != nil {
return err
}
_ = tx.Commit()
```
### Auto generating ID
The `Collection.ID()` function returns an integer to be used as a unique identifier for key/value pairs.
```go
tx := db.WriteTx()
collection, err := tx.GetCollection([]byte("test"))
if err != nil {
return err
}
id := collection.ID()
_ = tx.Commit()
```
## Key-Value Pairs
Key/value pairs reside inside collections. CRUD operations are possible using the methods `Collection.Put`
`Collection.Find` `Collection.Remove` as shown below.
```go
tx := db.WriteTx()
collection, err := tx.GetCollection([]byte("test"))
if err != nil {
return err
}
key, value := []byte("key1"), []byte("value1")
if err := collection.Put(key, value); err != nil {
return err
}
if item, err := collection.Find(key); err != nil {
return err
}
if err := collection.Remove(key); err != nil {
return err
}
_ = tx.Commit()
```