我们上一篇主要分析了boltdb初始化，也就是创建一个新的数据库的过程。

读取

数据库如果直接从文件读取，会效率低下，因此bolt做了一个mmap，也就是将数据使用内存映射的方法读取对应的数据。 我们接着第一篇的脚步，往后面执行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// Initialize page pool.
db.pagePool = sync.Pool{
	New: func() interface{} {
		return make([]byte, db.pageSize)
	},
}

// Memory map the data file.
if err := db.mmap(options.InitialMmapSize); err != nil {
	_ = db.close()
	return nil, err
}

// Read in the freelist.
db.freelist = newFreelist()
db.freelist.read(db.page(db.meta().freelist))

创建pagePool就忽略吧，页面池创建一个新的页面。 接下来是mmap了，我们看下是如何工作的。

mmap

首先我们看下mmap是如何工作的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

func (db *DB) mmap(minsz int) error {
	db.mmaplock.Lock()
	defer db.mmaplock.Unlock()

	info, err := db.file.Stat()
	if err != nil {
		return fmt.Errorf("mmap stat error: %s", err)
	} else if int(info.Size()) < db.pageSize*2 {
		return fmt.Errorf("file size too small")
	}

	// Ensure the size is at least the minimum size.
	var size = int(info.Size())
	if size < minsz {
		size = minsz
	}
	size, err = db.mmapSize(size)
	if err != nil {
		return err
	}

	// Dereference all mmap references before unmapping.
	if db.rwtx != nil {
		db.rwtx.root.dereference()
	}

	// Unmap existing data before continuing.
	if err := db.munmap(); err != nil {
		return err
	}

	// Memory-map the data file as a byte slice.
	if err := mmap(db, size); err != nil {
		return err
	}

	// Save references to the meta pages.
	db.meta0 = db.page(0).meta()
	db.meta1 = db.page(1).meta()

	// Validate the meta pages. We only return an error if both meta pages fail
	// validation, since meta0 failing validation means that it wasn't saved
	// properly -- but we can recover using meta1. And vice-versa.
	err0 := db.meta0.validate()
	err1 := db.meta1.validate()
	if err0 != nil && err1 != nil {
		return err0
	}

	return nil
}

程序首先加了一个锁，也就是说，从文件往内存映射的时候，一次只允许映射一次。 我们从前文知道，创建文件的时候至少创建了4个pageSize，而且options的默认InitialMmapSize没有指定，因此判断一次映射多大的时候就是用文件大小进行判断。 文件映射的大小从32K逐次翻倍直到1G,然后如果文件大小大于1G，就直接每次增加1G。 再对文件进行映射前，先解除引用，然后再进行映射。 我们之前知道，文件的前两页是metaPage，因此读取出来即可。

freelist

程序接下来创建freelist页面，我们看下freelist的结构

1
2
3
4
5

type freelist struct {
	ids     []pgid          
	pending map[txid][]pgid 
	cache   map[pgid]bool   
}

结构比较简单。 ids是指可用的页面的Id pending指将要空闲的页面，由于数据库中的各种事务，一些操作后部分页面就可以被释放了。 cache就是做了一个缓存，看一个页面是否可用。 我们在配置metaPage的时候强行指定了freelist的page位置是2，

1

db.freelist.read(db.page(db.meta().freelist))

由于我们在创建的时候没有对freelist进行配置，因此freelist读取之后也没有什么变化

结构

通过我们之前的阅读，我们知道目前的数据库结构如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

+----------+------------+-----------+-----------+
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
|   meta   |  meta      | freelist  |  leafpage |
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
|          |            |           |           |
+----------+------------+-----------+-----------+

到此为止，一个数据库的初始工作结束了。