mirror of
https://github.com/nabbar/golib.git
synced 2025-10-13 11:33:49 +08:00
854c2fa6e7
- Fix text formatting Package HTTPServer: - fix TLS check, config & loading for server Bump dependancies - change nutsdb owner repos
1681 lines
32 KiB
Go
1681 lines
32 KiB
Go
//go:build !386 && !arm && !mips && !mipsle
|
|
// +build !386,!arm,!mips,!mipsle
|
|
|
|
/***********************************************************************************************************************
|
|
*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2021 Nicolas JUHEL
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*
|
|
**********************************************************************************************************************/
|
|
|
|
package nutsdb
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/lni/dragonboat/v3/statemachine"
|
|
libclu "github.com/nabbar/golib/cluster"
|
|
liberr "github.com/nabbar/golib/errors"
|
|
"github.com/nutsdb/nutsdb"
|
|
"github.com/nutsdb/nutsdb/ds/zset"
|
|
)
|
|
|
|
type Client interface {
|
|
Commands
|
|
Run(cmd CmdCode, args []string) (*CommandResponse, liberr.Error)
|
|
}
|
|
|
|
type clientNutDB struct {
|
|
x context.Context
|
|
t time.Duration
|
|
c func() libclu.Cluster
|
|
w func(ctx context.Context, tick time.Duration)
|
|
}
|
|
|
|
func (c *clientNutDB) call(cmd *CommandRequest, read bool) (*CommandResponse, liberr.Error) {
|
|
var (
|
|
p []byte
|
|
e liberr.Error
|
|
i interface{}
|
|
d statemachine.Result
|
|
r *CommandResponse
|
|
|
|
ok bool
|
|
)
|
|
|
|
if read {
|
|
c.w(c.x, c.t)
|
|
if i, e = c.c().SyncRead(c.x, cmd); e != nil {
|
|
return nil, e
|
|
} else if r, ok = i.(*CommandResponse); !ok {
|
|
return nil, ErrorClientCommandResponseInvalid.Error(nil)
|
|
} else {
|
|
return r, nil
|
|
}
|
|
} else if p, e = cmd.EncodeRequest(); e != nil {
|
|
return nil, e
|
|
} else {
|
|
c.w(c.x, c.t)
|
|
if d, e = c.c().SyncPropose(c.x, c.c().GetNoOPSession(), p); e != nil {
|
|
return nil, e
|
|
} else if r, e = cmd.DecodeResult(d.Data); e != nil {
|
|
return nil, e
|
|
} else {
|
|
return r, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *clientNutDB) strToType(dest reflect.Type, val string) (interface{}, liberr.Error) {
|
|
sliceByte := reflect.ValueOf(make([]byte, 0))
|
|
|
|
switch dest.Kind() {
|
|
case reflect.Bool:
|
|
if v, e := strconv.ParseBool(val); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return v, nil
|
|
}
|
|
case reflect.Int:
|
|
if v, e := strconv.ParseInt(val, 10, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return int(v), nil
|
|
}
|
|
case reflect.Int8:
|
|
if v, e := strconv.ParseInt(val, 10, 8); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return int8(v), nil
|
|
}
|
|
case reflect.Int16:
|
|
if v, e := strconv.ParseInt(val, 10, 16); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return int16(v), nil
|
|
}
|
|
case reflect.Int32:
|
|
if v, e := strconv.ParseInt(val, 10, 32); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return int32(v), nil
|
|
}
|
|
case reflect.Int64:
|
|
if v, e := strconv.ParseInt(val, 10, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return v, nil
|
|
}
|
|
case reflect.Uint:
|
|
if v, e := strconv.ParseUint(val, 10, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return uint(v), nil
|
|
}
|
|
case reflect.Uint8:
|
|
if v, e := strconv.ParseUint(val, 10, 8); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return uint8(v), nil
|
|
}
|
|
case reflect.Uint16:
|
|
if v, e := strconv.ParseUint(val, 10, 16); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return uint16(v), nil
|
|
}
|
|
case reflect.Uint32:
|
|
if v, e := strconv.ParseUint(val, 10, 32); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return uint32(v), nil
|
|
}
|
|
case reflect.Uint64:
|
|
if v, e := strconv.ParseUint(val, 10, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return v, nil
|
|
}
|
|
case reflect.Uintptr:
|
|
return nil, ErrorParamsInvalid.ErrorParent(fmt.Errorf("cannot convert int UintPtr"))
|
|
case reflect.Float32:
|
|
if v, e := strconv.ParseFloat(val, 32); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return float32(v), nil
|
|
}
|
|
case reflect.Float64:
|
|
if v, e := strconv.ParseFloat(val, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return v, nil
|
|
}
|
|
case reflect.Complex64:
|
|
if v, e := strconv.ParseComplex(val, 64); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return complex64(v), nil
|
|
}
|
|
case reflect.Complex128:
|
|
if v, e := strconv.ParseComplex(val, 128); e != nil {
|
|
return nil, ErrorParamsMismatching.ErrorParent(e)
|
|
} else {
|
|
return v, nil
|
|
}
|
|
case reflect.Slice:
|
|
if dest == sliceByte.Type() {
|
|
return []byte(val), nil
|
|
} else {
|
|
return nil, ErrorParamsInvalid.Error(nil)
|
|
}
|
|
case reflect.String:
|
|
return val, nil
|
|
default:
|
|
return nil, ErrorParamsInvalid.Error(nil)
|
|
}
|
|
}
|
|
|
|
func (c *clientNutDB) Run(cmd CmdCode, args []string) (*CommandResponse, liberr.Error) {
|
|
method := reflect.ValueOf(c).MethodByName(cmd.Name())
|
|
nbPrm := method.Type().NumIn()
|
|
|
|
switch cmd {
|
|
case CmdZCount:
|
|
if len(args) < 3 || len(args) > 6 {
|
|
return nil, ErrorParamsInvalidNumber.Error(nil)
|
|
}
|
|
case CmdZRangeByScore:
|
|
if len(args) < 3 || len(args) > 6 {
|
|
return nil, ErrorParamsInvalidNumber.Error(nil)
|
|
}
|
|
default:
|
|
if len(args) != nbPrm {
|
|
return nil, ErrorParamsInvalidNumber.Error(nil)
|
|
}
|
|
}
|
|
|
|
params := make([]reflect.Value, nbPrm)
|
|
opt := &zset.GetByScoreRangeOptions{
|
|
Limit: 0,
|
|
ExcludeStart: false,
|
|
ExcludeEnd: false,
|
|
}
|
|
|
|
for i := 0; i < nbPrm; i++ {
|
|
switch cmd {
|
|
case CmdZCount, CmdZRangeByScore:
|
|
switch i {
|
|
case 3:
|
|
if v, e := c.strToType(reflect.TypeOf(opt.Limit), args[i]); e != nil {
|
|
return nil, e
|
|
} else if v == nil {
|
|
opt.Limit = 0
|
|
} else if vv, ok := v.(int); !ok {
|
|
return nil, ErrorParamsMismatching.Error(nil)
|
|
} else {
|
|
opt.Limit = vv
|
|
}
|
|
case 4:
|
|
if v, e := c.strToType(reflect.TypeOf(opt.ExcludeStart), args[i]); e != nil {
|
|
return nil, e
|
|
} else if v == nil {
|
|
opt.ExcludeStart = false
|
|
} else if vv, ok := v.(bool); !ok {
|
|
return nil, ErrorParamsMismatching.Error(nil)
|
|
} else {
|
|
opt.ExcludeStart = vv
|
|
}
|
|
case 5:
|
|
if v, e := c.strToType(reflect.TypeOf(opt.ExcludeEnd), args[i]); e != nil {
|
|
return nil, e
|
|
} else if v == nil {
|
|
opt.ExcludeEnd = false
|
|
} else if vv, ok := v.(bool); !ok {
|
|
return nil, ErrorParamsMismatching.Error(nil)
|
|
} else {
|
|
opt.ExcludeEnd = vv
|
|
}
|
|
default:
|
|
return nil, ErrorParamsInvalid.Error(nil)
|
|
}
|
|
default:
|
|
if v, e := c.strToType(method.Type().In(i), args[i]); e != nil {
|
|
return nil, e
|
|
} else {
|
|
params[i] = reflect.ValueOf(v)
|
|
}
|
|
}
|
|
}
|
|
|
|
switch cmd {
|
|
case CmdZCount, CmdZRangeByScore:
|
|
params[3] = reflect.ValueOf(opt)
|
|
}
|
|
|
|
resp := method.Call(params)
|
|
|
|
ret := CommandResponse{
|
|
Error: nil,
|
|
Value: make([]interface{}, 0),
|
|
}
|
|
|
|
for i := 0; i < len(resp); i++ {
|
|
v := resp[i].Interface()
|
|
if e, ok := v.(error); ok {
|
|
ret.Error = e
|
|
} else {
|
|
ret.Value = append(ret.Value, v)
|
|
}
|
|
}
|
|
|
|
if ret.Error == nil && len(ret.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
return &ret, nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) Put(bucket string, key, value []byte, ttl uint32) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, value, ttl)
|
|
|
|
if r, f = c.call(d, false); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) PutWithTimestamp(bucket string, key, value []byte, ttl uint32, timestamp uint64) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, value, ttl, timestamp)
|
|
|
|
if r, f = c.call(d, false); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) Get(bucket string, key []byte) (e *nutsdb.Entry, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if e, k = r.Value[0].(*nutsdb.Entry); !k {
|
|
e = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) GetAll(bucket string) (entries nutsdb.Entries, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if entries, k = r.Value[0].(nutsdb.Entries); !k {
|
|
entries = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) RangeScan(bucket string, start, end []byte) (es nutsdb.Entries, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, start, end)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if es, k = r.Value[0].(nutsdb.Entries); !k {
|
|
es = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) PrefixScan(bucket string, prefix []byte, offsetNum int, limitNum int) (es nutsdb.Entries, off int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, prefix, offsetNum, limitNum)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, 0, f
|
|
} else if r == nil {
|
|
return nil, 0, nil
|
|
} else if r.Error != nil {
|
|
return nil, 0, r.Error
|
|
} else if len(r.Value) < 2 {
|
|
return nil, 0, nil
|
|
}
|
|
|
|
if es, k = r.Value[0].(nutsdb.Entries); !k {
|
|
es = nil
|
|
}
|
|
|
|
if off, k = r.Value[1].(int); !k {
|
|
off = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) PrefixSearchScan(bucket string, prefix []byte, reg string, offsetNum int, limitNum int) (es nutsdb.Entries, off int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, prefix, reg, offsetNum, limitNum)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, 0, f
|
|
} else if r == nil {
|
|
return nil, 0, nil
|
|
} else if r.Error != nil {
|
|
return nil, 0, r.Error
|
|
} else if len(r.Value) < 2 {
|
|
return nil, 0, nil
|
|
}
|
|
|
|
if es, k = r.Value[0].(nutsdb.Entries); !k {
|
|
es = nil
|
|
}
|
|
|
|
if off, k = r.Value[1].(int); !k {
|
|
off = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) Delete(bucket string, key []byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) FindTxIDOnDisk(fID, txID uint64) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(fID, txID)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) FindOnDisk(fID uint64, rootOff uint64, key, newKey []byte) (entry *nutsdb.Entry, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(fID, rootOff, key, newKey)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if entry, k = r.Value[0].(*nutsdb.Entry); !k {
|
|
entry = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) FindLeafOnDisk(fID int64, rootOff int64, key, newKey []byte) (bn *nutsdb.BinaryNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(fID, rootOff, key, newKey)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if bn, k = r.Value[0].(*nutsdb.BinaryNode); !k {
|
|
bn = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SAdd(bucket string, key []byte, items ...[]byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, items)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SRem(bucket string, key []byte, items ...[]byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, items)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SAreMembers(bucket string, key []byte, items ...[]byte) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, items)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SIsMember(bucket string, key, item []byte) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, item)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SMembers(bucket string, key []byte) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SHasKey(bucket string, key []byte) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SPop(bucket string, key []byte) (val []byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if val, k = r.Value[0].([]byte); !k {
|
|
val = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SCard(bucket string, key []byte) (card int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if card, k = r.Value[0].(int); !k {
|
|
card = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SDiffByOneBucket(bucket string, key1, key2 []byte) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key1, key2)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SDiffByTwoBuckets(bucket1 string, key1 []byte, bucket2 string, key2 []byte) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket1, key1, bucket2, key2)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SMoveByOneBucket(bucket string, key1, key2, item []byte) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key1, key2, item)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SMoveByTwoBuckets(bucket1 string, key1 []byte, bucket2 string, key2, item []byte) (ok bool, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket1, key1, bucket2, key2, item)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return false, f
|
|
} else if r == nil {
|
|
return false, nil
|
|
} else if r.Error != nil {
|
|
return false, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return false, nil
|
|
}
|
|
|
|
if ok, k = r.Value[0].(bool); !k {
|
|
ok = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SUnionByOneBucket(bucket string, key1, key2 []byte) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key1, key2)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) SUnionByTwoBuckets(bucket1 string, key1 []byte, bucket2 string, key2 []byte) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket1, key1, bucket2, key2)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) RPop(bucket string, key []byte) (item []byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].([]byte); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) RPeek(bucket string, key []byte) (item []byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].([]byte); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) RPush(bucket string, key []byte, values ...[]byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, values)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LPush(bucket string, key []byte, values ...[]byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, values)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LPop(bucket string, key []byte) (item []byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].([]byte); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LPeek(bucket string, key []byte) (item []byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].([]byte); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LSize(bucket string, key []byte) (size int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if size, k = r.Value[0].(int); !k {
|
|
size = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LRange(bucket string, key []byte, start, end int) (list [][]byte, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, start, end)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([][]byte); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LRem(bucket string, key []byte, count int, value []byte) (removedNum int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, count, value)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if removedNum, k = r.Value[0].(int); !k {
|
|
removedNum = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LSet(bucket string, key []byte, index int, value []byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, index, value)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) LTrim(bucket string, key []byte, start, end int) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, start, end)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZAdd(bucket string, key []byte, score float64, val []byte) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key, score, val)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZMembers(bucket string) (list map[string]*zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].(map[string]*zset.SortedSetNode); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZCard(bucket string) (card int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if card, k = r.Value[0].(int); !k {
|
|
card = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZCount(bucket string, start, end float64, opts *zset.GetByScoreRangeOptions) (number int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, start, end, opts)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if number, k = r.Value[0].(int); !k {
|
|
number = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZPopMax(bucket string) (item *zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].(*zset.SortedSetNode); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZPopMin(bucket string) (item *zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].(*zset.SortedSetNode); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZPeekMax(bucket string) (item *zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].(*zset.SortedSetNode); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZPeekMin(bucket string) (item *zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].(*zset.SortedSetNode); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRangeByScore(bucket string, start, end float64, opts *zset.GetByScoreRangeOptions) (list []*zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, start, end, opts)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([]*zset.SortedSetNode); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRangeByRank(bucket string, start, end int) (list []*zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, start, end)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if list, k = r.Value[0].([]*zset.SortedSetNode); !k {
|
|
list = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRem(bucket, key string) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRemRangeByRank(bucket string, start, end int) error {
|
|
var (
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, start, end)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return f
|
|
} else if r == nil {
|
|
return nil
|
|
} else if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRank(bucket string, key []byte) (rank int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if rank, k = r.Value[0].(int); !k {
|
|
rank = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZRevRank(bucket string, key []byte) (rank int, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if rank, k = r.Value[0].(int); !k {
|
|
rank = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZScore(bucket string, key []byte) (score float64, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return 0, f
|
|
} else if r == nil {
|
|
return 0, nil
|
|
} else if r.Error != nil {
|
|
return 0, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return 0, nil
|
|
}
|
|
|
|
if score, k = r.Value[0].(float64); !k {
|
|
score = 0
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// nolint #dupl
|
|
func (c *clientNutDB) ZGetByKey(bucket string, key []byte) (item *zset.SortedSetNode, err error) {
|
|
var (
|
|
k bool
|
|
f liberr.Error
|
|
r *CommandResponse
|
|
d *CommandRequest
|
|
)
|
|
|
|
d = NewCommandByCaller(bucket, key)
|
|
|
|
if r, f = c.call(d, true); f != nil {
|
|
return nil, f
|
|
} else if r == nil {
|
|
return nil, nil
|
|
} else if r.Error != nil {
|
|
return nil, r.Error
|
|
} else if len(r.Value) < 1 {
|
|
return nil, nil
|
|
}
|
|
|
|
if item, k = r.Value[0].(*zset.SortedSetNode); !k {
|
|
item = nil
|
|
}
|
|
|
|
return
|
|
}
|