data

README

Data 📚

Swappable Database Adapters for Go

This library provides a common interface for making simple database calls. The goal of this package is to provide simple CRUD operations only, so each database will support many advanced features that are not available through this library. Other modules (such as data-mongo and data-mock) implement specific database adapters.

The "Object" interface

The data library works with any object that implements the Object interface. To implement this quickly in existing data models, you can just attach the journal.Journal object to your domain objects, and most of your work is already done.

// Object wraps all of the methods that a Domain Object must provide to Presto
type Object interface {

    // ID returns the primary key of the object
    ID() string

    // IsNew returns TRUE if the object has not yet been saved to the database
    IsNew() bool

    // SetCreated stamps the CreateDate and UpdateDate of the object, and adds a note to the Journal.
    SetCreated(comment string)

    // SetUpdated stamps the UpdateDate of the object, and adds a note to the Journal.
    SetUpdated(comment string)

    // SetDeleted marks the object virtually "deleted", and adds a note to the Journal.
    SetDeleted(comment string)
}

Datasource Interface

// Configure your database
ds := mongodb.New(uri, dbname)

// Create a new session, one per server request.
session := ds.Session()
defer session.Close()

// LOAD from a person object from the database
err := session.Load("Person", criteria, &person)

// INSERT/UPDATE a person object in the database
err := session.Save("Person", person)

// DELETE a person from the database
err := session.Delete("Person", person)


// LIST many records from the database, by using an iterator that will loop through all records that match the provided criteria.
it, err := session.List("Person", criteria, options...)

for it.Next(&person) {
    // do stuff with person.
}

Retrieving Record Sets

This library also includes an "iterator" interface, for retrieving large sets of data from the datasource efficiently.

// Create an object for the iterator to populate
person := Person{}

// Create the iterator.  Requires a collection name, criteria expression (below), and options (also below, such as sorting and pagination)
it := session.List(CollectionName, CriteriaExpression, Options)

for it.Next(&person) {

    // person.Name...
    // person.Email...
}

Expression Builder

Every database has its own query language, so this library uses the exp module to represent query expressions in an efficient intermediate format that should be easy to convert into whatever specific language you need to use.

// build single predicate expressions
c := exp.Equal("name", "John Connor")

// or chain logical expressions together
c := exp.Equal("name", "John Connor").OrEqual("name", "Sarah Connor")

Query Options

There's a package for managing optional query arguments, such as sorting and pagination. These options just encapsulate data. It is the responsibilty of each database adapter to implement each of these in its own query engine.

// get a new iterator.  Sort results by first name.  Return only the first 100 rows.
it := session.List(collection, criteria, options.SortAsc("name"), options.MaxRows(100))

SortAsc(fieldname) tells the database to sort by a particular field, in ascending order

SortDesc(fieldname) tells the database to sort by a particular field, in descending order

FirstRow(count) tells the database to start returning records at the provided row number

MaxRows(count) tells the database to limit the number of records to the designated number of rows.

Pull Requests Welcome

This library is a work in progress, and will benefit from your experience reports, use cases, and contributions. If you have an idea for making this library better, send in a pull request. We're all in this together! 📚

Documentation

Overview

Package data provides a data structure for defining simple database filters. This is not able to represent every imaginable query criteria, but it does a good job of making common criteria simple to format and pass around in your application.

Index

• type Collection
• type Iterator
• type Object
• type Server
• type Session

Types

type Collection

type Collection interface {
	List(filter exp.Expression, options ...option.Option) (Iterator, error)
	Load(filter exp.Expression, target Object) error
	Save(object Object, note string) error
	Delete(object Object, note string) error
	HardDelete(object Object) error
}

Collection represents a single database collection (or table) that is opened to support a single transactional request, and then closed when this transaction is complete

type Iterator

type Iterator interface {
	Next(Object) bool
	Count() int
	Close() error
}

Iterator interface allows callers to iterator over a large number of items in an array/slice

type Object

type Object interface {

	// ID returns the primary key of the object
	ID() string

	// IsNew returns TRUE if the object has not yet been saved to the database
	IsNew() bool

	// SetCreated stamps the CreateDate and UpdateDate of the object, and makes a note
	SetCreated(comment string)

	// SetUpdated stamps the UpdateDate of the object, and makes a note
	SetUpdated(comment string)

	// SetDeleted marks the object virtually "deleted", and makes a note
	SetDeleted(comment string)

	// Get implements the path.Getter interface.
	// It returns a value stored in the object.
	// Dotted values reference sub-objects.
	GetPath(string) (interface{}, bool)

	// SetPath implements the path.Setter interface.
	// It applies a value to the object's properties.
	// Dotted values reference sub-objects.
	SetPath(string, interface{}) error
}

Object interface defines all of the methods that a Domain Object must provide to Presto

type Server

type Server interface {
	Session(context.Context) (Session, error)
}

Server is an abstract representation of a database and its connection information.

type Session

type Session interface {
	Collection(collection string) Collection
	Close()
}

Session represents a single database session, that is opened to support a single transactional request, and then closed when this transaction is complete