golang rocksdb安装和使用

1、开发环境
ubuntu18
2、下载 rocksdb

wget https://github.com/facebook/rocksdb/archive/refs/tags/v7.2.2.tar.gz

tar xvzf v7.2.2.tar.gz
cd rocksdb-7.2.2/
make shared_lib -j9
sudo make install

3、安装其他依赖
文档写要安装
Linux - Ubuntu

sudo apt-get install libgflags-dev

sudo apt install -y libsnappy-dev liblz4-dev zlib1g-dev libbz2-dev liblz4-dev libzstd-dev

发现只有zlib ，bzip2 安装成功了，其他3个根本找不到安装包，也就算了

4、安装 gorocksdb

go get github.com/linxGnu/grocksdb

CGO_CFLAGS="-I/usr/local/include/rocksdb/" \
CGO_LDFLAGS="-L/usr/local/lib -lrocksdb -lstdc++ -lm -lz -lbz2 -lsnappy -llz4 -lzstd" \
go build

5.测试

package main

import (
	"errors"
	"log"
	"strconv"

	"github.com/linxGnu/grocksdb"

	"github.com/sirupsen/logrus"
)

const (
	DB_PATH      = "/data2/wuyongyu/test/grocksdb"
	TABLE_PREFIX = "TABLE_PREFIX"
)

// opendb
func OpenDB() (*grocksdb.DB, error) {
	options := grocksdb.NewDefaultOptions()
	options.SetCreateIfMissing(true)

	bloomFilter := grocksdb.NewBloomFilter(10)

	readOptions := grocksdb.NewDefaultReadOptions()
	readOptions.SetFillCache(false)

	rateLimiter := grocksdb.NewRateLimiter(10000000, 10000, 10)
	options.SetRateLimiter(rateLimiter)
	options.SetCreateIfMissing(true)
	options.EnableStatistics()
	options.SetWriteBufferSize(8 * 1024)
	options.SetMaxWriteBufferNumber(3)
	options.SetMaxBackgroundCompactions(10)
	// options.SetCompression(grocksdb.SnappyCompression)
	// options.SetCompactionStyle(grocksdb.UniversalCompactionStyle)

	options.SetHashSkipListRep(2000000, 4, 4)

	blockBasedTableOptions := grocksdb.NewDefaultBlockBasedTableOptions()
	blockBasedTableOptions.SetBlockCache(grocksdb.NewLRUCache(64 * 1024))
	blockBasedTableOptions.SetFilterPolicy(bloomFilter)
	blockBasedTableOptions.SetBlockSizeDeviation(5)
	blockBasedTableOptions.SetBlockRestartInterval(10)
	blockBasedTableOptions.SetBlockCacheCompressed(grocksdb.NewLRUCache(64 * 1024))
	blockBasedTableOptions.SetCacheIndexAndFilterBlocks(true)
	blockBasedTableOptions.SetIndexType(grocksdb.KHashSearchIndexType)

	options.SetBlockBasedTableFactory(blockBasedTableOptions)
	//log.Println(bloomFilter, readOptions)
	options.SetPrefixExtractor(grocksdb.NewFixedPrefixTransform(3))

	options.SetAllowConcurrentMemtableWrites(false)

	db, err := grocksdb.OpenDb(options, DB_PATH)

	if err != nil {
		log.Fatalln("OPEN DB error", db, err)
		db.Close()
		return nil, errors.New("fail to open db")
	} else {
		log.Println("OPEN DB success", db)
	}
	return db, nil
}

func TestRead(key string, db *grocksdb.DB) {
	readOptions := grocksdb.NewDefaultReadOptions()
	readOptions.SetFillCache(true)
	slice, err2 := db.Get(readOptions, []byte(key))
	defer slice.Free()
	if err2 != nil {
		log.Println("test_read get data exception：", key, err2)
	}
	logrus.Info("TestRead data:", slice.Exists())
	log.Println("test_read get data：", slice.Size(), string(slice.Data()))
}

func TestSetTableId(key string, db *grocksdb.DB) {
	writeOptions := grocksdb.NewDefaultWriteOptions()
	writeOptions.SetSync(true)
	keyStr := TABLE_PREFIX + ":" + key
	var keybyte []byte = []byte(keyStr)
	db.Put(writeOptions, keybyte, keybyte)
}

func TestUpdateTableId(key string, val string, db *grocksdb.DB) {
	writeOptions := grocksdb.NewDefaultWriteOptions()
	writeOptions.SetSync(true)
	keyStr := TABLE_PREFIX + ":" + key
	var keybyte []byte = []byte(keyStr)
	db.Put(writeOptions, keybyte, []byte(val))
}

func TestGetTableId(key string, db *grocksdb.DB) {
	readOptions := grocksdb.NewDefaultReadOptions()
	readOptions.SetFillCache(true)
	keyStr := TABLE_PREFIX + ":" + key
	var keybyte []byte = []byte(keyStr)
	slice, err2 := db.Get(readOptions, keybyte)
	defer slice.Free()
	if err2 != nil {
		log.Println("test_read get data exception：", key, err2)
	}
	logrus.Info("TestRead data:", slice.Exists())
	log.Println("test_read get data：", slice.Size(), string(slice.Data()))
}

func main() {
	logrus.Info("rocksdb test begin")
	db, err := OpenDB()
	if err != nil {
		log.Println("fail to open db,", nil, db)
	}

	readOptions := grocksdb.NewDefaultReadOptions()
	readOptions.SetFillCache(true)

	writeOptions := grocksdb.NewDefaultWriteOptions()
	writeOptions.SetSync(true)

	// for i := 0; i < 10; i++ {
	// 	keyStr := "test" + strconv.Itoa(i)
	// 	var key []byte = []byte(keyStr)
	// 	db.Put(writeOptions, key, key)
	// 	log.Println(i, keyStr)
	// 	slice, err2 := db.Get(readOptions, key)
	// 	if err2 != nil {
	// 		log.Println("get data exception：", key, err2)
	// 		continue
	// 	}
	// 	log.Println("get data：", slice.Size(), string(slice.Data()))
	// }

	for i := 0; i < 10; i++ {
		keyStr := "test" + strconv.Itoa(i)
		var key []byte = []byte(keyStr)
		log.Println(i, keyStr)
		slice, err2 := db.Get(readOptions, key)
		defer slice.Free()
		if err2 != nil {
			log.Println("get data exception：", key, err2)
			continue
		}
		log.Println("get data：", slice.Size(), string(slice.Data()))
	}
	TestRead("dasd", db)
	TestSetTableId("dasd", db)
	TestUpdateTableId("dasd", "1223", db)
	TestGetTableId("dasd", db)
	readOpts := grocksdb.NewDefaultReadOptions()
	readOpts.SetFillCache(true)
	it := db.NewIterator(readOpts)
	defer it.Close()
	for it.SeekToFirst(); it.Valid(); it.Next() {
		logrus.Info("table_db item name:", string((it.Key().Data())))
	}

	ds, err2 := db.GetBytes(readOpts, []byte("1222"))
	if err2 != nil {
		logrus.Error("error:", err2, " ds:", ds)
	} else {
		logrus.Info("ds:", len(ds))
	}
}