repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
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\n",
"var",
"err",
"error",
"\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"var",
"v",
"[",
"]",
"byte",
"\n",
"v",
",",
"err",
"=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"v",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"err",
"\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",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"return",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\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",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"return",
"db",
".",
"bucket",
".",
"GetSlice",
"(",
"key",
")",
"\n",
"}"
] |
// 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",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"oldValue",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n\n",
"return",
"oldValue",
",",
"err",
"\n",
"}"
] |
// 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\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"for",
"i",
":=",
"range",
"keys",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"keys",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"values",
"[",
"i",
"]",
"=",
"it",
".",
"Find",
"(",
"db",
".",
"encodeKVKey",
"(",
"keys",
"[",
"i",
"]",
")",
")",
"\n",
"}",
"\n\n",
"return",
"values",
",",
"nil",
"\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\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"var",
"err",
"error",
"\n",
"var",
"key",
"[",
"]",
"byte",
"\n",
"var",
"value",
"[",
"]",
"byte",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"args",
"[",
"i",
"]",
".",
"Key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"args",
"[",
"i",
"]",
".",
"Value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"args",
"[",
"i",
"]",
".",
"Key",
")",
"\n\n",
"value",
"=",
"args",
"[",
"i",
"]",
".",
"Value",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"err",
"\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",
"if",
"err",
":=",
"checkValueSize",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] |
// 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",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"var",
"n",
"int64",
"=",
"1",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"!=",
"nil",
"{",
"n",
"=",
"0",
"\n",
"}",
"else",
"{",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// 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",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"duration",
"<=",
"0",
"{",
"return",
"errExpireValue",
"\n",
"}",
"\n\n",
"ek",
":=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"Put",
"(",
"ek",
",",
"value",
")",
"\n",
"db",
".",
"expireAt",
"(",
"t",
",",
"KVType",
",",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n\n",
"return",
"t",
".",
"Commit",
"(",
")",
"\n",
"}"
] |
// 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\n",
"return",
"db",
".",
"setExpireAt",
"(",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n",
"}"
] |
// 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",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"setExpireAt",
"(",
"key",
",",
"when",
")",
"\n",
"}"
] |
// 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",
"}",
"\n\n",
"return",
"db",
".",
"ttl",
"(",
"KVType",
",",
"key",
")",
"\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\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n",
"n",
",",
"err",
":=",
"db",
".",
"rmExpire",
"(",
"t",
",",
"KVType",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"err",
"\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",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"value",
")",
"+",
"offset",
">",
"MaxValueSize",
"{",
"return",
"0",
",",
"errValueSize",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"oldValue",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"extra",
":=",
"offset",
"+",
"len",
"(",
"value",
")",
"-",
"len",
"(",
"oldValue",
")",
"\n",
"if",
"extra",
">",
"0",
"{",
"oldValue",
"=",
"append",
"(",
"oldValue",
",",
"make",
"(",
"[",
"]",
"byte",
",",
"extra",
")",
"...",
")",
"\n",
"}",
"\n\n",
"copy",
"(",
"oldValue",
"[",
"offset",
":",
"]",
",",
"value",
")",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"oldValue",
")",
"\n\n",
"if",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"int64",
"(",
"len",
"(",
"oldValue",
")",
")",
",",
"nil",
"\n",
"}"
] |
// 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",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"valLen",
":=",
"len",
"(",
"value",
")",
"\n\n",
"start",
",",
"end",
"=",
"getRange",
"(",
"start",
",",
"end",
",",
"valLen",
")",
"\n\n",
"if",
"start",
">",
"end",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"value",
"[",
"start",
":",
"end",
"+",
"1",
"]",
",",
"nil",
"\n",
"}"
] |
// 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",
",",
"err",
"\n",
"}",
"\n\n",
"n",
":=",
"s",
".",
"Size",
"(",
")",
"\n",
"s",
".",
"Free",
"(",
")",
"\n",
"return",
"int64",
"(",
"n",
")",
",",
"nil",
"\n",
"}"
] |
// 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\n",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"oldValue",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"oldValue",
")",
"+",
"len",
"(",
"value",
")",
">",
"MaxValueSize",
"{",
"return",
"0",
",",
"errValueSize",
"\n",
"}",
"\n\n",
"oldValue",
"=",
"append",
"(",
"oldValue",
",",
"value",
"...",
")",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"oldValue",
")",
"\n\n",
"if",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"int64",
"(",
"len",
"(",
"oldValue",
")",
")",
",",
"nil",
"\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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"op",
"=",
"strings",
".",
"ToLower",
"(",
"op",
")",
"\n",
"if",
"len",
"(",
"srcKeys",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"else",
"if",
"op",
"==",
"BitNot",
"&&",
"len",
"(",
"srcKeys",
")",
">",
"1",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"srcKeys",
")",
"<",
"2",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"key",
":=",
"db",
".",
"encodeKVKey",
"(",
"srcKeys",
"[",
"0",
"]",
")",
"\n\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"op",
"==",
"BitNot",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"value",
")",
";",
"i",
"++",
"{",
"value",
"[",
"i",
"]",
"=",
"^",
"value",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"else",
"{",
"for",
"j",
":=",
"1",
";",
"j",
"<",
"len",
"(",
"srcKeys",
")",
";",
"j",
"++",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"srcKeys",
"[",
"j",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"srcKeys",
"[",
"j",
"]",
")",
"\n",
"ovalue",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"value",
")",
"<",
"len",
"(",
"ovalue",
")",
"{",
"value",
",",
"ovalue",
"=",
"ovalue",
",",
"value",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"ovalue",
")",
";",
"i",
"++",
"{",
"switch",
"op",
"{",
"case",
"BitAND",
":",
"value",
"[",
"i",
"]",
"&=",
"ovalue",
"[",
"i",
"]",
"\n",
"case",
"BitOR",
":",
"value",
"[",
"i",
"]",
"|=",
"ovalue",
"[",
"i",
"]",
"\n",
"case",
"BitXOR",
":",
"value",
"[",
"i",
"]",
"^=",
"ovalue",
"[",
"i",
"]",
"\n",
"default",
":",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"op",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"len",
"(",
"ovalue",
")",
";",
"i",
"<",
"len",
"(",
"value",
")",
";",
"i",
"++",
"{",
"switch",
"op",
"{",
"case",
"BitAND",
":",
"value",
"[",
"i",
"]",
"&=",
"0",
"\n",
"case",
"BitOR",
":",
"value",
"[",
"i",
"]",
"|=",
"0",
"\n",
"case",
"BitXOR",
":",
"value",
"[",
"i",
"]",
"^=",
"0",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"destKey",
")",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n\n",
"if",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"int64",
"(",
"len",
"(",
"value",
")",
")",
",",
"nil",
"\n",
"}"
] |
// 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",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"start",
",",
"end",
"=",
"getRange",
"(",
"start",
",",
"end",
",",
"len",
"(",
"value",
")",
")",
"\n",
"value",
"=",
"value",
"[",
"start",
":",
"end",
"+",
"1",
"]",
"\n\n",
"var",
"n",
"int64",
"\n\n",
"pos",
":=",
"0",
"\n",
"for",
";",
"pos",
"+",
"4",
"<=",
"len",
"(",
"value",
")",
";",
"pos",
"=",
"pos",
"+",
"4",
"{",
"n",
"+=",
"int64",
"(",
"numberBitCount",
"(",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"value",
"[",
"pos",
":",
"pos",
"+",
"4",
"]",
")",
")",
")",
"\n",
"}",
"\n\n",
"for",
";",
"pos",
"<",
"len",
"(",
"value",
")",
";",
"pos",
"++",
"{",
"n",
"+=",
"int64",
"(",
"bitsInByte",
"[",
"value",
"[",
"pos",
"]",
"]",
")",
"\n",
"}",
"\n\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] |
// 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",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"(",
"on",
"&",
"^",
"1",
")",
"!=",
"0",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"on",
")",
"\n",
"}",
"\n\n",
"var",
"skipValue",
"uint8",
"\n",
"if",
"on",
"==",
"0",
"{",
"skipValue",
"=",
"0xFF",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"start",
",",
"end",
"=",
"getRange",
"(",
"start",
",",
"end",
",",
"len",
"(",
"value",
")",
")",
"\n",
"value",
"=",
"value",
"[",
"start",
":",
"end",
"+",
"1",
"]",
"\n\n",
"for",
"i",
",",
"v",
":=",
"range",
"value",
"{",
"if",
"uint8",
"(",
"v",
")",
"!=",
"skipValue",
"{",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"8",
";",
"j",
"++",
"{",
"isNull",
":=",
"uint8",
"(",
"v",
")",
"&",
"(",
"1",
"<<",
"uint8",
"(",
"7",
"-",
"j",
")",
")",
"==",
"0",
"\n\n",
"if",
"(",
"on",
"==",
"1",
"&&",
"!",
"isNull",
")",
"||",
"(",
"on",
"==",
"0",
"&&",
"isNull",
")",
"{",
"return",
"int64",
"(",
"(",
"start",
"+",
"i",
")",
"*",
"8",
"+",
"j",
")",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"-",
"1",
",",
"nil",
"\n",
"}"
] |
// 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",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"(",
"on",
"&",
"^",
"1",
")",
"!=",
"0",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"on",
")",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"byteOffset",
":=",
"int",
"(",
"uint32",
"(",
"offset",
")",
">>",
"3",
")",
"\n",
"extra",
":=",
"byteOffset",
"+",
"1",
"-",
"len",
"(",
"value",
")",
"\n",
"if",
"extra",
">",
"0",
"{",
"value",
"=",
"append",
"(",
"value",
",",
"make",
"(",
"[",
"]",
"byte",
",",
"extra",
")",
"...",
")",
"\n",
"}",
"\n\n",
"byteVal",
":=",
"value",
"[",
"byteOffset",
"]",
"\n",
"bit",
":=",
"7",
"-",
"uint8",
"(",
"uint32",
"(",
"offset",
")",
"&",
"0x7",
")",
"\n",
"bitVal",
":=",
"byteVal",
"&",
"(",
"1",
"<<",
"bit",
")",
"\n\n",
"byteVal",
"&=",
"^",
"(",
"1",
"<<",
"bit",
")",
"\n",
"byteVal",
"|=",
"(",
"uint8",
"(",
"on",
"&",
"0x1",
")",
"<<",
"bit",
")",
"\n\n",
"value",
"[",
"byteOffset",
"]",
"=",
"byteVal",
"\n\n",
"t",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n",
"if",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"bitVal",
">",
"0",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] |
// 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",
",",
"err",
"\n",
"}",
"\n\n",
"key",
"=",
"db",
".",
"encodeKVKey",
"(",
"key",
")",
"\n\n",
"value",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"byteOffset",
":=",
"uint32",
"(",
"offset",
")",
">>",
"3",
"\n",
"bit",
":=",
"7",
"-",
"uint8",
"(",
"uint32",
"(",
"offset",
")",
"&",
"0x7",
")",
"\n\n",
"if",
"byteOffset",
">=",
"uint32",
"(",
"len",
"(",
"value",
")",
")",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"bitVal",
":=",
"value",
"[",
"byteOffset",
"]",
"&",
"(",
"1",
"<<",
"bit",
")",
"\n",
"if",
"bitVal",
">",
"0",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] |
// 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",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"++",
"{",
"l",
".",
"noticeReplication",
"(",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"l",
".",
"rDoneCh",
":",
"case",
"<-",
"l",
".",
"quit",
":",
"return",
"nil",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n\n",
"b",
",",
"err",
":=",
"l",
".",
"r",
".",
"CommitIDBehind",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"!",
"b",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// 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",
".",
"Readonly",
"{",
"return",
"ErrRplInRDWR",
"\n",
"}",
"\n\n",
"log",
":=",
"&",
"rpl",
".",
"Log",
"{",
"}",
"\n\n",
"for",
"{",
"if",
"err",
":=",
"log",
".",
"Decode",
"(",
"rb",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"l",
".",
"r",
".",
"StoreLog",
"(",
"log",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"l",
".",
"noticeReplication",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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\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",
"(",
")",
"{",
"// no replication log",
"nextLogID",
"=",
"0",
"\n",
"err",
"=",
"ErrRplNotSupport",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"firtID",
",",
"lastID",
"uint64",
"\n\n",
"firtID",
",",
"err",
"=",
"l",
".",
"r",
".",
"FirstLogID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"startLogID",
"<",
"firtID",
"{",
"err",
"=",
"ErrLogMissed",
"\n",
"return",
"\n",
"}",
"\n\n",
"lastID",
",",
"err",
"=",
"l",
".",
"r",
".",
"LastLogID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"nextLogID",
"=",
"startLogID",
"\n\n",
"log",
":=",
"&",
"rpl",
".",
"Log",
"{",
"}",
"\n",
"for",
"i",
":=",
"startLogID",
";",
"i",
"<=",
"lastID",
";",
"i",
"++",
"{",
"if",
"err",
"=",
"l",
".",
"r",
".",
"GetLog",
"(",
"i",
",",
"log",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"log",
".",
"Encode",
"(",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"nextLogID",
"=",
"i",
"+",
"1",
"\n\n",
"n",
"+=",
"log",
".",
"Size",
"(",
")",
"\n\n",
"if",
"n",
">",
"maxReplLogSize",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// 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",
"error",
")",
"{",
"n",
",",
"nextLogID",
",",
"err",
"=",
"l",
".",
"ReadLogsTo",
"(",
"startLogID",
",",
"w",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"else",
"if",
"n",
"!=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"//no events read",
"select",
"{",
"case",
"<-",
"l",
".",
"r",
".",
"WaitLog",
"(",
")",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Duration",
"(",
"timeout",
")",
"*",
"time",
".",
"Second",
")",
":",
"case",
"<-",
"quitCh",
":",
"return",
"\n",
"}",
"\n",
"return",
"l",
".",
"ReadLogsTo",
"(",
"startLogID",
",",
"w",
")",
"\n",
"}"
] |
// 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\n",
"l",
".",
"rhs",
"=",
"append",
"(",
"l",
".",
"rhs",
",",
"h",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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\n",
"return",
"l",
".",
"r",
".",
"Stat",
"(",
")",
"\n",
"}"
] |
// 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\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"score",
":=",
"args",
"[",
"i",
"]",
".",
"Score",
"\n",
"member",
":=",
"args",
"[",
"i",
"]",
".",
"Member",
"\n\n",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"member",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"n",
",",
"err",
":=",
"db",
".",
"zSetItem",
"(",
"t",
",",
"key",
",",
"score",
",",
"member",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"n",
"==",
"0",
"{",
"//add new",
"num",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"db",
".",
"zIncrSize",
"(",
"t",
",",
"key",
",",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\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\n",
"sk",
":=",
"db",
".",
"zEncodeSizeKey",
"(",
"key",
")",
"\n",
"return",
"Int64",
"(",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
")",
"\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",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"\n\n",
"score",
":=",
"InvalidScore",
"\n\n",
"k",
":=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"member",
")",
"\n",
"if",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"k",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"InvalidScore",
",",
"ErrScoreMiss",
"\n",
"}",
"else",
"{",
"if",
"score",
",",
"err",
"=",
"Int64",
"(",
"v",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"score",
",",
"nil",
"\n",
"}"
] |
// 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",
"}",
"\n\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"members",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"members",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"n",
",",
"err",
":=",
"db",
".",
"zDelItem",
"(",
"t",
",",
"key",
",",
"members",
"[",
"i",
"]",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"n",
"==",
"1",
"{",
"num",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"db",
".",
"zIncrSize",
"(",
"t",
",",
"key",
",",
"-",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"ek",
":=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"member",
")",
"\n\n",
"var",
"oldScore",
"int64",
"\n",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"ek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"db",
".",
"zIncrSize",
"(",
"t",
",",
"key",
",",
"1",
")",
"\n",
"}",
"else",
"{",
"if",
"oldScore",
",",
"err",
"=",
"Int64",
"(",
"v",
",",
"err",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidScore",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"newScore",
":=",
"oldScore",
"+",
"delta",
"\n",
"if",
"newScore",
">=",
"MaxScore",
"||",
"newScore",
"<=",
"MinScore",
"{",
"return",
"InvalidScore",
",",
"errScoreOverflow",
"\n",
"}",
"\n\n",
"sk",
":=",
"db",
".",
"zEncodeScoreKey",
"(",
"key",
",",
"member",
",",
"newScore",
")",
"\n",
"t",
".",
"Put",
"(",
"sk",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"t",
".",
"Put",
"(",
"ek",
",",
"PutInt64",
"(",
"newScore",
")",
")",
"\n\n",
"if",
"v",
"!=",
"nil",
"{",
"// so as to update score, we must delete the old one",
"oldSk",
":=",
"db",
".",
"zEncodeScoreKey",
"(",
"key",
",",
"member",
",",
"oldScore",
")",
"\n",
"t",
".",
"Delete",
"(",
"oldSk",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"newScore",
",",
"err",
"\n",
"}"
] |
// 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\n",
"rmCnt",
",",
"err",
":=",
"db",
".",
"zRemRange",
"(",
"t",
",",
"key",
",",
"MinScore",
",",
"MaxScore",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"rmCnt",
",",
"err",
"\n",
"}"
] |
// 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",
"(",
")",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"if",
"_",
",",
"err",
":=",
"db",
".",
"zRemRange",
"(",
"t",
",",
"key",
",",
"MinScore",
",",
"MaxScore",
",",
"0",
",",
"-",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n\n",
"return",
"int64",
"(",
"len",
"(",
"keys",
")",
")",
",",
"err",
"\n",
"}"
] |
// 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",
",",
"stop",
",",
"false",
")",
"\n",
"}"
] |
// 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",
".",
"ZRangeByScoreGeneric",
"(",
"key",
",",
"min",
",",
"max",
",",
"offset",
",",
"count",
",",
"false",
")",
"\n",
"}"
] |
// 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",
",",
"start",
",",
"stop",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"rmCnt",
"int64",
"\n\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"rmCnt",
",",
"err",
"=",
"db",
".",
"zRemRange",
"(",
"t",
",",
"key",
",",
"MinScore",
",",
"MaxScore",
",",
"offset",
",",
"count",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"rmCnt",
",",
"err",
"\n",
"}"
] |
// 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",
",",
"stop",
",",
"true",
")",
"\n",
"}"
] |
// 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",
":=",
"db",
".",
"zParseLimit",
"(",
"key",
",",
"start",
",",
"stop",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"zRange",
"(",
"key",
",",
"MinScore",
",",
"MaxScore",
",",
"offset",
",",
"count",
",",
"reverse",
")",
"\n",
"}"
] |
// 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",
")",
"{",
"return",
"db",
".",
"zRange",
"(",
"key",
",",
"min",
",",
"max",
",",
"offset",
",",
"count",
",",
"reverse",
")",
"\n",
"}"
] |
// 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\n",
"return",
"db",
".",
"zExpireAt",
"(",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n",
"}"
] |
// 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",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"zExpireAt",
"(",
"key",
",",
"when",
")",
"\n",
"}"
] |
// 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",
"}",
"\n\n",
"return",
"db",
".",
"ttl",
"(",
"ZSetType",
",",
"key",
")",
"\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",
"}",
"\n\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
",",
"err",
":=",
"db",
".",
"rmExpire",
"(",
"t",
",",
"ZSetType",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"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",
"destMap",
"=",
"map",
"[",
"string",
"]",
"int64",
"{",
"}",
"\n",
"aggregateFunc",
":=",
"getAggregateFunc",
"(",
"aggregate",
")",
"\n",
"if",
"aggregateFunc",
"==",
"nil",
"{",
"return",
"0",
",",
"errInvalidAggregate",
"\n",
"}",
"\n",
"if",
"len",
"(",
"srcKeys",
")",
"<",
"1",
"{",
"return",
"0",
",",
"errInvalidSrcKeyNum",
"\n",
"}",
"\n",
"if",
"weights",
"!=",
"nil",
"{",
"if",
"len",
"(",
"srcKeys",
")",
"!=",
"len",
"(",
"weights",
")",
"{",
"return",
"0",
",",
"errInvalidWeightNum",
"\n",
"}",
"\n",
"}",
"else",
"{",
"weights",
"=",
"make",
"(",
"[",
"]",
"int64",
",",
"len",
"(",
"srcKeys",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"weights",
")",
";",
"i",
"++",
"{",
"weights",
"[",
"i",
"]",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"key",
":=",
"range",
"srcKeys",
"{",
"scorePairs",
",",
"err",
":=",
"db",
".",
"ZRange",
"(",
"key",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"pair",
":=",
"range",
"scorePairs",
"{",
"if",
"score",
",",
"ok",
":=",
"destMap",
"[",
"hack",
".",
"String",
"(",
"pair",
".",
"Member",
")",
"]",
";",
"!",
"ok",
"{",
"destMap",
"[",
"hack",
".",
"String",
"(",
"pair",
".",
"Member",
")",
"]",
"=",
"pair",
".",
"Score",
"*",
"weights",
"[",
"i",
"]",
"\n",
"}",
"else",
"{",
"destMap",
"[",
"hack",
".",
"String",
"(",
"pair",
".",
"Member",
")",
"]",
"=",
"aggregateFunc",
"(",
"score",
",",
"pair",
".",
"Score",
"*",
"weights",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"db",
".",
"zDelete",
"(",
"t",
",",
"destKey",
")",
"\n\n",
"for",
"member",
",",
"score",
":=",
"range",
"destMap",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"destKey",
",",
"[",
"]",
"byte",
"(",
"member",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"db",
".",
"zSetItem",
"(",
"t",
",",
"destKey",
",",
"score",
",",
"[",
"]",
"byte",
"(",
"member",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"var",
"n",
"=",
"int64",
"(",
"len",
"(",
"destMap",
")",
")",
"\n",
"sk",
":=",
"db",
".",
"zEncodeSizeKey",
"(",
"destKey",
")",
"\n",
"t",
".",
"Put",
"(",
"sk",
",",
"PutInt64",
"(",
"n",
")",
")",
"\n\n",
"if",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] |
// 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",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"min",
"==",
"nil",
"{",
"min",
"=",
"db",
".",
"zEncodeStartSetKey",
"(",
"key",
")",
"\n",
"}",
"else",
"{",
"min",
"=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"min",
")",
"\n",
"}",
"\n",
"if",
"max",
"==",
"nil",
"{",
"max",
"=",
"db",
".",
"zEncodeStopSetKey",
"(",
"key",
")",
"\n",
"}",
"else",
"{",
"max",
"=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"max",
")",
"\n",
"}",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"RangeLimitIterator",
"(",
"min",
",",
"max",
",",
"rangeType",
",",
"offset",
",",
"count",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"ay",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"16",
")",
"\n",
"for",
";",
"it",
".",
"Valid",
"(",
")",
";",
"it",
".",
"Next",
"(",
")",
"{",
"if",
"_",
",",
"m",
",",
"err",
":=",
"db",
".",
"zDecodeSetKey",
"(",
"it",
".",
"Key",
"(",
")",
")",
";",
"err",
"==",
"nil",
"{",
"ay",
"=",
"append",
"(",
"ay",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"ay",
",",
"nil",
"\n",
"}"
] |
// 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",
"{",
"min",
"=",
"db",
".",
"zEncodeStartSetKey",
"(",
"key",
")",
"\n",
"}",
"else",
"{",
"min",
"=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"min",
")",
"\n",
"}",
"\n",
"if",
"max",
"==",
"nil",
"{",
"max",
"=",
"db",
".",
"zEncodeStopSetKey",
"(",
"key",
")",
"\n",
"}",
"else",
"{",
"max",
"=",
"db",
".",
"zEncodeSetKey",
"(",
"key",
",",
"max",
")",
"\n",
"}",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"RangeIterator",
"(",
"min",
",",
"max",
",",
"rangeType",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"var",
"n",
"int64",
"\n",
"for",
";",
"it",
".",
"Valid",
"(",
")",
";",
"it",
".",
"Next",
"(",
")",
"{",
"n",
"++",
"\n",
"}",
"\n\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] |
// 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",
"}",
"\n",
"sk",
":=",
"db",
".",
"zEncodeSizeKey",
"(",
"key",
")",
"\n",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
"\n",
"if",
"v",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"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",
"{",
"// invalid command format",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"hack",
".",
"String",
"(",
"upperSlice",
"(",
"c",
".",
"args",
"[",
"1",
"]",
")",
")",
"!=",
"\"",
"\"",
"{",
"// invalid command format, just resturn here",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"index",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"hack",
".",
"String",
"(",
"c",
".",
"args",
"[",
"0",
"]",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"db",
",",
"err",
":=",
"c",
".",
"app",
".",
"ldb",
".",
"Select",
"(",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"db",
"=",
"db",
"\n\n",
"c",
".",
"cmd",
"=",
"hack",
".",
"String",
"(",
"lowerSlice",
"(",
"c",
".",
"args",
"[",
"2",
"]",
")",
")",
"\n",
"c",
".",
"args",
"=",
"c",
".",
"args",
"[",
"3",
":",
"]",
"\n\n",
"return",
"nil",
"\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",
",",
"err",
"error",
")",
"{",
"if",
"!",
"reverse",
"{",
"if",
"minKey",
",",
"err",
"=",
"db",
".",
"encodeDataScanMinKey",
"(",
"storeDataType",
",",
"key",
",",
"cursor",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"maxKey",
",",
"err",
"=",
"db",
".",
"encodeDataScanMaxKey",
"(",
"storeDataType",
",",
"key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"minKey",
",",
"err",
"=",
"db",
".",
"encodeDataScanMinKey",
"(",
"storeDataType",
",",
"key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"maxKey",
",",
"err",
"=",
"db",
".",
"encodeDataScanMaxKey",
"(",
"storeDataType",
",",
"key",
",",
"cursor",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// 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",
"db",
".",
"hScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"false",
")",
"\n",
"}"
] |
// 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",
"db",
".",
"hScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"true",
")",
"\n",
"}"
] |
// 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",
")",
"{",
"return",
"db",
".",
"sScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"false",
")",
"\n",
"}"
] |
// 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",
")",
"{",
"return",
"db",
".",
"sScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"true",
")",
"\n",
"}"
] |
// 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",
"db",
".",
"zScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"false",
")",
"\n",
"}"
] |
// 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",
"db",
".",
"zScanGeneric",
"(",
"key",
",",
"cursor",
",",
"count",
",",
"inclusive",
",",
"match",
",",
"true",
")",
"\n",
"}"
] |
// 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",
")",
"\n",
"}",
"\n\n",
"wb",
".",
"data",
".",
"Load",
"(",
"data",
")",
"\n",
"return",
"wb",
".",
"data",
"\n",
"}"
] |
// 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",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"else",
"if",
"len",
"(",
"v",
")",
"!=",
"8",
"{",
"return",
"0",
",",
"errIntNumber",
"\n",
"}",
"\n\n",
"return",
"binary",
".",
"LittleEndian",
".",
"Uint64",
"(",
"v",
")",
",",
"nil",
"\n",
"}"
] |
// 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",
"\n",
"}"
] |
// 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",
"\n",
"}",
"else",
"{",
"return",
"strconv",
".",
"ParseInt",
"(",
"hack",
".",
"String",
"(",
"v",
")",
",",
"10",
",",
"64",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"strconv",
".",
"ParseUint",
"(",
"hack",
".",
"String",
"(",
"v",
")",
",",
"10",
",",
"64",
")",
"\n",
"}",
"\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",
"\n",
"}",
"else",
"{",
"res",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"hack",
".",
"String",
"(",
"v",
")",
",",
"10",
",",
"32",
")",
"\n",
"return",
"int32",
"(",
"res",
")",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// 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",
"\n",
"}",
"else",
"{",
"res",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"hack",
".",
"String",
"(",
"v",
")",
",",
"10",
",",
"8",
")",
"\n",
"return",
"int8",
"(",
"res",
")",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// 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",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"values",
",",
"err",
":=",
"db",
".",
"LRange",
"(",
"key",
",",
"0",
",",
"-",
"1",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"xsort",
"(",
"values",
",",
"offset",
",",
"size",
",",
"alpha",
",",
"desc",
",",
"sortBy",
",",
"sortGet",
")",
"\n",
"}"
] |
// 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",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"values",
",",
"err",
":=",
"db",
".",
"ZRangeByLex",
"(",
"key",
",",
"nil",
",",
"nil",
",",
"store",
".",
"RangeClose",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"xsort",
"(",
"values",
",",
"offset",
",",
"size",
",",
"alpha",
",",
"desc",
",",
"sortBy",
",",
"sortGet",
")",
"\n",
"}"
] |
// 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\n",
"return",
"Int64",
"(",
"db",
".",
"bucket",
".",
"Get",
"(",
"db",
".",
"hEncodeSizeKey",
"(",
"key",
")",
")",
")",
"\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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
",",
"err",
":=",
"db",
".",
"hSetItem",
"(",
"key",
",",
"field",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// 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",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"bucket",
".",
"Get",
"(",
"db",
".",
"hEncodeHashKey",
"(",
"key",
",",
"field",
")",
")",
"\n",
"}"
] |
// 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\n",
"var",
"err",
"error",
"\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"args",
"[",
"i",
"]",
".",
"Field",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"err",
":=",
"checkValueSize",
"(",
"args",
"[",
"i",
"]",
".",
"Value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ek",
"=",
"db",
".",
"hEncodeHashKey",
"(",
"key",
",",
"args",
"[",
"i",
"]",
".",
"Field",
")",
"\n\n",
"if",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"ek",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"num",
"++",
"\n",
"}",
"\n\n",
"t",
".",
"Put",
"(",
"ek",
",",
"args",
"[",
"i",
"]",
".",
"Value",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"hIncrSize",
"(",
"key",
",",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"//todo add binglog",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"err",
"\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\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"r",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"args",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ek",
"=",
"db",
".",
"hEncodeHashKey",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
"\n\n",
"r",
"[",
"i",
"]",
"=",
"it",
".",
"Find",
"(",
"ek",
")",
"\n",
"}",
"\n\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] |
// 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\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"v",
"[",
"]",
"byte",
"\n",
"var",
"err",
"error",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ek",
"=",
"db",
".",
"hEncodeHashKey",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
"\n\n",
"v",
"=",
"it",
".",
"RawFind",
"(",
"ek",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"else",
"{",
"num",
"++",
"\n",
"t",
".",
"Delete",
"(",
"ek",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"hIncrSize",
"(",
"key",
",",
"-",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n\n",
"return",
"num",
",",
"err",
"\n",
"}"
] |
// 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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"err",
"error",
"\n\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"ek",
"=",
"db",
".",
"hEncodeHashKey",
"(",
"key",
",",
"field",
")",
"\n\n",
"var",
"n",
"int64",
"\n",
"if",
"n",
",",
"err",
"=",
"StrInt64",
"(",
"db",
".",
"bucket",
".",
"Get",
"(",
"ek",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"n",
"+=",
"delta",
"\n\n",
"_",
",",
"err",
"=",
"db",
".",
"hSetItem",
"(",
"key",
",",
"field",
",",
"num",
".",
"FormatInt64ToSlice",
"(",
"n",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// 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
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HGetAll
|
func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, f, err := db.hDecodeHashKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, FVPair{Field: f, Value: it.Value()})
}
return v, nil
}
|
go
|
func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, f, err := db.hDecodeHashKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, FVPair{Field: f, Value: it.Value()})
}
return v, nil
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HGetAll",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"start",
":=",
"db",
".",
"hEncodeStartKey",
"(",
"key",
")",
"\n",
"stop",
":=",
"db",
".",
"hEncodeStopKey",
"(",
"key",
")",
"\n\n",
"v",
":=",
"make",
"(",
"[",
"]",
"FVPair",
",",
"0",
",",
"16",
")",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"RangeLimitIterator",
"(",
"start",
",",
"stop",
",",
"store",
".",
"RangeROpen",
",",
"0",
",",
"-",
"1",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"for",
";",
"it",
".",
"Valid",
"(",
")",
";",
"it",
".",
"Next",
"(",
")",
"{",
"_",
",",
"f",
",",
"err",
":=",
"db",
".",
"hDecodeHashKey",
"(",
"it",
".",
"Key",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"v",
"=",
"append",
"(",
"v",
",",
"FVPair",
"{",
"Field",
":",
"f",
",",
"Value",
":",
"it",
".",
"Value",
"(",
")",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] |
// HGetAll returns all field-values.
|
[
"HGetAll",
"returns",
"all",
"field",
"-",
"values",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L378-L401
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HClear
|
func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
}
|
go
|
func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"num",
":=",
"db",
".",
"hDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"HashType",
",",
"key",
")",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\n",
"}"
] |
// HClear clears the data.
|
[
"HClear",
"clears",
"the",
"data",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L455-L469
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HMclear
|
func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
}
|
go
|
func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"db",
".",
"hDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"HashType",
",",
"key",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"int64",
"(",
"len",
"(",
"keys",
")",
")",
",",
"err",
"\n",
"}"
] |
// HMclear cleans multi data.
|
[
"HMclear",
"cleans",
"multi",
"data",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L472-L488
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HExpire
|
func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
}
|
go
|
func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"hExpireAt",
"(",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n",
"}"
] |
// HExpire expires the data with duration.
|
[
"HExpire",
"expires",
"the",
"data",
"with",
"duration",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L500-L506
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HExpireAt
|
func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
}
|
go
|
func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"hExpireAt",
"(",
"key",
",",
"when",
")",
"\n",
"}"
] |
// HExpireAt expires the data at time when.
|
[
"HExpireAt",
"expires",
"the",
"data",
"at",
"time",
"when",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L509-L515
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HTTL
|
func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
}
|
go
|
func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"ttl",
"(",
"HashType",
",",
"key",
")",
"\n",
"}"
] |
// HTTL gets the TTL of data.
|
[
"HTTL",
"gets",
"the",
"TTL",
"of",
"data",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L518-L524
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HPersist
|
func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
}
|
go
|
func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
",",
"err",
":=",
"db",
".",
"rmExpire",
"(",
"t",
",",
"HashType",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// HPersist removes the TTL of data.
|
[
"HPersist",
"removes",
"the",
"TTL",
"of",
"data",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L527-L543
|
train
|
siddontang/ledisdb
|
ledis/t_hash.go
|
HKeyExists
|
func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
}
|
go
|
func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"HKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"sk",
":=",
"db",
".",
"hEncodeSizeKey",
"(",
"key",
")",
"\n",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
"\n",
"if",
"v",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}"
] |
// HKeyExists checks whether data exists or not.
|
[
"HKeyExists",
"checks",
"whether",
"data",
"exists",
"or",
"not",
"."
] |
8ceb77e66a9234dc460f28234390a5896a96a584
|
https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L546-L556
|
train
|
maxence-charriere/app
|
dom.go
|
Contains
|
func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
}
|
go
|
func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
}
|
[
"func",
"(",
"e",
"*",
"domEngine",
")",
"Contains",
"(",
"c",
"Compo",
")",
"bool",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"_",
",",
"ok",
":=",
"e",
".",
"compos",
"[",
"c",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] |
// Contains reports whether the given component is in the dom.
|
[
"Contains",
"reports",
"whether",
"the",
"given",
"component",
"is",
"in",
"the",
"dom",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L60-L66
|
train
|
maxence-charriere/app
|
dom.go
|
CompoByID
|
func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
}
|
go
|
func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
}
|
[
"func",
"(",
"e",
"*",
"domEngine",
")",
"CompoByID",
"(",
"id",
"string",
")",
"(",
"Compo",
",",
"error",
")",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"c",
",",
"ok",
":=",
"e",
".",
"compoIDs",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"ErrCompoNotMounted",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"Compo",
",",
"nil",
"\n",
"}"
] |
// CompoByID returns the component with the given identifier.
|
[
"CompoByID",
"returns",
"the",
"component",
"with",
"the",
"given",
"identifier",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L69-L79
|
train
|
maxence-charriere/app
|
dom.go
|
New
|
func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
}
|
go
|
func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
}
|
[
"func",
"(",
"e",
"*",
"domEngine",
")",
"New",
"(",
"c",
"Compo",
")",
"error",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"e",
".",
"close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"e",
".",
"render",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ic",
":=",
"e",
".",
"compos",
"[",
"c",
"]",
"\n",
"e",
".",
"rootID",
"=",
"ic",
".",
"ID",
"\n\n",
"e",
".",
"changes",
"=",
"append",
"(",
"e",
".",
"changes",
",",
"change",
"{",
"Action",
":",
"setRoot",
",",
"NodeID",
":",
"ic",
".",
"ID",
",",
"}",
")",
"\n\n",
"return",
"e",
".",
"sync",
"(",
")",
"\n",
"}"
] |
// New renders the given component and set it as the dom root.
|
[
"New",
"renders",
"the",
"given",
"component",
"and",
"set",
"it",
"as",
"the",
"dom",
"root",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L82-L102
|
train
|
maxence-charriere/app
|
dom.go
|
Close
|
func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
}
|
go
|
func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
}
|
[
"func",
"(",
"e",
"*",
"domEngine",
")",
"Close",
"(",
")",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"e",
".",
"close",
"(",
")",
"\n\n",
"}"
] |
// Close deletes the components and nodes from the dom.
|
[
"Close",
"deletes",
"the",
"components",
"and",
"nodes",
"from",
"the",
"dom",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L105-L111
|
train
|
maxence-charriere/app
|
internal/http/cache.go
|
CacheHandler
|
func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
}
|
go
|
func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
}
|
[
"func",
"CacheHandler",
"(",
"h",
"http",
".",
"Handler",
",",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"cacheHandler",
"{",
"Handler",
":",
"h",
",",
"webDir",
":",
"webDir",
",",
"}",
"\n",
"}"
] |
// CacheHandler returns a decorated version of the given cache that injects
// cache related headers.
|
[
"CacheHandler",
"returns",
"a",
"decorated",
"version",
"of",
"the",
"given",
"cache",
"that",
"injects",
"cache",
"related",
"headers",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L15-L20
|
train
|
maxence-charriere/app
|
internal/http/cache.go
|
GenerateEtag
|
func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
}
|
go
|
func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
}
|
[
"func",
"GenerateEtag",
"(",
")",
"string",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"String",
"(",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"`%x`",
",",
"sha1",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
"t",
")",
")",
")",
"\n",
"}"
] |
// GenerateEtag generates an etag.
|
[
"GenerateEtag",
"generates",
"an",
"etag",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L63-L66
|
train
|
maxence-charriere/app
|
internal/http/cache.go
|
GetEtag
|
func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
}
|
go
|
func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
}
|
[
"func",
"GetEtag",
"(",
"webDir",
"string",
")",
"string",
"{",
"filename",
":=",
"filepath",
".",
"Join",
"(",
"webDir",
",",
"\"",
"\"",
")",
"\n\n",
"etag",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"string",
"(",
"etag",
")",
"\n",
"}"
] |
// GetEtag returns the etag for the given web directory.
|
[
"GetEtag",
"returns",
"the",
"etag",
"for",
"the",
"given",
"web",
"directory",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L69-L77
|
train
|
maxence-charriere/app
|
attr.go
|
jsToGoHandler
|
func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
}
|
go
|
func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
}
|
[
"func",
"jsToGoHandler",
"(",
"name",
",",
"value",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"\"",
"\"",
")",
"{",
"return",
"name",
",",
"value",
"\n",
"}",
"\n\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"value",
",",
"\"",
"\"",
")",
"{",
"return",
"name",
",",
"strings",
".",
"TrimPrefix",
"(",
"value",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"name",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"}"
] |
// jsToGoHandler convert a javascript handler to a go component handler.
|
[
"jsToGoHandler",
"convert",
"a",
"javascript",
"handler",
"to",
"a",
"go",
"component",
"handler",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/attr.go#L12-L22
|
train
|
maxence-charriere/app
|
app.go
|
Import
|
func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
}
|
go
|
func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
}
|
[
"func",
"Import",
"(",
"c",
"...",
"Compo",
")",
"{",
"for",
"_",
",",
"compo",
":=",
"range",
"c",
"{",
"if",
"_",
",",
"err",
":=",
"components",
".",
"register",
"(",
"compo",
")",
";",
"err",
"!=",
"nil",
"{",
"Panicf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Import imports the given components into the app.
// Components must be imported in order the be used by the app package.
// This allows components to be created dynamically when they are found into
// markup.
|
[
"Import",
"imports",
"the",
"given",
"components",
"into",
"the",
"app",
".",
"Components",
"must",
"be",
"imported",
"in",
"order",
"the",
"be",
"used",
"by",
"the",
"app",
"package",
".",
"This",
"allows",
"components",
"to",
"be",
"created",
"dynamically",
"when",
"they",
"are",
"found",
"into",
"markup",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L77-L83
|
train
|
maxence-charriere/app
|
app.go
|
Log
|
func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
}
|
go
|
func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
}
|
[
"func",
"Log",
"(",
"a",
"...",
"interface",
"{",
"}",
")",
"{",
"format",
":=",
"\"",
"\"",
"\n\n",
"for",
"range",
"a",
"{",
"format",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"format",
"=",
"format",
"[",
":",
"len",
"(",
"format",
")",
"-",
"1",
"]",
"\n",
"Logger",
"(",
"format",
",",
"a",
"...",
")",
"\n",
"}"
] |
// Log formats using the default formats for its operands and logs the resulting
// string.
// Spaces are always added between operands and a newline is appended.
|
[
"Log",
"formats",
"using",
"the",
"default",
"formats",
"for",
"its",
"operands",
"and",
"logs",
"the",
"resulting",
"string",
".",
"Spaces",
"are",
"always",
"added",
"between",
"operands",
"and",
"a",
"newline",
"is",
"appended",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L88-L97
|
train
|
maxence-charriere/app
|
app.go
|
Render
|
func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
}
|
go
|
func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
}
|
[
"func",
"Render",
"(",
"c",
"Compo",
")",
"{",
"WhenDebug",
"(",
"func",
"(",
")",
"{",
"Logf",
"(",
"\"",
"\"",
")",
"\n",
"}",
")",
"\n\n",
"if",
"err",
":=",
"render",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"Log",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// Render renders the given component.
// It should be called whenever a component is modified.
//
// It panics if called before Run.
|
[
"Render",
"renders",
"the",
"given",
"component",
".",
"It",
"should",
"be",
"called",
"whenever",
"a",
"component",
"is",
"modified",
".",
"It",
"panics",
"if",
"called",
"before",
"Run",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L167-L175
|
train
|
maxence-charriere/app
|
mapping.go
|
Map
|
func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
}
|
go
|
func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
}
|
[
"func",
"(",
"m",
"*",
"mapping",
")",
"Map",
"(",
"c",
"Compo",
")",
"(",
"f",
"func",
"(",
")",
",",
"err",
"error",
")",
"{",
"if",
"m",
".",
"pipeline",
",",
"err",
"=",
"pipeline",
"(",
"m",
".",
"FieldOrMethod",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"mapTo",
"(",
"reflect",
".",
"ValueOf",
"(",
"c",
")",
")",
"\n",
"}"
] |
// Map performs the mapping to the given component.
|
[
"Map",
"performs",
"the",
"mapping",
"to",
"the",
"given",
"component",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/mapping.go#L91-L97
|
train
|
maxence-charriere/app
|
demo/cmd/demo-wasm/hello.go
|
OnMenuClick
|
func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.MenuItem{
Label: "Source code",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app/blob/master/demo/cmd/demo-wasm/hello.go")
}},
)
}
|
go
|
func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.MenuItem{
Label: "Source code",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app/blob/master/demo/cmd/demo-wasm/hello.go")
}},
)
}
|
[
"func",
"(",
"h",
"*",
"Hello",
")",
"OnMenuClick",
"(",
")",
"{",
"app",
".",
"NewContextMenu",
"(",
"app",
".",
"MenuItem",
"{",
"Label",
":",
"\"",
"\"",
",",
"Keys",
":",
"\"",
"\"",
",",
"OnClick",
":",
"app",
".",
"Reload",
"}",
",",
"app",
".",
"MenuItem",
"{",
"Separator",
":",
"true",
"}",
",",
"app",
".",
"MenuItem",
"{",
"Label",
":",
"\"",
"\"",
",",
"OnClick",
":",
"func",
"(",
")",
"{",
"app",
".",
"Navigate",
"(",
"\"",
"\"",
")",
"\n",
"}",
"}",
",",
"app",
".",
"MenuItem",
"{",
"Label",
":",
"\"",
"\"",
",",
"OnClick",
":",
"func",
"(",
")",
"{",
"app",
".",
"Navigate",
"(",
"\"",
"\"",
")",
"\n",
"}",
"}",
",",
")",
"\n",
"}"
] |
// OnMenuClick creates a context menu when the menu button is clicked.
|
[
"OnMenuClick",
"creates",
"a",
"context",
"menu",
"when",
"the",
"menu",
"button",
"is",
"clicked",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/demo/cmd/demo-wasm/hello.go#L37-L55
|
train
|
maxence-charriere/app
|
internal/http/file.go
|
FileHandler
|
func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
}
|
go
|
func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
}
|
[
"func",
"FileHandler",
"(",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"FileServer",
"(",
"http",
".",
"Dir",
"(",
"webDir",
")",
")",
"\n",
"}"
] |
// FileHandler returns a handler that serves files located in the web directory.
|
[
"FileHandler",
"returns",
"a",
"handler",
"that",
"serves",
"files",
"located",
"in",
"the",
"web",
"directory",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/file.go#L6-L8
|
train
|
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.