bolteo

README

Bolteo

Bolteo is a simple BoltDB wrapper. The main goal of the project is provide simple API for access to BoldDB collections.

Getting Started

go get -u github.com/nyan2d/bolteo

Import Bolteo

import "github.com/nyan2d/bolteo"

Usage

Open a database

db, err := bolteo.Open("mydatabase.db")
defer db.Close();

Simple data model structure

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  uint   `json:"age"
}

Set bucket name

db.bucket("users")

Save an object

u := User{
    ID:   0,
    Name: "Billy",
    Age:  20,
}
db.Put(u.ID, u)

Bulk save

objects := map[interface{}]interface{}{
    first.ID: first,
    second.ID: second,
}
db.PutBulk(objects)

Get an object by item ID

user := User{}
db.Get(0, &user)

Get all records from the bucket

users, ok := db.GetAll(User{})

Delete record

db.Delete(0)

Delete bucket

db.DropBucket("Users")

Autoincrementing ID for the bucket

id := db.NextID()

Requests for retrieve data from the database

You need to set the bucket data type to get the data

db.As(User{})

Now you need to choose one of the methods of data retrieval Request All:

db.As(User{}).All()

Request Where:

db.As(User{}).Where("ID", bolteo.Fl.Equals, 1)

Then you can use functions to reduce the data sampling

db.As(User{}).
    Where("ID", bolteo.Fl.Equals, 1).
    Where("Age", bolteo.Fl.GreaterThan, 18).
    Skip(10).
    Take(10).
    OrderBy("Age").
    Reverse()

And at the end you must use one of the following functions to get results:

Collect() // Get all the results as a slice
First() // Take only the first item
Last() // Take only the last item
Count() // Get the number of elements
Any() // Returns true if the result contains any entries

Where Query

Basic syntax:

Where("FieldName", FilterFromBolteo.Fl, valueToCompare)

Available filters:

bolteo.Fl.Equals
bolteo.Fl.NotEquals
bolteo.Fl.GreatherThan
bolteo.Fl.LessThan
bolteo.Fl.StringEquals
bolteo.Fl.StringHasPrefix
bolteo.Fl.StringHasSuffix
bolteo.Fl.TimeBefore
bolteo.Fl.TimeAfter

Documentation

Index

• Variables
• func NewUUID() string
• type Bolteo
  • func MustOpen(path string) *Bolteo
  • func Open(path string) (*Bolteo, error)
  • func (b *Bolteo) Bucket(name string) *Bucket
  • func (b *Bolteo) Close() error
  • func (b *Bolteo) DropBucket(name string) error
• type Bucket
  • func (b *Bucket) As(elementsType interface{}) *Query
  • func (b *Bucket) Delete(key interface{}) error
  • func (b *Bucket) Drop() error
  • func (b *Bucket) Get(key interface{}, value interface{}) error
  • func (b *Bucket) GetAll(objType interface{}) (result interface{}, ok bool)
  • func (b *Bucket) InitBucket() error
  • func (b *Bucket) NextID() int
  • func (b *Bucket) Put(key, val interface{}) error
  • func (b *Bucket) PutBulk(data map[interface{}]interface{}) error
• type Iterator
• type Query
  • func (q *Query) Any() bool
  • func (q *Query) Collect() interface{}
  • func (q *Query) Count() int
  • func (q *Query) First() interface{}
  • func (q *Query) Last() interface{}
  • func (q *Query) OrderBy(field string) *Query
  • func (q *Query) Reverse() *Query
  • func (q *Query) Skip(count int) *Query
  • func (q *Query) Take(count int) *Query
  • func (q *Query) Where(field string, fn filter, what interface{}) *Query

Variables

var Fl = filters{
	GetAll: func(first, second interface{}) bool {
		return true
	},
	Equals: func(first, second interface{}) bool {
		return first == second
	},
	StringEquals: func(first, second interface{}) bool {
		if !isString(first) || !isString(second) {
			return false
		}
		a, b := first.(string), second.(string)
		return strings.EqualFold(a, b)
	},
	NotEquals: func(first, second interface{}) bool {
		return first != second
	},
	GreaterThan: func(first, second interface{}) bool {
		if !isNumber(first) || !isNumber(second) {
			return false
		}
		if !isTypeEquals(first, second) {
			return false
		}
		return compareNumbers(first, second)
	},
	LessThan: func(first, second interface{}) bool {
		if !isNumber(first) || !isNumber(second) {
			return false
		}
		if !isTypeEquals(first, second) {
			return false
		}
		return compareNumbers(second, first)
	},
	StringHasPrefix: func(first, second interface{}) bool {
		if !isString(first) || isString(second) {
			return false
		}
		return strings.HasPrefix(first.(string), second.(string))
	},
	StringHasSuffix: func(first, second interface{}) bool {
		if !isString(first) || isString(second) {
			return false
		}
		return strings.HasSuffix(first.(string), second.(string))
	},
	TimeBefore: func(first, second interface{}) bool {
		a, ok := first.(time.Time)
		b, ak := second.(time.Time)
		if !ok || !ak {
			return false
		}
		return a.Before(b)
	},
	TimeAfter: func(first, second interface{}) bool {
		a, ok := first.(time.Time)
		b, ak := second.(time.Time)
		if !ok || !ak {
			return false
		}
		return a.After(b)
	},
}

Functions

func NewUUID

func NewUUID() string

Types

type Bolteo

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

func MustOpen

func MustOpen(path string) *Bolteo

func Open

func Open(path string) (*Bolteo, error)

func (*Bolteo) Bucket

func (b *Bolteo) Bucket(name string) *Bucket

func (*Bolteo) Close

func (b *Bolteo) Close() error

func (*Bolteo) DropBucket

func (b *Bolteo) DropBucket(name string) error

type Bucket

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

func (*Bucket) As

func (b *Bucket) As(elementsType interface{}) *Query

func (*Bucket) Delete

func (b *Bucket) Delete(key interface{}) error

func (*Bucket) Drop

func (b *Bucket) Drop() error

func (*Bucket) Get

func (b *Bucket) Get(key interface{}, value interface{}) error

func (*Bucket) GetAll

func (b *Bucket) GetAll(objType interface{}) (result interface{}, ok bool)

func (*Bucket) InitBucket

func (b *Bucket) InitBucket() error

func (*Bucket) NextID

func (b *Bucket) NextID() int

func (*Bucket) Put

func (b *Bucket) Put(key, val interface{}) error

func (*Bucket) PutBulk

func (b *Bucket) PutBulk(data map[interface{}]interface{}) error

type Iterator

type Iterator interface {
	MoveNext() bool
	Current() interface{}
	Close() // TODO: ???
}

type Query

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

func (*Query) Any

func (q *Query) Any() bool

func (*Query) Collect

func (q *Query) Collect() interface{}

func (*Query) Count

func (q *Query) Count() int

func (*Query) First

func (q *Query) First() interface{}

func (*Query) Last

func (q *Query) Last() interface{}

func (*Query) OrderBy

func (q *Query) OrderBy(field string) *Query

func (*Query) Reverse

func (q *Query) Reverse() *Query

func (*Query) Skip

func (q *Query) Skip(count int) *Query

func (*Query) Take

func (q *Query) Take(count int) *Query

func (*Query) Where

func (q *Query) Where(field string, fn filter, what interface{}) *Query