repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
siddontang/ledisdb | ledis/t_set.go | SUnionStore | func (db *DB) SUnionStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, UnionType, keys...)
return n, err
} | go | func (db *DB) SUnionStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, UnionType, keys...)
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SUnionStore",
"(",
"dstKey",
"[",
"]",
"byte",
",",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"db",
".",
"sStoreGeneric",
"(",
"dstKey",
",",
"UnionType"... | // SUnionStore unions the sets and stores to the dest set. | [
"SUnionStore",
"unions",
"the",
"sets",
"and",
"stores",
"to",
"the",
"dest",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L506-L509 | train |
siddontang/ledisdb | ledis/t_set.go | SClear | func (db *DB) SClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
num := db.sDelete(t, key)
db.rmExpire(t, SetType, key)
err := t.Commit()
return num, err
} | go | func (db *DB) SClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
num := db.sDelete(t, key)
db.rmExpire(t, SetType, key)
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n"... | // SClear clears the set. | [
"SClear",
"clears",
"the",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L564-L578 | train |
siddontang/ledisdb | ledis/t_set.go | SMclear | func (db *DB) SMclear(keys ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.sDelete(t, key)
db.rmExpire(t, SetType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) SMclear(keys ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.sDelete(t, key)
db.rmExpire(t, SetType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
... | // SMclear clears multi sets. | [
"SMclear",
"clears",
"multi",
"sets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L581-L597 | train |
siddontang/ledisdb | ledis/t_set.go | SExpire | func (db *DB) SExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.sExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) SExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.sExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n",
"return",
"d... | // SExpire expries the set. | [
"SExpire",
"expries",
"the",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L600-L607 | train |
siddontang/ledisdb | ledis/t_set.go | SExpireAt | func (db *DB) SExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.sExpireAt(key, when)
} | go | func (db *DB) SExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.sExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // SExpireAt expires the set at when. | [
"SExpireAt",
"expires",
"the",
"set",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L610-L617 | train |
siddontang/ledisdb | ledis/t_set.go | STTL | func (db *DB) STTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(SetType, key)
} | go | func (db *DB) STTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(SetType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"STTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // STTL gets the TTL of set. | [
"STTL",
"gets",
"the",
"TTL",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L620-L626 | train |
siddontang/ledisdb | ledis/t_set.go | SPersist | func (db *DB) SPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, SetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) SPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, SetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\... | // SPersist removes the TTL of set. | [
"SPersist",
"removes",
"the",
"TTL",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L629-L644 | train |
siddontang/ledisdb | ledis/ledis.go | Open | func Open(cfg *config.Config) (*Ledis, error) {
if len(cfg.DataDir) == 0 {
cfg.DataDir = config.DefaultDataDir
}
if cfg.Databases == 0 {
cfg.Databases = 16
} else if cfg.Databases > MaxDatabases {
cfg.Databases = MaxDatabases
}
os.MkdirAll(cfg.DataDir, 0755)
var err error
l := new(Ledis)
l.cfg = cfg
if l.lock, err = filelock.Lock(path.Join(cfg.DataDir, "LOCK")); err != nil {
return nil, err
}
l.quit = make(chan struct{})
if l.ldb, err = store.Open(cfg); err != nil {
return nil, err
}
if cfg.UseReplication {
if l.r, err = rpl.NewReplication(cfg); err != nil {
return nil, err
}
l.rc = make(chan struct{}, 1)
l.rbatch = l.ldb.NewWriteBatch()
l.rDoneCh = make(chan struct{}, 1)
l.wg.Add(1)
go l.onReplication()
//first we must try wait all replication ok
//maybe some logs are not committed
l.WaitReplication()
} else {
l.r = nil
}
l.dbs = make(map[int]*DB, 16)
l.checkTTL()
return l, nil
} | go | func Open(cfg *config.Config) (*Ledis, error) {
if len(cfg.DataDir) == 0 {
cfg.DataDir = config.DefaultDataDir
}
if cfg.Databases == 0 {
cfg.Databases = 16
} else if cfg.Databases > MaxDatabases {
cfg.Databases = MaxDatabases
}
os.MkdirAll(cfg.DataDir, 0755)
var err error
l := new(Ledis)
l.cfg = cfg
if l.lock, err = filelock.Lock(path.Join(cfg.DataDir, "LOCK")); err != nil {
return nil, err
}
l.quit = make(chan struct{})
if l.ldb, err = store.Open(cfg); err != nil {
return nil, err
}
if cfg.UseReplication {
if l.r, err = rpl.NewReplication(cfg); err != nil {
return nil, err
}
l.rc = make(chan struct{}, 1)
l.rbatch = l.ldb.NewWriteBatch()
l.rDoneCh = make(chan struct{}, 1)
l.wg.Add(1)
go l.onReplication()
//first we must try wait all replication ok
//maybe some logs are not committed
l.WaitReplication()
} else {
l.r = nil
}
l.dbs = make(map[int]*DB, 16)
l.checkTTL()
return l, nil
} | [
"func",
"Open",
"(",
"cfg",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"Ledis",
",",
"error",
")",
"{",
"if",
"len",
"(",
"cfg",
".",
"DataDir",
")",
"==",
"0",
"{",
"cfg",
".",
"DataDir",
"=",
"config",
".",
"DefaultDataDir",
"\n",
"}",
"\n",
... | // Open opens the Ledis with a config. | [
"Open",
"opens",
"the",
"Ledis",
"with",
"a",
"config",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L47-L99 | train |
siddontang/ledisdb | ledis/ledis.go | Close | func (l *Ledis) Close() {
close(l.quit)
l.wg.Wait()
l.ldb.Close()
if l.r != nil {
l.r.Close()
//l.r = nil
}
if l.lock != nil {
l.lock.Close()
//l.lock = nil
}
} | go | func (l *Ledis) Close() {
close(l.quit)
l.wg.Wait()
l.ldb.Close()
if l.r != nil {
l.r.Close()
//l.r = nil
}
if l.lock != nil {
l.lock.Close()
//l.lock = nil
}
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"Close",
"(",
")",
"{",
"close",
"(",
"l",
".",
"quit",
")",
"\n",
"l",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"l",
".",
"ldb",
".",
"Close",
"(",
")",
"\n",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"... | // Close closes the Ledis. | [
"Close",
"closes",
"the",
"Ledis",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L102-L117 | train |
siddontang/ledisdb | ledis/ledis.go | Select | func (l *Ledis) Select(index int) (*DB, error) {
if index < 0 || index >= l.cfg.Databases {
return nil, fmt.Errorf("invalid db index %d, must in [0, %d]", index, l.cfg.Databases-1)
}
l.dbLock.Lock()
defer l.dbLock.Unlock()
db, ok := l.dbs[index]
if ok {
return db, nil
}
db = l.newDB(index)
l.dbs[index] = db
go func(db *DB) {
l.ttlCheckerCh <- db.ttlChecker
}(db)
return db, nil
} | go | func (l *Ledis) Select(index int) (*DB, error) {
if index < 0 || index >= l.cfg.Databases {
return nil, fmt.Errorf("invalid db index %d, must in [0, %d]", index, l.cfg.Databases-1)
}
l.dbLock.Lock()
defer l.dbLock.Unlock()
db, ok := l.dbs[index]
if ok {
return db, nil
}
db = l.newDB(index)
l.dbs[index] = db
go func(db *DB) {
l.ttlCheckerCh <- db.ttlChecker
}(db)
return db, nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"Select",
"(",
"index",
"int",
")",
"(",
"*",
"DB",
",",
"error",
")",
"{",
"if",
"index",
"<",
"0",
"||",
"index",
">=",
"l",
".",
"cfg",
".",
"Databases",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
... | // Select chooses a database. | [
"Select",
"chooses",
"a",
"database",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L120-L141 | train |
siddontang/ledisdb | ledis/ledis.go | FlushAll | func (l *Ledis) FlushAll() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.flushAll()
} | go | func (l *Ledis) FlushAll() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.flushAll()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"FlushAll",
"(",
")",
"error",
"{",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"l",
".",
"flushAll",
"(",
")",
"\n",
"}"
] | // FlushAll will clear all data and replication logs | [
"FlushAll",
"will",
"clear",
"all",
"data",
"and",
"replication",
"logs"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L144-L149 | train |
siddontang/ledisdb | ledis/ledis.go | IsReadOnly | func (l *Ledis) IsReadOnly() bool {
if l.cfg.GetReadonly() {
return true
} else if l.r != nil {
if b, _ := l.r.CommitIDBehind(); b {
return true
}
}
return false
} | go | func (l *Ledis) IsReadOnly() bool {
if l.cfg.GetReadonly() {
return true
} else if l.r != nil {
if b, _ := l.r.CommitIDBehind(); b {
return true
}
}
return false
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"IsReadOnly",
"(",
")",
"bool",
"{",
"if",
"l",
".",
"cfg",
".",
"GetReadonly",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"else",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"if",
"b",
",",
"_",
":=",
"l",
... | // IsReadOnly returns whether Ledis is read only or not. | [
"IsReadOnly",
"returns",
"whether",
"Ledis",
"is",
"read",
"only",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L189-L198 | train |
siddontang/ledisdb | ledis/ledis.go | CompactStore | func (l *Ledis) CompactStore() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.ldb.Compact()
} | go | func (l *Ledis) CompactStore() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.ldb.Compact()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"CompactStore",
"(",
")",
"error",
"{",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"l",
".",
"ldb",
".",
"Compact",
"(",
")",
"\n",
... | // CompactStore compacts the backend storage. | [
"CompactStore",
"compacts",
"the",
"backend",
"storage",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L243-L248 | train |
siddontang/ledisdb | store/iterator.go | Key | func (it *Iterator) Key() []byte {
k := it.it.Key()
if k == nil {
return nil
}
return append([]byte{}, k...)
} | go | func (it *Iterator) Key() []byte {
k := it.it.Key()
if k == nil {
return nil
}
return append([]byte{}, k...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Key",
"(",
")",
"[",
"]",
"byte",
"{",
"k",
":=",
"it",
".",
"it",
".",
"Key",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"append",
"(",
"[",
"]",
"byte... | // Returns a copy of key. | [
"Returns",
"a",
"copy",
"of",
"key",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L48-L55 | train |
siddontang/ledisdb | store/iterator.go | Value | func (it *Iterator) Value() []byte {
v := it.it.Value()
if v == nil {
return nil
}
return append([]byte{}, v...)
} | go | func (it *Iterator) Value() []byte {
v := it.it.Value()
if v == nil {
return nil
}
return append([]byte{}, v...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Value",
"(",
")",
"[",
"]",
"byte",
"{",
"v",
":=",
"it",
".",
"it",
".",
"Value",
"(",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"append",
"(",
"[",
"]",
"... | // Returns a copy of value. | [
"Returns",
"a",
"copy",
"of",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L58-L65 | train |
siddontang/ledisdb | store/iterator.go | BufKey | func (it *Iterator) BufKey(b []byte) []byte {
k := it.RawKey()
if k == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, k...)
} | go | func (it *Iterator) BufKey(b []byte) []byte {
k := it.RawKey()
if k == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, k...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"BufKey",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"b",
"==",
"nil"... | // Copy key to b, if b len is small or nil, returns a new one. | [
"Copy",
"key",
"to",
"b",
"if",
"b",
"len",
"is",
"small",
"or",
"nil",
"returns",
"a",
"new",
"one",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L80-L91 | train |
siddontang/ledisdb | store/iterator.go | BufValue | func (it *Iterator) BufValue(b []byte) []byte {
v := it.RawValue()
if v == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, v...)
} | go | func (it *Iterator) BufValue(b []byte) []byte {
v := it.RawValue()
if v == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, v...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"BufValue",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"v",
":=",
"it",
".",
"RawValue",
"(",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"b",
"==",
"... | // Copy value to b, if b len is small or nil, returns a new one. | [
"Copy",
"value",
"to",
"b",
"if",
"b",
"len",
"is",
"small",
"or",
"nil",
"returns",
"a",
"new",
"one",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L94-L106 | train |
siddontang/ledisdb | store/iterator.go | Find | func (it *Iterator) Find(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.Value()
}
}
return nil
} | go | func (it *Iterator) Find(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.Value()
}
}
return nil
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Find",
"(",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"it",
".",
"Seek",
"(",
"key",
")",
"\n",
"if",
"it",
".",
"Valid",
"(",
")",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",
... | // Finds by key, if not found, nil returns. | [
"Finds",
"by",
"key",
"if",
"not",
"found",
"nil",
"returns",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L146-L158 | train |
siddontang/ledisdb | store/iterator.go | RawFind | func (it *Iterator) RawFind(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.RawValue()
}
}
return nil
} | go | func (it *Iterator) RawFind(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.RawValue()
}
}
return nil
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"RawFind",
"(",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"it",
".",
"Seek",
"(",
"key",
")",
"\n",
"if",
"it",
".",
"Valid",
"(",
")",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",... | // Finds by key, if not found, nil returns, else a reference of value returns.
// you must be careful that it will be changed after next iterate. | [
"Finds",
"by",
"key",
"if",
"not",
"found",
"nil",
"returns",
"else",
"a",
"reference",
"of",
"value",
"returns",
".",
"you",
"must",
"be",
"careful",
"that",
"it",
"will",
"be",
"changed",
"after",
"next",
"iterate",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L162-L174 | train |
siddontang/ledisdb | ledis/t_kv.go | Decr | func (db *DB) Decr(key []byte) (int64, error) {
return db.incr(key, -1)
} | go | func (db *DB) Decr(key []byte) (int64, error) {
return db.incr(key, -1)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Decr",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"-",
"1",
")",
"\n",
"}"
] | // Decr decreases the data. | [
"Decr",
"decreases",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L124-L126 | train |
siddontang/ledisdb | ledis/t_kv.go | DecrBy | func (db *DB) DecrBy(key []byte, decrement int64) (int64, error) {
return db.incr(key, -decrement)
} | go | func (db *DB) DecrBy(key []byte, decrement int64) (int64, error) {
return db.incr(key, -decrement)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"DecrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"decrement",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"-",
"decrement",
")",
"\n",
"}"
] | // DecrBy decreases the data by decrement. | [
"DecrBy",
"decreases",
"the",
"data",
"by",
"decrement",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L129-L131 | train |
siddontang/ledisdb | ledis/t_kv.go | Del | func (db *DB) Del(keys ...[]byte) (int64, error) {
if len(keys) == 0 {
return 0, nil
}
codedKeys := make([][]byte, len(keys))
for i, k := range keys {
codedKeys[i] = db.encodeKVKey(k)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
for i, k := range keys {
t.Delete(codedKeys[i])
db.rmExpire(t, KVType, k)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) Del(keys ...[]byte) (int64, error) {
if len(keys) == 0 {
return 0, nil
}
codedKeys := make([][]byte, len(keys))
for i, k := range keys {
codedKeys[i] = db.encodeKVKey(k)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
for i, k := range keys {
t.Delete(codedKeys[i])
db.rmExpire(t, KVType, k)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Del",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n",
"codedKeys",
":=",
"make",
... | // Del deletes the data. | [
"Del",
"deletes",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L134-L155 | train |
siddontang/ledisdb | ledis/t_kv.go | Exists | func (db *DB) Exists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var v []byte
v, err = db.bucket.Get(key)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) Exists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var v []byte
v, err = db.bucket.Get(key)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Exists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n"... | // Exists check data exists or not. | [
"Exists",
"check",
"data",
"exists",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L158-L173 | train |
siddontang/ledisdb | ledis/t_kv.go | Get | func (db *DB) Get(key []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.Get(key)
} | go | func (db *DB) Get(key []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.Get(key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
... | // Get gets the value. | [
"Get",
"gets",
"the",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L176-L184 | train |
siddontang/ledisdb | ledis/t_kv.go | GetSlice | func (db *DB) GetSlice(key []byte) (store.Slice, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.GetSlice(key)
} | go | func (db *DB) GetSlice(key []byte) (store.Slice, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.GetSlice(key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetSlice",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"store",
".",
"Slice",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",... | // GetSlice gets the slice of the data. | [
"GetSlice",
"gets",
"the",
"slice",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L187-L195 | train |
siddontang/ledisdb | ledis/t_kv.go | GetSet | func (db *DB) GetSet(key []byte, value []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
} else if err := checkValueSize(value); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
t.Put(key, value)
err = t.Commit()
return oldValue, err
} | go | func (db *DB) GetSet(key []byte, value []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
} else if err := checkValueSize(value); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
t.Put(key, value)
err = t.Commit()
return oldValue, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetSet",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
... | // GetSet gets the value and sets new value. | [
"GetSet",
"gets",
"the",
"value",
"and",
"sets",
"new",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L198-L222 | train |
siddontang/ledisdb | ledis/t_kv.go | Incr | func (db *DB) Incr(key []byte) (int64, error) {
return db.incr(key, 1)
} | go | func (db *DB) Incr(key []byte) (int64, error) {
return db.incr(key, 1)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Incr",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"1",
")",
"\n",
"}"
] | // Incr increases the data. | [
"Incr",
"increases",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L225-L227 | train |
siddontang/ledisdb | ledis/t_kv.go | IncrBy | func (db *DB) IncrBy(key []byte, increment int64) (int64, error) {
return db.incr(key, increment)
} | go | func (db *DB) IncrBy(key []byte, increment int64) (int64, error) {
return db.incr(key, increment)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"IncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"increment",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"increment",
")",
"\n",
"}"
] | // IncrBy increases the data by increment. | [
"IncrBy",
"increases",
"the",
"data",
"by",
"increment",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L230-L232 | train |
siddontang/ledisdb | ledis/t_kv.go | MGet | func (db *DB) MGet(keys ...[]byte) ([][]byte, error) {
values := make([][]byte, len(keys))
it := db.bucket.NewIterator()
defer it.Close()
for i := range keys {
if err := checkKeySize(keys[i]); err != nil {
return nil, err
}
values[i] = it.Find(db.encodeKVKey(keys[i]))
}
return values, nil
} | go | func (db *DB) MGet(keys ...[]byte) ([][]byte, error) {
values := make([][]byte, len(keys))
it := db.bucket.NewIterator()
defer it.Close()
for i := range keys {
if err := checkKeySize(keys[i]); err != nil {
return nil, err
}
values[i] = it.Find(db.encodeKVKey(keys[i]))
}
return values, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"MGet",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"values",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"keys",
")",
")",
"\n... | // MGet gets multi data. | [
"MGet",
"gets",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L235-L250 | train |
siddontang/ledisdb | ledis/t_kv.go | MSet | func (db *DB) MSet(args ...KVPair) error {
if len(args) == 0 {
return nil
}
t := db.kvBatch
var err error
var key []byte
var value []byte
t.Lock()
defer t.Unlock()
for i := 0; i < len(args); i++ {
if err := checkKeySize(args[i].Key); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil {
return err
}
key = db.encodeKVKey(args[i].Key)
value = args[i].Value
t.Put(key, value)
}
err = t.Commit()
return err
} | go | func (db *DB) MSet(args ...KVPair) error {
if len(args) == 0 {
return nil
}
t := db.kvBatch
var err error
var key []byte
var value []byte
t.Lock()
defer t.Unlock()
for i := 0; i < len(args); i++ {
if err := checkKeySize(args[i].Key); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil {
return err
}
key = db.encodeKVKey(args[i].Key)
value = args[i].Value
t.Put(key, value)
}
err = t.Commit()
return err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"MSet",
"(",
"args",
"...",
"KVPair",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n",
"var",
"err",
"error",
"\n",
"... | // MSet sets multi data. | [
"MSet",
"sets",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L253-L284 | train |
siddontang/ledisdb | ledis/t_kv.go | Set | func (db *DB) Set(key []byte, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
}
var err error
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
err = t.Commit()
return err
} | go | func (db *DB) Set(key []byte, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
}
var err error
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
err = t.Commit()
return err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Set",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"... | // Set sets the data. | [
"Set",
"sets",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L287-L307 | train |
siddontang/ledisdb | ledis/t_kv.go | SetNX | func (db *DB) SetNX(key []byte, value []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var n int64 = 1
t := db.kvBatch
t.Lock()
defer t.Unlock()
if v, err := db.bucket.Get(key); err != nil {
return 0, err
} else if v != nil {
n = 0
} else {
t.Put(key, value)
err = t.Commit()
}
return n, err
} | go | func (db *DB) SetNX(key []byte, value []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var n int64 = 1
t := db.kvBatch
t.Lock()
defer t.Unlock()
if v, err := db.bucket.Get(key); err != nil {
return 0, err
} else if v != nil {
n = 0
} else {
t.Put(key, value)
err = t.Commit()
}
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetNX",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"... | // SetNX sets the data if not existed. | [
"SetNX",
"sets",
"the",
"data",
"if",
"not",
"existed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L310-L338 | train |
siddontang/ledisdb | ledis/t_kv.go | SetEX | func (db *DB) SetEX(key []byte, duration int64, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
} else if duration <= 0 {
return errExpireValue
}
ek := db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(ek, value)
db.expireAt(t, KVType, key, time.Now().Unix()+duration)
return t.Commit()
} | go | func (db *DB) SetEX(key []byte, duration int64, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
} else if duration <= 0 {
return errExpireValue
}
ek := db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(ek, value)
db.expireAt(t, KVType, key, time.Now().Unix()+duration)
return t.Commit()
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetEX",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"... | // SetEX sets the data with a TTL. | [
"SetEX",
"sets",
"the",
"data",
"with",
"a",
"TTL",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L341-L361 | train |
siddontang/ledisdb | ledis/t_kv.go | Expire | func (db *DB) Expire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.setExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) Expire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.setExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Expire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n",
"return",
"db... | // Expire expires the data. | [
"Expire",
"expires",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L371-L377 | train |
siddontang/ledisdb | ledis/t_kv.go | ExpireAt | func (db *DB) ExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.setExpireAt(key, when)
} | go | func (db *DB) ExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.setExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // ExpireAt expires the data at when. | [
"ExpireAt",
"expires",
"the",
"data",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L380-L386 | train |
siddontang/ledisdb | ledis/t_kv.go | TTL | func (db *DB) TTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(KVType, key)
} | go | func (db *DB) TTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(KVType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"TTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // TTL returns the TTL of the data. | [
"TTL",
"returns",
"the",
"TTL",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L389-L395 | train |
siddontang/ledisdb | ledis/t_kv.go | Persist | func (db *DB) Persist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, KVType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) Persist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, KVType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Persist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n... | // Persist removes the TTL of the data. | [
"Persist",
"removes",
"the",
"TTL",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L398-L413 | train |
siddontang/ledisdb | ledis/t_kv.go | SetRange | func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
} else if len(value)+offset > MaxValueSize {
return 0, errValueSize
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
extra := offset + len(value) - len(oldValue)
if extra > 0 {
oldValue = append(oldValue, make([]byte, extra)...)
}
copy(oldValue[offset:], value)
t.Put(key, oldValue)
if err := t.Commit(); err != nil {
return 0, err
}
return int64(len(oldValue)), nil
} | go | func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
} else if len(value)+offset > MaxValueSize {
return 0, errValueSize
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
extra := offset + len(value) - len(oldValue)
if extra > 0 {
oldValue = append(oldValue, make([]byte, extra)...)
}
copy(oldValue[offset:], value)
t.Put(key, oldValue)
if err := t.Commit(); err != nil {
return 0, err
}
return int64(len(oldValue)), nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetRange",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"0",
",",
... | // SetRange sets the data with new value from offset. | [
"SetRange",
"sets",
"the",
"data",
"with",
"new",
"value",
"from",
"offset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L416-L453 | train |
siddontang/ledisdb | ledis/t_kv.go | GetRange | func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
start, end = getRange(start, end, valLen)
if start > end {
return nil, nil
}
return value[start : end+1], nil
} | go | func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
start, end = getRange(start, end, valLen)
if start > end {
return nil, nil
}
return value[start : end+1], nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"ni... | // GetRange gets the range of the data. | [
"GetRange",
"gets",
"the",
"range",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L479-L499 | train |
siddontang/ledisdb | ledis/t_kv.go | StrLen | func (db *DB) StrLen(key []byte) (int64, error) {
s, err := db.GetSlice(key)
if err != nil {
return 0, err
}
n := s.Size()
s.Free()
return int64(n), nil
} | go | func (db *DB) StrLen(key []byte) (int64, error) {
s, err := db.GetSlice(key)
if err != nil {
return 0, err
}
n := s.Size()
s.Free()
return int64(n), nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"StrLen",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"db",
".",
"GetSlice",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"e... | // StrLen returns the length of the data. | [
"StrLen",
"returns",
"the",
"length",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L502-L511 | train |
siddontang/ledisdb | ledis/t_kv.go | Append | func (db *DB) Append(key []byte, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if len(oldValue)+len(value) > MaxValueSize {
return 0, errValueSize
}
oldValue = append(oldValue, value...)
t.Put(key, oldValue)
if err := t.Commit(); err != nil {
return 0, nil
}
return int64(len(oldValue)), nil
} | go | func (db *DB) Append(key []byte, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if len(oldValue)+len(value) > MaxValueSize {
return 0, errValueSize
}
oldValue = append(oldValue, value...)
t.Put(key, oldValue)
if err := t.Commit(); err != nil {
return 0, nil
}
return int64(len(oldValue)), nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Append",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n"... | // Append appends the value to the data. | [
"Append",
"appends",
"the",
"value",
"to",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L514-L547 | train |
siddontang/ledisdb | ledis/t_kv.go | BitOP | func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error) {
if err := checkKeySize(destKey); err != nil {
return 0, err
}
op = strings.ToLower(op)
if len(srcKeys) == 0 {
return 0, nil
} else if op == BitNot && len(srcKeys) > 1 {
return 0, fmt.Errorf("BITOP NOT has only one srckey")
} else if len(srcKeys) < 2 {
return 0, nil
}
key := db.encodeKVKey(srcKeys[0])
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if op == BitNot {
for i := 0; i < len(value); i++ {
value[i] = ^value[i]
}
} else {
for j := 1; j < len(srcKeys); j++ {
if err := checkKeySize(srcKeys[j]); err != nil {
return 0, err
}
key = db.encodeKVKey(srcKeys[j])
ovalue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if len(value) < len(ovalue) {
value, ovalue = ovalue, value
}
for i := 0; i < len(ovalue); i++ {
switch op {
case BitAND:
value[i] &= ovalue[i]
case BitOR:
value[i] |= ovalue[i]
case BitXOR:
value[i] ^= ovalue[i]
default:
return 0, fmt.Errorf("invalid op type: %s", op)
}
}
for i := len(ovalue); i < len(value); i++ {
switch op {
case BitAND:
value[i] &= 0
case BitOR:
value[i] |= 0
case BitXOR:
value[i] ^= 0
}
}
}
}
key = db.encodeKVKey(destKey)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
return int64(len(value)), nil
} | go | func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error) {
if err := checkKeySize(destKey); err != nil {
return 0, err
}
op = strings.ToLower(op)
if len(srcKeys) == 0 {
return 0, nil
} else if op == BitNot && len(srcKeys) > 1 {
return 0, fmt.Errorf("BITOP NOT has only one srckey")
} else if len(srcKeys) < 2 {
return 0, nil
}
key := db.encodeKVKey(srcKeys[0])
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if op == BitNot {
for i := 0; i < len(value); i++ {
value[i] = ^value[i]
}
} else {
for j := 1; j < len(srcKeys); j++ {
if err := checkKeySize(srcKeys[j]); err != nil {
return 0, err
}
key = db.encodeKVKey(srcKeys[j])
ovalue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if len(value) < len(ovalue) {
value, ovalue = ovalue, value
}
for i := 0; i < len(ovalue); i++ {
switch op {
case BitAND:
value[i] &= ovalue[i]
case BitOR:
value[i] |= ovalue[i]
case BitXOR:
value[i] ^= ovalue[i]
default:
return 0, fmt.Errorf("invalid op type: %s", op)
}
}
for i := len(ovalue); i < len(value); i++ {
switch op {
case BitAND:
value[i] &= 0
case BitOR:
value[i] |= 0
case BitXOR:
value[i] ^= 0
}
}
}
}
key = db.encodeKVKey(destKey)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
return int64(len(value)), nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitOP",
"(",
"op",
"string",
",",
"destKey",
"[",
"]",
"byte",
",",
"srcKeys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"destKey",
")",
";",
... | // BitOP does the bit operations in data. | [
"BitOP",
"does",
"the",
"bit",
"operations",
"in",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L550-L631 | train |
siddontang/ledisdb | ledis/t_kv.go | BitCount | func (db *DB) BitCount(key []byte, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
var n int64
pos := 0
for ; pos+4 <= len(value); pos = pos + 4 {
n += int64(numberBitCount(binary.BigEndian.Uint32(value[pos : pos+4])))
}
for ; pos < len(value); pos++ {
n += int64(bitsInByte[value[pos]])
}
return n, nil
} | go | func (db *DB) BitCount(key []byte, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
var n int64
pos := 0
for ; pos+4 <= len(value); pos = pos + 4 {
n += int64(numberBitCount(binary.BigEndian.Uint32(value[pos : pos+4])))
}
for ; pos < len(value); pos++ {
n += int64(bitsInByte[value[pos]])
}
return n, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitCount",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
... | // BitCount returns the bit count of data. | [
"BitCount",
"returns",
"the",
"bit",
"count",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L653-L679 | train |
siddontang/ledisdb | ledis/t_kv.go | BitPos | func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
var skipValue uint8
if on == 0 {
skipValue = 0xFF
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
for i, v := range value {
if uint8(v) != skipValue {
for j := 0; j < 8; j++ {
isNull := uint8(v)&(1<<uint8(7-j)) == 0
if (on == 1 && !isNull) || (on == 0 && isNull) {
return int64((start+i)*8 + j), nil
}
}
}
}
return -1, nil
} | go | func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
var skipValue uint8
if on == 0 {
skipValue = 0xFF
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
for i, v := range value {
if uint8(v) != skipValue {
for j := 0; j < 8; j++ {
isNull := uint8(v)&(1<<uint8(7-j)) == 0
if (on == 1 && !isNull) || (on == 0 && isNull) {
return int64((start+i)*8 + j), nil
}
}
}
}
return -1, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitPos",
"(",
"key",
"[",
"]",
"byte",
",",
"on",
"int",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!... | // BitPos returns the pos of the data. | [
"BitPos",
"returns",
"the",
"pos",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L682-L718 | train |
siddontang/ledisdb | ledis/t_kv.go | SetBit | func (db *DB) SetBit(key []byte, offset int, on int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := int(uint32(offset) >> 3)
extra := byteOffset + 1 - len(value)
if extra > 0 {
value = append(value, make([]byte, extra)...)
}
byteVal := value[byteOffset]
bit := 7 - uint8(uint32(offset)&0x7)
bitVal := byteVal & (1 << bit)
byteVal &= ^(1 << bit)
byteVal |= (uint8(on&0x1) << bit)
value[byteOffset] = byteVal
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
if bitVal > 0 {
return 1, nil
}
return 0, nil
} | go | func (db *DB) SetBit(key []byte, offset int, on int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := int(uint32(offset) >> 3)
extra := byteOffset + 1 - len(value)
if extra > 0 {
value = append(value, make([]byte, extra)...)
}
byteVal := value[byteOffset]
bit := 7 - uint8(uint32(offset)&0x7)
bitVal := byteVal & (1 << bit)
byteVal &= ^(1 << bit)
byteVal |= (uint8(on&0x1) << bit)
value[byteOffset] = byteVal
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
if bitVal > 0 {
return 1, nil
}
return 0, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetBit",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"on",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"r... | // SetBit sets the bit to the data. | [
"SetBit",
"sets",
"the",
"bit",
"to",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L721-L766 | train |
siddontang/ledisdb | ledis/t_kv.go | GetBit | func (db *DB) GetBit(key []byte, offset int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := uint32(offset) >> 3
bit := 7 - uint8(uint32(offset)&0x7)
if byteOffset >= uint32(len(value)) {
return 0, nil
}
bitVal := value[byteOffset] & (1 << bit)
if bitVal > 0 {
return 1, nil
}
return 0, nil
} | go | func (db *DB) GetBit(key []byte, offset int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := uint32(offset) >> 3
bit := 7 - uint8(uint32(offset)&0x7)
if byteOffset >= uint32(len(value)) {
return 0, nil
}
bitVal := value[byteOffset] & (1 << bit)
if bitVal > 0 {
return 1, nil
}
return 0, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetBit",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
... | // GetBit gets the bit of data at offset. | [
"GetBit",
"gets",
"the",
"bit",
"of",
"data",
"at",
"offset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L769-L794 | train |
siddontang/ledisdb | ledis/replication.go | WaitReplication | func (l *Ledis) WaitReplication() error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
for i := 0; i < 100; i++ {
l.noticeReplication()
select {
case <-l.rDoneCh:
case <-l.quit:
return nil
}
time.Sleep(100 * time.Millisecond)
b, err := l.r.CommitIDBehind()
if err != nil {
return err
} else if !b {
return nil
}
}
return errors.New("wait replication too many times")
} | go | func (l *Ledis) WaitReplication() error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
for i := 0; i < 100; i++ {
l.noticeReplication()
select {
case <-l.rDoneCh:
case <-l.quit:
return nil
}
time.Sleep(100 * time.Millisecond)
b, err := l.r.CommitIDBehind()
if err != nil {
return err
} else if !b {
return nil
}
}
return errors.New("wait replication too many times")
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"WaitReplication",
"(",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"++",
"{"... | // WaitReplication waits replication done | [
"WaitReplication",
"waits",
"replication",
"done"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L95-L120 | train |
siddontang/ledisdb | ledis/replication.go | StoreLogsFromReader | func (l *Ledis) StoreLogsFromReader(rb io.Reader) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
} else if !l.cfg.Readonly {
return ErrRplInRDWR
}
log := &rpl.Log{}
for {
if err := log.Decode(rb); err != nil {
if err == io.EOF {
break
} else {
return err
}
}
if err := l.r.StoreLog(log); err != nil {
return err
}
}
l.noticeReplication()
return nil
} | go | func (l *Ledis) StoreLogsFromReader(rb io.Reader) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
} else if !l.cfg.Readonly {
return ErrRplInRDWR
}
log := &rpl.Log{}
for {
if err := log.Decode(rb); err != nil {
if err == io.EOF {
break
} else {
return err
}
}
if err := l.r.StoreLog(log); err != nil {
return err
}
}
l.noticeReplication()
return nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"StoreLogsFromReader",
"(",
"rb",
"io",
".",
"Reader",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n",
"}",
"else",
"if",
"!",
"l",
".",
"cfg",
".",
... | // StoreLogsFromReader stores logs from the Reader | [
"StoreLogsFromReader",
"stores",
"logs",
"from",
"the",
"Reader"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L123-L150 | train |
siddontang/ledisdb | ledis/replication.go | StoreLogsFromData | func (l *Ledis) StoreLogsFromData(data []byte) error {
rb := bytes.NewReader(data)
return l.StoreLogsFromReader(rb)
} | go | func (l *Ledis) StoreLogsFromData(data []byte) error {
rb := bytes.NewReader(data)
return l.StoreLogsFromReader(rb)
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"StoreLogsFromData",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"rb",
":=",
"bytes",
".",
"NewReader",
"(",
"data",
")",
"\n",
"return",
"l",
".",
"StoreLogsFromReader",
"(",
"rb",
")",
"\n",
"}"
] | // StoreLogsFromData stores logs from data. | [
"StoreLogsFromData",
"stores",
"logs",
"from",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L157-L161 | train |
siddontang/ledisdb | ledis/replication.go | ReadLogsTo | func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error) {
if !l.ReplicationUsed() {
// no replication log
nextLogID = 0
err = ErrRplNotSupport
return
}
var firtID, lastID uint64
firtID, err = l.r.FirstLogID()
if err != nil {
return
}
if startLogID < firtID {
err = ErrLogMissed
return
}
lastID, err = l.r.LastLogID()
if err != nil {
return
}
nextLogID = startLogID
log := &rpl.Log{}
for i := startLogID; i <= lastID; i++ {
if err = l.r.GetLog(i, log); err != nil {
return
}
if err = log.Encode(w); err != nil {
return
}
nextLogID = i + 1
n += log.Size()
if n > maxReplLogSize {
break
}
}
return
} | go | func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error) {
if !l.ReplicationUsed() {
// no replication log
nextLogID = 0
err = ErrRplNotSupport
return
}
var firtID, lastID uint64
firtID, err = l.r.FirstLogID()
if err != nil {
return
}
if startLogID < firtID {
err = ErrLogMissed
return
}
lastID, err = l.r.LastLogID()
if err != nil {
return
}
nextLogID = startLogID
log := &rpl.Log{}
for i := startLogID; i <= lastID; i++ {
if err = l.r.GetLog(i, log); err != nil {
return
}
if err = log.Encode(w); err != nil {
return
}
nextLogID = i + 1
n += log.Size()
if n > maxReplLogSize {
break
}
}
return
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReadLogsTo",
"(",
"startLogID",
"uint64",
",",
"w",
"io",
".",
"Writer",
")",
"(",
"n",
"int",
",",
"nextLogID",
"uint64",
",",
"err",
"error",
")",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
... | // ReadLogsTo reads logs and write to the Writer. | [
"ReadLogsTo",
"reads",
"logs",
"and",
"write",
"to",
"the",
"Writer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L164-L211 | train |
siddontang/ledisdb | ledis/replication.go | ReadLogsToTimeout | func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error) {
n, nextLogID, err = l.ReadLogsTo(startLogID, w)
if err != nil {
return
} else if n != 0 {
return
}
//no events read
select {
case <-l.r.WaitLog():
case <-time.After(time.Duration(timeout) * time.Second):
case <-quitCh:
return
}
return l.ReadLogsTo(startLogID, w)
} | go | func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error) {
n, nextLogID, err = l.ReadLogsTo(startLogID, w)
if err != nil {
return
} else if n != 0 {
return
}
//no events read
select {
case <-l.r.WaitLog():
case <-time.After(time.Duration(timeout) * time.Second):
case <-quitCh:
return
}
return l.ReadLogsTo(startLogID, w)
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReadLogsToTimeout",
"(",
"startLogID",
"uint64",
",",
"w",
"io",
".",
"Writer",
",",
"timeout",
"int",
",",
"quitCh",
"chan",
"struct",
"{",
"}",
")",
"(",
"n",
"int",
",",
"nextLogID",
"uint64",
",",
"err",
"err... | // ReadLogsToTimeout tries to read events, if no events read,
// tres to wait the new event singal until timeout seconds | [
"ReadLogsToTimeout",
"tries",
"to",
"read",
"events",
"if",
"no",
"events",
"read",
"tres",
"to",
"wait",
"the",
"new",
"event",
"singal",
"until",
"timeout",
"seconds"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L215-L230 | train |
siddontang/ledisdb | ledis/replication.go | AddNewLogEventHandler | func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
l.rhs = append(l.rhs, h)
return nil
} | go | func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
l.rhs = append(l.rhs, h)
return nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"AddNewLogEventHandler",
"(",
"h",
"NewLogEventHandler",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n",
"}",
"\n",
"l",
".",
"rhs",
"=",
"append",
"(",
... | // AddNewLogEventHandler adds the handler for the new log event | [
"AddNewLogEventHandler",
"adds",
"the",
"handler",
"for",
"the",
"new",
"log",
"event"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L242-L250 | train |
siddontang/ledisdb | ledis/replication.go | ReplicationStat | func (l *Ledis) ReplicationStat() (*rpl.Stat, error) {
if !l.ReplicationUsed() {
return nil, ErrRplNotSupport
}
return l.r.Stat()
} | go | func (l *Ledis) ReplicationStat() (*rpl.Stat, error) {
if !l.ReplicationUsed() {
return nil, ErrRplNotSupport
}
return l.r.Stat()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReplicationStat",
"(",
")",
"(",
"*",
"rpl",
".",
"Stat",
",",
"error",
")",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"nil",
",",
"ErrRplNotSupport",
"\n",
"}",
"\n",
"return",
"l",... | // ReplicationStat returns the statistics of repliaciton. | [
"ReplicationStat",
"returns",
"the",
"statistics",
"of",
"repliaciton",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L253-L259 | train |
siddontang/ledisdb | ledis/t_zset.go | ZAdd | func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error) {
if len(args) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(args); i++ {
score := args[i].Score
member := args[i].Member
if err := checkZSetKMSize(key, member); err != nil {
return 0, err
}
if n, err := db.zSetItem(t, key, score, member); err != nil {
return 0, err
} else if n == 0 {
//add new
num++
}
}
if _, err := db.zIncrSize(t, key, num); err != nil {
return 0, err
}
err := t.Commit()
return num, err
} | go | func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error) {
if len(args) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(args); i++ {
score := args[i].Score
member := args[i].Member
if err := checkZSetKMSize(key, member); err != nil {
return 0, err
}
if n, err := db.zSetItem(t, key, score, member); err != nil {
return 0, err
} else if n == 0 {
//add new
num++
}
}
if _, err := db.zIncrSize(t, key, num); err != nil {
return 0, err
}
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZAdd",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"ScorePair",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n",
... | // ZAdd add the members. | [
"ZAdd",
"add",
"the",
"members",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L317-L349 | train |
siddontang/ledisdb | ledis/t_zset.go | ZCard | func (db *DB) ZCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | go | func (db *DB) ZCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZCard",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",... | // ZCard gets the size of the zset. | [
"ZCard",
"gets",
"the",
"size",
"of",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L371-L378 | train |
siddontang/ledisdb | ledis/t_zset.go | ZScore | func (db *DB) ZScore(key []byte, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
score := InvalidScore
k := db.zEncodeSetKey(key, member)
if v, err := db.bucket.Get(k); err != nil {
return InvalidScore, err
} else if v == nil {
return InvalidScore, ErrScoreMiss
} else {
if score, err = Int64(v, nil); err != nil {
return InvalidScore, err
}
}
return score, nil
} | go | func (db *DB) ZScore(key []byte, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
score := InvalidScore
k := db.zEncodeSetKey(key, member)
if v, err := db.bucket.Get(k); err != nil {
return InvalidScore, err
} else if v == nil {
return InvalidScore, ErrScoreMiss
} else {
if score, err = Int64(v, nil); err != nil {
return InvalidScore, err
}
}
return score, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZScore",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"member",
")",
";",
"err",
"!=",
"nil"... | // ZScore gets the score of member. | [
"ZScore",
"gets",
"the",
"score",
"of",
"member",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L381-L400 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRem | func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error) {
if len(members) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(members); i++ {
if err := checkZSetKMSize(key, members[i]); err != nil {
return 0, err
}
if n, err := db.zDelItem(t, key, members[i], false); err != nil {
return 0, err
} else if n == 1 {
num++
}
}
if _, err := db.zIncrSize(t, key, -num); err != nil {
return 0, err
}
err := t.Commit()
return num, err
} | go | func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error) {
if len(members) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(members); i++ {
if err := checkZSetKMSize(key, members[i]); err != nil {
return 0, err
}
if n, err := db.zDelItem(t, key, members[i], false); err != nil {
return 0, err
} else if n == 1 {
num++
}
}
if _, err := db.zIncrSize(t, key, -num); err != nil {
return 0, err
}
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRem",
"(",
"key",
"[",
"]",
"byte",
",",
"members",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"members",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
... | // ZRem removes members | [
"ZRem",
"removes",
"members"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L403-L431 | train |
siddontang/ledisdb | ledis/t_zset.go | ZIncrBy | func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
ek := db.zEncodeSetKey(key, member)
var oldScore int64
v, err := db.bucket.Get(ek)
if err != nil {
return InvalidScore, err
} else if v == nil {
db.zIncrSize(t, key, 1)
} else {
if oldScore, err = Int64(v, err); err != nil {
return InvalidScore, err
}
}
newScore := oldScore + delta
if newScore >= MaxScore || newScore <= MinScore {
return InvalidScore, errScoreOverflow
}
sk := db.zEncodeScoreKey(key, member, newScore)
t.Put(sk, []byte{})
t.Put(ek, PutInt64(newScore))
if v != nil {
// so as to update score, we must delete the old one
oldSk := db.zEncodeScoreKey(key, member, oldScore)
t.Delete(oldSk)
}
err = t.Commit()
return newScore, err
} | go | func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
ek := db.zEncodeSetKey(key, member)
var oldScore int64
v, err := db.bucket.Get(ek)
if err != nil {
return InvalidScore, err
} else if v == nil {
db.zIncrSize(t, key, 1)
} else {
if oldScore, err = Int64(v, err); err != nil {
return InvalidScore, err
}
}
newScore := oldScore + delta
if newScore >= MaxScore || newScore <= MinScore {
return InvalidScore, errScoreOverflow
}
sk := db.zEncodeScoreKey(key, member, newScore)
t.Put(sk, []byte{})
t.Put(ek, PutInt64(newScore))
if v != nil {
// so as to update score, we must delete the old one
oldSk := db.zEncodeScoreKey(key, member, oldScore)
t.Delete(oldSk)
}
err = t.Commit()
return newScore, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZIncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"delta",
"int64",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"member",
")",
... | // ZIncrBy increases the score of member with delta. | [
"ZIncrBy",
"increases",
"the",
"score",
"of",
"member",
"with",
"delta",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L434-L474 | train |
siddontang/ledisdb | ledis/t_zset.go | ZClear | func (db *DB) ZClear(key []byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | go | func (db *DB) ZClear(key []byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n",
"r... | // ZClear clears the zset. | [
"ZClear",
"clears",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L672-L683 | train |
siddontang/ledisdb | ledis/t_zset.go | ZMclear | func (db *DB) ZMclear(keys ...[]byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if _, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1); err != nil {
return 0, err
}
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) ZMclear(keys ...[]byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if _, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1); err != nil {
return 0, err
}
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
... | // ZMclear clears multi zsets. | [
"ZMclear",
"clears",
"multi",
"zsets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L686-L700 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRange | func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, false)
} | go | func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
"ZRangeGeneric",
"(",
"key",
",",
"start",
",",
"s... | // ZRange gets the members from start to stop. | [
"ZRange",
"gets",
"the",
"members",
"from",
"start",
"to",
"stop",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L703-L705 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByScore | func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
offset int, count int) ([]ScorePair, error) {
return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
} | go | func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
offset int, count int) ([]ScorePair, error) {
return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeByScore",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"int64",
",",
"max",
"int64",
",",
"offset",
"int",
",",
"count",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
... | // 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 | [
"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"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L710-L713 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRank | func (db *DB) ZRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, false)
} | go | func (db *DB) ZRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRank",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"zrank",
"(",
"key",
",",
"member",
",",
"false",
")",
"\n",
"}"
] | // ZRank gets the rank of member. | [
"ZRank",
"gets",
"the",
"rank",
"of",
"member",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L716-L718 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRemRangeByRank | func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return 0, err
}
var rmCnt int64
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err = db.zRemRange(t, key, MinScore, MaxScore, offset, count)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | go | func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return 0, err
}
var rmCnt int64
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err = db.zRemRange(t, key, MinScore, MaxScore, offset, count)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRemRangeByRank",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"offset",
",",
"count",
",",
"err",
":=",
"db",
".",
"zParseLimit",
"(",
"key"... | // ZRemRangeByRank removes the member at range from start to stop. | [
"ZRemRangeByRank",
"removes",
"the",
"member",
"at",
"range",
"from",
"start",
"to",
"stop",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L721-L739 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRevRange | func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, true)
} | go | func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
"ZRangeGeneric",
"(",
"key",
",",
"start",
",",
... | // ZRevRange gets the data reversed. | [
"ZRevRange",
"gets",
"the",
"data",
"reversed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L756-L758 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRevRank | func (db *DB) ZRevRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, true)
} | go | func (db *DB) ZRevRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevRank",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"zrank",
"(",
"key",
",",
"member",
",",
"true",
")",
"\n",
"}"
] | // ZRevRank gets the rank of member reversed. | [
"ZRevRank",
"gets",
"the",
"rank",
"of",
"member",
"reversed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L761-L763 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeGeneric | func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return nil, err
}
return db.zRange(key, MinScore, MaxScore, offset, count, reverse)
} | go | func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return nil, err
}
return db.zRange(key, MinScore, MaxScore, offset, count, reverse)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeGeneric",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
",",
"reverse",
"bool",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"offset",
",",
"count",
",",
"err",
":=",
... | // ZRangeGeneric is a generic function for scan zset. | [
"ZRangeGeneric",
"is",
"a",
"generic",
"function",
"for",
"scan",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L773-L780 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByScoreGeneric | func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
offset int, count int, reverse bool) ([]ScorePair, error) {
return db.zRange(key, min, max, offset, count, reverse)
} | go | func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
offset int, count int, reverse bool) ([]ScorePair, error) {
return db.zRange(key, min, max, offset, count, reverse)
} | [
"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 | [
"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"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L785-L789 | train |
siddontang/ledisdb | ledis/t_zset.go | ZExpire | func (db *DB) ZExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.zExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) ZExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.zExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n",
"return",
"d... | // ZExpire expires the zset. | [
"ZExpire",
"expires",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L799-L805 | train |
siddontang/ledisdb | ledis/t_zset.go | ZExpireAt | func (db *DB) ZExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.zExpireAt(key, when)
} | go | func (db *DB) ZExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.zExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // ZExpireAt expires the zset at when. | [
"ZExpireAt",
"expires",
"the",
"zset",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L808-L814 | train |
siddontang/ledisdb | ledis/t_zset.go | ZTTL | func (db *DB) ZTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ZSetType, key)
} | go | func (db *DB) ZTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ZSetType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // ZTTL gets the TTL of zset. | [
"ZTTL",
"gets",
"the",
"TTL",
"of",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L817-L823 | train |
siddontang/ledisdb | ledis/t_zset.go | ZPersist | func (db *DB) ZPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ZSetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) ZPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ZSetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\... | // ZPersist removes the TTL of zset. | [
"ZPersist",
"removes",
"the",
"TTL",
"of",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L826-L842 | train |
siddontang/ledisdb | ledis/t_zset.go | ZUnionStore | func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error) {
var destMap = map[string]int64{}
aggregateFunc := getAggregateFunc(aggregate)
if aggregateFunc == nil {
return 0, errInvalidAggregate
}
if len(srcKeys) < 1 {
return 0, errInvalidSrcKeyNum
}
if weights != nil {
if len(srcKeys) != len(weights) {
return 0, errInvalidWeightNum
}
} else {
weights = make([]int64, len(srcKeys))
for i := 0; i < len(weights); i++ {
weights[i] = 1
}
}
for i, key := range srcKeys {
scorePairs, err := db.ZRange(key, 0, -1)
if err != nil {
return 0, err
}
for _, pair := range scorePairs {
if score, ok := destMap[hack.String(pair.Member)]; !ok {
destMap[hack.String(pair.Member)] = pair.Score * weights[i]
} else {
destMap[hack.String(pair.Member)] = aggregateFunc(score, pair.Score*weights[i])
}
}
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
db.zDelete(t, destKey)
for member, score := range destMap {
if err := checkZSetKMSize(destKey, []byte(member)); err != nil {
return 0, err
}
if _, err := db.zSetItem(t, destKey, score, []byte(member)); err != nil {
return 0, err
}
}
var n = int64(len(destMap))
sk := db.zEncodeSizeKey(destKey)
t.Put(sk, PutInt64(n))
if err := t.Commit(); err != nil {
return 0, err
}
return n, nil
} | go | func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error) {
var destMap = map[string]int64{}
aggregateFunc := getAggregateFunc(aggregate)
if aggregateFunc == nil {
return 0, errInvalidAggregate
}
if len(srcKeys) < 1 {
return 0, errInvalidSrcKeyNum
}
if weights != nil {
if len(srcKeys) != len(weights) {
return 0, errInvalidWeightNum
}
} else {
weights = make([]int64, len(srcKeys))
for i := 0; i < len(weights); i++ {
weights[i] = 1
}
}
for i, key := range srcKeys {
scorePairs, err := db.ZRange(key, 0, -1)
if err != nil {
return 0, err
}
for _, pair := range scorePairs {
if score, ok := destMap[hack.String(pair.Member)]; !ok {
destMap[hack.String(pair.Member)] = pair.Score * weights[i]
} else {
destMap[hack.String(pair.Member)] = aggregateFunc(score, pair.Score*weights[i])
}
}
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
db.zDelete(t, destKey)
for member, score := range destMap {
if err := checkZSetKMSize(destKey, []byte(member)); err != nil {
return 0, err
}
if _, err := db.zSetItem(t, destKey, score, []byte(member)); err != nil {
return 0, err
}
}
var n = int64(len(destMap))
sk := db.zEncodeSizeKey(destKey)
t.Put(sk, PutInt64(n))
if err := t.Commit(); err != nil {
return 0, err
}
return n, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZUnionStore",
"(",
"destKey",
"[",
"]",
"byte",
",",
"srcKeys",
"[",
"]",
"[",
"]",
"byte",
",",
"weights",
"[",
"]",
"int64",
",",
"aggregate",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"destMa... | // ZUnionStore unions the zsets and stores to dest zset. | [
"ZUnionStore",
"unions",
"the",
"zsets",
"and",
"stores",
"to",
"dest",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L869-L928 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByLex | func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeLimitIterator(min, max, rangeType, offset, count)
defer it.Close()
ay := make([][]byte, 0, 16)
for ; it.Valid(); it.Next() {
if _, m, err := db.zDecodeSetKey(it.Key()); err == nil {
ay = append(ay, m)
}
}
return ay, nil
} | go | func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeLimitIterator(min, max, rangeType, offset, count)
defer it.Close()
ay := make([][]byte, 0, 16)
for ; it.Valid(); it.Next() {
if _, m, err := db.zDecodeSetKey(it.Key()); err == nil {
ay = append(ay, m)
}
}
return ay, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeByLex",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"[",
"]",
"byte",
",",
"max",
"[",
"]",
"byte",
",",
"rangeType",
"uint8",
",",
"offset",
"int",
",",
"count",
"int",
")",
"(",
"[",
"]",
"[",
"]",
"b... | // ZRangeByLex scans the zset lexicographically | [
"ZRangeByLex",
"scans",
"the",
"zset",
"lexicographically"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1000-L1023 | train |
siddontang/ledisdb | ledis/t_zset.go | ZLexCount | func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeIterator(min, max, rangeType)
defer it.Close()
var n int64
for ; it.Valid(); it.Next() {
n++
}
return n, nil
} | go | func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeIterator(min, max, rangeType)
defer it.Close()
var n int64
for ; it.Valid(); it.Next() {
n++
}
return n, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZLexCount",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"[",
"]",
"byte",
",",
"max",
"[",
"]",
"byte",
",",
"rangeType",
"uint8",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"min",
"==",
"nil",
"{",
"mi... | // ZLexCount gets the count of zset lexicographically. | [
"ZLexCount",
"gets",
"the",
"count",
"of",
"zset",
"lexicographically",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1059-L1080 | train |
siddontang/ledisdb | ledis/t_zset.go | ZKeyExists | func (db *DB) ZKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) ZKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
... | // ZKeyExists checks zset existed or not. | [
"ZKeyExists",
"checks",
"zset",
"existed",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1083-L1093 | train |
siddontang/ledisdb | server/client_resp.go | handleXSelectCmd | func (c *respClient) handleXSelectCmd() error {
if len(c.args) <= 2 {
// invalid command format
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
if hack.String(upperSlice(c.args[1])) != "THEN" {
// invalid command format, just resturn here
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
index, err := strconv.Atoi(hack.String(c.args[0]))
if err != nil {
return fmt.Errorf("invalid db for XSELECT, err %v", err)
}
db, err := c.app.ldb.Select(index)
if err != nil {
return fmt.Errorf("invalid db for XSELECT, err %v", err)
}
c.db = db
c.cmd = hack.String(lowerSlice(c.args[2]))
c.args = c.args[3:]
return nil
} | go | func (c *respClient) handleXSelectCmd() error {
if len(c.args) <= 2 {
// invalid command format
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
if hack.String(upperSlice(c.args[1])) != "THEN" {
// invalid command format, just resturn here
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
index, err := strconv.Atoi(hack.String(c.args[0]))
if err != nil {
return fmt.Errorf("invalid db for XSELECT, err %v", err)
}
db, err := c.app.ldb.Select(index)
if err != nil {
return fmt.Errorf("invalid db for XSELECT, err %v", err)
}
c.db = db
c.cmd = hack.String(lowerSlice(c.args[2]))
c.args = c.args[3:]
return nil
} | [
"func",
"(",
"c",
"*",
"respClient",
")",
"handleXSelectCmd",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"c",
".",
"args",
")",
"<=",
"2",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"invalid format for XSELECT, must XSELECT db THEN your command\"",
")",
"\n",
... | // XSELECT db THEN command | [
"XSELECT",
"db",
"THEN",
"command"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/server/client_resp.go#L191-L218 | train |
siddontang/ledisdb | ledis/scan.go | buildDataScanKeyRange | func (db *DB) buildDataScanKeyRange(storeDataType byte, key []byte, cursor []byte, reverse bool) (minKey []byte, maxKey []byte, err error) {
if !reverse {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, cursor); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, nil); err != nil {
return
}
} else {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, nil); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, cursor); err != nil {
return
}
}
return
} | go | func (db *DB) buildDataScanKeyRange(storeDataType byte, key []byte, cursor []byte, reverse bool) (minKey []byte, maxKey []byte, err error) {
if !reverse {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, cursor); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, nil); err != nil {
return
}
} else {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, nil); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, cursor); err != nil {
return
}
}
return
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"buildDataScanKeyRange",
"(",
"storeDataType",
"byte",
",",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"reverse",
"bool",
")",
"(",
"minKey",
"[",
"]",
"byte",
",",
"maxKey",
"[",
"]",
"byte",
... | // for specail data scan | [
"for",
"specail",
"data",
"scan"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L202-L219 | train |
siddontang/ledisdb | ledis/scan.go | HScan | func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"return",
"d... | // HScan scans data for hash. | [
"HScan",
"scans",
"data",
"for",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L304-L306 | train |
siddontang/ledisdb | ledis/scan.go | HRevScan | func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"return",
... | // HRevScan reversed scans data for hash. | [
"HRevScan",
"reversed",
"scans",
"data",
"for",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L309-L311 | train |
siddontang/ledisdb | ledis/scan.go | SScan | func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"r... | // SScan scans data for set. | [
"SScan",
"scans",
"data",
"for",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L347-L349 | train |
siddontang/ledisdb | ledis/scan.go | SRevScan | func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
... | // SRevScan scans data reversed for set. | [
"SRevScan",
"scans",
"data",
"reversed",
"for",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L352-L354 | train |
siddontang/ledisdb | ledis/scan.go | ZScan | func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
... | // ZScan scans data for zset. | [
"ZScan",
"scans",
"data",
"for",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L395-L397 | train |
siddontang/ledisdb | ledis/scan.go | ZRevScan | func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return"... | // ZRevScan scans data reversed for zset. | [
"ZRevScan",
"scans",
"data",
"reversed",
"for",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L400-L402 | train |
siddontang/ledisdb | store/writebatch.go | BatchData | func (wb *WriteBatch) BatchData() *BatchData {
data := wb.wb.Data()
if wb.data == nil {
wb.data = new(BatchData)
}
wb.data.Load(data)
return wb.data
} | go | func (wb *WriteBatch) BatchData() *BatchData {
data := wb.wb.Data()
if wb.data == nil {
wb.data = new(BatchData)
}
wb.data.Load(data)
return wb.data
} | [
"func",
"(",
"wb",
"*",
"WriteBatch",
")",
"BatchData",
"(",
")",
"*",
"BatchData",
"{",
"data",
":=",
"wb",
".",
"wb",
".",
"Data",
"(",
")",
"\n",
"if",
"wb",
".",
"data",
"==",
"nil",
"{",
"wb",
".",
"data",
"=",
"new",
"(",
"BatchData",
")"... | // the data will be undefined after commit or rollback | [
"the",
"data",
"will",
"be",
"undefined",
"after",
"commit",
"or",
"rollback"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/writebatch.go#L63-L71 | train |
siddontang/ledisdb | ledis/util.go | Uint64 | func Uint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil || len(v) == 0 {
return 0, nil
} else if len(v) != 8 {
return 0, errIntNumber
}
return binary.LittleEndian.Uint64(v), nil
} | go | func Uint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil || len(v) == 0 {
return 0, nil
} else if len(v) != 8 {
return 0, errIntNumber
}
return binary.LittleEndian.Uint64(v), nil
} | [
"func",
"Uint64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"||",
"len",
"(",
"v",
")",
... | // Uint64 gets unsigned 64 integer. | [
"Uint64",
"gets",
"unsigned",
"64",
"integer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L32-L42 | train |
siddontang/ledisdb | ledis/util.go | PutInt64 | func PutInt64(v int64) []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(v))
return b
} | go | func PutInt64(v int64) []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(v))
return b
} | [
"func",
"PutInt64",
"(",
"v",
"int64",
")",
"[",
"]",
"byte",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"b",
",",
"uint64",
"(",
"v",
")",
")",
"\n",
"return",
"b",... | // PutInt64 puts the 64 integer. | [
"PutInt64",
"puts",
"the",
"64",
"integer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L45-L49 | train |
siddontang/ledisdb | ledis/util.go | StrInt64 | func StrInt64(v []byte, err error) (int64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseInt(hack.String(v), 10, 64)
}
} | go | func StrInt64(v []byte, err error) (int64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseInt(hack.String(v), 10, 64)
}
} | [
"func",
"StrInt64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil... | // StrInt64 gets the 64 integer with string format. | [
"StrInt64",
"gets",
"the",
"64",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L52-L60 | train |
siddontang/ledisdb | ledis/util.go | StrUint64 | func StrUint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseUint(hack.String(v), 10, 64)
}
} | go | func StrUint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseUint(hack.String(v), 10, 64)
}
} | [
"func",
"StrUint64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"n... | // StrUint64 gets the unsigned 64 integer with string format. | [
"StrUint64",
"gets",
"the",
"unsigned",
"64",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L63-L71 | train |
siddontang/ledisdb | ledis/util.go | StrInt32 | func StrInt32(v []byte, err error) (int32, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 32)
return int32(res), err
}
} | go | func StrInt32(v []byte, err error) (int32, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 32)
return int32(res), err
}
} | [
"func",
"StrInt32",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int32",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil... | // StrInt32 gets the 32 integer with string format. | [
"StrInt32",
"gets",
"the",
"32",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L74-L83 | train |
siddontang/ledisdb | ledis/util.go | StrInt8 | func StrInt8(v []byte, err error) (int8, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 8)
return int8(res), err
}
} | go | func StrInt8(v []byte, err error) (int8, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 8)
return int8(res), err
}
} | [
"func",
"StrInt8",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int8",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil",... | // StrInt8 ets the 8 integer with string format. | [
"StrInt8",
"ets",
"the",
"8",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L86-L95 | train |
siddontang/ledisdb | ledis/sort.go | XLSort | func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"XLSort",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"size",
"int",
",",
"alpha",
"bool",
",",
"desc",
"bool",
",",
"sortBy",
"[",
"]",
"byte",
",",
"sortGet",
"[",
"]",
"[",
"]",
"byte",
")",
... | // XLSort sorts list. | [
"XLSort",
"sorts",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/sort.go#L207-L215 | train |
siddontang/ledisdb | ledis/sort.go | XZSort | func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"XZSort",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"size",
"int",
",",
"alpha",
"bool",
",",
"desc",
"bool",
",",
"sortBy",
"[",
"]",
"byte",
",",
"sortGet",
"[",
"]",
"[",
"]",
"byte",
")",
... | // XZSort sorts zset. | [
"XZSort",
"sorts",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/sort.go#L228-L235 | train |
siddontang/ledisdb | ledis/t_hash.go | HLen | func (db *DB) HLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
return Int64(db.bucket.Get(db.hEncodeSizeKey(key)))
} | go | func (db *DB) HLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
return Int64(db.bucket.Get(db.hEncodeSizeKey(key)))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HLen",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
... | // HLen returns the lengh of hash. | [
"HLen",
"returns",
"the",
"lengh",
"of",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L188-L194 | train |
siddontang/ledisdb | ledis/t_hash.go | HSet | func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.hSetItem(key, field, value)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.hSetItem(key, field, value)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HSet",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
... | // HSet sets the field with value of key. | [
"HSet",
"sets",
"the",
"field",
"with",
"value",
"of",
"key",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L197-L215 | train |
siddontang/ledisdb | ledis/t_hash.go | HGet | func (db *DB) HGet(key []byte, field []byte) ([]byte, error) {
if err := checkHashKFSize(key, field); err != nil {
return nil, err
}
return db.bucket.Get(db.hEncodeHashKey(key, field))
} | go | func (db *DB) HGet(key []byte, field []byte) ([]byte, error) {
if err := checkHashKFSize(key, field); err != nil {
return nil, err
}
return db.bucket.Get(db.hEncodeHashKey(key, field))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HGet",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
")",
";",
"err",
"!="... | // HGet gets the value of the field. | [
"HGet",
"gets",
"the",
"value",
"of",
"the",
"field",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L218-L224 | train |
siddontang/ledisdb | ledis/t_hash.go | HMset | func (db *DB) HMset(key []byte, args ...FVPair) error {
t := db.hashBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i].Field); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil {
return err
}
ek = db.hEncodeHashKey(key, args[i].Field)
if v, err := db.bucket.Get(ek); err != nil {
return err
} else if v == nil {
num++
}
t.Put(ek, args[i].Value)
}
if _, err = db.hIncrSize(key, num); err != nil {
return err
}
//todo add binglog
err = t.Commit()
return err
} | go | func (db *DB) HMset(key []byte, args ...FVPair) error {
t := db.hashBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i].Field); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil {
return err
}
ek = db.hEncodeHashKey(key, args[i].Field)
if v, err := db.bucket.Get(ek); err != nil {
return err
} else if v == nil {
num++
}
t.Put(ek, args[i].Value)
}
if _, err = db.hIncrSize(key, num); err != nil {
return err
}
//todo add binglog
err = t.Commit()
return err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMset",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"FVPair",
")",
"error",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n",... | // HMset sets multi field-values. | [
"HMset",
"sets",
"multi",
"field",
"-",
"values",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L227-L260 | train |
siddontang/ledisdb | ledis/t_hash.go | HMget | func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error) {
var ek []byte
it := db.bucket.NewIterator()
defer it.Close()
r := make([][]byte, len(args))
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return nil, err
}
ek = db.hEncodeHashKey(key, args[i])
r[i] = it.Find(ek)
}
return r, nil
} | go | func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error) {
var ek []byte
it := db.bucket.NewIterator()
defer it.Close()
r := make([][]byte, len(args))
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return nil, err
}
ek = db.hEncodeHashKey(key, args[i])
r[i] = it.Find(ek)
}
return r, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMget",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"it",
":=",
"db",
".",
"buc... | // HMget gets multi values of fields | [
"HMget",
"gets",
"multi",
"values",
"of",
"fields"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L263-L281 | train |
siddontang/ledisdb | ledis/t_hash.go | HDel | func (db *DB) HDel(key []byte, args ...[]byte) (int64, error) {
t := db.hashBatch
var ek []byte
var v []byte
var err error
t.Lock()
defer t.Unlock()
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return 0, err
}
ek = db.hEncodeHashKey(key, args[i])
v = it.RawFind(ek)
if v == nil {
continue
} else {
num++
t.Delete(ek)
}
}
if _, err = db.hIncrSize(key, -num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | go | func (db *DB) HDel(key []byte, args ...[]byte) (int64, error) {
t := db.hashBatch
var ek []byte
var v []byte
var err error
t.Lock()
defer t.Unlock()
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return 0, err
}
ek = db.hEncodeHashKey(key, args[i])
v = it.RawFind(ek)
if v == nil {
continue
} else {
num++
t.Delete(ek)
}
}
if _, err = db.hIncrSize(key, -num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HDel",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"... | // HDel deletes the fields. | [
"HDel",
"deletes",
"the",
"fields",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L284-L321 | train |
siddontang/ledisdb | ledis/t_hash.go | HIncrBy | func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
}
t := db.hashBatch
var ek []byte
var err error
t.Lock()
defer t.Unlock()
ek = db.hEncodeHashKey(key, field)
var n int64
if n, err = StrInt64(db.bucket.Get(ek)); err != nil {
return 0, err
}
n += delta
_, err = db.hSetItem(key, field, num.FormatInt64ToSlice(n))
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
}
t := db.hashBatch
var ek []byte
var err error
t.Lock()
defer t.Unlock()
ek = db.hEncodeHashKey(key, field)
var n int64
if n, err = StrInt64(db.bucket.Get(ek)); err != nil {
return 0, err
}
n += delta
_, err = db.hSetItem(key, field, num.FormatInt64ToSlice(n))
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HIncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
",",
"delta",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
")",
"... | // HIncrBy increases the value of field by delta. | [
"HIncrBy",
"increases",
"the",
"value",
"of",
"field",
"by",
"delta",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L346-L375 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.