// Delete a key
func (client *Client) Delete(key string) error {
client.lock()
defer client.unlock()
rawKey := client.addPrefix(key)
cKey := C.CString(rawKey)
defer C.free(unsafe.Pointer(cKey))
cKeyLen := C.size_t(len(rawKey))
cNoreply := C.bool(client.noreply)
var rst **C.message_result_t
var n C.size_t
errCode := C.client_delete(
client._imp, &cKey, &cKeyLen, cNoreply, 1, &rst, &n,
)
defer C.client_destroy_message_result(client._imp)
if errCode == 0 {
if client.noreply {
return nil
} else if int(n) == 1 {
if (*rst).type_ == C.MSG_DELETED {
return nil
} else if (*rst).type_ == C.MSG_NOT_FOUND {
return ErrCacheMiss
}
}
} else if errCode == C.RET_INVALID_KEY_ERR {
return ErrMalformedKey
}
return networkError(errorMessage[errCode])
}
// Delete a key
func (client *Client) Delete(key string) error {
client.lock()
defer client.unlock()
rawKey := client.addPrefix(key)
cKey := C.CString(rawKey)
defer C.free(unsafe.Pointer(cKey))
cKeyLen := C.size_t(len(rawKey))
cNoreply := C.bool(client.noreply)
var rst **C.message_result_t
var n C.size_t
errCode := C.client_delete(
client._imp, &cKey, &cKeyLen, cNoreply, 1, &rst, &n,
)
defer C.client_destroy_message_result(client._imp)
if errCode == 0 {
if client.noreply {
return nil
} else if int(n) == 1 && ((*rst).type_ == C.MSG_DELETED || (*rst).type_ == C.MSG_NOT_FOUND) {
return nil
}
}
return errors.New(errorMessage[errCode])
}
// DeleteMulti will delete multi keys at once
func (client *Client) DeleteMulti(keys []string) (failedKeys []string, err error) {
client.lock()
defer client.unlock()
var rawKeys []string
if len(client.prefix) == 0 {
rawKeys = keys
} else {
rawKeys = make([]string, len(keys))
for i, key := range keys {
rawKeys[i] = key
}
}
nKeys := len(rawKeys)
cNKeys := C.size_t(nKeys)
cKeys := make([]*C.char, nKeys)
cKeyLens := make([]C.size_t, nKeys)
cNoreply := C.bool(client.noreply)
var results **C.message_result_t
var n C.size_t
for i, key := range rawKeys {
cKey := C.CString(key)
defer C.free(unsafe.Pointer(cKey))
cKeys[i] = cKey
cKeyLen := C.size_t(len(key))
cKeyLens[i] = cKeyLen
}
errCode := C.client_delete(
client._imp, (**C.char)(&cKeys[0]), (*C.size_t)(&cKeyLens[0]), cNoreply, cNKeys,
&results,
&n,
)
defer C.client_destroy_message_result(client._imp)
switch errCode {
case 0:
err = nil
return
case C.RET_INVALID_KEY_ERR:
err = ErrMalformedKey
default:
err = networkError(errorMessage[errCode])
}
if client.noreply {
failedKeys = keys
return
}
deletedKeySet := make(map[string]struct{})
sr := unsafe.Sizeof(*results)
for i := 0; i <= int(n); i++ {
if (*results).type_ == C.MSG_DELETED {
deletedKey := C.GoStringN((*results).key, C.int((*results).key_len))
deletedKeySet[deletedKey] = struct{}{}
}
results = (**C.message_result_t)(
unsafe.Pointer(uintptr(unsafe.Pointer(results)) + sr),
)
}
err = networkError(errorMessage[errCode])
failedKeys = make([]string, len(rawKeys)-len(deletedKeySet))
i := 0
for _, key := range rawKeys {
if _, contains := deletedKeySet[key]; contains {
continue
}
failedKeys[i] = client.removePrefix(key)
i++
}
return
}