redis

package

Go to main page

Versions in this module

v0

v0.5.6

May 15, 2015

Changes in this version

type Reply

+ func (r *Reply) Float64() (float64, error)

v0.5.5

May 9, 2015

v0.5.4

Feb 25, 2015

v0.5.3

Feb 1, 2015

v0.5.2

Jan 27, 2015

v0.5.1

Dec 18, 2014

Changes in this version

type CmdError

+ func (cerr *CmdError) Readonly() bool

v0.5.0

Dec 8, 2014

v0.4.8

Nov 4, 2014

v0.4.7

Oct 23, 2014

Changes in this version

+ type CmdError struct

+ Err error

+ func (cerr *CmdError) Error() string

v0.4.6

Sep 22, 2014

v0.4.5

Aug 22, 2014

v0.4.4

Aug 18, 2014

v0.4.3

Aug 14, 2014

v0.4.2

Aug 14, 2014

v0.4.1

Aug 14, 2014

Changes in this version

type Client

+ Conn net.Conn

v0.4.0

Aug 11, 2014

Changes in this version

+ var LoadingError error = errors.New("server is busy loading dataset in memory")

+ var PipelineQueueEmptyError error = errors.New("pipeline queue empty")

type Client

+ func Dial(network, addr string) (*Client, error)

+ func DialTimeout(network, addr string, timeout time.Duration) (*Client, error)

+ func (c *Client) Cmd(cmd string, args ...interface{}) *Reply

+ func (c *Client) GetReply() *Reply

+ func (c *Client) ReadReply() *Reply

type Reply

+ func (r *Reply) ListBytes() ([][]byte, error)

type ReplyType

+ const BulkReply

+ const ErrorReply

+ const IntegerReply

+ const MultiReply

+ const NilReply

+ const StatusReply

v0.3.4

Oct 5, 2012

v0.3.3

Oct 2, 2012

v0.3.2

Sep 29, 2012

Changes in this version

type Config

+ Network string

v0.3.1

Aug 7, 2012

v0.3.0

Aug 3, 2012

Changes in this version

type Client

+ func (c *Client) AsyncBitcount(args ...interface{}) Future

+ func (c *Client) AsyncBitop(args ...interface{}) Future

+ func (c *Client) AsyncReplconf(args ...interface{}) Future

+ func (c *Client) Bitcount(args ...interface{}) *Reply

+ func (c *Client) Bitop(args ...interface{}) *Reply

+ func (c *Client) InfoMap() (map[string]string, error)

+ func (c *Client) Replconf(args ...interface{}) *Reply

type Config

+ Address string

+ Database int

+ Password string

+ Path string

+ PoolCapacity int

+ RetryLoading bool

+ Timeout time.Duration

+ func DefaultConfig() Config

type ErrorFlag

+ const ErrorInvalid

type MultiCall

+ func (mc *MultiCall) Bitcount(args ...interface{})

+ func (mc *MultiCall) Bitop(args ...interface{})

+ func (mc *MultiCall) Replconf(args ...interface{})

type Reply

+ Err *Error

+ func (r *Reply) Hash() (map[string]string, error)

+ func (r *Reply) List() ([]string, error)

v0.2.1

May 25, 2012

Changes in this version

type Client

+ func (c *Client) AsyncCall(cmd string, args ...interface{}) Future

+ func (c *Client) AsyncMultiCall(mc func(*MultiCall)) Future

+ func (c *Client) Call(cmd string, args ...interface{}) *Reply

+ func (c *Client) MultiCall(f func(*MultiCall)) *Reply

+ type Cmd string

+ const CmdAppend

+ const CmdAsking

+ const CmdAuth

+ const CmdBgrewriteaof

+ const CmdBgsave

+ const CmdBlpop

+ const CmdBrpop

+ const CmdBrpoplpush

+ const CmdClient

+ const CmdCluster

+ const CmdConfig

+ const CmdDbsize

+ const CmdDebug

+ const CmdDecr

+ const CmdDecrby

+ const CmdDel

+ const CmdDiscard

+ const CmdDump

+ const CmdEcho

+ const CmdEval

+ const CmdExec

+ const CmdExists

+ const CmdExpire

+ const CmdExpireat

+ const CmdFlushall

+ const CmdFlushdb

+ const CmdGet

+ const CmdGetbit

+ const CmdGetrange

+ const CmdGetset

+ const CmdHdel

+ const CmdHexists

+ const CmdHget

+ const CmdHgetall

+ const CmdHincrby

+ const CmdHincrbyfloat

+ const CmdHkeys

+ const CmdHlen

+ const CmdHmget

+ const CmdHmset

+ const CmdHset

+ const CmdHsetnx

+ const CmdHvals

+ const CmdIncr

+ const CmdIncrby

+ const CmdIncrbyfloat

+ const CmdInfo

+ const CmdKeys

+ const CmdLastsave

+ const CmdLindex

+ const CmdLinsert

+ const CmdLlen

+ const CmdLpop

+ const CmdLpush

+ const CmdLpushx

+ const CmdLrange

+ const CmdLrem

+ const CmdLset

+ const CmdLtrim

+ const CmdMget

+ const CmdMigrate

+ const CmdMonitor

+ const CmdMove

+ const CmdMset

+ const CmdMsetnx

+ const CmdMulti

+ const CmdObject

+ const CmdPersist

+ const CmdPexpire

+ const CmdPexpireat

+ const CmdPing

+ const CmdPsetex

+ const CmdPsubscribe

+ const CmdPttl

+ const CmdPublish

+ const CmdPunsubscribe

+ const CmdRandomkey

+ const CmdRename

+ const CmdRenamenx

+ const CmdRestore

+ const CmdRpop

+ const CmdRpoplpush

+ const CmdRpush

+ const CmdRpushx

+ const CmdSadd

+ const CmdSave

+ const CmdScard

+ const CmdScript

+ const CmdSdiff

+ const CmdSdiffstore

+ const CmdSelect

+ const CmdSet

+ const CmdSetbit

+ const CmdSetex

+ const CmdSetnx

+ const CmdSetrange

+ const CmdShutdown

+ const CmdSinter

+ const CmdSinterstore

+ const CmdSismember

+ const CmdSlaveof

+ const CmdSmembers

+ const CmdSmove

+ const CmdSort

+ const CmdSpop

+ const CmdSrandmember

+ const CmdSrem

+ const CmdStrlen

+ const CmdSubscribe

+ const CmdSunion

+ const CmdSunionstore

+ const CmdSync

+ const CmdTime

+ const CmdTtl

+ const CmdType

+ const CmdUnsubscribe

+ const CmdUnwatch

+ const CmdWatch

+ const CmdZadd

+ const CmdZcard

+ const CmdZcount

+ const CmdZincrby

+ const CmdZinterstore

+ const CmdZrange

+ const CmdZrangebyscore

+ const CmdZrank

+ const CmdZrem

+ const CmdZremrangebyrank

+ const CmdZremrangebyscore

+ const CmdZrevrange

+ const CmdZrevrangebyscore

+ const CmdZrevrank

+ const CmdZscore

+ const CmdZunionstore

type Error

+ Cmd Cmd

+ type MultiCall struct

+ func (mc *MultiCall) Append(args ...interface{})

+ func (mc *MultiCall) Asking(args ...interface{})

+ func (mc *MultiCall) Auth(args ...interface{})

+ func (mc *MultiCall) Bgrewriteaof(args ...interface{})

+ func (mc *MultiCall) Bgsave(args ...interface{})

+ func (mc *MultiCall) Blpop(args ...interface{})

+ func (mc *MultiCall) Brpop(args ...interface{})

+ func (mc *MultiCall) Brpoplpush(args ...interface{})

+ func (mc *MultiCall) Call(cmd string, args ...interface{})

+ func (mc *MultiCall) Client(args ...interface{})

+ func (mc *MultiCall) Cluster(args ...interface{})

+ func (mc *MultiCall) Config(args ...interface{})

+ func (mc *MultiCall) Dbsize(args ...interface{})

+ func (mc *MultiCall) Debug(args ...interface{})

+ func (mc *MultiCall) Decr(args ...interface{})

+ func (mc *MultiCall) Decrby(args ...interface{})

+ func (mc *MultiCall) Del(args ...interface{})

+ func (mc *MultiCall) Discard(args ...interface{})

+ func (mc *MultiCall) Dump(args ...interface{})

+ func (mc *MultiCall) Echo(args ...interface{})

+ func (mc *MultiCall) Eval(args ...interface{})

+ func (mc *MultiCall) Exec(args ...interface{})

+ func (mc *MultiCall) Exists(args ...interface{})

+ func (mc *MultiCall) Expire(args ...interface{})

+ func (mc *MultiCall) Expireat(args ...interface{})

+ func (mc *MultiCall) Flush() (r *Reply)

+ func (mc *MultiCall) Flushall(args ...interface{})

+ func (mc *MultiCall) Flushdb(args ...interface{})

+ func (mc *MultiCall) Get(args ...interface{})

+ func (mc *MultiCall) Getbit(args ...interface{})

+ func (mc *MultiCall) Getrange(args ...interface{})

+ func (mc *MultiCall) Getset(args ...interface{})

+ func (mc *MultiCall) Hdel(args ...interface{})

+ func (mc *MultiCall) Hexists(args ...interface{})

+ func (mc *MultiCall) Hget(args ...interface{})

+ func (mc *MultiCall) Hgetall(args ...interface{})

+ func (mc *MultiCall) Hincrby(args ...interface{})

+ func (mc *MultiCall) Hincrbyfloat(args ...interface{})

+ func (mc *MultiCall) Hkeys(args ...interface{})

+ func (mc *MultiCall) Hlen(args ...interface{})

+ func (mc *MultiCall) Hmget(args ...interface{})

+ func (mc *MultiCall) Hmset(args ...interface{})

+ func (mc *MultiCall) Hset(args ...interface{})

+ func (mc *MultiCall) Hsetnx(args ...interface{})

+ func (mc *MultiCall) Hvals(args ...interface{})

+ func (mc *MultiCall) Incr(args ...interface{})

+ func (mc *MultiCall) Incrby(args ...interface{})

+ func (mc *MultiCall) Incrbyfloat(args ...interface{})

+ func (mc *MultiCall) Info(args ...interface{})

+ func (mc *MultiCall) Keys(args ...interface{})

+ func (mc *MultiCall) Lastsave(args ...interface{})

+ func (mc *MultiCall) Lindex(args ...interface{})

+ func (mc *MultiCall) Linsert(args ...interface{})

+ func (mc *MultiCall) Llen(args ...interface{})

+ func (mc *MultiCall) Lpop(args ...interface{})

+ func (mc *MultiCall) Lpush(args ...interface{})

+ func (mc *MultiCall) Lpushx(args ...interface{})

+ func (mc *MultiCall) Lrange(args ...interface{})

+ func (mc *MultiCall) Lrem(args ...interface{})

+ func (mc *MultiCall) Lset(args ...interface{})

+ func (mc *MultiCall) Ltrim(args ...interface{})

+ func (mc *MultiCall) Mget(args ...interface{})

+ func (mc *MultiCall) Migrate(args ...interface{})

+ func (mc *MultiCall) Monitor(args ...interface{})

+ func (mc *MultiCall) Move(args ...interface{})

+ func (mc *MultiCall) Mset(args ...interface{})

+ func (mc *MultiCall) Msetnx(args ...interface{})

+ func (mc *MultiCall) Multi(args ...interface{})

+ func (mc *MultiCall) Object(args ...interface{})

+ func (mc *MultiCall) Persist(args ...interface{})

+ func (mc *MultiCall) Pexpire(args ...interface{})

+ func (mc *MultiCall) Pexpireat(args ...interface{})

+ func (mc *MultiCall) Ping(args ...interface{})

+ func (mc *MultiCall) Psetex(args ...interface{})

+ func (mc *MultiCall) Psubscribe(args ...interface{})

+ func (mc *MultiCall) Pttl(args ...interface{})

+ func (mc *MultiCall) Publish(args ...interface{})

+ func (mc *MultiCall) Punsubscribe(args ...interface{})

+ func (mc *MultiCall) Randomkey(args ...interface{})

+ func (mc *MultiCall) Rename(args ...interface{})

+ func (mc *MultiCall) Renamenx(args ...interface{})

+ func (mc *MultiCall) Restore(args ...interface{})

+ func (mc *MultiCall) Rpop(args ...interface{})

+ func (mc *MultiCall) Rpoplpush(args ...interface{})

+ func (mc *MultiCall) Rpush(args ...interface{})

+ func (mc *MultiCall) Rpushx(args ...interface{})

+ func (mc *MultiCall) Sadd(args ...interface{})

+ func (mc *MultiCall) Save(args ...interface{})

+ func (mc *MultiCall) Scard(args ...interface{})

+ func (mc *MultiCall) Script(args ...interface{})

+ func (mc *MultiCall) Sdiff(args ...interface{})

+ func (mc *MultiCall) Sdiffstore(args ...interface{})

+ func (mc *MultiCall) Select(args ...interface{})

+ func (mc *MultiCall) Set(args ...interface{})

+ func (mc *MultiCall) Setbit(args ...interface{})

+ func (mc *MultiCall) Setex(args ...interface{})

+ func (mc *MultiCall) Setnx(args ...interface{})

+ func (mc *MultiCall) Setrange(args ...interface{})

+ func (mc *MultiCall) Shutdown(args ...interface{})

+ func (mc *MultiCall) Sinter(args ...interface{})

+ func (mc *MultiCall) Sinterstore(args ...interface{})

+ func (mc *MultiCall) Sismember(args ...interface{})

+ func (mc *MultiCall) Slaveof(args ...interface{})

+ func (mc *MultiCall) Smembers(args ...interface{})

+ func (mc *MultiCall) Smove(args ...interface{})

+ func (mc *MultiCall) Sort(args ...interface{})

+ func (mc *MultiCall) Spop(args ...interface{})

+ func (mc *MultiCall) Srandmember(args ...interface{})

+ func (mc *MultiCall) Srem(args ...interface{})

+ func (mc *MultiCall) Strlen(args ...interface{})

+ func (mc *MultiCall) Subscribe(args ...interface{})

+ func (mc *MultiCall) Sunion(args ...interface{})

+ func (mc *MultiCall) Sunionstore(args ...interface{})

+ func (mc *MultiCall) Sync(args ...interface{})

+ func (mc *MultiCall) Time(args ...interface{})

+ func (mc *MultiCall) Ttl(args ...interface{})

+ func (mc *MultiCall) Type(args ...interface{})

+ func (mc *MultiCall) Unsubscribe(args ...interface{})

+ func (mc *MultiCall) Unwatch(args ...interface{})

+ func (mc *MultiCall) Watch(args ...interface{})

+ func (mc *MultiCall) Zadd(args ...interface{})

+ func (mc *MultiCall) Zcard(args ...interface{})

+ func (mc *MultiCall) Zcount(args ...interface{})

+ func (mc *MultiCall) Zincrby(args ...interface{})

+ func (mc *MultiCall) Zinterstore(args ...interface{})

+ func (mc *MultiCall) Zrange(args ...interface{})

+ func (mc *MultiCall) Zrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrank(args ...interface{})

+ func (mc *MultiCall) Zrem(args ...interface{})

+ func (mc *MultiCall) Zremrangebyrank(args ...interface{})

+ func (mc *MultiCall) Zremrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrevrange(args ...interface{})

+ func (mc *MultiCall) Zrevrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrevrank(args ...interface{})

+ func (mc *MultiCall) Zscore(args ...interface{})

+ func (mc *MultiCall) Zunionstore(args ...interface{})

type Reply

+ Cmd Cmd

v0.2.0

May 19, 2012

Changes in this version

type Client

+ func (c *Client) Append(args ...interface{}) *Reply

+ func (c *Client) Asking(args ...interface{}) *Reply

+ func (c *Client) AsyncAppend(args ...interface{}) Future

+ func (c *Client) AsyncAsking(args ...interface{}) Future

+ func (c *Client) AsyncAuth(args ...interface{}) Future

+ func (c *Client) AsyncBgrewriteaof(args ...interface{}) Future

+ func (c *Client) AsyncBgsave(args ...interface{}) Future

+ func (c *Client) AsyncBlpop(args ...interface{}) Future

+ func (c *Client) AsyncBrpop(args ...interface{}) Future

+ func (c *Client) AsyncBrpoplpush(args ...interface{}) Future

+ func (c *Client) AsyncClient(args ...interface{}) Future

+ func (c *Client) AsyncCluster(args ...interface{}) Future

+ func (c *Client) AsyncConfig(args ...interface{}) Future

+ func (c *Client) AsyncDbsize(args ...interface{}) Future

+ func (c *Client) AsyncDebug(args ...interface{}) Future

+ func (c *Client) AsyncDecr(args ...interface{}) Future

+ func (c *Client) AsyncDecrby(args ...interface{}) Future

+ func (c *Client) AsyncDel(args ...interface{}) Future

+ func (c *Client) AsyncDiscard(args ...interface{}) Future

+ func (c *Client) AsyncDump(args ...interface{}) Future

+ func (c *Client) AsyncEcho(args ...interface{}) Future

+ func (c *Client) AsyncEval(args ...interface{}) Future

+ func (c *Client) AsyncExec(args ...interface{}) Future

+ func (c *Client) AsyncExists(args ...interface{}) Future

+ func (c *Client) AsyncExpire(args ...interface{}) Future

+ func (c *Client) AsyncExpireat(args ...interface{}) Future

+ func (c *Client) AsyncFlushall(args ...interface{}) Future

+ func (c *Client) AsyncFlushdb(args ...interface{}) Future

+ func (c *Client) AsyncGet(args ...interface{}) Future

+ func (c *Client) AsyncGetbit(args ...interface{}) Future

+ func (c *Client) AsyncGetrange(args ...interface{}) Future

+ func (c *Client) AsyncGetset(args ...interface{}) Future

+ func (c *Client) AsyncHdel(args ...interface{}) Future

+ func (c *Client) AsyncHexists(args ...interface{}) Future

+ func (c *Client) AsyncHget(args ...interface{}) Future

+ func (c *Client) AsyncHgetall(args ...interface{}) Future

+ func (c *Client) AsyncHincrby(args ...interface{}) Future

+ func (c *Client) AsyncHincrbyfloat(args ...interface{}) Future

+ func (c *Client) AsyncHkeys(args ...interface{}) Future

+ func (c *Client) AsyncHlen(args ...interface{}) Future

+ func (c *Client) AsyncHmget(args ...interface{}) Future

+ func (c *Client) AsyncHmset(args ...interface{}) Future

+ func (c *Client) AsyncHset(args ...interface{}) Future

+ func (c *Client) AsyncHsetnx(args ...interface{}) Future

+ func (c *Client) AsyncHvals(args ...interface{}) Future

+ func (c *Client) AsyncIncr(args ...interface{}) Future

+ func (c *Client) AsyncIncrby(args ...interface{}) Future

+ func (c *Client) AsyncIncrbyfloat(args ...interface{}) Future

+ func (c *Client) AsyncInfo(args ...interface{}) Future

+ func (c *Client) AsyncKeys(args ...interface{}) Future

+ func (c *Client) AsyncLastsave(args ...interface{}) Future

+ func (c *Client) AsyncLindex(args ...interface{}) Future

+ func (c *Client) AsyncLinsert(args ...interface{}) Future

+ func (c *Client) AsyncLlen(args ...interface{}) Future

+ func (c *Client) AsyncLpop(args ...interface{}) Future

+ func (c *Client) AsyncLpush(args ...interface{}) Future

+ func (c *Client) AsyncLpushx(args ...interface{}) Future

+ func (c *Client) AsyncLrange(args ...interface{}) Future

+ func (c *Client) AsyncLrem(args ...interface{}) Future

+ func (c *Client) AsyncLset(args ...interface{}) Future

+ func (c *Client) AsyncLtrim(args ...interface{}) Future

+ func (c *Client) AsyncMget(args ...interface{}) Future

+ func (c *Client) AsyncMigrate(args ...interface{}) Future

+ func (c *Client) AsyncMonitor(args ...interface{}) Future

+ func (c *Client) AsyncMove(args ...interface{}) Future

+ func (c *Client) AsyncMset(args ...interface{}) Future

+ func (c *Client) AsyncMsetnx(args ...interface{}) Future

+ func (c *Client) AsyncMulti(args ...interface{}) Future

+ func (c *Client) AsyncObject(args ...interface{}) Future

+ func (c *Client) AsyncPersist(args ...interface{}) Future

+ func (c *Client) AsyncPexpire(args ...interface{}) Future

+ func (c *Client) AsyncPexpireat(args ...interface{}) Future

+ func (c *Client) AsyncPing(args ...interface{}) Future

+ func (c *Client) AsyncPsetex(args ...interface{}) Future

+ func (c *Client) AsyncPsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncPttl(args ...interface{}) Future

+ func (c *Client) AsyncPublish(args ...interface{}) Future

+ func (c *Client) AsyncPunsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncRandomkey(args ...interface{}) Future

+ func (c *Client) AsyncRename(args ...interface{}) Future

+ func (c *Client) AsyncRenamenx(args ...interface{}) Future

+ func (c *Client) AsyncRestore(args ...interface{}) Future

+ func (c *Client) AsyncRpop(args ...interface{}) Future

+ func (c *Client) AsyncRpoplpush(args ...interface{}) Future

+ func (c *Client) AsyncRpush(args ...interface{}) Future

+ func (c *Client) AsyncRpushx(args ...interface{}) Future

+ func (c *Client) AsyncSadd(args ...interface{}) Future

+ func (c *Client) AsyncSave(args ...interface{}) Future

+ func (c *Client) AsyncScard(args ...interface{}) Future

+ func (c *Client) AsyncScript(args ...interface{}) Future

+ func (c *Client) AsyncSdiff(args ...interface{}) Future

+ func (c *Client) AsyncSdiffstore(args ...interface{}) Future

+ func (c *Client) AsyncSelect(args ...interface{}) Future

+ func (c *Client) AsyncSet(args ...interface{}) Future

+ func (c *Client) AsyncSetbit(args ...interface{}) Future

+ func (c *Client) AsyncSetex(args ...interface{}) Future

+ func (c *Client) AsyncSetnx(args ...interface{}) Future

+ func (c *Client) AsyncSetrange(args ...interface{}) Future

+ func (c *Client) AsyncShutdown(args ...interface{}) Future

+ func (c *Client) AsyncSinter(args ...interface{}) Future

+ func (c *Client) AsyncSinterstore(args ...interface{}) Future

+ func (c *Client) AsyncSismember(args ...interface{}) Future

+ func (c *Client) AsyncSlaveof(args ...interface{}) Future

+ func (c *Client) AsyncSmembers(args ...interface{}) Future

+ func (c *Client) AsyncSmove(args ...interface{}) Future

+ func (c *Client) AsyncSort(args ...interface{}) Future

+ func (c *Client) AsyncSpop(args ...interface{}) Future

+ func (c *Client) AsyncSrandmember(args ...interface{}) Future

+ func (c *Client) AsyncSrem(args ...interface{}) Future

+ func (c *Client) AsyncStrlen(args ...interface{}) Future

+ func (c *Client) AsyncSubscribe(args ...interface{}) Future

+ func (c *Client) AsyncSunion(args ...interface{}) Future

+ func (c *Client) AsyncSunionstore(args ...interface{}) Future

+ func (c *Client) AsyncSync(args ...interface{}) Future

+ func (c *Client) AsyncTime(args ...interface{}) Future

+ func (c *Client) AsyncTtl(args ...interface{}) Future

+ func (c *Client) AsyncType(args ...interface{}) Future

+ func (c *Client) AsyncUnsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncUnwatch(args ...interface{}) Future

+ func (c *Client) AsyncWatch(args ...interface{}) Future

+ func (c *Client) AsyncZadd(args ...interface{}) Future

+ func (c *Client) AsyncZcard(args ...interface{}) Future

+ func (c *Client) AsyncZcount(args ...interface{}) Future

+ func (c *Client) AsyncZincrby(args ...interface{}) Future

+ func (c *Client) AsyncZinterstore(args ...interface{}) Future

+ func (c *Client) AsyncZrange(args ...interface{}) Future

+ func (c *Client) AsyncZrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrank(args ...interface{}) Future

+ func (c *Client) AsyncZrem(args ...interface{}) Future

+ func (c *Client) AsyncZremrangebyrank(args ...interface{}) Future

+ func (c *Client) AsyncZremrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrevrange(args ...interface{}) Future

+ func (c *Client) AsyncZrevrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrevrank(args ...interface{}) Future

+ func (c *Client) AsyncZscore(args ...interface{}) Future

+ func (c *Client) AsyncZunionstore(args ...interface{}) Future

+ func (c *Client) Auth(args ...interface{}) *Reply

+ func (c *Client) Bgrewriteaof(args ...interface{}) *Reply

+ func (c *Client) Bgsave(args ...interface{}) *Reply

+ func (c *Client) Blpop(args ...interface{}) *Reply

+ func (c *Client) Brpop(args ...interface{}) *Reply

+ func (c *Client) Brpoplpush(args ...interface{}) *Reply

+ func (c *Client) Client(args ...interface{}) *Reply

+ func (c *Client) Cluster(args ...interface{}) *Reply

+ func (c *Client) Config(args ...interface{}) *Reply

+ func (c *Client) Dbsize(args ...interface{}) *Reply

+ func (c *Client) Debug(args ...interface{}) *Reply

+ func (c *Client) Decr(args ...interface{}) *Reply

+ func (c *Client) Decrby(args ...interface{}) *Reply

+ func (c *Client) Del(args ...interface{}) *Reply

+ func (c *Client) Discard(args ...interface{}) *Reply

+ func (c *Client) Dump(args ...interface{}) *Reply

+ func (c *Client) Echo(args ...interface{}) *Reply

+ func (c *Client) Eval(args ...interface{}) *Reply

+ func (c *Client) Exec(args ...interface{}) *Reply

+ func (c *Client) Exists(args ...interface{}) *Reply

+ func (c *Client) Expire(args ...interface{}) *Reply

+ func (c *Client) Expireat(args ...interface{}) *Reply

+ func (c *Client) Flushall(args ...interface{}) *Reply

+ func (c *Client) Flushdb(args ...interface{}) *Reply

+ func (c *Client) Get(args ...interface{}) *Reply

+ func (c *Client) Getbit(args ...interface{}) *Reply

+ func (c *Client) Getrange(args ...interface{}) *Reply

+ func (c *Client) Getset(args ...interface{}) *Reply

+ func (c *Client) Hdel(args ...interface{}) *Reply

+ func (c *Client) Hexists(args ...interface{}) *Reply

+ func (c *Client) Hget(args ...interface{}) *Reply

+ func (c *Client) Hgetall(args ...interface{}) *Reply

+ func (c *Client) Hincrby(args ...interface{}) *Reply

+ func (c *Client) Hincrbyfloat(args ...interface{}) *Reply

+ func (c *Client) Hkeys(args ...interface{}) *Reply

+ func (c *Client) Hlen(args ...interface{}) *Reply

+ func (c *Client) Hmget(args ...interface{}) *Reply

+ func (c *Client) Hmset(args ...interface{}) *Reply

+ func (c *Client) Hset(args ...interface{}) *Reply

+ func (c *Client) Hsetnx(args ...interface{}) *Reply

+ func (c *Client) Hvals(args ...interface{}) *Reply

+ func (c *Client) Incr(args ...interface{}) *Reply

+ func (c *Client) Incrby(args ...interface{}) *Reply

+ func (c *Client) Incrbyfloat(args ...interface{}) *Reply

+ func (c *Client) Info(args ...interface{}) *Reply

+ func (c *Client) Keys(args ...interface{}) *Reply

+ func (c *Client) Lastsave(args ...interface{}) *Reply

+ func (c *Client) Lindex(args ...interface{}) *Reply

+ func (c *Client) Linsert(args ...interface{}) *Reply

+ func (c *Client) Llen(args ...interface{}) *Reply

+ func (c *Client) Lpop(args ...interface{}) *Reply

+ func (c *Client) Lpush(args ...interface{}) *Reply

+ func (c *Client) Lpushx(args ...interface{}) *Reply

+ func (c *Client) Lrange(args ...interface{}) *Reply

+ func (c *Client) Lrem(args ...interface{}) *Reply

+ func (c *Client) Lset(args ...interface{}) *Reply

+ func (c *Client) Ltrim(args ...interface{}) *Reply

+ func (c *Client) Mget(args ...interface{}) *Reply

+ func (c *Client) Migrate(args ...interface{}) *Reply

+ func (c *Client) Monitor(args ...interface{}) *Reply

+ func (c *Client) Move(args ...interface{}) *Reply

+ func (c *Client) Mset(args ...interface{}) *Reply

+ func (c *Client) Msetnx(args ...interface{}) *Reply

+ func (c *Client) Multi(args ...interface{}) *Reply

+ func (c *Client) Object(args ...interface{}) *Reply

+ func (c *Client) Persist(args ...interface{}) *Reply

+ func (c *Client) Pexpire(args ...interface{}) *Reply

+ func (c *Client) Pexpireat(args ...interface{}) *Reply

+ func (c *Client) Ping(args ...interface{}) *Reply

+ func (c *Client) Psetex(args ...interface{}) *Reply

+ func (c *Client) Psubscribe(args ...interface{}) *Reply

+ func (c *Client) Pttl(args ...interface{}) *Reply

+ func (c *Client) Publish(args ...interface{}) *Reply

+ func (c *Client) Punsubscribe(args ...interface{}) *Reply

+ func (c *Client) Randomkey(args ...interface{}) *Reply

+ func (c *Client) Rename(args ...interface{}) *Reply

+ func (c *Client) Renamenx(args ...interface{}) *Reply

+ func (c *Client) Restore(args ...interface{}) *Reply

+ func (c *Client) Rpop(args ...interface{}) *Reply

+ func (c *Client) Rpoplpush(args ...interface{}) *Reply

+ func (c *Client) Rpush(args ...interface{}) *Reply

+ func (c *Client) Rpushx(args ...interface{}) *Reply

+ func (c *Client) Sadd(args ...interface{}) *Reply

+ func (c *Client) Save(args ...interface{}) *Reply

+ func (c *Client) Scard(args ...interface{}) *Reply

+ func (c *Client) Script(args ...interface{}) *Reply

+ func (c *Client) Sdiff(args ...interface{}) *Reply

+ func (c *Client) Sdiffstore(args ...interface{}) *Reply

+ func (c *Client) Set(args ...interface{}) *Reply

+ func (c *Client) Setbit(args ...interface{}) *Reply

+ func (c *Client) Setex(args ...interface{}) *Reply

+ func (c *Client) Setnx(args ...interface{}) *Reply

+ func (c *Client) Setrange(args ...interface{}) *Reply

+ func (c *Client) Shutdown(args ...interface{}) *Reply

+ func (c *Client) Sinter(args ...interface{}) *Reply

+ func (c *Client) Sinterstore(args ...interface{}) *Reply

+ func (c *Client) Sismember(args ...interface{}) *Reply

+ func (c *Client) Slaveof(args ...interface{}) *Reply

+ func (c *Client) Smembers(args ...interface{}) *Reply

+ func (c *Client) Smove(args ...interface{}) *Reply

+ func (c *Client) Sort(args ...interface{}) *Reply

+ func (c *Client) Spop(args ...interface{}) *Reply

+ func (c *Client) Srandmember(args ...interface{}) *Reply

+ func (c *Client) Srem(args ...interface{}) *Reply

+ func (c *Client) Strlen(args ...interface{}) *Reply

+ func (c *Client) Subscribe(args ...interface{}) *Reply

+ func (c *Client) Sunion(args ...interface{}) *Reply

+ func (c *Client) Sunionstore(args ...interface{}) *Reply

+ func (c *Client) Sync(args ...interface{}) *Reply

+ func (c *Client) Time(args ...interface{}) *Reply

+ func (c *Client) Ttl(args ...interface{}) *Reply

+ func (c *Client) Type(args ...interface{}) *Reply

+ func (c *Client) Unsubscribe(args ...interface{}) *Reply

+ func (c *Client) Unwatch(args ...interface{}) *Reply

+ func (c *Client) Watch(args ...interface{}) *Reply

+ func (c *Client) Zadd(args ...interface{}) *Reply

+ func (c *Client) Zcard(args ...interface{}) *Reply

+ func (c *Client) Zcount(args ...interface{}) *Reply

+ func (c *Client) Zincrby(args ...interface{}) *Reply

+ func (c *Client) Zinterstore(args ...interface{}) *Reply

+ func (c *Client) Zrange(args ...interface{}) *Reply

+ func (c *Client) Zrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrank(args ...interface{}) *Reply

+ func (c *Client) Zrem(args ...interface{}) *Reply

+ func (c *Client) Zremrangebyrank(args ...interface{}) *Reply

+ func (c *Client) Zremrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrevrange(args ...interface{}) *Reply

+ func (c *Client) Zrevrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrevrank(args ...interface{}) *Reply

+ func (c *Client) Zscore(args ...interface{}) *Reply

+ func (c *Client) Zunionstore(args ...interface{}) *Reply

type MessageType

+ const MessagePmessage

+ const MessagePsubscribe

+ const MessagePunsubscribe

type MultiCommand

+ func (mc *MultiCommand) Append(args ...interface{})

+ func (mc *MultiCommand) Asking(args ...interface{})

+ func (mc *MultiCommand) Auth(args ...interface{})

+ func (mc *MultiCommand) Bgrewriteaof(args ...interface{})

+ func (mc *MultiCommand) Bgsave(args ...interface{})

+ func (mc *MultiCommand) Blpop(args ...interface{})

+ func (mc *MultiCommand) Brpop(args ...interface{})

+ func (mc *MultiCommand) Brpoplpush(args ...interface{})

+ func (mc *MultiCommand) Client(args ...interface{})

+ func (mc *MultiCommand) Cluster(args ...interface{})

+ func (mc *MultiCommand) Config(args ...interface{})

+ func (mc *MultiCommand) Dbsize(args ...interface{})

+ func (mc *MultiCommand) Debug(args ...interface{})

+ func (mc *MultiCommand) Decr(args ...interface{})

+ func (mc *MultiCommand) Decrby(args ...interface{})

+ func (mc *MultiCommand) Del(args ...interface{})

+ func (mc *MultiCommand) Discard(args ...interface{})

+ func (mc *MultiCommand) Dump(args ...interface{})

+ func (mc *MultiCommand) Echo(args ...interface{})

+ func (mc *MultiCommand) Eval(args ...interface{})

+ func (mc *MultiCommand) Exec(args ...interface{})

+ func (mc *MultiCommand) Exists(args ...interface{})

+ func (mc *MultiCommand) Expire(args ...interface{})

+ func (mc *MultiCommand) Expireat(args ...interface{})

+ func (mc *MultiCommand) Flushall(args ...interface{})

+ func (mc *MultiCommand) Flushdb(args ...interface{})

+ func (mc *MultiCommand) Get(args ...interface{})

+ func (mc *MultiCommand) Getbit(args ...interface{})

+ func (mc *MultiCommand) Getrange(args ...interface{})

+ func (mc *MultiCommand) Getset(args ...interface{})

+ func (mc *MultiCommand) Hdel(args ...interface{})

+ func (mc *MultiCommand) Hexists(args ...interface{})

+ func (mc *MultiCommand) Hget(args ...interface{})

+ func (mc *MultiCommand) Hgetall(args ...interface{})

+ func (mc *MultiCommand) Hincrby(args ...interface{})

+ func (mc *MultiCommand) Hincrbyfloat(args ...interface{})

+ func (mc *MultiCommand) Hkeys(args ...interface{})

+ func (mc *MultiCommand) Hlen(args ...interface{})

+ func (mc *MultiCommand) Hmget(args ...interface{})

+ func (mc *MultiCommand) Hmset(args ...interface{})

+ func (mc *MultiCommand) Hset(args ...interface{})

+ func (mc *MultiCommand) Hsetnx(args ...interface{})

+ func (mc *MultiCommand) Hvals(args ...interface{})

+ func (mc *MultiCommand) Incr(args ...interface{})

+ func (mc *MultiCommand) Incrby(args ...interface{})

+ func (mc *MultiCommand) Incrbyfloat(args ...interface{})

+ func (mc *MultiCommand) Info(args ...interface{})

+ func (mc *MultiCommand) Keys(args ...interface{})

+ func (mc *MultiCommand) Lastsave(args ...interface{})

+ func (mc *MultiCommand) Lindex(args ...interface{})

+ func (mc *MultiCommand) Linsert(args ...interface{})

+ func (mc *MultiCommand) Llen(args ...interface{})

+ func (mc *MultiCommand) Lpop(args ...interface{})

+ func (mc *MultiCommand) Lpush(args ...interface{})

+ func (mc *MultiCommand) Lpushx(args ...interface{})

+ func (mc *MultiCommand) Lrange(args ...interface{})

+ func (mc *MultiCommand) Lrem(args ...interface{})

+ func (mc *MultiCommand) Lset(args ...interface{})

+ func (mc *MultiCommand) Ltrim(args ...interface{})

+ func (mc *MultiCommand) Mget(args ...interface{})

+ func (mc *MultiCommand) Migrate(args ...interface{})

+ func (mc *MultiCommand) Monitor(args ...interface{})

+ func (mc *MultiCommand) Move(args ...interface{})

+ func (mc *MultiCommand) Mset(args ...interface{})

+ func (mc *MultiCommand) Msetnx(args ...interface{})

+ func (mc *MultiCommand) Multi(args ...interface{})

+ func (mc *MultiCommand) Object(args ...interface{})

+ func (mc *MultiCommand) Persist(args ...interface{})

+ func (mc *MultiCommand) Pexpire(args ...interface{})

+ func (mc *MultiCommand) Pexpireat(args ...interface{})

+ func (mc *MultiCommand) Ping(args ...interface{})

+ func (mc *MultiCommand) Psetex(args ...interface{})

+ func (mc *MultiCommand) Psubscribe(args ...interface{})

+ func (mc *MultiCommand) Pttl(args ...interface{})

+ func (mc *MultiCommand) Publish(args ...interface{})

+ func (mc *MultiCommand) Punsubscribe(args ...interface{})

+ func (mc *MultiCommand) Randomkey(args ...interface{})

+ func (mc *MultiCommand) Rename(args ...interface{})

+ func (mc *MultiCommand) Renamenx(args ...interface{})

+ func (mc *MultiCommand) Restore(args ...interface{})

+ func (mc *MultiCommand) Rpop(args ...interface{})

+ func (mc *MultiCommand) Rpoplpush(args ...interface{})

+ func (mc *MultiCommand) Rpush(args ...interface{})

+ func (mc *MultiCommand) Rpushx(args ...interface{})

+ func (mc *MultiCommand) Sadd(args ...interface{})

+ func (mc *MultiCommand) Save(args ...interface{})

+ func (mc *MultiCommand) Scard(args ...interface{})

+ func (mc *MultiCommand) Script(args ...interface{})

+ func (mc *MultiCommand) Sdiff(args ...interface{})

+ func (mc *MultiCommand) Sdiffstore(args ...interface{})

+ func (mc *MultiCommand) Select(args ...interface{})

+ func (mc *MultiCommand) Set(args ...interface{})

+ func (mc *MultiCommand) Setbit(args ...interface{})

+ func (mc *MultiCommand) Setex(args ...interface{})

+ func (mc *MultiCommand) Setnx(args ...interface{})

+ func (mc *MultiCommand) Setrange(args ...interface{})

+ func (mc *MultiCommand) Shutdown(args ...interface{})

+ func (mc *MultiCommand) Sinter(args ...interface{})

+ func (mc *MultiCommand) Sinterstore(args ...interface{})

+ func (mc *MultiCommand) Sismember(args ...interface{})

+ func (mc *MultiCommand) Slaveof(args ...interface{})

+ func (mc *MultiCommand) Smembers(args ...interface{})

+ func (mc *MultiCommand) Smove(args ...interface{})

+ func (mc *MultiCommand) Sort(args ...interface{})

+ func (mc *MultiCommand) Spop(args ...interface{})

+ func (mc *MultiCommand) Srandmember(args ...interface{})

+ func (mc *MultiCommand) Srem(args ...interface{})

+ func (mc *MultiCommand) Strlen(args ...interface{})

+ func (mc *MultiCommand) Subscribe(args ...interface{})

+ func (mc *MultiCommand) Sunion(args ...interface{})

+ func (mc *MultiCommand) Sunionstore(args ...interface{})

+ func (mc *MultiCommand) Sync(args ...interface{})

+ func (mc *MultiCommand) Time(args ...interface{})

+ func (mc *MultiCommand) Ttl(args ...interface{})

+ func (mc *MultiCommand) Type(args ...interface{})

+ func (mc *MultiCommand) Unsubscribe(args ...interface{})

+ func (mc *MultiCommand) Unwatch(args ...interface{})

+ func (mc *MultiCommand) Watch(args ...interface{})

+ func (mc *MultiCommand) Zadd(args ...interface{})

+ func (mc *MultiCommand) Zcard(args ...interface{})

+ func (mc *MultiCommand) Zcount(args ...interface{})

+ func (mc *MultiCommand) Zincrby(args ...interface{})

+ func (mc *MultiCommand) Zinterstore(args ...interface{})

+ func (mc *MultiCommand) Zrange(args ...interface{})

+ func (mc *MultiCommand) Zrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrank(args ...interface{})

+ func (mc *MultiCommand) Zrem(args ...interface{})

+ func (mc *MultiCommand) Zremrangebyrank(args ...interface{})

+ func (mc *MultiCommand) Zremrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrevrange(args ...interface{})

+ func (mc *MultiCommand) Zrevrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrevrank(args ...interface{})

+ func (mc *MultiCommand) Zscore(args ...interface{})

+ func (mc *MultiCommand) Zunionstore(args ...interface{})

type Subscription

+ func (s *Subscription) Psubscribe(patterns ...string) *Error

+ func (s *Subscription) Punsubscribe(patterns ...string) *Error

v0.1.5

May 15, 2012

Changes in this version

+ type Command string

+ const Append

+ const Asking

+ const Auth

+ const Bgrewriteaof

+ const Bgsave

+ const Blpop

+ const Brpop

+ const Brpoplpush

+ const ClientCmd

+ const Cluster

+ const Config

+ const Dbsize

+ const Debug

+ const Decr

+ const Decrby

+ const Del

+ const Discard

+ const Dump

+ const Echo

+ const Eval

+ const Exec

+ const Exists

+ const Expire

+ const Expireat

+ const Flushall

+ const Flushdb

+ const Get

+ const Getbit

+ const Getrange

+ const Getset

+ const Hdel

+ const Hexists

+ const Hget

+ const Hgetall

+ const Hincrby

+ const Hincrbyfloat

+ const Hkeys

+ const Hlen

+ const Hmget

+ const Hmset

+ const Hset

+ const Hsetnx

+ const Hvals

+ const Incr

+ const Incrby

+ const Incrbyfloat

+ const Info

+ const Keys

+ const Lastsave

+ const Lindex

+ const Linsert

+ const Llen

+ const Lpop

+ const Lpush

+ const Lpushx

+ const Lrange

+ const Lrem

+ const Lset

+ const Ltrim

+ const Mget

+ const Migrate

+ const Monitor

+ const Move

+ const Mset

+ const Msetnx

+ const Multi

+ const Object

+ const Persist

+ const Pexpire

+ const Pexpireat

+ const Ping

+ const Psetex

+ const Psubscribe

+ const Pttl

+ const Publish

+ const Punsubscribe

+ const Randomkey

+ const Rename

+ const Renamenx

+ const Restore

+ const Rpop

+ const Rpoplpush

+ const Rpush

+ const Rpushx

+ const Sadd

+ const Save

+ const Scard

+ const Script

+ const Sdiff

+ const Sdiffstore

+ const Select

+ const Set

+ const Setbit

+ const Setex

+ const Setnx

+ const Setrange

+ const Shutdown

+ const Sinter

+ const Sinterstore

+ const Sismember

+ const Slaveof

+ const Smembers

+ const Smove

+ const Sort

+ const Spop

+ const Srandmember

+ const Srem

+ const Strlen

+ const Subscribe

+ const Sunion

+ const Sunionstore

+ const Sync

+ const Time

+ const Ttl

+ const Type

+ const Unsubscribe

+ const Unwatch

+ const Watch

+ const Zadd

+ const Zcard

+ const Zcount

+ const Zincrby

+ const Zinterstore

+ const Zrange

+ const Zrangebyscore

+ const Zrank

+ const Zrem

+ const Zremrangebyrank

+ const Zremrangebyscore

+ const Zrevrange

+ const Zrevrangebyscore

+ const Zrevrank

+ const Zscore

+ const Zunionstore

v0.1.1

Mar 1, 2012

Changes in this version

+ type Client struct

+ func NewClient(conf Configuration) *Client

+ func (c *Client) AsyncCommand(cmd string, args ...interface{}) Future

+ func (c *Client) AsyncMultiCommand(f func(*MultiCommand)) Future

+ func (c *Client) AsyncTransaction(f func(*MultiCommand)) Future

+ func (c *Client) Close()

+ func (c *Client) Command(cmd string, args ...interface{}) *Reply

+ func (c *Client) MultiCommand(f func(*MultiCommand)) *Reply

+ func (c *Client) Select(database int)

+ func (c *Client) Subscription(msgHdlr func(msg *Message)) (*Subscription, *Error)

+ func (c *Client) Transaction(f func(*MultiCommand)) *Reply

+ type Configuration struct

+ Address string

+ Auth string

+ Database int

+ NoLoadingRetry bool

+ Path string

+ PoolSize int

+ Timeout int

+ type Error struct

+ func (e *Error) Error() string

+ func (e *Error) Test(flags ...ErrorFlag) bool

+ type ErrorFlag uint8

+ const ErrorAuth

+ const ErrorConnection

+ const ErrorInvalidReply

+ const ErrorLoading

+ const ErrorParse

+ const ErrorRedis

+ const ErrorTimeout

+ type Future chan *Reply

+ func (f Future) Reply() (r *Reply)

+ type Message struct

+ Channel string

+ Error error

+ Pattern string

+ Payload string

+ Subscriptions int

+ Type MessageType

+ func (m *Message) String() string

+ type MessageType int

+ const MessageError

+ const MessageMessage

+ const MessagePMessage

+ const MessagePSubscribe

+ const MessagePUnsubscribe

+ const MessageSubscribe

+ const MessageUnsubscribe

+ type MultiCommand struct

+ func (mc *MultiCommand) Command(cmd string, args ...interface{})

+ func (mc *MultiCommand) Flush() *Reply

+ type Reply struct

+ func (r *Reply) At(i int) *Reply

+ func (r *Reply) Bool() bool

+ func (r *Reply) Bytes() []byte

+ func (r *Reply) Elems() []*Reply

+ func (r *Reply) Error() *Error

+ func (r *Reply) ErrorString() string

+ func (r *Reply) Int() int

+ func (r *Reply) Int64() int64

+ func (r *Reply) Len() int

+ func (r *Reply) Map() (map[string]*Reply, error)

+ func (r *Reply) Nil() bool

+ func (r *Reply) Str() string

+ func (r *Reply) String() string

+ func (r *Reply) StringMap() (map[string]string, error)

+ func (r *Reply) Strings() ([]string, error)

+ func (r *Reply) Type() ReplyType

+ type ReplyType uint8

+ const ReplyError

+ const ReplyInteger

+ const ReplyMulti

+ const ReplyNil

+ const ReplyStatus

+ const ReplyString

+ type Subscription struct

+ func (s *Subscription) Close()

+ func (s *Subscription) PSubscribe(patterns ...string) *Error

+ func (s *Subscription) PUnsubscribe(patterns ...string) *Error

+ func (s *Subscription) Subscribe(channels ...string) *Error

+ func (s *Subscription) Unsubscribe(channels ...string) *Error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL