ots/vendor/github.com/xuyu/goredis/transactions.go
Knut Ahlers 5e3d84df9b
Vendor dependencies
Signed-off-by: Knut Ahlers <knut@ahlers.me>
2017-08-03 20:07:30 +02:00

105 lines
2.7 KiB
Go

package goredis
import (
"errors"
)
// Transaction doc: http://redis.io/topics/transactions
// MULTI, EXEC, DISCARD and WATCH are the foundation of transactions in Redis.
// A Redis script is transactional by definition,
// so everything you can do with a Redis transaction, you can also do with a script,
// and usually the script will be both simpler and faster.
type Transaction struct {
redis *Redis
conn *connection
}
// Transaction new a *transaction from *redis
func (r *Redis) Transaction() (*Transaction, error) {
c, err := r.pool.Get()
if err != nil {
return nil, err
}
if err := c.SendCommand("MULTI"); err != nil {
r.pool.Put(c)
return nil, err
}
if _, err := c.RecvReply(); err != nil {
r.pool.Put(c)
return nil, err
}
return &Transaction{r, c}, nil
}
// Close closes the transaction, put the under connection back for reuse
func (t *Transaction) Close() {
t.redis.pool.Put(t.conn)
}
// Discard flushes all previously queued commands in a transaction
// and restores the connection state to normal.
// If WATCH was used, DISCARD unwatches all keys.
func (t *Transaction) Discard() error {
if err := t.conn.SendCommand("DISCARD"); err != nil {
return err
}
_, err := t.conn.RecvReply()
return err
}
// Watch marks the given keys to be watched for conditional execution of a transaction.
func (t *Transaction) Watch(keys ...string) error {
args := packArgs("WATCH", keys)
if err := t.conn.SendCommand(args...); err != nil {
return err
}
_, err := t.conn.RecvReply()
return err
}
// UnWatch flushes all the previously watched keys for a transaction.
// If you call EXEC or DISCARD, there's no need to manually call UNWATCH.
func (t *Transaction) UnWatch() error {
if err := t.conn.SendCommand("UNWATCH"); err != nil {
return err
}
_, err := t.conn.RecvReply()
return err
}
// Exec executes all previously queued commands in a transaction
// and restores the connection state to normal.
// When using WATCH, EXEC will execute commands only if the watched keys were not modified,
// allowing for a check-and-set mechanism.
func (t *Transaction) Exec() ([]*Reply, error) {
if err := t.conn.SendCommand("EXEC"); err != nil {
return nil, err
}
rp, err := t.conn.RecvReply()
if err != nil {
return nil, err
}
return rp.MultiValue()
}
// Command send raw redis command to redis server
// and redis will return QUEUED back
func (t *Transaction) Command(args ...interface{}) error {
args2 := packArgs(args...)
if err := t.conn.SendCommand(args2...); err != nil {
return err
}
rp, err := t.conn.RecvReply()
if err != nil {
return err
}
s, err := rp.StatusValue()
if err != nil {
return err
}
if s != "QUEUED" {
return errors.New(s)
}
return nil
}