欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

blot数据库007

程序员文章站 2024-01-19 17:16:46
...

blot数据库go的专属

blot数据库007

思路: 找到数据库名字 -->找到blockbucket---->put或者读数据库

package main

import (
	"fmt"
	"github.com/boltdb/bolt"
	"log"
)

func main()  {
	//1 打开数据库
	db,err:=bolt.Open("test.db",0660,nil)
	defer db.Close()  //关闭数据库
    if err!=nil{
    	log.Panic("打开数据库失败")
	}
	//2 查看数据库是否存在
	db.Update(func(tx *bolt.Tx) error {
	   bucket:=	tx.Bucket([]byte("b1"))
	   //如果等于nil 需要创建
	   if bucket==nil{
	   	  bucket,err=tx.CreateBucket([]byte("b1"))
	   	  if err!=nil{
	   	  	log.Panic("创建失败")
		  }
	   }
	   //3 写数据
	   bucket.Put([]byte("11111"),[]byte("hello"))
		bucket.Put([]byte("2222"),[]byte("world"))
		return nil
	})
	//4 读数据
	db.View(func(tx *bolt.Tx) error {
		//1 找到抽屉 没有的话直接报错退出
		 bucket:= tx.Bucket([]byte("b1"))
		if bucket==nil{
			log.Panic("bucket不应该为空请检查")
		}
		//2 直接读取数据
	    v1:=bucket.Get([]byte("11111"))
		v2:=bucket.Get([]byte("2222"))
		fmt.Printf("v1 %s\n",v1)
		fmt.Printf("v2 %s\n",v2)
		return nil
	})

}

BlotDB简介

Bolt是一个go语言实现的纯粹的 key /value存储,受到Howard Chu的 LMDB项目的启发。该项目的目标是为不需要完整数据库服务器(如Postgres或MySQL)的项目提供简单,快速,可靠的数据库。
Bolt它很小,只关注值的设置和读取。Bolt虽小但是很稳定,它能够用于高负载生产环境。

安装Blot

Blot仅在Go中使用,所以使用前请先安装Go,然后使用go get

$ go get github.com/boltdb/bolt / ...
  •  

创建或打开数据库

db, err := bolt.Open("my.db", 0600, nil)
  •  

Open 的第一个参数为路径,如果数据库不存在则会创建名为my.db的数据库, 第二个参数为文件操作权限,第三个参数是可选参数, 内部可以配置只读和超时时间等。 特别需要注意的地方就是因为boltdb是文件操作类型的数据库,所以只能单点写入和读取,如果多个同时操作的话后者会被挂起直到前者关闭操作为止。

关闭数据库

调用数据库、I/O这类 ,随用随关是个好习惯。

defer db.Close()
  •  

读写事务

boltdb的读写事务操作我们可以使用DB.Update()来完成。

err := db.Update(func(tx *bolt.Tx) error {
    ...
    return nil
})

创建桶(表)

既然说到读写事务,我们当然得实战演练一下,首先我们就来创建一个桶。

db.Update(func(tx *bolt.Tx) error {	b,err:=tx.CreateBucketIfNotExists([]byte("bucket"))
		if err!=nil{
			return  err
		}
			return nil
	})

上面我们使用了tx.CreateBucketIfNotExists( )来创建了一个桶,该函数会先判断桶是否存在,如果不存在会自动创建。我们也可用使用tx.CreateBucket([]byte(“bucket”)) 来完成bucket桶的创建

使用Put()设置值

db.Update(func(tx *bolt.Tx) error {	err:=tx.CreateBucketIfNotExists([]byte("bucket"))
		if err!=nil{
			return  err
		}
		err = b.Put([]byte("name"), []byte("Jay"))
		return err
	})

这里我们使用了Put() 设置 key 为name ,value 为Jay

删除桶

删除桶可以使用Tx.DeleteBucket()来完成

db.Update(func(tx *bolt.Tx) error {	err:=tx.DeleteBucket([]byte("bucket"))
		if err!=nil{
			return  err
		}
			return nil
	})

桶的嵌套

func (*Bucket) CreateBucket(key []byte) (*Bucket, error)
  • 1

当然使用CreateBucketIfNotExists函数也是可以的

只读事务

小伙伴们现在肯定迫不及待的想要知道怎么获取name的值吧?别急我们先来看看只读事务

err := db.View(func(tx *bolt.Tx) error {
    ...
    return nil
})

使用Get()获取值

db.View(func(tx *bolt.Tx) error {
  	b:=tx.Bucket([]byte("bucket"))
	v:=b.Get([]byte("name"))
	fmt.Println(“name=”+v)
	return  nil
})
  • Bucket

使用游标

boltdb以桶中的字节排序顺序存储键。这使得在这些键上的顺序迭代非常快。要遍历键,我们将使用游标Cursor():

db.View(func(tx *bolt.Tx) error {
    // Assume bucket exists and has keys
    b := tx.Bucket([]byte("MyBucket"))
    c := b.Cursor()
    for k, v := c.First(); k != nil; k, v = c.Next() {
        fmt.Printf("key=%s, value=%s\n", k, v)
    }
    return nil
})

游标Cursor()允许您移动到键列表中的特定点,并一次一个地通过操作键前进或后退。
光标上有以下函数:

First() 移动到第一个健.
Last() 移动到最后一个健.
Seek() 移动到特定的一个健.
Next() 移动到下一个健.
Prev() 移动到上一个健.

使用ForEach

如果你知道所在桶中拥有键,你也可以使用ForEach()来迭代:

db.View(func(tx *bolt.Tx) error {
    // Assume bucket exists and has keys
    b := tx.Bucket([]byte("MyBucket"))
   b.ForEach(func(k, v []byte) error {
        fmt.Printf("key=%s, value=%s\n", k, v)
        return nil
    })
    return nil
})

范围查询

Bolt也可以在两个值之间遍历查询,如两个时间直接、数字之间等。

db.View(func(tx *bolt.Tx) error {
    // Assume our events bucket exists and has RFC3339 encoded time keys.
    c := tx.Bucket([]byte("Events")).Cursor()
    // Our time range spans the 90's decade.
    min := []byte("1990-01-01T00:00:00Z")
    max := []byte("2018-01-01T00:00:00Z")

    // Iterate over the 90's.
    for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() {
        fmt.Printf("%s: %s\n", k, v)
    }

    return nil
})

桶的自增

利用nextsequence()功能,你可以让boltdb生成序列作为你键值对的唯一标识。

func (s *Store) CreateUser(u *User) error {
    return s.db.Update(func(tx *bolt.Tx) error {
        // 创建users桶
        b := tx.Bucket([]byte("users"))
        // 生成自增序列
        id, _ = b.NextSequence()
        u.ID = int(id)
        // Marshal user data into bytes.
        buf, err := json.Marshal(u)
        if err != nil {
            return err
        }
        // Persist bytes to users bucket.
        return b.Put(itob(u.ID), buf)
    })
}

// itob returns an 8-byte big endian representation of v.
func itob(v int) []byte {
    b := make([]byte, 8)
    binary.BigEndian.PutUint64(b, uint64(v))
    return b
}

type User struct {
    ID int
    ...
}

批量读写事务

每一次新的事物都需要等待上一次事物的结束,这种开销我们可以通过DB.Batch()批处理来完成。在批处理过程中如果某个事务失败了,批处理会多次调用这个函数函数返回成功则成功。如果中途失败了,则整个事务会回滚。

err := db.Batch(func(tx *bolt.Tx) error {
    ...
    return nil
})
相关标签: golang