Solving the challenge 0102

0102/kv.go

@@ -0,0 +1,36 @@
+package db0102
+
+import (
+	"bytes"
+)
+
+type KV struct {
+	mem map[string][]byte
+}
+
+func (kv *KV) Open() error {
+	kv.mem = map[string][]byte{} // empty
+	return nil
+}
+
+func (kv *KV) Close() error { return nil }
+
+func (kv *KV) Get(key []byte) (val []byte, ok bool, err error) {
+	val, ok = kv.mem[string(key)]
+	return
+}
+
+func (kv *KV) Set(key []byte, val []byte) (updated bool, err error) {
+	prev, exist := kv.mem[string(key)]
+	kv.mem[string(key)] = val
+	updated = !exist || !bytes.Equal(prev, val)
+	return
+}
+
+func (kv *KV) Del(key []byte) (deleted bool, err error) {
+	_, deleted = kv.mem[string(key)]
+	delete(kv.mem, string(key))
+	return
+}
+
+// QzBQWVJJOUhU https://trialofcode.org/

0102/kv_entry.go

@@ -0,0 +1,61 @@
+package db0102
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+type Entry struct {
+	key []byte
+	val []byte
+}
+
+func (ent *Entry) Encode() []byte {
+	data := make([]byte, 4+4+len(ent.key)+len(ent.val))
+	binary.LittleEndian.PutUint32(data[0:4], uint32(len(ent.key)))
+	binary.LittleEndian.PutUint32(data[4:8], uint32(len(ent.val)))
+	copy(data[8:], ent.key)
+	copy(data[8+len(ent.key):], ent.val)
+	return data
+}
+
+func (ent *Entry) Decode(r io.Reader) error {
+	key_len := make([]byte, 4)
+	s, err := r.Read(key_len)
+	if err != nil {
+		return err
+	}
+	if s != 4 {
+		return errors.New("invalid size when reading key length")
+	}
+	val_len := make([]byte, 4)
+	s, err = r.Read(val_len)
+	if err != nil {
+		return err
+	}
+	if s != 4 {
+		return errors.New("invalid size when reading val length")
+	}
+	key_data := make([]byte, binary.LittleEndian.Uint32(key_len))
+	s, err = r.Read(key_data)
+	if err != nil {
+		return err
+	}
+	if s != int(binary.LittleEndian.Uint32(key_len)) {
+		return errors.New("invalid size when reading key data")
+	}
+	val_data := make([]byte, binary.LittleEndian.Uint32(val_len))
+	s, err = r.Read(val_data)
+	if err != nil {
+		return err
+	}
+	if s != int(binary.LittleEndian.Uint32(val_len)) {
+		return errors.New("invalid size when reading val data")
+	}
+	ent.key = key_data
+	ent.val = val_data
+	return nil
+}
+
+// QzBQWVJJOUhU https://trialofcode.org/

0102/kv_test.go

@@ -0,0 +1,47 @@
+package db0102
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKVBasic(t *testing.T) {
+	kv := KV{}
+	err := kv.Open()
+	assert.Nil(t, err)
+	defer kv.Close()
+
+	updated, err := kv.Set([]byte("k1"), []byte("v1"))
+	assert.True(t, updated && err == nil)
+
+	val, ok, err := kv.Get([]byte("k1"))
+	assert.True(t, string(val) == "v1" && ok && err == nil)
+
+	_, ok, err = kv.Get([]byte("xxx"))
+	assert.True(t, !ok && err == nil)
+
+	updated, err = kv.Del([]byte("xxx"))
+	assert.True(t, !updated && err == nil)
+
+	updated, err = kv.Del([]byte("k1"))
+	assert.True(t, updated && err == nil)
+
+	_, ok, err = kv.Get([]byte("xxx"))
+	assert.True(t, !ok && err == nil)
+}
+
+func TestEntryEncode(t *testing.T) {
+	ent := Entry{key: []byte("k1"), val: []byte("xxx")}
+	data := []byte{2, 0, 0, 0, 3, 0, 0, 0, 'k', '1', 'x', 'x', 'x'}
+
+	assert.Equal(t, data, ent.Encode())
+
+	decoded := Entry{}
+	err := decoded.Decode(bytes.NewBuffer(data))
+	assert.Nil(t, err)
+	assert.Equal(t, ent, decoded)
+}
+
+// QzBQWVJJOUhU https://trialofcode.org/