纯 Go 中的 Boltdb-key-Value 数据存储
Boltdb-key-Value Data Store purely in Go
Bolt 获得了数据文件的文件锁,因此多个进程无法同时打开同一个数据库。打开一个已经打开的 Bolt 数据库将导致它挂起,直到另一个进程将其关闭。
既然如此,有没有类似各种客户端同时连接和访问数据库的连接池概念?这在boltdb中可以吗?像有各种连接同时读写数据库time.How可以实现吗?
boltdb中没有连接池的概念,因为没有连接。它不是 client/server 数据库,而是嵌入式数据库(如 sqlite 或 Berkeley-DB)。
Boltdb的设计是为了让同一个进程的多个goroutine可以同时访问数据库(使用不同的事务)。该模型是单个作者,多个读者。 Boltdb 不支持多进程访问。
如果你需要一个 Go 程序来使用支持同时从多个进程访问的嵌入式数据库,你可能想看看 LMDB 的包装器,例如:
Bolt 数据库通常嵌入到一个更大的程序中,而不是像共享数据库那样通过网络使用(想想 SQLite 与 MySQL)。如果可能的话,使用 Bolt 有点像拥有一个持久的 map[[]byte][]byte
。根据你在做什么,你可能只想使用像 Redis 这样的东西。
也就是说,如果您需要以这种方式使用 Bolt,用一个简单的服务器包装起来并不是很难。这是一个示例,writes/reads 通过 HTTP 从 Bolt DB 键入密钥。您可以使用 Keep-Alive
进行连接池。
代码位于:https://github.com/skyec/boltdb-server
package main
import (
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"time"
"github.com/boltdb/bolt"
"github.com/gorilla/mux"
)
type server struct {
db *bolt.DB
}
func newServer(filename string) (s *server, err error) {
s = &server{}
s.db, err = bolt.Open(filename, 0600, &bolt.Options{Timeout: 1 * time.Second})
return
}
func (s *server) Put(bucket, key, contentType string, val []byte) error {
return s.db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte(bucket))
if err != nil {
return err
}
if err = b.Put([]byte(key), val); err != nil {
return err
}
return b.Put([]byte(fmt.Sprintf("%s-ContentType", key)), []byte(contentType))
})
}
func (s *server) Get(bucket, key string) (ct string, data []byte, err error) {
s.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(bucket))
r := b.Get([]byte(key))
if r != nil {
data = make([]byte, len(r))
copy(data, r)
}
r = b.Get([]byte(fmt.Sprintf("%s-ContentType", key)))
ct = string(r)
return nil
})
return
}
func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
if vars["bucket"] == "" || vars["key"] == "" {
http.Error(w, "Missing bucket or key", http.StatusBadRequest)
return
}
switch r.Method {
case "POST", "PUT":
data, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.Put(vars["bucket"], vars["key"], r.Header.Get("Content-Type"), data)
w.WriteHeader(http.StatusOK)
case "GET":
ct, data, err := s.Get(vars["bucket"], vars["key"])
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Add("Content-Type", ct)
w.Write(data)
}
}
func main() {
var (
addr string
dbfile string
)
flag.StringVar(&addr, "l", ":9988", "Address to listen on")
flag.StringVar(&dbfile, "db", "/var/data/bolt.db", "Bolt DB file")
flag.Parse()
log.Println("Using Bolt DB file:", dbfile)
log.Println("Listening on:", addr)
server, err := newServer(dbfile)
if err != nil {
log.Fatalf("Error: %s", err)
}
router := mux.NewRouter()
router.Handle("/v1/buckets/{bucket}/keys/{key}", server)
http.Handle("/", router)
log.Fatal(http.ListenAndServe(addr, nil))
}
Bolt 获得了数据文件的文件锁,因此多个进程无法同时打开同一个数据库。打开一个已经打开的 Bolt 数据库将导致它挂起,直到另一个进程将其关闭。
既然如此,有没有类似各种客户端同时连接和访问数据库的连接池概念?这在boltdb中可以吗?像有各种连接同时读写数据库time.How可以实现吗?
boltdb中没有连接池的概念,因为没有连接。它不是 client/server 数据库,而是嵌入式数据库(如 sqlite 或 Berkeley-DB)。
Boltdb的设计是为了让同一个进程的多个goroutine可以同时访问数据库(使用不同的事务)。该模型是单个作者,多个读者。 Boltdb 不支持多进程访问。
如果你需要一个 Go 程序来使用支持同时从多个进程访问的嵌入式数据库,你可能想看看 LMDB 的包装器,例如:
Bolt 数据库通常嵌入到一个更大的程序中,而不是像共享数据库那样通过网络使用(想想 SQLite 与 MySQL)。如果可能的话,使用 Bolt 有点像拥有一个持久的 map[[]byte][]byte
。根据你在做什么,你可能只想使用像 Redis 这样的东西。
也就是说,如果您需要以这种方式使用 Bolt,用一个简单的服务器包装起来并不是很难。这是一个示例,writes/reads 通过 HTTP 从 Bolt DB 键入密钥。您可以使用 Keep-Alive
进行连接池。
代码位于:https://github.com/skyec/boltdb-server
package main
import (
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"time"
"github.com/boltdb/bolt"
"github.com/gorilla/mux"
)
type server struct {
db *bolt.DB
}
func newServer(filename string) (s *server, err error) {
s = &server{}
s.db, err = bolt.Open(filename, 0600, &bolt.Options{Timeout: 1 * time.Second})
return
}
func (s *server) Put(bucket, key, contentType string, val []byte) error {
return s.db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte(bucket))
if err != nil {
return err
}
if err = b.Put([]byte(key), val); err != nil {
return err
}
return b.Put([]byte(fmt.Sprintf("%s-ContentType", key)), []byte(contentType))
})
}
func (s *server) Get(bucket, key string) (ct string, data []byte, err error) {
s.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(bucket))
r := b.Get([]byte(key))
if r != nil {
data = make([]byte, len(r))
copy(data, r)
}
r = b.Get([]byte(fmt.Sprintf("%s-ContentType", key)))
ct = string(r)
return nil
})
return
}
func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
if vars["bucket"] == "" || vars["key"] == "" {
http.Error(w, "Missing bucket or key", http.StatusBadRequest)
return
}
switch r.Method {
case "POST", "PUT":
data, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.Put(vars["bucket"], vars["key"], r.Header.Get("Content-Type"), data)
w.WriteHeader(http.StatusOK)
case "GET":
ct, data, err := s.Get(vars["bucket"], vars["key"])
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Add("Content-Type", ct)
w.Write(data)
}
}
func main() {
var (
addr string
dbfile string
)
flag.StringVar(&addr, "l", ":9988", "Address to listen on")
flag.StringVar(&dbfile, "db", "/var/data/bolt.db", "Bolt DB file")
flag.Parse()
log.Println("Using Bolt DB file:", dbfile)
log.Println("Listening on:", addr)
server, err := newServer(dbfile)
if err != nil {
log.Fatalf("Error: %s", err)
}
router := mux.NewRouter()
router.Handle("/v1/buckets/{bucket}/keys/{key}", server)
http.Handle("/", router)
log.Fatal(http.ListenAndServe(addr, nil))
}