blog | percy

life

0%

bblot transaction

发表于 更新于 分类于

[TOC]

boltdb事务Tx定义

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
// Tx 主要封装了读事务和写事务。其中通过writable来区分是读事务还是写事务
type Tx struct {
    writable       bool
    managed        bool
    db             *DB
    meta           *meta
    root           Bucket
    pages          map[pgid]*page
    stats          TxStats
    // 提交时执行的动作
    commitHandlers []func()

    // WriteFlag specifies the flag for write-related methods like WriteTo().
    // Tx opens the database file with the specified flag to copy the data.
    //
    // By default, the flag is unset, which works well for mostly in-memory
    // workloads. For databases that are much larger than available RAM,
    // set the flag to syscall.O_DIRECT to avoid trashing the page cache.
    WriteFlag int
}

// init initializes the transaction.
func (tx *Tx) init(db *DB) {
    tx.db = db
    tx.pages = nil

    // Copy the meta page since it can be changed by the writer.
    // 拷贝元信息
    tx.meta = &meta{}
    db.meta().copy(tx.meta)

    // Copy over the root bucket.
    // 拷贝根节点
    tx.root = newBucket(tx)
    tx.root.bucket = &bucket{}
    // meta.root=bucket{root:3}
    *tx.root.bucket = tx.meta.root

    // Increment the transaction id and add a page cache for writable transactions.
    if tx.writable {
        tx.pages = make(map[pgid]*page)
        tx.meta.txid += txid(1)
    }
}

Begin()实现

1
2
3
4
5
6
7
// return tx
func (db *DB) Begin(writable bool) (*Tx, error) {
	if writable {
		return db.beginRWTx()
	}
	return db.beginTx()
}

Commit()实现

Commit()方法内部实现中，总体思路是：

  1. 先判定节点要不要合并、分裂
  2. 对空闲列表的判断，是否存在溢出的情况，溢出的话，需要重新分配空间
  3. 将事务中涉及改动的页进行排序(保证尽可能的顺序IO)，排序后循环写入到磁盘中，最后再执行刷盘
  4. 当数据写入成功后，再将元信息页写到磁盘中，刷盘以保证持久化
  5. 上述操作中，但凡有失败，当前事务都会进行回滚
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 先更新数据然后再更新元信息
// 更新数据成功、元信息未来得及更新机器就挂掉了。数据如何恢复？
func (tx *Tx) Commit() error {
		// Write dirty pages to disk.
		startTime = time.Now()
		if err := tx.write(); err != nil {
			tx.rollback()
			return err
		}
    // Write meta to disk.
    // 元信息写入到磁盘
    if err := tx.writeMeta(); err != nil {
        tx.rollback()
        return err
    }
}

// write writes any dirty pages to disk.
func (tx *Tx) write() error {
  
}

Rollback()实现

Rollback()中，主要对不同事务进行不同操作：

  1. 如果当前事务是只读事务，则只需要从db中的txs中找到当前事务，然后移除掉即可。
  2. 如果当前事务是读写事务，则需要将空闲列表中和该事务关联的页释放掉，同时重新从freelist中加载空闲页。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func (tx *Tx) Rollback() error {
    _assert(!tx.managed, "managed tx rollback not allowed")
    if tx.db == nil {
        return ErrTxClosed
    }
    tx.rollback()
    return nil
}
func (tx *Tx) rollback() {
    if tx.db == nil {
        return
    }
    if tx.writable {
        // 移除该事务关联的pages
        tx.db.freelist.rollback(tx.meta.txid)
        // 重新从freelist页中读取构建空闲列表
        tx.db.freelist.reload(tx.db.page(tx.db.meta().freelist))
    }
    tx.close()
}

WriteTo()和CopyFile()实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// WriteTo writes the entire database to a writer.
// If err == nil then exactly tx.Size() bytes will be written into the writer.
// 将当前 database 写入到 w
func (tx *Tx) WriteTo(w io.Writer) (n int64, err error) {}

func (tx *Tx) CopyFile(path string, mode os.FileMode) error {
    f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, mode)
    if err != nil {
        return err
    }
    err = tx.Copy(f)
    if err != nil {
        _ = f.Close()
        return err
    }
    return f.Close()
}

总结

本章主要详细分析了下，boltdb内部事务的实现机制，再此基础上对事务中核心的几个方法做了代码的分析。到此基本上一个数据库核心的部件都已经实现完毕。那剩下的功能就把各部分功能进行组装起来，实现一个完整对外可用的数据库了。下一章我们来详细分析下boltdb中DB对象的内部一些实现。