func main() {
   // 我们的大柜子
   db, err := bolt.Open("./my.db", 0600, nil)
   if err != nil {
      panic(err)
   }
   defer db.Close()
   // 往小柜子里放东西
   err = db.Update(func(tx *bolt.Tx) error {
      //我们的小柜子
      bucket, err := tx.CreateBucketIfNotExists([]byte("user"))
      if err != nil {
         log.Fatalf("CreateBucketIfNotExists err:%s", err.Error())
         return err
      }
      //放入东西
      if err = bucket.Put([]byte("hello"), []byte("world")); err != nil {
         log.Fatalf("bucket Put err:%s", err.Error())
         return err
      }
      return nil
   })
   if err != nil {
      log.Fatalf("db.Update err:%s", err.Error())
   }
   // 从柜子里取东西
   err = db.View(func(tx *bolt.Tx) error {
      //找到柜子
      bucket := tx.Bucket([]byte("user"))
      //找东西
      val := bucket.Get([]byte("hello"))
      log.Printf("the get val:%s", val)
      val = bucket.Get([]byte("hello2"))
      log.Printf("the get val2:%s", val)
      return nil
   })
   if err != nil {
      log.Fatalf("db.View err:%s", err.Error())
   }
}

type pgid uint64
type page struct {
 // 页id 8字节
 id pgid
 // flags：页类型，可以是分支，叶子节点，元信息，空闲列表  2字节，该值的取值详细参见下面描述
 flags uint16
 // 个数 2字节，统计叶子节点、非叶子节点、空闲列表页的个数
 count uint16
 // 4字节，数据是否有溢出，主要在空闲列表上有用
 overflow uint32
 // 真实的数据
 ptr uintptr
}

// 页头的大小：16字节
const pageHeaderSize = int(unsafe.Offsetof(((*page)(nil)).ptr))

const minKeysPerPage = 2

//分支节点页中每个元素所占的大小
const branchPageElementSize = int(unsafe.Sizeof(branchPageElement{}))
//叶子节点页中每个元素所占的大小
const leafPageElementSize = int(unsafe.Sizeof(leafPageElement{}))

const (
 branchPageFlag   = 0x01 //分支节点页类型
 leafPageFlag     = 0x02 //叶子节点页类型
 metaPageFlag     = 0x04 //元数据页类型
 freelistPageFlag = 0x10 //空闲列表页类型
)

// typ returns a human readable page type string used for debugging.
func (p *page) typ() string {
 if (p.flags & branchPageFlag) != 0 {
  return "branch"
 } else if (p.flags & leafPageFlag) != 0 {
  return "leaf"
 } else if (p.flags & metaPageFlag) != 0 {
  return "meta"
 } else if (p.flags & freelistPageFlag) != 0 {
  return "freelist"
 }
 return fmt.Sprintf("unknown<%02x>", p.flags)
}

// meta returns a pointer to the metadata section of the page.
func (p *page) meta() *meta {
 // 将p.ptr转为meta信息
 return (*meta)(unsafe.Pointer(&p.ptr))
}

type meta struct {
 magic    uint32 //魔数
 version  uint32 //版本
 pageSize uint32 //page页的大小，该值和操作系统默认的页大小保持一致
 flags    uint32 //保留值，目前貌似还没用到
 root     bucket //所有小柜子bucket的根
 freelist pgid //空闲列表页的id
 pgid     pgid //元数据页的id
 txid     txid //最大的事务id
 checksum uint64 //用作校验的校验和
}

// write writes the meta onto a page.
func (m *meta) write(p *page) {
   if m.root.root >= m.pgid {
      panic(fmt.Sprintf("root bucket pgid (%d) above high water mark (%d)", m.root.root, m.pgid))
   } else if m.freelist >= m.pgid {
      panic(fmt.Sprintf("freelist pgid (%d) above high water mark (%d)", m.freelist, m.pgid))
   }

   // Page id is either going to be 0 or 1 which we can determine by the transaction ID.
   // 指定页id和页类型
   p.id = pgid(m.txid % 2)
   p.flags |= metaPageFlag

   // Calculate the checksum.
   m.checksum = m.sum64()
   // 这儿p.meta()返回的是p.ptr的地址，因此通过copy之后，meta信息就放到page中了
   m.copy(p.meta())
}

// copy copies one meta object to another.
func (m *meta) copy(dest *meta) {
   *dest = *m
}

page.go
// meta returns a pointer to the metadata section of the page.
func (p *page) meta() *meta {
 // 将p.ptr转为meta信息
 return (*meta)(unsafe.Pointer(&p.ptr))
}

// freelist represents a list of all pages that are available for allocation.
// It also tracks pages that have been freed but are still in use by open transactions.
type freelist struct {
   // 已经可以被分配的空闲页
   ids []pgid // all free and available free page ids.
   // 将来很快能被释放的空闲页，部分事务可能在读或者写
   pending map[txid][]pgid // mapping of soon-to-be free page ids by tx.
   cache   map[pgid]bool   // fast lookup of all free and pending page ids.
}

// newFreelist returns an empty, initialized freelist.
func newFreelist() *freelist {
   return &freelist{
      pending: make(map[txid][]pgid),
      cache:   make(map[pgid]bool),
   }
}

// write writes the page ids onto a freelist page. All free and pending ids are
// saved to disk since in the event of a program crash, all pending ids will
// become free.
//将 freelist信息写入到p中
func (f *freelist) write(p *page) error {
 // Combine the old free pgids and pgids waiting on an open transaction.

 // Update the header flag.
 // 设置页头中的页类型标识
 p.flags |= freelistPageFlag

 // The page.count can only hold up to 64k elements so if we overflow that
 // number then we handle it by putting the size in the first element.

 lenids := f.count()
 if lenids == 0 {
  p.count = uint16(lenids)
 } else if lenids < 0xFFFF {
  p.count = uint16(lenids)
  // 拷贝到page的ptr中
  f.copyall(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[:])
 } else {
  // 有溢出的情况下，后面第一个元素放置其长度，然后再存放所有的pgid列表
  p.count = 0xFFFF
  ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0] = pgid(lenids)
  // 从第一个元素位置拷贝
  f.copyall(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[1:])
 }
 return nil
}

// copyall copies into dst a list of all free ids and all pending ids in one sorted list.
// f.count returns the minimum length required for dst.
func (f *freelist) copyall(dst []pgid) {
 // 首先把pending状态的页放到一个数组中，并使其有序
 m := make(pgids, 0, f.pending_count())
 for _, list := range f.pending {
  m = append(m, list...)
 }
 sort.Sort(m)
 // 合并两个有序的列表，最后结果输出到dst中
 mergepgids(dst, f.ids, m)
}

// mergepgids copies the sorted union of a and b into dst.
// If dst is too small, it panics.
// 将a和b按照有序合并成到dst中，a和b有序
func mergepgids(dst, a, b pgids) {
 ...
 // Assign lead to the slice with a lower starting value, follow to the higher value.
 lead, follow := a, b
 if b[0] < a[0] {
  lead, follow = b, a
 }

 // Continue while there are elements in the lead.
 for len(lead) > 0 {
  // Merge largest prefix of lead that is ahead of follow[0].
  n := sort.Search(len(lead), func(i int) bool { return lead[i] > follow[0] })
  merged = append(merged, lead[:n]...)
  if n >= len(lead) {
   break
  }

  // Swap lead and follow.
  lead, follow = follow, lead[n:]
 }
 // Append what's left in follow.
 _ = append(merged, follow...)
 ...
}

//从磁盘中的page初始化freelist
// read initializes the freelist from a freelist page.
func (f *freelist) read(p *page) {
 // If the page.count is at the max uint16 value (64k) then it's considered
 // an overflow and the size of the freelist is stored as the first element.
 idx, count := 0, int(p.count)
 if count == 0xFFFF {
  idx = 1
  // 用第一个uint64来存储整个count的值
  count = int(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0])
 }

 // Copy the list of page ids from the freelist.
 if count == 0 {
  f.ids = nil
 } else {
  ids := ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[idx:count]
  f.ids = make([]pgid, len(ids))
  copy(f.ids, ids)

  // Make sure they're sorted.
  sort.Sort(pgids(f.ids))
 }

 // Rebuild the page cache.
 f.reindex()
}

// reindex rebuilds the free cache based on available and pending free lists.
func (f *freelist) reindex() {
 f.cache = make(map[pgid]bool, len(f.ids))
 for _, id := range f.ids {
  f.cache[id] = true
 }
 for _, pendingIDs := range f.pending {
  for _, pendingID := range pendingIDs {
   f.cache[pendingID] = true
  }
 }
}

// branchPageElement represents a node on a branch page.
type branchPageElement struct {
 pos   uint32 //该元信息和真实key之间的偏移量
 ksize uint32
 pgid  pgid
}

// key returns a byte slice of the node key.
func (n *branchPageElement) key() []byte {
 buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
 // pos~ksize
 return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos]))[:n.ksize]
}

// branchPageElement retrieves the branch node by index
func (p *page) branchPageElement(index uint16) *branchPageElement {
 return &((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[index]
}

// branchPageElements retrieves a list of branch nodes.
func (p *page) branchPageElements() []branchPageElement {
 if p.count == 0 {
  return nil
 }
 return ((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[:]
}

// node represents an in-memory, deserialized page.
type node struct {
 bucket     *Bucket
 isLeaf     bool
 unbalanced bool
 spilled    bool
 key        []byte
 pgid       pgid
 parent     *node
 children   nodes
 inodes     inodes
}

const (
 bucketLeafFlag = 0x01
)
type nodes []*node

func (s nodes) Len() int           { return len(s) }
func (s nodes) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
func (s nodes) Less(i, j int) bool { return bytes.Compare(s[i].inodes[0].key, s[j].inodes[0].key) == -1 }

// inode represents an internal node inside of a node.
// It can be used to point to elements in a page or point
// to an element which hasn't been added to a page yet.
type inode struct {
 // 表示是否是子桶叶子节点还是普通叶子节点。如果flags值为1表示子桶叶子节点，否则为普通叶子节点
 flags uint32
 // 当inode为分支元素时，pgid才有值，为叶子元素时，则没值
 pgid  pgid
 key   []byte
 // 当inode为分支元素时，value为空，为叶子元素时，才有值
 value []byte
}

type inodes []inode

// 根据page来初始化node
// read initializes the node from a page.
func (n *node) read(p *page) {
 n.pgid = p.id
 n.isLeaf = ((p.flags & leafPageFlag) != 0)
 n.inodes = make(inodes, int(p.count))

 for i := 0; i < int(p.count); i++ {
  inode := &n.inodes[i]
  if n.isLeaf {
   // 获取第i个叶子节点
   elem := p.leafPageElement(uint16(i))
   inode.flags = elem.flags
   inode.key = elem.key()
   inode.value = elem.value()
  } else {
   // 树枝节点
   elem := p.branchPageElement(uint16(i))
   inode.pgid = elem.pgid
   inode.key = elem.key()
  }
  _assert(len(inode.key) > 0, "read: zero-length inode key")
 }

 // Save first key so we can find the node in the parent when we spill.
 if len(n.inodes) > 0 {
  // 保存第1个元素的值
  n.key = n.inodes[0].key
  _assert(len(n.key) > 0, "read: zero-length node key")
 } else {
  n.key = nil
 }
}

// write writes the items onto one or more pages.
// 将node转为page
func (n *node) write(p *page) {
 // Initialize page.
 // 判断是否是叶子节点还是非叶子节点
 if n.isLeaf {
  p.flags |= leafPageFlag
 } else {
  p.flags |= branchPageFlag
 }

 // 这儿叶子节点不可能溢出，因为溢出时，会分裂
 if len(n.inodes) >= 0xFFFF {
  panic(fmt.Sprintf("inode overflow: %d (pgid=%d)", len(n.inodes), p.id))
 }
 p.count = uint16(len(n.inodes))

 // Stop here if there are no items to write.
 if p.count == 0 {
  return
 }

 // Loop over each item and write it to the page.
 // b指向的指针为提逃过所有item头部的位置
 b := (*[maxAllocSize]byte)(unsafe.Pointer(&p.ptr))[n.pageElementSize()*len(n.inodes):]
 for i, item := range n.inodes {
  _assert(len(item.key) > 0, "write: zero-length inode key")

  // Write the page element.
  // 写入叶子节点数据
  if n.isLeaf {
   elem := p.leafPageElement(uint16(i))
   elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem)))
   elem.flags = item.flags
   elem.ksize = uint32(len(item.key))
   elem.vsize = uint32(len(item.value))
  } else {
   // 写入分支节点数据
   elem := p.branchPageElement(uint16(i))
   elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem)))
   elem.ksize = uint32(len(item.key))
   elem.pgid = item.pgid
   _assert(elem.pgid != p.id, "write: circular dependency occurred")
  }

  // If the length of key+value is larger than the max allocation size
  // then we need to reallocate the byte array pointer.
  //
  // See: https://github.com/boltdb/bolt/pull/335
  klen, vlen := len(item.key), len(item.value)
  if len(b) < klen+vlen {
   b = (*[maxAllocSize]byte)(unsafe.Pointer(&b[0]))[:]
  }

  // Write data for the element to the end of the page.
  copy(b[0:], item.key)
  b = b[klen:]
  copy(b[0:], item.value)
  b = b[vlen:]
 }

 // DEBUG ONLY: n.dump()
}

// leafPageElement represents a node on a leaf page.
// 叶子节点既存储key，也存储value
type leafPageElement struct {
 flags uint32 //该值主要用来区分，是子桶叶子节点元素还是普通的key/value叶子节点元素。flags值为1时表示子桶。否则为key/value
 pos   uint32
 ksize uint32
 vsize uint32
}

// 叶子节点的key
// key returns a byte slice of the node key.
func (n *leafPageElement) key() []byte {
 buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
 // pos~ksize
 return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos]))[:n.ksize:n.ksize]
}

// 叶子节点的value
// value returns a byte slice of the node value.
func (n *leafPageElement) value() []byte {
 buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
 // key:pos~ksize
 // value:pos+ksize~pos+ksize+vsize
 return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos+n.ksize]))[:n.vsize:n.vsize]
}

// leafPageElement retrieves the leaf node by index
func (p *page) leafPageElement(index uint16) *leafPageElement {
 n := &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index]

 // 最原始的指针：unsafe.Pointer(&p.ptr)
 // 将其转为(*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr))
 // 然后再取第index个元素 ((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index]
 // 最后返回该元素指针 &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index]

 // ((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))
 // (*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr))==>[]leafPageElement
 // &leafElements[index]
 return n
}

// leafPageElements retrieves a list of leaf nodes.
func (p *page) leafPageElements() []leafPageElement {
 if p.count == 0 {
  return nil
 }
 return ((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[:]
}

// 16 byte
const bucketHeaderSize = int(unsafe.Sizeof(bucket{}))

// Bucket represents a collection of key/value pairs inside the database.
// 一组key/value的集合，也就是一个b+树
type Bucket struct {
 *bucket //在内联时bucket主要用来存储其桶的value并在后面拼接所有的元素，即所谓的内联
 tx       *Tx                // the associated transaction
 buckets  map[string]*Bucket // subbucket cache
 page     *page              // inline page reference，内联页引用
 rootNode *node              // materialized node for the root page.
 nodes    map[pgid]*node     // node cache

 // Sets the threshold for filling nodes when they split. By default,
 // the bucket will fill to 50% but it can be useful to increase this
 // amount if you know that your write workloads are mostly append-only.
 //
 // This is non-persisted across transactions so it must be set in every Tx.
 // 填充率，默认值0.5
 FillPercent float64
}

// bucket represents the on-file representation of a bucket.
// This is stored as the "value" of a bucket key. If the bucket is small enough,
// then its root page can be stored inline in the "value", after the bucket
// header. In the case of inline buckets, the "root" will be 0.
type bucket struct {
 root     pgid   // page id of the bucket's root-level page
 sequence uint64 // monotonically incrementing, used by NextSequence()
}

// newBucket returns a new bucket associated with a transaction.
func newBucket(tx *Tx) Bucket {
 var b = Bucket{tx: tx, FillPercent: DefaultFillPercent}
 if tx.writable {
  b.buckets = make(map[string]*Bucket)
  b.nodes = make(map[pgid]*node)
 }
 return b
}

// Cursor creates a cursor associated with the bucket.
// The cursor is only valid as long as the transaction is open.
// Do not use a cursor after the transaction is closed.
func (b *Bucket) Cursor() *Cursor {
 // Update transaction statistics.
 b.tx.stats.CursorCount++

 // Allocate and return a cursor.
 return &Cursor{
  bucket: b,
  stack:  make([]elemRef, 0),
 }
}

// Cursor represents an iterator that can traverse over all key/value pairs in a bucket in sorted order.
// Cursors see nested buckets with value == nil.
// Cursors can be obtained from a transaction and are valid as long as the transaction is open.
//
// Keys and values returned from the cursor are only valid for the life of the transaction.
//
// Changing data while traversing with a cursor may cause it to be invalidated
// and return unexpected keys and/or values. You must reposition your cursor
// after mutating data.
type Cursor struct {
 bucket *Bucket
 // 保存遍历搜索的路径
 stack []elemRef
}

// elemRef represents a reference to an element on a given page/node.
type elemRef struct {
 page  *page
 node  *node
 index int
}

// First moves the cursor to the first item in the bucket and returns its key and value.
// If the bucket is empty then a nil key and value are returned.
// The returned key and value are only valid for the life of the transaction.
func (c *Cursor) First() (key []byte, value []byte)

// Last moves the cursor to the last item in the bucket and returns its key and value.
//...
func (c *Cursor) Last() (key []byte, value []byte)

// Next moves the cursor to the next item in the bucket and returns its key and value.
//...
func (c *Cursor) Next() (key []byte, value []byte)

// Prev moves the cursor to the previous item in the bucket and returns its key and value.
//...
func (c *Cursor) Prev() (key []byte, value []byte)

// Delete removes the current key/value under the cursor from the bucket.
// Delete fails if current key/value is a bucket or if the transaction is not writable.
func (c *Cursor) Delete() error

// Seek moves the cursor to a given key and returns it.
// If the key does not exist then the next key is used. If no keys follow, a nil key is returned.
// The returned key and value are only valid for the life of the transaction.
func (c *Cursor) Seek(seek []byte) (key []byte, value []byte)

// node represents an in-memory, deserialized page.
type node struct {
 bucket     *Bucket // 关联一个桶
 isLeaf     bool
 unbalanced bool   // 值为true的话，需要考虑页合并
 spilled    bool   // 值为true的话，需要考虑页分裂
 key        []byte // 对于分支节点的话，保留的是最小的key
 pgid       pgid   // 分支节点关联的页id
 parent     *node  // 该节点的parent
 children   nodes  // 该节点的孩子节点
 inodes     inodes // 该节点上保存的索引数据
}

// inode represents an internal node inside of a node.
// It can be used to point to elements in a page or point
// to an element which hasn't been added to a page yet.
type inode struct {
 // 表示是否是子桶叶子节点还是普通叶子节点。如果flags值为1表示子桶叶子节点，否则为普通叶子节点
 flags uint32
 // 当inode为分支元素时，pgid才有值，为叶子元素时，则没值
 pgid pgid
 key  []byte
 // 当inode为分支元素时，value为空，为叶子元素时，才有值
 value []byte
}

type inodes []inode

// put inserts a key/value.
// 如果put的是一个key、value的话，不需要指定pgid。
// 如果put的一个树枝节点，则需要指定pgid，不需要指定value
func (n *node) put(oldKey, newKey, value []byte, pgid pgid, flags uint32) {
 if pgid >= n.bucket.tx.meta.pgid {
  panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", pgid, n.bucket.tx.meta.pgid))
 } else if len(oldKey) <= 0 {
  panic("put: zero-length old key")
 } else if len(newKey) <= 0 {
  panic("put: zero-length new key")
 }

 // Find insertion index.
 index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, oldKey) != -1 })

 // Add capacity and shift nodes if we don't have an exact match and need to insert.
 exact := (len(n.inodes) > 0 && index < len(n.inodes) && bytes.Equal(n.inodes[index].key, oldKey))
 if !exact {
  n.inodes = append(n.inodes, inode{})
  copy(n.inodes[index+1:], n.inodes[index:])
 }

 inode := &n.inodes[index]
 inode.flags = flags
 inode.key = newKey
 inode.value = value
 inode.pgid = pgid
 _assert(len(inode.key) > 0, "put: zero-length inode key")
}

// del removes a key from the node.
func (n *node) del(key []byte) {
 // Find index of key.
 index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, key) != -1 })

 // Exit if the key isn't found.
 if index >= len(n.inodes) || !bytes.Equal(n.inodes[index].key, key) {
  return
 }

 // Delete inode from the node.
 n.inodes = append(n.inodes[:index], n.inodes[index+1:]...)

 // Mark the node as needing rebalancing.
 n.unbalanced = true
}

// CreateBucketIfNotExists creates a new bucket if it doesn't already exist and returns a reference to it.
// Returns an error if the bucket name is blank, or if the bucket name is too long.
// The bucket instance is only valid for the lifetime of the transaction.
func (b *Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error) {
 child, err := b.CreateBucket(key)
 if err == ErrBucketExists {
  return b.Bucket(key), nil
 } else if err != nil {
  return nil, err
 }
 return child, nil
}

// CreateBucket creates a new bucket at the given key and returns the new bucket.
// Returns an error if the key already exists, if the bucket name is blank, or if the bucket name is too long.
// The bucket instance is only valid for the lifetime of the transaction.
func (b *Bucket) CreateBucket(key []byte) (*Bucket, error) {
 // ...
 // 省去异常检查逻辑

 // Move cursor to correct position.
 // 拿到游标
 c := b.Cursor()
 // 开始遍历、找到合适的位置
 k, _, flags := c.seek(key)

 // Return an error if there is an existing key.
 if bytes.Equal(key, k) {
  // 是桶,已经存在了
  if (flags & bucketLeafFlag) != 0 {
   return nil, ErrBucketExists
  }
  // 不是桶、但key已经存在了
  return nil, ErrIncompatibleValue
 }

 // Create empty, inline bucket.
 var bucket = Bucket{
  bucket:      &bucket{},
  rootNode:    &node{isLeaf: true},
  FillPercent: DefaultFillPercent,
 }
 // 拿到bucket对应的value
 var value = bucket.write()

 // Insert into node.
 key = cloneBytes(key)
 // 插入到inode中
 // c.node()方法会在内存中建立这棵树，调用n.read(page)
 c.node().put(key, key, value, 0, bucketLeafFlag)

 // Since subbuckets are not allowed on inline buckets, we need to
 // dereference the inline page, if it exists. This will cause the bucket
 // to be treated as a regular, non-inline bucket for the rest of the tx.
 b.page = nil

 //根据key获取一个桶
 return b.Bucket(key), nil
}

// write allocates and writes a bucket to a byte slice.
// 内联桶的话，其value中bucketHeaderSize后面的内容为其page的数据
func (b *Bucket) write() []byte {
 // Allocate the appropriate size.
 var n = b.rootNode
 var value = make([]byte, bucketHeaderSize+n.size())

 // Write a bucket header.
 var bucket = (*bucket)(unsafe.Pointer(&value[0]))
 *bucket = *b.bucket

 // Convert byte slice to a fake page and write the root node.
 var p = (*page)(unsafe.Pointer(&value[bucketHeaderSize]))
 // 将该桶中的元素压缩存储，放在value中
 n.write(p)

 return value
}


// node returns the node that the cursor is currently positioned on.
func (c *Cursor) node() *node {
 _assert(len(c.stack) > 0, "accessing a node with a zero-length cursor stack")

 // If the top of the stack is a leaf node then just return it.
 if ref := &c.stack[len(c.stack)-1]; ref.node != nil && ref.isLeaf() {
  return ref.node
 }

 // Start from root and traverse down the hierarchy.
 var n = c.stack[0].node
 if n == nil {
  n = c.bucket.node(c.stack[0].page.id, nil)
 }
 // 非叶子节点
 for _, ref := range c.stack[:len(c.stack)-1] {
  _assert(!n.isLeaf, "expected branch node")
  n = n.childAt(int(ref.index))
 }
 _assert(n.isLeaf, "expected leaf node")
 return n
}

// put inserts a key/value.
// 如果put的是一个key、value的话，不需要指定pgid。
// 如果put的一个树枝节点，则需要指定pgid，不需要指定value
func (n *node) put(oldKey, newKey, value []byte, pgid pgid, flags uint32) {
 put方法的具体实现3.3节中的put(k,v)。
}

// Bucket retrieves a nested bucket by name.
// Returns nil if the bucket does not exist.
// The bucket instance is only valid for the lifetime of the transaction.
func (b *Bucket) Bucket(name []byte) *Bucket {
 if b.buckets != nil {
  if child := b.buckets[string(name)]; child != nil {
   return child
  }
 }
 // Move cursor to key.
 // 根据游标找key
 c := b.Cursor()
 k, v, flags := c.seek(name)
 // Return nil if the key doesn't exist or it is not a bucket.
 if !bytes.Equal(name, k) || (flags&bucketLeafFlag) == 0 {
  return nil
 }
 // Otherwise create a bucket and cache it.
 // 根据找到的value来打开桶。
 var child = b.openBucket(v)
 // 加速缓存的作用
 if b.buckets != nil {
  b.buckets[string(name)] = child
 }

 return child
}

// Helper method that re-interprets a sub-bucket value
// from a parent into a Bucket
func (b *Bucket) openBucket(value []byte) *Bucket {
 var child = newBucket(b.tx)

 // If unaligned load/stores are broken on this arch and value is
 // unaligned simply clone to an aligned byte array.
 unaligned := brokenUnaligned && uintptr(unsafe.Pointer(&value[0]))&3 != 0

 if unaligned {
  value = cloneBytes(value)
 }

 // If this is a writable transaction then we need to copy the bucket entry.
 // Read-only transactions can point directly at the mmap entry.
 if b.tx.writable && !unaligned {
  child.bucket = &bucket{}
  *child.bucket = *(*bucket)(unsafe.Pointer(&value[0]))
 } else {
  child.bucket = (*bucket)(unsafe.Pointer(&value[0]))
 }

 // Save a reference to the inline page if the bucket is inline.
 // 内联桶
 if child.root == 0 {
  child.page = (*page)(unsafe.Pointer(&value[bucketHeaderSize]))
 }

 return &child
}

// DeleteBucket deletes a bucket at the given key.
// Returns an error if the bucket does not exists, or if the key represents a non-bucket value.
func (b *Bucket) DeleteBucket(key []byte) error {
 //异常逻辑检查
 // Move cursor to correct position.
 c := b.Cursor()
 k, _, flags := c.seek(key)

 // Return an error if bucket doesn't exist or is not a bucket.
 if !bytes.Equal(key, k) {
  return ErrBucketNotFound
 } else if (flags & bucketLeafFlag) == 0 {
  return ErrIncompatibleValue
 }

 // Recursively delete all child buckets.
 child := b.Bucket(key)
 // 将该桶下面的所有桶都删除
 err := child.ForEach(func(k, v []byte) error {
  if v == nil {
   if err := child.DeleteBucket(k); err != nil {
    return fmt.Errorf("delete bucket: %s", err)
   }
  }
  return nil
 })
 if err != nil {
  return err
 }

 // Remove cached copy.
 delete(b.buckets, string(key))

 // Release all bucket pages to freelist.
 child.nodes = nil
 child.rootNode = nil
 child.free()

 // Delete the node if we have a matching key.
 c.node().del(key)

 return nil
}

// del removes a key from the node.
func (n *node) del(key []byte) {
 node的del()方法具体实现参考之前3.3节del(k)
}

// Put sets the value for a key in the bucket.
// If the key exist then its previous value will be overwritten.
// Supplied value must remain valid for the life of the transaction.
// Returns an error if the bucket was created from a read-only transaction,
// if the key is blank, if the key is too large, or if the value is too large.
func (b *Bucket) Put(key []byte, value []byte) error {
 if b.tx.db == nil {
  return ErrTxClosed
 } else if !b.Writable() {
  return ErrTxNotWritable
 } else if len(key) == 0 {
  return ErrKeyRequired
 } else if len(key) > MaxKeySize {
  return ErrKeyTooLarge
 } else if int64(len(value)) > MaxValueSize {
  return ErrValueTooLarge
 }

 // Move cursor to correct position.
 c := b.Cursor()
 k, _, flags := c.seek(key)

 // Return an error if there is an existing key with a bucket value.
 if bytes.Equal(key, k) && (flags&bucketLeafFlag) != 0 {
  return ErrIncompatibleValue
 }

 // Insert into node.
 key = cloneBytes(key)
 c.node().put(key, key, value, 0, 0)

 return nil
}

// Get retrieves the value for a key in the bucket.
// Returns a nil value if the key does not exist or if the key is a nested bucket.
// The returned value is only valid for the life of the transaction.
func (b *Bucket) Get(key []byte) []byte {
 k, v, flags := b.Cursor().seek(key)
 // Return nil if this is a bucket.
 if (flags & bucketLeafFlag) != 0 {
  return nil
 }
 // If our target node isn't the same key as what's passed in then return nil.
 if !bytes.Equal(key, k) {
  return nil
 }
 return v
}

// Delete removes a key from the bucket.
// If the key does not exist then nothing is done and a nil error is returned.
// Returns an error if the bucket was created from a read-only transaction.
func (b *Bucket) Delete(key []byte) error {
 if b.tx.db == nil {
  return ErrTxClosed
 } else if !b.Writable() {
  return ErrTxNotWritable
 }
 // Move cursor to correct position.
 c := b.Cursor()
 _, _, flags := c.seek(key)

 // Return an error if there is already existing bucket value.
 if (flags & bucketLeafFlag) != 0 {
  return ErrIncompatibleValue
 }
 // Delete the node if we have a matching key.
 c.node().del(key)

 return nil
}

// ForEach executes a function for each key/value pair in a bucket.
// If the provided function returns an error then the iteration is stopped and
// the error is returned to the caller. The provided function must not modify
// the bucket; this will result in undefined behavior.
func (b *Bucket) ForEach(fn func(k, v []byte) error) error {
 if b.tx.db == nil {
  return ErrTxClosed
 }
 c := b.Cursor()
 // 遍历键值对
 for k, v := c.First(); k != nil; k, v = c.Next() {
  if err := fn(k, v); err != nil {
   return err
  }
 }
 return nil
}