Package ledis is a high performance embedded NoSQL.

Ledis supports various data structure like kv, list, hash and zset like redis.

Other features include replication, data with a limited time-to-live.


First create a ledis instance before use:

l := ledis.Open(cfg)

cfg is a Config instance which contains configuration for ledis use, like DataDir (root directory for ledis working to store data).

After you create a ledis instance, you can select a DB to store you data:

db, _ := l.Select(0)

DB must be selected by a index, ledis supports only 16 databases, so the index range is [0-15].


KV is the most basic ledis type like any other key-value database.

err := db.Set(key, value)
value, err := db.Get(key)


List is simply lists of values, sorted by insertion order. You can push or pop value on the list head (left) or tail (right).

err := db.LPush(key, value1)
err := db.RPush(key, value2)
value1, err := db.LPop(key)
value2, err := db.RPop(key)


Hash is a map between fields and values.

n, err := db.HSet(key, field1, value1)
n, err := db.HSet(key, field2, value2)
value1, err := db.HGet(key, field1)
value2, err := db.HGet(key, field2)


ZSet is a sorted collections of values. Every member of zset is associated with score, a int64 value which used to sort, from smallest to greatest score. Members are unique, but score may be same.

n, err := db.ZAdd(key, ScorePair{score1, member1}, ScorePair{score2, member2})
ay, err := db.ZRangeByScore(key, minScore, maxScore, 0, -1)



View Source
const (
	KVName   = "KV"
	ListName = "LIST"
	HashName = "HASH"
	SetName  = "SET"
	ZSetName = "ZSET"

    For different type name

    View Source
    const (
    	NoneType   byte = 0
    	KVType     byte = 1
    	HashType   byte = 2
    	HSizeType  byte = 3
    	ListType   byte = 4
    	LMetaType  byte = 5
    	ZSetType   byte = 6
    	ZSizeType  byte = 7
    	ZScoreType byte = 8
    	// BitType     byte = 9
    	// BitMetaType byte = 10
    	SetType   byte = 11
    	SSizeType byte = 12
    		I make a big mistake about TTL time key format and have to use a new one (change 101 to 103).
    		You must run the ledis-upgrade-ttl to upgrade db.
    	ObsoleteExpTimeType byte = 101
    	ExpMetaType         byte = 102
    	ExpTimeType         byte = 103
    	MetaType byte = 201

      for backend store

      View Source
      const (
      	// max allowed databases
      	MaxDatabases int = 10240
      	// max key size
      	MaxKeySize int = 1024
      	// max hash field size
      	MaxHashFieldSize int = 1024
      	// max zset member size
      	MaxZSetMemberSize int = 1024
      	// max set member size
      	MaxSetMemberSize int = 1024
      	// max value size
      	MaxValueSize int = 1024 * 1024 * 1024

        For different const size configuration

        View Source
        const (
        	BitAND = "and"
        	BitOR  = "or"
        	BitXOR = "xor"
        	BitNot = "not"

          For bit operation

          View Source
          const (
          	UnionType byte = 51
          	DiffType  byte = 52
          	InterType byte = 53

            For set operation type.

            View Source
            const (
            	MinScore     int64 = -1<<63 + 1
            	MaxScore     int64 = 1<<63 - 1
            	InvalidScore int64 = -1 << 63
            	AggregateSum byte = 0
            	AggregateMin byte = 1
            	AggregateMax byte = 2

              For zset const.

              View Source
              const Version = "0.5"

                Version is for version


                View Source
                var (
                	ErrScoreMiss     = errors.New("zset score miss")
                	ErrWriteInROnly  = errors.New("write not support in readonly mode")
                	ErrRplInRDWR     = errors.New("replication not support in read write mode")
                	ErrRplNotSupport = errors.New("replication not support")

                  For different common errors

                  View Source
                  var (
                  	ErrLogMissed = errors.New("log is pured in server")

                    For replication error.

                    View Source
                    var TypeName = map[byte]string{
                    	KVType:     "kv",
                    	HashType:   "hash",
                    	HSizeType:  "hsize",
                    	ListType:   "list",
                    	LMetaType:  "lmeta",
                    	ZSetType:   "zset",
                    	ZSizeType:  "zsize",
                    	ZScoreType: "zscore",
                    	SetType:     "set",
                    	SSizeType:   "ssize",
                    	ExpTimeType: "exptime",
                    	ExpMetaType: "expmeta",

                      TypeName is the map of type -> name


                      func AsyncNotify

                      func AsyncNotify(ch chan struct{})

                        AsyncNotify notices the channel.

                        func Int64

                        func Int64(v []byte, err error) (int64, error)

                          Int64 gets 64 integer with the little endian format.

                          func PutInt64

                          func PutInt64(v int64) []byte

                            PutInt64 puts the 64 integer.

                            func StrInt32

                            func StrInt32(v []byte, err error) (int32, error)

                              StrInt32 gets the 32 integer with string format.

                              func StrInt64

                              func StrInt64(v []byte, err error) (int64, error)

                                StrInt64 gets the 64 integer with string format.

                                func StrInt8

                                func StrInt8(v []byte, err error) (int8, error)

                                  StrInt8 ets the 8 integer with string format.

                                  func StrUint64

                                  func StrUint64(v []byte, err error) (uint64, error)

                                    StrUint64 gets the unsigned 64 integer with string format.

                                    func Uint64

                                    func Uint64(v []byte, err error) (uint64, error)

                                      Uint64 gets unsigned 64 integer.


                                      type DB

                                      type DB struct {
                                      	// contains filtered or unexported fields

                                        DB is the database.

                                        func (*DB) Append

                                        func (db *DB) Append(key []byte, value []byte) (int64, error)

                                          Append appends the value to the data.

                                          func (*DB) BLPop

                                          func (db *DB) BLPop(keys [][]byte, timeout time.Duration) ([]interface{}, error)

                                            BLPop pops the list with block way.

                                            func (*DB) BRPop

                                            func (db *DB) BRPop(keys [][]byte, timeout time.Duration) ([]interface{}, error)

                                              BRPop bpops the list with block way.

                                              func (*DB) BitCount

                                              func (db *DB) BitCount(key []byte, start int, end int) (int64, error)

                                                BitCount returns the bit count of data.

                                                func (*DB) BitOP

                                                func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error)

                                                  BitOP does the bit operations in data.

                                                  func (*DB) BitPos

                                                  func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error)

                                                    BitPos returns the pos of the data.

                                                    func (*DB) Decr

                                                    func (db *DB) Decr(key []byte) (int64, error)

                                                      Decr decreases the data.

                                                      func (*DB) DecrBy

                                                      func (db *DB) DecrBy(key []byte, decrement int64) (int64, error)

                                                        DecrBy decreases the data by decrement.

                                                        func (*DB) Del

                                                        func (db *DB) Del(keys ...[]byte) (int64, error)

                                                          Del deletes the data.

                                                          func (*DB) Dump

                                                          func (db *DB) Dump(key []byte) ([]byte, error)

                                                            Dump dumps the KV value of key

                                                            func (*DB) Exists

                                                            func (db *DB) Exists(key []byte) (int64, error)

                                                              Exists check data exists or not.

                                                              func (*DB) Expire

                                                              func (db *DB) Expire(key []byte, duration int64) (int64, error)

                                                                Expire expires the data.

                                                                func (*DB) ExpireAt

                                                                func (db *DB) ExpireAt(key []byte, when int64) (int64, error)

                                                                  ExpireAt expires the data at when.

                                                                  func (*DB) FlushAll

                                                                  func (db *DB) FlushAll() (drop int64, err error)

                                                                    FlushAll flushes the data.

                                                                    func (*DB) Get

                                                                    func (db *DB) Get(key []byte) ([]byte, error)

                                                                      Get gets the value.

                                                                      func (*DB) GetBit

                                                                      func (db *DB) GetBit(key []byte, offset int) (int64, error)

                                                                        GetBit gets the bit of data at offset.

                                                                        func (*DB) GetRange

                                                                        func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error)

                                                                          GetRange gets the range of the data.

                                                                          func (*DB) GetSet

                                                                          func (db *DB) GetSet(key []byte, value []byte) ([]byte, error)

                                                                            GetSet gets the value and sets new value.

                                                                            func (*DB) GetSlice

                                                                            func (db *DB) GetSlice(key []byte) (store.Slice, error)

                                                                              GetSlice gets the slice of the data.

                                                                              func (*DB) HClear

                                                                              func (db *DB) HClear(key []byte) (int64, error)

                                                                                HClear clears the data.

                                                                                func (*DB) HDel

                                                                                func (db *DB) HDel(key []byte, args ...[]byte) (int64, error)

                                                                                  HDel deletes the fields.

                                                                                  func (*DB) HDump

                                                                                  func (db *DB) HDump(key []byte) ([]byte, error)

                                                                                    HDump dumps the hash value of key

                                                                                    func (*DB) HExpire

                                                                                    func (db *DB) HExpire(key []byte, duration int64) (int64, error)

                                                                                      HExpire expires the data with duration.

                                                                                      func (*DB) HExpireAt

                                                                                      func (db *DB) HExpireAt(key []byte, when int64) (int64, error)

                                                                                        HExpireAt expires the data at time when.

                                                                                        func (*DB) HGet

                                                                                        func (db *DB) HGet(key []byte, field []byte) ([]byte, error)

                                                                                          HGet gets the value of the field.

                                                                                          func (*DB) HGetAll

                                                                                          func (db *DB) HGetAll(key []byte) ([]FVPair, error)

                                                                                            HGetAll returns all field-values.

                                                                                            func (*DB) HIncrBy

                                                                                            func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error)

                                                                                              HIncrBy increases the value of field by delta.

                                                                                              func (*DB) HKeyExists

                                                                                              func (db *DB) HKeyExists(key []byte) (int64, error)

                                                                                                HKeyExists checks whether data exists or not.

                                                                                                func (*DB) HKeys

                                                                                                func (db *DB) HKeys(key []byte) ([][]byte, error)

                                                                                                  HKeys returns the all fields.

                                                                                                  func (*DB) HLen

                                                                                                  func (db *DB) HLen(key []byte) (int64, error)

                                                                                                    HLen returns the lengh of hash.

                                                                                                    func (*DB) HMclear

                                                                                                    func (db *DB) HMclear(keys ...[]byte) (int64, error)

                                                                                                      HMclear cleans multi data.

                                                                                                      func (*DB) HMget

                                                                                                      func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error)

                                                                                                        HMget gets multi values of fields

                                                                                                        func (*DB) HMset

                                                                                                        func (db *DB) HMset(key []byte, args ...FVPair) error

                                                                                                          HMset sets multi field-values.

                                                                                                          func (*DB) HPersist

                                                                                                          func (db *DB) HPersist(key []byte) (int64, error)

                                                                                                            HPersist removes the TTL of data.

                                                                                                            func (*DB) HRevScan

                                                                                                            func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error)

                                                                                                              HRevScan reversed scans data for hash.

                                                                                                              func (*DB) HScan

                                                                                                              func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error)

                                                                                                                HScan scans data for hash.

                                                                                                                func (*DB) HSet

                                                                                                                func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error)

                                                                                                                  HSet sets the field with value of key.

                                                                                                                  func (*DB) HTTL

                                                                                                                  func (db *DB) HTTL(key []byte) (int64, error)

                                                                                                                    HTTL gets the TTL of data.

                                                                                                                    func (*DB) HValues

                                                                                                                    func (db *DB) HValues(key []byte) ([][]byte, error)

                                                                                                                      HValues returns all values

                                                                                                                      func (*DB) Incr

                                                                                                                      func (db *DB) Incr(key []byte) (int64, error)

                                                                                                                        Incr increases the data.

                                                                                                                        func (*DB) IncrBy

                                                                                                                        func (db *DB) IncrBy(key []byte, increment int64) (int64, error)

                                                                                                                          IncrBy increases the data by increment.

                                                                                                                          func (*DB) Index

                                                                                                                          func (db *DB) Index() int

                                                                                                                            Index gets the index of database.

                                                                                                                            func (*DB) LClear

                                                                                                                            func (db *DB) LClear(key []byte) (int64, error)

                                                                                                                              LClear clears the list.

                                                                                                                              func (*DB) LDump

                                                                                                                              func (db *DB) LDump(key []byte) ([]byte, error)

                                                                                                                                LDump dumps the list value of key

                                                                                                                                func (*DB) LExpire

                                                                                                                                func (db *DB) LExpire(key []byte, duration int64) (int64, error)

                                                                                                                                  LExpire expires the list.

                                                                                                                                  func (*DB) LExpireAt

                                                                                                                                  func (db *DB) LExpireAt(key []byte, when int64) (int64, error)

                                                                                                                                    LExpireAt expires the list at when.

                                                                                                                                    func (*DB) LIndex

                                                                                                                                    func (db *DB) LIndex(key []byte, index int32) ([]byte, error)

                                                                                                                                      LIndex returns the value at index.

                                                                                                                                      func (*DB) LKeyExists

                                                                                                                                      func (db *DB) LKeyExists(key []byte) (int64, error)

                                                                                                                                        LKeyExists check list existed or not.

                                                                                                                                        func (*DB) LLen

                                                                                                                                        func (db *DB) LLen(key []byte) (int64, error)

                                                                                                                                          LLen gets the length of the list.

                                                                                                                                          func (*DB) LMclear

                                                                                                                                          func (db *DB) LMclear(keys ...[]byte) (int64, error)

                                                                                                                                            LMclear clears multi lists.

                                                                                                                                            func (*DB) LPersist

                                                                                                                                            func (db *DB) LPersist(key []byte) (int64, error)

                                                                                                                                              LPersist removes the TTL of list.

                                                                                                                                              func (*DB) LPop

                                                                                                                                              func (db *DB) LPop(key []byte) ([]byte, error)

                                                                                                                                                LPop pops the value.

                                                                                                                                                func (*DB) LPush

                                                                                                                                                func (db *DB) LPush(key []byte, args ...[]byte) (int64, error)

                                                                                                                                                  LPush push the value to the list.

                                                                                                                                                  func (*DB) LRange

                                                                                                                                                  func (db *DB) LRange(key []byte, start int32, stop int32) ([][]byte, error)

                                                                                                                                                    LRange gets the value of list at range.

                                                                                                                                                    func (*DB) LSet

                                                                                                                                                    func (db *DB) LSet(key []byte, index int32, value []byte) error

                                                                                                                                                      LSet sets the value at index.

                                                                                                                                                      func (*DB) LTTL

                                                                                                                                                      func (db *DB) LTTL(key []byte) (int64, error)

                                                                                                                                                        LTTL gets the TTL of list.

                                                                                                                                                        func (*DB) LTrim

                                                                                                                                                        func (db *DB) LTrim(key []byte, start, stop int64) error

                                                                                                                                                          LTrim trims the value from start to stop.

                                                                                                                                                          func (*DB) LTrimBack

                                                                                                                                                          func (db *DB) LTrimBack(key []byte, trimSize int32) (int32, error)

                                                                                                                                                            LTrimBack trims the value from back.

                                                                                                                                                            func (*DB) LTrimFront

                                                                                                                                                            func (db *DB) LTrimFront(key []byte, trimSize int32) (int32, error)

                                                                                                                                                              LTrimFront trims the value from top.

                                                                                                                                                              func (*DB) MGet

                                                                                                                                                              func (db *DB) MGet(keys ...[]byte) ([][]byte, error)

                                                                                                                                                                MGet gets multi data.

                                                                                                                                                                func (*DB) MSet

                                                                                                                                                                func (db *DB) MSet(args ...KVPair) error

                                                                                                                                                                  MSet sets multi data.

                                                                                                                                                                  func (*DB) Persist

                                                                                                                                                                  func (db *DB) Persist(key []byte) (int64, error)

                                                                                                                                                                    Persist removes the TTL of the data.

                                                                                                                                                                    func (*DB) RPop

                                                                                                                                                                    func (db *DB) RPop(key []byte) ([]byte, error)

                                                                                                                                                                      RPop rpops the value.

                                                                                                                                                                      func (*DB) RPush

                                                                                                                                                                      func (db *DB) RPush(key []byte, args ...[]byte) (int64, error)

                                                                                                                                                                        RPush rpushs the value .

                                                                                                                                                                        func (*DB) Restore

                                                                                                                                                                        func (db *DB) Restore(key []byte, ttl int64, data []byte) error

                                                                                                                                                                          Restore restores a key into database.

                                                                                                                                                                          func (*DB) RevScan

                                                                                                                                                                          func (db *DB) RevScan(dataType DataType, cursor []byte, count int, inclusive bool, match string) ([][]byte, error)

                                                                                                                                                                            RevScan scans the data reversed. if inclusive is true, revscan range (-inf, cursor] else (inf, cursor)

                                                                                                                                                                            func (*DB) SAdd

                                                                                                                                                                            func (db *DB) SAdd(key []byte, args ...[]byte) (int64, error)

                                                                                                                                                                              SAdd adds the value to the set.

                                                                                                                                                                              func (*DB) SCard

                                                                                                                                                                              func (db *DB) SCard(key []byte) (int64, error)

                                                                                                                                                                                SCard gets the size of set.

                                                                                                                                                                                func (*DB) SClear

                                                                                                                                                                                func (db *DB) SClear(key []byte) (int64, error)

                                                                                                                                                                                  SClear clears the set.

                                                                                                                                                                                  func (*DB) SDiff

                                                                                                                                                                                  func (db *DB) SDiff(keys ...[]byte) ([][]byte, error)

                                                                                                                                                                                    SDiff gets the different of sets.

                                                                                                                                                                                    func (*DB) SDiffStore

                                                                                                                                                                                    func (db *DB) SDiffStore(dstKey []byte, keys ...[]byte) (int64, error)

                                                                                                                                                                                      SDiffStore gets the different of sets and stores to dest set.

                                                                                                                                                                                      func (*DB) SDump

                                                                                                                                                                                      func (db *DB) SDump(key []byte) ([]byte, error)

                                                                                                                                                                                        SDump dumps the set value of key

                                                                                                                                                                                        func (*DB) SExpire

                                                                                                                                                                                        func (db *DB) SExpire(key []byte, duration int64) (int64, error)

                                                                                                                                                                                          SExpire expires the set.

                                                                                                                                                                                          func (*DB) SExpireAt

                                                                                                                                                                                          func (db *DB) SExpireAt(key []byte, when int64) (int64, error)

                                                                                                                                                                                            SExpireAt expires the set at when.

                                                                                                                                                                                            func (*DB) SInter

                                                                                                                                                                                            func (db *DB) SInter(keys ...[]byte) ([][]byte, error)

                                                                                                                                                                                              SInter intersects the sets.

                                                                                                                                                                                              func (*DB) SInterStore

                                                                                                                                                                                              func (db *DB) SInterStore(dstKey []byte, keys ...[]byte) (int64, error)

                                                                                                                                                                                                SInterStore intersects the sets and stores to dest set.

                                                                                                                                                                                                func (*DB) SIsMember

                                                                                                                                                                                                func (db *DB) SIsMember(key []byte, member []byte) (int64, error)

                                                                                                                                                                                                  SIsMember checks member in set.

                                                                                                                                                                                                  func (*DB) SKeyExists

                                                                                                                                                                                                  func (db *DB) SKeyExists(key []byte) (int64, error)

                                                                                                                                                                                                    SKeyExists checks whether set existed or not.

                                                                                                                                                                                                    func (*DB) SMclear

                                                                                                                                                                                                    func (db *DB) SMclear(keys ...[]byte) (int64, error)

                                                                                                                                                                                                      SMclear clears multi sets.

                                                                                                                                                                                                      func (*DB) SMembers

                                                                                                                                                                                                      func (db *DB) SMembers(key []byte) ([][]byte, error)

                                                                                                                                                                                                        SMembers gets members of set.

                                                                                                                                                                                                        func (*DB) SPersist

                                                                                                                                                                                                        func (db *DB) SPersist(key []byte) (int64, error)

                                                                                                                                                                                                          SPersist removes the TTL of set.

                                                                                                                                                                                                          func (*DB) SRem

                                                                                                                                                                                                          func (db *DB) SRem(key []byte, args ...[]byte) (int64, error)

                                                                                                                                                                                                            SRem removes the members of set.

                                                                                                                                                                                                            func (*DB) SRevScan

                                                                                                                                                                                                            func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error)

                                                                                                                                                                                                              SRevScan scans data reversed for set.

                                                                                                                                                                                                              func (*DB) SScan

                                                                                                                                                                                                              func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error)

                                                                                                                                                                                                                SScan scans data for set.

                                                                                                                                                                                                                func (*DB) STTL

                                                                                                                                                                                                                func (db *DB) STTL(key []byte) (int64, error)

                                                                                                                                                                                                                  STTL gets the TTL of set.

                                                                                                                                                                                                                  func (*DB) SUnion

                                                                                                                                                                                                                  func (db *DB) SUnion(keys ...[]byte) ([][]byte, error)

                                                                                                                                                                                                                    SUnion unions the sets.

                                                                                                                                                                                                                    func (*DB) SUnionStore

                                                                                                                                                                                                                    func (db *DB) SUnionStore(dstKey []byte, keys ...[]byte) (int64, error)

                                                                                                                                                                                                                      SUnionStore unions the sets and stores to the dest set.

                                                                                                                                                                                                                      func (*DB) Scan

                                                                                                                                                                                                                      func (db *DB) Scan(dataType DataType, cursor []byte, count int, inclusive bool, match string) ([][]byte, error)

                                                                                                                                                                                                                        Scan scans the data. If inclusive is true, scan range [cursor, inf) else (cursor, inf)

                                                                                                                                                                                                                        func (*DB) Set

                                                                                                                                                                                                                        func (db *DB) Set(key []byte, value []byte) error

                                                                                                                                                                                                                          Set sets the data.

                                                                                                                                                                                                                          func (*DB) SetBit

                                                                                                                                                                                                                          func (db *DB) SetBit(key []byte, offset int, on int) (int64, error)

                                                                                                                                                                                                                            SetBit sets the bit to the data.

                                                                                                                                                                                                                            func (*DB) SetEX

                                                                                                                                                                                                                            func (db *DB) SetEX(key []byte, duration int64, value []byte) error

                                                                                                                                                                                                                              SetEX sets the data with a TTL.

                                                                                                                                                                                                                              func (*DB) SetNX

                                                                                                                                                                                                                              func (db *DB) SetNX(key []byte, value []byte) (int64, error)

                                                                                                                                                                                                                                SetNX sets the data if not existed.

                                                                                                                                                                                                                                func (*DB) SetRange

                                                                                                                                                                                                                                func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error)

                                                                                                                                                                                                                                  SetRange sets the data with new value from offset.

                                                                                                                                                                                                                                  func (*DB) StrLen

                                                                                                                                                                                                                                  func (db *DB) StrLen(key []byte) (int64, error)

                                                                                                                                                                                                                                    StrLen returns the length of the data.

                                                                                                                                                                                                                                    func (*DB) TTL

                                                                                                                                                                                                                                    func (db *DB) TTL(key []byte) (int64, error)

                                                                                                                                                                                                                                      TTL returns the TTL of the data.

                                                                                                                                                                                                                                      func (*DB) XLSort

                                                                                                                                                                                                                                      func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error)

                                                                                                                                                                                                                                        XLSort sorts list.

                                                                                                                                                                                                                                        func (*DB) XSSort

                                                                                                                                                                                                                                        func (db *DB) XSSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error)

                                                                                                                                                                                                                                          XSSort sorts set.

                                                                                                                                                                                                                                          func (*DB) XZSort

                                                                                                                                                                                                                                          func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error)

                                                                                                                                                                                                                                            XZSort sorts zset.

                                                                                                                                                                                                                                            func (*DB) ZAdd

                                                                                                                                                                                                                                            func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error)

                                                                                                                                                                                                                                              ZAdd add the members.

                                                                                                                                                                                                                                              func (*DB) ZCard

                                                                                                                                                                                                                                              func (db *DB) ZCard(key []byte) (int64, error)

                                                                                                                                                                                                                                                ZCard gets the size of the zset.

                                                                                                                                                                                                                                                func (*DB) ZClear

                                                                                                                                                                                                                                                func (db *DB) ZClear(key []byte) (int64, error)

                                                                                                                                                                                                                                                  ZClear clears the zset.

                                                                                                                                                                                                                                                  func (*DB) ZCount

                                                                                                                                                                                                                                                  func (db *DB) ZCount(key []byte, min int64, max int64) (int64, error)

                                                                                                                                                                                                                                                    ZCount gets the number of score in [min, max]

                                                                                                                                                                                                                                                    func (*DB) ZDump

                                                                                                                                                                                                                                                    func (db *DB) ZDump(key []byte) ([]byte, error)

                                                                                                                                                                                                                                                      ZDump dumps the zset value of key

                                                                                                                                                                                                                                                      func (*DB) ZExpire

                                                                                                                                                                                                                                                      func (db *DB) ZExpire(key []byte, duration int64) (int64, error)

                                                                                                                                                                                                                                                        ZExpire expires the zset.

                                                                                                                                                                                                                                                        func (*DB) ZExpireAt

                                                                                                                                                                                                                                                        func (db *DB) ZExpireAt(key []byte, when int64) (int64, error)

                                                                                                                                                                                                                                                          ZExpireAt expires the zset at when.

                                                                                                                                                                                                                                                          func (*DB) ZIncrBy

                                                                                                                                                                                                                                                          func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error)

                                                                                                                                                                                                                                                            ZIncrBy increases the score of member with delta.

                                                                                                                                                                                                                                                            func (*DB) ZInterStore

                                                                                                                                                                                                                                                            func (db *DB) ZInterStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error)

                                                                                                                                                                                                                                                              ZInterStore intersects the zsets and stores to dest zset.

                                                                                                                                                                                                                                                              func (*DB) ZKeyExists

                                                                                                                                                                                                                                                              func (db *DB) ZKeyExists(key []byte) (int64, error)

                                                                                                                                                                                                                                                                ZKeyExists checks zset existed or not.

                                                                                                                                                                                                                                                                func (*DB) ZLexCount

                                                                                                                                                                                                                                                                func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error)

                                                                                                                                                                                                                                                                  ZLexCount gets the count of zset lexicographically.

                                                                                                                                                                                                                                                                  func (*DB) ZMclear

                                                                                                                                                                                                                                                                  func (db *DB) ZMclear(keys ...[]byte) (int64, error)

                                                                                                                                                                                                                                                                    ZMclear clears multi zsets.

                                                                                                                                                                                                                                                                    func (*DB) ZPersist

                                                                                                                                                                                                                                                                    func (db *DB) ZPersist(key []byte) (int64, error)

                                                                                                                                                                                                                                                                      ZPersist removes the TTL of zset.

                                                                                                                                                                                                                                                                      func (*DB) ZRange

                                                                                                                                                                                                                                                                      func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error)

                                                                                                                                                                                                                                                                        ZRange gets the members from start to stop.

                                                                                                                                                                                                                                                                        func (*DB) ZRangeByLex

                                                                                                                                                                                                                                                                        func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error)

                                                                                                                                                                                                                                                                          ZRangeByLex scans the zset lexicographically

                                                                                                                                                                                                                                                                          func (*DB) ZRangeByScore

                                                                                                                                                                                                                                                                          func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
                                                                                                                                                                                                                                                                          	offset int, count int) ([]ScorePair, error)

                                                                                                                                                                                                                                                                            ZRangeByScore gets the data with score in min and max. min and max must be inclusive if no limit, set offset = 0 and count = -1

                                                                                                                                                                                                                                                                            func (*DB) ZRangeByScoreGeneric

                                                                                                                                                                                                                                                                            func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
                                                                                                                                                                                                                                                                            	offset int, count int, reverse bool) ([]ScorePair, error)

                                                                                                                                                                                                                                                                              ZRangeByScoreGeneric is a generic function to scan zset with score. min and max must be inclusive if no limit, set offset = 0 and count = -1

                                                                                                                                                                                                                                                                              func (*DB) ZRangeGeneric

                                                                                                                                                                                                                                                                              func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error)

                                                                                                                                                                                                                                                                                ZRangeGeneric is a generic function for scan zset.

                                                                                                                                                                                                                                                                                func (*DB) ZRank

                                                                                                                                                                                                                                                                                func (db *DB) ZRank(key []byte, member []byte) (int64, error)

                                                                                                                                                                                                                                                                                  ZRank gets the rank of member.

                                                                                                                                                                                                                                                                                  func (*DB) ZRem

                                                                                                                                                                                                                                                                                  func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error)

                                                                                                                                                                                                                                                                                    ZRem removes members

                                                                                                                                                                                                                                                                                    func (*DB) ZRemRangeByLex

                                                                                                                                                                                                                                                                                    func (db *DB) ZRemRangeByLex(key []byte, min []byte, max []byte, rangeType uint8) (int64, error)

                                                                                                                                                                                                                                                                                      ZRemRangeByLex remvoes members in [min, max] lexicographically

                                                                                                                                                                                                                                                                                      func (*DB) ZRemRangeByRank

                                                                                                                                                                                                                                                                                      func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error)

                                                                                                                                                                                                                                                                                        ZRemRangeByRank removes the member at range from start to stop.

                                                                                                                                                                                                                                                                                        func (*DB) ZRemRangeByScore

                                                                                                                                                                                                                                                                                        func (db *DB) ZRemRangeByScore(key []byte, min int64, max int64) (int64, error)

                                                                                                                                                                                                                                                                                          ZRemRangeByScore removes the data with score at [min, max]

                                                                                                                                                                                                                                                                                          func (*DB) ZRevRange

                                                                                                                                                                                                                                                                                          func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error)

                                                                                                                                                                                                                                                                                            ZRevRange gets the data reversed.

                                                                                                                                                                                                                                                                                            func (*DB) ZRevRangeByScore

                                                                                                                                                                                                                                                                                            func (db *DB) ZRevRangeByScore(key []byte, min int64, max int64, offset int, count int) ([]ScorePair, error)

                                                                                                                                                                                                                                                                                              ZRevRangeByScore gets the data with score at [min, max] min and max must be inclusive if no limit, set offset = 0 and count = -1

                                                                                                                                                                                                                                                                                              func (*DB) ZRevRank

                                                                                                                                                                                                                                                                                              func (db *DB) ZRevRank(key []byte, member []byte) (int64, error)

                                                                                                                                                                                                                                                                                                ZRevRank gets the rank of member reversed.

                                                                                                                                                                                                                                                                                                func (*DB) ZRevScan

                                                                                                                                                                                                                                                                                                func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error)

                                                                                                                                                                                                                                                                                                  ZRevScan scans data reversed for zset.

                                                                                                                                                                                                                                                                                                  func (*DB) ZScan

                                                                                                                                                                                                                                                                                                  func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error)

                                                                                                                                                                                                                                                                                                    ZScan scans data for zset.

                                                                                                                                                                                                                                                                                                    func (*DB) ZScore

                                                                                                                                                                                                                                                                                                    func (db *DB) ZScore(key []byte, member []byte) (int64, error)

                                                                                                                                                                                                                                                                                                      ZScore gets the score of member.

                                                                                                                                                                                                                                                                                                      func (*DB) ZTTL

                                                                                                                                                                                                                                                                                                      func (db *DB) ZTTL(key []byte) (int64, error)

                                                                                                                                                                                                                                                                                                        ZTTL gets the TTL of zset.

                                                                                                                                                                                                                                                                                                        func (*DB) ZUnionStore

                                                                                                                                                                                                                                                                                                        func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error)

                                                                                                                                                                                                                                                                                                          ZUnionStore unions the zsets and stores to dest zset.

                                                                                                                                                                                                                                                                                                          type DataType

                                                                                                                                                                                                                                                                                                          type DataType byte

                                                                                                                                                                                                                                                                                                            DataType is defined for the different types

                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                            	KV DataType = iota

                                                                                                                                                                                                                                                                                                              for out use

                                                                                                                                                                                                                                                                                                              func (DataType) String

                                                                                                                                                                                                                                                                                                              func (d DataType) String() string

                                                                                                                                                                                                                                                                                                              type DumpHead

                                                                                                                                                                                                                                                                                                              type DumpHead struct {
                                                                                                                                                                                                                                                                                                              	CommitID uint64

                                                                                                                                                                                                                                                                                                                DumpHead is the head of a dump.

                                                                                                                                                                                                                                                                                                                func (*DumpHead) Read

                                                                                                                                                                                                                                                                                                                func (h *DumpHead) Read(r io.Reader) error

                                                                                                                                                                                                                                                                                                                  Read reads meta from the Reader.

                                                                                                                                                                                                                                                                                                                  func (*DumpHead) Write

                                                                                                                                                                                                                                                                                                                  func (h *DumpHead) Write(w io.Writer) error

                                                                                                                                                                                                                                                                                                                    Write writes meta to the Writer

                                                                                                                                                                                                                                                                                                                    type FVPair

                                                                                                                                                                                                                                                                                                                    type FVPair struct {
                                                                                                                                                                                                                                                                                                                    	Field []byte
                                                                                                                                                                                                                                                                                                                    	Value []byte

                                                                                                                                                                                                                                                                                                                      FVPair is the pair of field and value.

                                                                                                                                                                                                                                                                                                                      type KVPair

                                                                                                                                                                                                                                                                                                                      type KVPair struct {
                                                                                                                                                                                                                                                                                                                      	Key   []byte
                                                                                                                                                                                                                                                                                                                      	Value []byte

                                                                                                                                                                                                                                                                                                                        KVPair is the pair of key-value.

                                                                                                                                                                                                                                                                                                                        type Ledis

                                                                                                                                                                                                                                                                                                                        type Ledis struct {
                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields

                                                                                                                                                                                                                                                                                                                          Ledis is the core structure to handle the database.

                                                                                                                                                                                                                                                                                                                          func Open

                                                                                                                                                                                                                                                                                                                          func Open(cfg *config.Config) (*Ledis, error)

                                                                                                                                                                                                                                                                                                                            Open opens the Ledis with a config.

                                                                                                                                                                                                                                                                                                                            func (*Ledis) AddNewLogEventHandler

                                                                                                                                                                                                                                                                                                                            func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error

                                                                                                                                                                                                                                                                                                                              AddNewLogEventHandler adds the handler for the new log event

                                                                                                                                                                                                                                                                                                                              func (*Ledis) Close

                                                                                                                                                                                                                                                                                                                              func (l *Ledis) Close()

                                                                                                                                                                                                                                                                                                                                Close closes the Ledis.

                                                                                                                                                                                                                                                                                                                                func (*Ledis) CompactStore

                                                                                                                                                                                                                                                                                                                                func (l *Ledis) CompactStore() error

                                                                                                                                                                                                                                                                                                                                  CompactStore compacts the backend storage.

                                                                                                                                                                                                                                                                                                                                  func (*Ledis) Dump

                                                                                                                                                                                                                                                                                                                                  func (l *Ledis) Dump(w io.Writer) error

                                                                                                                                                                                                                                                                                                                                    Dump dumps data to the Writer.

                                                                                                                                                                                                                                                                                                                                    func (*Ledis) DumpFile

                                                                                                                                                                                                                                                                                                                                    func (l *Ledis) DumpFile(path string) error

                                                                                                                                                                                                                                                                                                                                      DumpFile dumps data to the file

                                                                                                                                                                                                                                                                                                                                      func (*Ledis) FlushAll

                                                                                                                                                                                                                                                                                                                                      func (l *Ledis) FlushAll() error

                                                                                                                                                                                                                                                                                                                                        FlushAll will clear all data and replication logs

                                                                                                                                                                                                                                                                                                                                        func (*Ledis) IsReadOnly

                                                                                                                                                                                                                                                                                                                                        func (l *Ledis) IsReadOnly() bool

                                                                                                                                                                                                                                                                                                                                          IsReadOnly returns whether Ledis is read only or not.

                                                                                                                                                                                                                                                                                                                                          func (*Ledis) LoadDump

                                                                                                                                                                                                                                                                                                                                          func (l *Ledis) LoadDump(r io.Reader) (*DumpHead, error)

                                                                                                                                                                                                                                                                                                                                            LoadDump clears all data and loads dump file to db

                                                                                                                                                                                                                                                                                                                                            func (*Ledis) LoadDumpFile

                                                                                                                                                                                                                                                                                                                                            func (l *Ledis) LoadDumpFile(path string) (*DumpHead, error)

                                                                                                                                                                                                                                                                                                                                              LoadDumpFile clears all data and loads dump file to db

                                                                                                                                                                                                                                                                                                                                              func (*Ledis) ReadLogsTo

                                                                                                                                                                                                                                                                                                                                              func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error)

                                                                                                                                                                                                                                                                                                                                                ReadLogsTo reads logs and write to the Writer.

                                                                                                                                                                                                                                                                                                                                                func (*Ledis) ReadLogsToTimeout

                                                                                                                                                                                                                                                                                                                                                func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error)

                                                                                                                                                                                                                                                                                                                                                  ReadLogsToTimeout tries to read events, if no events read, tres to wait the new event singal until timeout seconds

                                                                                                                                                                                                                                                                                                                                                  func (*Ledis) ReplicationStat

                                                                                                                                                                                                                                                                                                                                                  func (l *Ledis) ReplicationStat() (*rpl.Stat, error)

                                                                                                                                                                                                                                                                                                                                                    ReplicationStat returns the statistics of repliaciton.

                                                                                                                                                                                                                                                                                                                                                    func (*Ledis) ReplicationUsed

                                                                                                                                                                                                                                                                                                                                                    func (l *Ledis) ReplicationUsed() bool

                                                                                                                                                                                                                                                                                                                                                      ReplicationUsed returns whether replication is used or not.

                                                                                                                                                                                                                                                                                                                                                      func (*Ledis) Select

                                                                                                                                                                                                                                                                                                                                                      func (l *Ledis) Select(index int) (*DB, error)

                                                                                                                                                                                                                                                                                                                                                        Select chooses a database.

                                                                                                                                                                                                                                                                                                                                                        func (*Ledis) StoreLogsFromData

                                                                                                                                                                                                                                                                                                                                                        func (l *Ledis) StoreLogsFromData(data []byte) error

                                                                                                                                                                                                                                                                                                                                                          StoreLogsFromData stores logs from data.

                                                                                                                                                                                                                                                                                                                                                          func (*Ledis) StoreLogsFromReader

                                                                                                                                                                                                                                                                                                                                                          func (l *Ledis) StoreLogsFromReader(rb io.Reader) error

                                                                                                                                                                                                                                                                                                                                                            StoreLogsFromReader stores logs from the Reader

                                                                                                                                                                                                                                                                                                                                                            func (*Ledis) StoreStat

                                                                                                                                                                                                                                                                                                                                                            func (l *Ledis) StoreStat() *store.Stat

                                                                                                                                                                                                                                                                                                                                                              StoreStat returns the statistics.

                                                                                                                                                                                                                                                                                                                                                              func (*Ledis) WaitReplication

                                                                                                                                                                                                                                                                                                                                                              func (l *Ledis) WaitReplication() error

                                                                                                                                                                                                                                                                                                                                                                WaitReplication waits replication done

                                                                                                                                                                                                                                                                                                                                                                type Limit

                                                                                                                                                                                                                                                                                                                                                                type Limit struct {
                                                                                                                                                                                                                                                                                                                                                                	Offset int
                                                                                                                                                                                                                                                                                                                                                                	Size   int

                                                                                                                                                                                                                                                                                                                                                                  Limit is for sort.

                                                                                                                                                                                                                                                                                                                                                                  type NewLogEventHandler

                                                                                                                                                                                                                                                                                                                                                                  type NewLogEventHandler func(rl *rpl.Log)

                                                                                                                                                                                                                                                                                                                                                                    NewLogEventHandler is the handler to handle new log event.

                                                                                                                                                                                                                                                                                                                                                                    type ScorePair

                                                                                                                                                                                                                                                                                                                                                                    type ScorePair struct {
                                                                                                                                                                                                                                                                                                                                                                    	Score  int64
                                                                                                                                                                                                                                                                                                                                                                    	Member []byte

                                                                                                                                                                                                                                                                                                                                                                      ScorePair is the pair of score and member.