easydb

README

Easydb

A library on go to access easily some databases. The main rule of this library is to follow a unique interface for all databases that we implemented. So, you will only need to know one library (easydb) for accessing many databases.

Supported databases

• MongoDB
• ArangoDB

Getting started

Download

go get github.com/ednailson/easydb-go

Database Interface

The main principle of the library is the database interface.

Every implemented database follows this interface after created.

There is a New(...params) function for every database, and all of them there is their own config struct param. This function will return a database interface, so after that it will be the same usage for every database.

Check how to use it below.

Usage

Creating a database

We will create a mongoDB instance right now but you can created an instance of any easydb implemented database.

config := mongo.Config {
            Host:     "mongodb.service.com.br",
            Port:     27017,
            Database: "easydb_test",
            Username: "root",
            Password: "dummyPass",
}
db, err := mongo.NewDatabase(config)

Creating a table/collection

table, err := db.Table("easydb-table-example")

Now you can write or read from this table

Writing on a table/collection

writer := table.Writer()
writer.Save(`{"data": "your data"}`)

Reading on a table/collection

reader := table.Reader()
reader.Read("document-id")

Developer

Junior

Documentation

Index

• Constants
• type Database
• type Errors
• type Filter
• type Filters
  • func NewFilters() *Filters
  • func (f *Filters) AddFilter(key string, value interface{}, operator string) *Filters
  • func (f *Filters) Done() []Filter
• type Reader
• type Table
• type Writer

Constants

const ApplicationName = "easydb-go"

const Version = "0.2.0"

Types

type Database

type Database interface {
	Table(table string) (Table, error)
	Query(query string) (interface{}, error)
	Errors() Errors
}

type Errors

type Errors interface {
	IsConflict(err error) bool
	IsNotFound(err error) bool
}

type Filter

type Filter struct {
	Key      string
	Value    interface{}
	Operator string
}

type Filters

type Filters struct {
	Filters []Filter
}

func NewFilters

func NewFilters() *Filters

func (*Filters) AddFilter

func (f *Filters) AddFilter(key string, value interface{}, operator string) *Filters

func (*Filters) Done

func (f *Filters) Done() []Filter

type Reader

type Reader interface {
	Read(id string) (interface{}, error)
	ReadAll() ([]interface{}, error)
	Filter(filters []Filter) ([]interface{}, error)
	Errors() Errors
}

type Table

type Table interface {
	Writer() Writer
	Reader() Reader
}

type Writer

type Writer interface {
	Save(data interface{}) (interface{}, error)
	Update(id string, data interface{}) (interface{}, error)
	Delete(id string) error
	Errors() Errors
}