[](https://github.com/albrow/zoom/releases)

Requires Redis version >= 2.8.9 and Go version >= 1.5 with

`GO15VENDOREXPERIMENT=1`. The latest version of both is recommended.

- [When is Zoom a Good Fit?](#when-is-zoom-a-good-fit)

- [Testing & Benchmarking](#testing--benchmarking)

Zoom has been around for more than a year. It is well-tested and going forward the API

behave. See [issue #25](https://github.com/albrow/zoom/issues/25) for discussion. Almost

any type of field is supported, including custom types, slices, maps, complex types, and embedded

structs. The only things that are not supported are recursive data structures and functions.

for example, if you wanted the fields to be stored as lowercase fields in redis, you could use the

// Iff Index is true, any model in the collection that is saved will be added

// to a set in redis which acts as an index. The default value is false. The

// Name is a unique string identifier to use for the collection in redis. All

You can also execute custom Redis commands or run lua scripts with the

[`Script`](http://godoc.org/github.com/albrow/zoom/#Transaction.Script) methods. Both methods expect a

[`ReplyHandler`](http://godoc.org/github.com/albrow/zoom/#ReplyHandler) as an argument. A `ReplyHandler` is

simply a function that will do something with the reply from Redis corresponding to the script or command

that was run. `ReplyHandler`'s are executed in order when you call `Exec`.

datastore, it is recommended that you turn on both AOF and RDB persistence options and set fsync to

everysec. This will give you good performance while making data loss highly unlikely.

If you want greater protections against data loss, you can set fsync to always. This will hinder performance

Redis transactions and lua scripts when necessary. What this means is that Zoom will not

easy to fix the problem with the redis-check-aof tool, which will remove the partial transaction

Currently, Zoom does not support concurrent "read before write" updates on

models. The `UpdateFields` method introduced in version 0.12 offers some

still not safe by default. For example, consider the following code:

This can cause a bug if the function is called across multiple threads or

`Save`. Future versions of Zoom may provide

[optimistic locking](https://github.com/albrow/zoom/issues/13) or other means to

avoid these kinds of errors. In the meantime, you could fix this code by using

an `HINCRBY` command directly like so:

``` go

func likePost(postId string) error {

// modelKey is the key of the main hash for the model, which

// stores the struct fields as hash fields in Redis.

modelKey, err := Posts.ModelKey(postId)

if err != nil {

return err

}

conn := zoom.NewConn()

defer conn.Close()

if _, err := conn.Do("HINCRBY", modelKey, 1); err != nil {

return err

}

You could also use a lua script, which have full transactional support in Zoom,

for more complicated "read before write" updates.

which uses the latest version of Zoom. It is a simple example that doesn't use all of

Zoom's features, but should be good enough for understanding how zoom can work in a

real application.

func (c *Collection) ModelKey(id string) (string, error) {

return c.spec.modelKey(id)

t.Command("HMGET", args, newScanModelHandler(mr.spec.fieldNames(), mr))

t.Command("HMGET", args, newScanModelHandler(fieldNames, mr))

t.Command("SCARD", redis.Args{c.IndexKey()}, newScanIntHandler(count))

handler = newScanBoolHandler(deleted)

handler = newScanIntHandler(count)

t.deleteModelsBySetIds(c.IndexKey(), c.Name(), handler)

key, _ := testModels.ModelKey(model.ModelId())

key, _ := testModels.ModelKey(model.ModelId())