memdb

README

SimpleMemDB

Simple in-memory database written in Go

Stores any structure in memory. Provide some methods to access data and save/load on a disc.

Example:

    const indexSlug = "slug"
    
    type myItem struct {
        Name  string
        Slug  string
        Value int
    }
    
    func (md myItem) GetIndex(name string) interface{} {
        switch name {
        case indexSlug:
            return md.Slug
        default:
            return nil
        }
    }
    
    db := NewMemDB("/path/to/db/dbname.gob")
    // Set index
    db.AddIndex(indexSlug)
  
    id1, err := db.Create(myItem{
        Name:  "Sirius",
        Slug:  "sir",
        Value: 3,
    })
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("New ID: %d\n", id1)
  
    id2, err := db.Create(myItem{
        Name:  "Orion",
        Slug:  "or",
        Value: 5,
    })
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("New ID: %d\n", id2)
  
    // Get
    val, err := db.Get(id2)
    if err != nil {
        fmt.Println(err)
    }
    secondItem := val.(myItem)
    fmt.Printf("Second item: %s\n", secondItem.Name)
  
    // Update
    secondItem.Value = 10
    err = db.Update(id2, secondItem)
    if err != nil {
        fmt.Println(err)
    }
  
    // Get by index
    vals, _ := db.GetAllByIndex(indexSlug, "sir")
    if len(vals) == 1 {
        item := vals[0].(myItem)
        fmt.Printf("Item with slug 'sir': %s\n", item.Name)
    }
  
    // Iterate
    err = db.Iterate(func(id int64, item Item) (stop bool, err error) {
        myItem := item.(myItem)
        fmt.Printf("%d - Name: %s, Value: %d\n", id, myItem.Name, myItem.Value)
        return false, nil
    })
    if err != nil {
        fmt.Println(err)
    }
  
    // Get all with limit and skip
    allItems, err := db.GetAll(1, 1)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(allItems)
  
    // Delete
    err = db.Delete(id1)
    if err != nil {
        fmt.Println(err)
    }
    // Clean deleted items
    db.CleanUp()
  
    // Save / Load
    err = db.SaveDB(myItem{})
    if err != nil {
        fmt.Println(err)
    }
  
    err = db.LoadDB(myItem{})
    if err != nil {
        fmt.Println(err)
    }
    
   

Documentation

Index

• Variables
• type Item
• type MemDB
  • func NewMemDB(filename string) *MemDB
  • func (mdb *MemDB) AddIndex(name string)
  • func (mdb *MemDB) CleanUp()
  • func (mdb *MemDB) Create(item Item) int64
  • func (mdb *MemDB) Delete(id int64) error
  • func (mdb MemDB) Get(id int64) (Item, error)
  • func (mdb MemDB) GetAll(limit, skip int64) ([]Item, error)
  • func (mdb MemDB) GetAllByIndex(indexName string, value interface{}) ([]Item, error)
  • func (mdb MemDB) Iterate(fn func(id int64, item Item) (stop bool, err error)) error
  • func (mdb *MemDB) LoadDB(dataType interface{}) error
  • func (mdb *MemDB) ReindexAll()
  • func (mdb *MemDB) SaveDB(dataType interface{}) error
  • func (mdb *MemDB) Update(id int64, item Item) error

Variables

var (
	ErrNoIDProvided   = errors.New("No ID provided")
	ErrIDNotExists    = errors.New("ID not exists")
	ErrIndexNotFound  = errors.New("Secondary index not found")
	ErrFilenameNotSet = errors.New("DB filename not set")
)

Types

type Item

type Item interface {
	GetIndex(name string) interface{}
}

type MemDB

type MemDB struct {
	// contains filtered or unexported fields
}

func NewMemDB

func NewMemDB(filename string) *MemDB

func (*MemDB) AddIndex

func (mdb *MemDB) AddIndex(name string)

AddIndex adds secondary index by name You should provide GetIndex(name) method on your Item interface implementation

func (*MemDB) CleanUp

func (mdb *MemDB) CleanUp()

Clean deleted items Iterate all DB and create a new

func (*MemDB) Create

func (mdb *MemDB) Create(item Item) int64

func (*MemDB) Delete

func (mdb *MemDB) Delete(id int64) error

func (MemDB) Get

func (mdb MemDB) Get(id int64) (Item, error)

func (MemDB) GetAll

func (mdb MemDB) GetAll(limit, skip int64) ([]Item, error)

func (MemDB) GetAllByIndex

func (mdb MemDB) GetAllByIndex(indexName string, value interface{}) ([]Item, error)

func (MemDB) Iterate

func (mdb MemDB) Iterate(fn func(id int64, item Item) (stop bool, err error)) error

func (*MemDB) LoadDB

func (mdb *MemDB) LoadDB(dataType interface{}) error

You have to pass your implementation of Item E.g. SaveDB(myItem{})

func (*MemDB) ReindexAll

func (mdb *MemDB) ReindexAll()

func (*MemDB) SaveDB

func (mdb *MemDB) SaveDB(dataType interface{}) error

You have to pass your implementation of Item E.g. SaveDB(myItem{})

func (*MemDB) Update

func (mdb *MemDB) Update(id int64, item Item) error