More functionality

2024-11-26 17:15:21 -06:00
parent 1ccac4d7b9
commit 58cd1cf257
3 changed files with 489 additions and 26 deletions
@@ -0,0 +1,323 @@
+package boltease
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/boltdb/bolt"
+)
+
+func DoUpdate(b *DB, path []string, fn func(bkt *bolt.Bucket) error) error {
+	var err error
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return err
+		}
+		defer b.CloseDB()
+	}
+
+	err = b.MkBucketPath(path)
+	if err != nil {
+		return err
+	}
+	err = b.boltDB.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
+			if err != nil {
+				return err
+			}
+		}
+		// bkt should have the last bucket in the path
+		return fn(bkt)
+	})
+	return err
+}
+
+func DoRead(b *DB, path []string, fn func(bkt *bolt.Bucket) error) error {
+	var err error
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return err
+		}
+		defer b.CloseDB()
+	}
+	err = b.boltDB.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt = bkt.Bucket([]byte(path[idx]))
+			if bkt == nil {
+				return fmt.Errorf("couldn't find bucket " + strings.Join(path[:idx+1], "/"))
+			}
+		}
+		// bkt should have the last bucket in the path
+		return fn(bkt)
+	})
+	return err
+}
+
+// These bucket functions are meant to be run inside of a boltdb
+// transaction (Update/View)
+// GetBucket must be run inside of an Update transaction
+// Otherwise, any Get* function can be in either.
+// And any Set* function needs to be in an Update.
+func GetBucket(bkt *bolt.Bucket, path ...string) (*bolt.Bucket, error) {
+	if bkt == nil {
+		return nil, fmt.Errorf("bucket must not be nil")
+	}
+	var ret *bolt.Bucket
+	var err error
+	ret, err = bkt.CreateBucketIfNotExists([]byte(path[0]))
+	if len(path) > 1 {
+		for idx := 1; idx < len(path); idx++ {
+			ret, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	return ret, err
+}
+
+func GetString(bkt *bolt.Bucket, key string) (string, error) {
+	if bkt == nil {
+		return "", fmt.Errorf("bucket must not be nil")
+	}
+	return string(bkt.Get([]byte(key))), nil
+}
+
+func SetString(bkt *bolt.Bucket, key, val string) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	return bkt.Put([]byte(key), []byte(val))
+}
+
+func GetInt(bkt *bolt.Bucket, key string) (int, error) {
+	if bkt == nil {
+		return 0, fmt.Errorf("bucket must not be nil")
+	}
+	r, err := GetString(bkt, key)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(r)
+}
+
+func SetInt(bkt *bolt.Bucket, key string, val int) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	return SetString(bkt, key, strconv.Itoa(val))
+}
+
+func GetBool(bkt *bolt.Bucket, key string) (bool, error) {
+	r, err := GetString(bkt, key)
+	if err != nil {
+		return false, err
+	}
+	if r == "true" || r == "1" {
+		return true, nil
+	} else if r == "false" || r == "0" {
+		return false, nil
+	} else {
+		return false, fmt.Errorf("cannot parse as a boolean")
+	}
+}
+
+func SetBool(bkt *bolt.Bucket, key string, val bool) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	if val {
+		return SetString(bkt, key, "true")
+	}
+	return SetString(bkt, key, "false")
+}
+
+func GetTimestamp(bkt *bolt.Bucket, key string) (time.Time, error) {
+	r, err := GetString(bkt, key)
+	if err != nil {
+		return time.Unix(0, 0), err
+	}
+	return time.Parse(time.RFC3339, r)
+}
+
+func SetTimestamp(bkt *bolt.Bucket, key string, val time.Time) error {
+	return SetString(bkt, key, val.Format(time.RFC3339))
+}
+
+func GetBucketList(bkt *bolt.Bucket) ([]string, error) {
+	var ret []string
+	if bkt == nil {
+		return ret, fmt.Errorf("bucket must not be nil")
+	}
+	bkt.ForEach(func(k, v []byte) error {
+		if v == nil {
+			// Must be a bucket
+			ret = append(ret, string(k))
+		}
+		return nil
+	})
+	return ret, nil
+}
+
+func GetKeyList(bkt *bolt.Bucket) ([]string, error) {
+	var ret []string
+	if bkt == nil {
+		return ret, fmt.Errorf("bucket must not be nil")
+	}
+	bkt.ForEach(func(k, v []byte) error {
+		if v != nil {
+			ret = append(ret, string(k))
+		}
+		return nil
+	})
+	return ret, nil
+}
+
+func DeletePair(bkt *bolt.Bucket, key string) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	// Make sure that the key belongs to a pair
+	if tst := bkt.Bucket([]byte(key)); tst != nil {
+		return fmt.Errorf("key is a bucket")
+	}
+	return bkt.Delete([]byte(key))
+}
+
+func DeleteBucket(bkt *bolt.Bucket, key string) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	// Make sure that the key belongs to a pair
+	if tst := bkt.Bucket([]byte(key)); tst == nil {
+		return fmt.Errorf("key is not a bucket")
+	}
+	return bkt.DeleteBucket([]byte(key))
+}
+
+func GetStringList(bkt *bolt.Bucket) ([]string, error) {
+	var ret []string
+	if bkt == nil {
+		return ret, fmt.Errorf("bucket must not be nil")
+	}
+	bkt.ForEach(func(k, v []byte) error {
+		if v != nil {
+			// Must be a key
+			ret = append(ret, string(v))
+		}
+		return nil
+	})
+	return ret, nil
+}
+
+func SetStringList(bkt *bolt.Bucket, val []string) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	genseq := func(id uint64) []byte {
+		bId := make([]byte, 8)
+		binary.BigEndian.PutUint64(bId, id)
+		return bId
+	}
+	var err error
+	// We need to get the sequence number, if it's greater than the length of
+	// val, we're going to have to delete values
+	seq := bkt.Sequence()
+	bkt.SetSequence(0)
+	for _, v := range val {
+		id, _ := bkt.NextSequence()
+		if err = bkt.Put(genseq(id), []byte(v)); err != nil {
+			return err
+		}
+	}
+	currSeq := bkt.Sequence()
+	for ; seq < currSeq; seq++ {
+		err = bkt.Delete(genseq(seq))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func AddToStringList(bkt *bolt.Bucket, key string, values ...string) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	genseq := func(id uint64) []byte {
+		bId := make([]byte, 8)
+		binary.BigEndian.PutUint64(bId, id)
+		return bId
+	}
+	var err error
+	for _, v := range values {
+		id, _ := bkt.NextSequence()
+		if err = bkt.Put(genseq(id), []byte(v)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func GetKeyValueMap(bkt *bolt.Bucket) (map[string][]byte, error) {
+	ret := make(map[string][]byte)
+	if bkt == nil {
+		return ret, fmt.Errorf("bucket must not be nil")
+	}
+	bkt.ForEach(func(k, v []byte) error {
+		if v != nil {
+			ret[string(k)] = v
+		}
+		return nil
+	})
+	return ret, nil
+}
+
+func SetKeyValueMap(bkt *bolt.Bucket, kvMap map[string][]byte) error {
+	if bkt == nil {
+		return fmt.Errorf("bucket must not be nil")
+	}
+	var err error
+	for k, v := range kvMap {
+		err = bkt.Put([]byte(k), v)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func GetKeyValueStringMap(bkt *bolt.Bucket) (map[string]string, error) {
+	ret := make(map[string]string)
+	if bkt == nil {
+		return ret, fmt.Errorf("bucket must not be nil")
+	}
+	btMap, err := GetKeyValueMap(bkt)
+	if err != nil {
+		return ret, err
+	}
+	for k, v := range btMap {
+		ret[k] = string(v)
+	}
+	return ret, nil
+}
+
+func SetKeyValueStringMap(bkt *bolt.Bucket, kvMap map[string]string) error {
+	chain := make(map[string][]byte)
+	for k, v := range kvMap {
+		chain[k] = []byte(v)
+	}
+	return SetKeyValueMap(bkt, chain)
+}