使用 LSM Tree 思想实现一个 KV 元数据

SSTable 文档)外，有一点警惕了 WAL 会话文档。

文件系统表格用作附加写出新入操纵，当 Key/Value 写出新入文件系统表格后，也亦会同时就有到 WAL 文档中都，WAL 文档可以作为直至文件系统表格资料的依据。流程反向，如果推测资料库中都假定 WAL 文档，则须要驱动器 WAL 文档，直至流程中都的文件系统表格。

在FAT文档中都，显现出多层目录文档， 四边都亦会假定多个 SSTable 文档，SSTable 文档用作传输资料，即目录文档。下一层的目录文档，都是上一层的目录文档JPEG最初设 后作用作，因此，层数越大，目录文档越大。

举例来时说我们来明白参考资料一点的 LSM Tree 完全不尽相同部份的外观设计设想，以及互联进行念过写出新操纵时，须要经过哪些阶段。

文件系统表格

在 LSM Tree 的文件系统区外域中都，有两个文件系统表格，一个是如前所述文件系统表格 Memory Table，一个是不如前所述文件系统表格 Immutable Memory Table，两者显现出不尽相同的资料形态，一般是二叉先行后顺序果树。

在早先时，目录很难资料，此时 Memory Table 为空，即很难任何表格达方式，而 Immutable Memory Table 为 nil，即很难被分配任何文件系统，此时，所有写出新操纵仅在 Memory Table 上，写出新操纵最主要新设 Key 的最大值和移除 Key。如果写出新入 Memory Table 形同功，接着操纵资讯亦会就有到 WAL 会话文档中都。

当然，Memory Table 中都传输的 Key/Value 也不必太多，否则亦会分之二用太多文件系统，因此，一般当 Memory Table 中都的 Key 为数大幅降低阈最大值时，Memory Table 就亦会渐变为 Immutable Memory Table ，然后创建者一个最初的 Memory Table， Immutable Memory Table 亦会在合理的必定会，转既有为 SSTable，传输到FAT文档中都。

因此， Immutable Memory Table 是一个临时的某类，只在互联文件系统中都的表格达方式到 SSTable 时，临时假定。

这中都还要警惕的是，当文件系统表格被互联到 SSTable 后，Wal 文档是须要移除的。运用作 Wal 文档可以直至的资料应与现阶段文件系统中都的 KV 表格达方式明确，才可以利用 WAL 文档直至上一次流程的运行情况下，如果现阶段文件系统表格仍未漂移到 SSTable ，那么 WAL 文档仍未没必要存留，应移除并重最初创建者一个空的 WAL 文档。

关于 WAL 部份的解决缺陷，有完全不尽相同的作例，有的一个系统只有唯一一个 WAL 文档，有的则运用作多个 WAL 文档，具躯的解决缺陷亦会根据场景而改渐变。

WAL

WAL 即 Write Ahead LOG，当互联进行写出新入操纵（、渐变更或移除 Key）时，因为资料都在文件系统中都，为了避免流程崩溃先取消或ROM停机等，致使文件系统资料丢失，因此须要及时将写出新操纵就有到 WAL 文档中都，所想次重启流程时，流程可以从 WAL 文档中都，驱动器操纵就有，通过操纵就有直至到流程引退前所的情况下。

WAL 完好的会话，就有了现阶段文件系统表格的所有操纵，运用作 WAL 直至上一次流程的文件系统表格时，须要从 WAL 文档中都，驱动器每一次操纵资讯，重最初作用作文件系统表格，即重最初执行者各种写出新入操纵。因此，必要对文件系统表格互联进行写出新操纵，和从 WAL 直至资料重最初对文件系统表格互联进行写出新操纵，都是一样的。

可以这样时说， WAL 就有了操纵步骤，而且二叉先行后顺序果树传输的是再一结果。

WAL 要做的是，并能浓缩所有对文件系统表格的写出新操纵，重最初依序执行者这些操纵，使得文件系统表格直至到上一次的情况下。

WAL 文档不是文件系统表格的二进位文档备份，WAL 文档是对写出新操纵的备份，浓缩的也是写出新操纵步骤，而不是文件系统资料

SSTable 的形态

SSTable 又称是 Sorted String Table，是文件系统表格的持久既有文档。

SSTable 文档由资料区外、浓密目录区外、配置文件三个部份都是由，如示意图例右图。

文件系统表格转既有为 SSTable 时，首先行重构 Immutable Memory Table ，依序将每个 KV JPEG形同二进位资料，并且创建者一个也就是说的目录形态，就有这个二进位 KV 的右方和资料尺寸。然后将所有二进位 KV 放于FAT文档的末尾，接着将所有的目录形态转用二进位，置于资料区外再次。如此一来 将关于资料区外和目录区外的资讯，放于一个配置文件形态中都，写出新入到文档结尾处。

文件系统中都每一个表格达方式都亦会有一个 Key，在文件系统表格转既有为 SSTable 时，表格达方式子集亦会根据 Key 互联进行先行后顺序，然后如此一来将这些表格达方式转既有为二进位，传输到文档的末尾，即资料区外中都。

但是，我们怎么从资料区外中都连接紧紧出新每一个表格达方式呢？

对于完全不尽相同的开发者，编码方式步骤中都，新设的 SSTable 的形态是不一样的，将文件系统表格转用 SSTable 的处理步骤分析方例也不一样，因此这中都来龙去脉只时说自己在写出新 LSM Tree 时的作例。

来龙去脉的作例是在作用作资料区外的时候，不将表格达方式子集一次性作用作二进位，而是一个个表格达方式依序重构处理步骤。

首先行，将一个 Key/Value 表格达方式，作用作二进位，放于文档的末尾，然后作用作一个目录，就有这个表格达方式二进位资料在文档的算起右方以及尺寸，然后将这个目录先行放于文件系统中都。

接着，不断处理步骤剩下的表格达方式，在文件系统中都作用作也就是说的目录。

浓密目录坚称每一个目录执行者文档中都的一个资料块。

当所有表格达方式处理步骤天内，此时 SSTable 文档仍未作用作资料区外。接着，我们如此一来将所有的目录子集，作用作二进位资料，外加到文档中都。

然后，我们还须要为资料区外和浓密目录区外的算起右方和尺寸，作用作文档配置文件，以再次后续驱动器文档时可以一分为二资料区外和浓密目录区外，将两部份的资料之外处理步骤。

配置文件形态也很直观，其主要有四个最大值：

// 资料区外算起目录 dataStart int64 // 资料区外尺寸 dataLen int64 // 浓密目录区外算起目录 indexStart int64 // 浓密目录区外尺寸 indexLen int64

配置文件亦会被外加到文档的结尾处中都，并且一般而言了元组尺寸。

在驱动器 SSTable 文档时，我们先行驱动器文档之前所的几个元组，如 64 个元组，然后根据每 8 个元组浓缩字段的最大值，作用作配置文件，然后就可以对资料区外和浓密目录区外互联进行处理步骤了。

SSTable 表格达方式和目录的形态

我们将一个 Key/Value 传输在资料区外，那么这块传输了一个 Key/Value 表格达方式的文档块，被称作 block，为了坚称 Key/Value，我们可以判别一个这样的形态：

Key Value Deleted

然后将这个形态转既有为二进位资料，写出新到文档的资料区外中都。

为了整合 Key/Value 在资料区外的右方，我们还须要判别一个目录，其形态如下：

Key Start Length

每个 Key/Value 运用作一个目录互联进行整合。

SSTable Tree

每次将文件系统表格转既有为 SSTable 时，都亦会作用作一个 SSTable 文档，因此我们须要主要职责 SSTable 文档，以免文档为数不必要。

举例来时说是 LSM Tree 的 SSTable 文档有组织形态。

在上示意图中都可以看见，目录由很多的 SSTable 文档都是由，而且 SSTable 被连接紧紧在完全不尽相同的层中都都，为了主要职责完全不尽相同层的 SSTable，所有 SSTable FAT文档的有组织也有一个果树形态，通过 SSTable Tree，主要职责完全不尽相同层的FAT文档个数或者 SSTable 为数。

关于 SSTable Tree，有三个通则：

1，第 0 层的 SSTable 文档，都是文件系统表格转既有的。

2，除第 0 层，下一层的 SSTable 文档，根本无例由上一层的 SSTable 文档通过JPEG最初设作用作，而一层的 SSTable 文档在总文档个数或为数大幅降低阈最大值时，才能互联进行最初设，作用作一个最初的 SSTable 到下一层。

3，每一层的 SSTable 都有一个依序，根据作用作整整来先行后顺序。这个在结构上用作从所有的 SSTable 中都浏览资料。

由于每次持久既有文件系统表格，都亦会创建者一个 SSTable 文档，因此 SSTable 文档为数亦会越来越多了，文档多了再次，须要完好多数的文档嵌套，而且在多个文档中都驱动器资料时，飞行速度也亦会渐变慢。如果不互联进行控制，那么不必要的文档亦会致使念过稳定性渐变差以及分之二用三维空间过于膨胀，这一具躯情况被被称作 三维空间可视和念过可视。

由于 SSTable 是不必改回的，那么如果要移除一个 Key，或者渐变更一个 Key 的最大值，根本无例在最初的 SSTable 中都标示出新，而不必渐变更，这样亦会致使完全不尽相同的 SSTable 假定不尽相同的 Key，文档不够为散漫。

因此，还须要对小的 SSTable 文档互联进行JPEG，最初设形同一个大的 SSTable 文档，放于下一层中都，以再次降低驱动器稳定性。

当一层的 SSTable 文档总个数大于阈最大值时，或者 SSTable 文档的为数太多时，就须要触发最初设动作，作用作最初的 SSTable 文档，先取出新下一层中都，如此一来将原先行的 SSTable 文档移除，示意图例预览了这一步骤。

虽然对 SSTable 互联进行最初设JPEG，可以抑制三维空间可视和念过可视缺陷，但是对多个 SSTable 最初设为一个 SSTable 时，须要存储每个 SSTable 文档，在文件系统驱动器文档的主旨，创建者一个最初的 SSTable 文档，并且移除干脆新的文档，这样亦会耗损大量的 CPU 整整和FAT IO。这种具躯情况被被称作写出新可视。

示意图例预览了最初设前所后的传输三维空间改渐变。

文件系统中都的 SSTable

当流程重启后，亦会存储每个 SSTable 的配置文件和浓密目录区外到文件系统中都，也就是 SSTable 在文件系统中都CPU了 Key 表格列出新，须要在 SSTable 中都浏览 Key 时，首先行在文件系统的浓密目录区外浏览，如果认出新 Key，则根据 目录的 Start 和 Length，从FAT文档中都驱动器 Key/Value 的二进位资料。接着将二进位资料转既有为 Key/Value 形态。

因此，要已确定一个 SSTable 是否是假定某个 Key 时，是在文件系统中都浏览的，这个步骤很迟，只有当须要驱动器 Key 的最大值时，才须要从文档中都念过出新。

可是，当 Key 为数太多时，全部缓假定文件系统中都亦会耗损很多的文件系统，并且逐个浏览也须要浪费一定的整整，还可以通过运用作布隆容器(BloomFilter)来不够迟地判断一个 Key 是否是假定。

资料浏览步骤

首先行根据要浏览的 Key，从 Memory Table 中都浏览。

如果 Memory Table 中都，找将近也就是说的 Key，则从 Immutable Memory Table 中都浏览。

来龙去脉所述出新的 LSM Tree 目录中都，只有 Memory Table，很难 Immutable Memory Table。

如果在两个文件系统表格中都都浏览将近 Key，那么就要从 SSTable 表格列出新中都浏览。

首先行浏览第 0 层的 SSTable 表格，从该层最最初的 SSTable 表格开始浏览，如果很难认出新，再次浏览同一层的其他 SSTable，如果还是很难，则接着查下一层。

当浏览到 Key 时，无论 Key 情况下如何 (有效或已被移除)，都亦会先取消浏览，调回此 Key 的最大值和移除标志。

解决缺陷步骤

在本节中都，来龙去脉将亦会时说明了自己解决缺陷 LSM Tree 大躯的解决缺陷设想，理应都计算出新来一部份code请出新处意，但是完备的code须要在堆放中都查看，这中都只计算出新来解决缺陷就其的code判别，不列出新具躯的code细节。

示意图例是 LSM Tree 主要追捧的某类：

对于文件系统表格，我们要解决缺陷增删查改、重构；

对于 WAL，须要将操纵资讯写出新到文档中都，并且并能从 WAL 文档直至文件系统表格；

对于 SSTable，并能存储文档资讯，理应都浏览也就是说的资料；

也就是说 SSTable Tree，负责主要职责所有 SSTable，互联进行文档最初设等。

▌Key/Value 的坚称

作为 Key/Value 目录，我们须要并能完好任何种类的最大值。虽时说 GO 1.18 增加了泛型，但是泛型形态躯并不必任意传输任何最大值，解决贮藏各种种类的 Value 的缺陷，因此来龙去脉不运用作泛型形态躯。而且，无论传输的是什么资料，对目录来时说是不举足轻重，目录也完全不必想到 Value 的意思，这个最大值的种类和意思，只对运用作者有用，因此我们可以必要将最大值转用二进位传输，在用户先取资料时，如此一来将二进位转既有为也就是说种类。

判别一个形态躯，用作完好任何种类的最大值：

// Value 坚称一个 KV type Value struct { Key string Value []byte Deleted bool }

Value 形态躯提到路径是 kv.Value。

如果有一个这样的形态躯：

type TestValue struct { A int64 B int64 C int64 D string }

那么可以将形态躯资料流后的二进位资料放于 Value字段中都。

data,_ := json.Marshal(value)

v := Value{Key: "test",Value: data,Deleted: false,}

Key/Value 通过 json 资料流最大值，转用二进位如此一来传输到文件系统中都。

因为在 LSM Tree 中都，即使一个 Key 被移除了，也不亦会修整干脆这个表格达方式，只是将该表格达方式标示出新为移除情况下，所以为了已确定浏览结果，我们须要判别一个枚举，用作判断浏览到此 Key 后，此 Key 是否是有效。

// SearchResult 浏览结果type SearchResult int

const (// None 很难浏览到None SearchResult = iota// Deleted 仍未被移除Deleted// Success 浏览形同功Success)

关于code部份，念过者群可以参考资料：

▌ 文件系统表格的解决缺陷

LSM Tree 中都的文件系统表格是一个二叉先行后顺序果树，关于二叉先行后顺序果树的操纵，主要有新设最大值、、浏览、重构，参考资料的code念过者群可以参考资料：

举例来时说来直观时说明了二叉先行后顺序果树的解决缺陷。

结论我们要的 Key 表格列出新为 [30,45,25,23,17,24,26,28]，那么后，文件系统表格的形态如下右图：

来龙去脉在写出新二叉先行后顺序果树时，推测几个更易出新错的之外，因此这中都所列一下。

首先行，我们要记住：路由再次，右方不如此一来改渐变，不必被移除，也不必被不够换右方。

第一点，最初的路由，根本无例作为枝叶。

举例来时说是一个合理的操纵：

如示意图右图，本身仍未假定了 23、17、24，那么 18 时，须要在 17 的右孩。

举例来时说是一个有误的操纵：

互联进行操纵时，不必漂移新路由的右方，不必改渐变左孩右孩的关系。

第二点，移除路由时，根本无例标示出新移除，不必真正移除路由。

二叉先行后顺序果树形态判别

二叉先行后顺序果树的形态躯和分析方例判别如下：

// treeNode 一组果树路由type treeNode struct {KV kv.ValueLeft *treeNodeRight *treeNode}

// Tree 一组果树type Tree struct {root *treeNodecount intrWLock *sync.RWMutex}

// Search 浏览 Key 的最大值func (tree *Tree) Search(key string) (kv.Value, kv.SearchResult) {}

// Set 新设 Key 的最大值并调回新最大值func (tree *Tree) Set(key string, value []byte) (oldValue kv.Value, hasOld bool) {}

// Delete 移除 key 并调回新最大值func (tree *Tree) Delete(key string) (oldValue kv.Value, hasOld bool) {}

具躯的code解决缺陷请求参考资料：

因为 Go 语言学的 string 种类是最大值种类，因此并能必要不够为个数的，因此在 Key/BValue 时，可以简既有不少code。

操纵

因为果树是一组的， Key/Value 时，须要在果树的根路由左至右对比 Key 的个数，然后以枝叶路由的型式到而亦会。

步骤，可以总称多种具躯情况。

第一种，不假定就其的 Key 时，必要作为枝叶路由，作为上一层表格达方式的左孩或右孩。

if key < current.KV.Key {// 左孩为空，必要前面if current.Left == nil {current.Left = newNode// ... ...}// 继续对比下一层current = current.Left} else {// 右孩为空，必要右方if current.Right == nil {current.Right = newNode// ... ...}current = current.Right}

第二种，当 Key 仍未假定，该路由可能是有效的，我们须要附加 Value才可；该路由有可能是被准则移除了，须要附加 Value ，并且将 Deleted标示出新改为 false。

node.KV.Value = valueisDeleted := node.KV.Deletednode.KV.Deleted = false

那么，当向二叉先行后顺序果树一个 Key/Value 时，整整演正则表达式如何？

如果二叉先行后顺序果树是不够为最大限度的，即数不够为圆锥，那么互联进行操纵时，其整整演正则表达式为 O(logn)。

如示意图例右图，而亦会有 7 个路由，只有三层，那么操纵时，最多须要对比三次。

如果二叉先行后顺序果树不最大限度，现阶段的具躯情况是所有路由都在前面或右方，此时的整整演正则表达式为 O(n)。

如示意图例右图，而亦会有四个路由，也有四层，那么互联进行操纵时，最多须要对比四次。

路由的code请求参考资料：

#L64

浏览

在二叉先行后顺序而亦会浏览 Key 时，根据 Key 的个数来考虑左孩或右孩互联进行下一层浏览，浏览code请出新处意如下：

currentNode := tree.root// 一组浏览for currentNode != nil {if key == currentNode.KV.Key {if currentNode.KV.Deleted == false {return currentNode.KV, kv.Success} else {return kv.Value{}, kv.Deleted}}if key < currentNode.KV.Key {// 继续对比下一层currentNode = currentNode.Left} else {// 继续对比下一层currentNode = currentNode.Right}}

其整整演正则表达式与明确。

移除

移除操纵时，只须要浏览到也就是说的路由，将 Value弃置，然后新设移除标示出新才可，该路由是不必被移除的。

currentNode.KV.Value = nilcurrentNode.KV.Deleted = true

其整整演正则表达式与明确。

重构正则表达式

参考资料code：#L175

为了将二叉先行后顺序果树的路由依序重构出新来，表格达式正则表达式是最直观的，但是当果树的具体来说极低时，表格达式亦会致使耗损很多文件系统三维空间，因此我们须要运用作子流程正则表达式，来对果树互联进行重构，依序拿到所有路由。

Go 语言学中都，利用切片解决缺陷子流程：

二叉先行后顺序果树的依序重构，显然就是前所序重构，按照前所序重构，重构进行时后，授予的路由子集，其 Key 一定是依序的。

参考资料code如下：

// 运用作子流程，而非表格达式，子流程运用作了切片，可以启动时引入个数，不必担心子流程满stack := InitStack(tree.count / 2)values := make([]kv.Value, 0)

tree.rWLock.RLockdefer tree.rWLock.RUnlock

// ；也获先取果树的表格达方式currentNode := tree.rootfor {if currentNode != nil {stack.Push(currentNode)currentNode = currentNode.Left} else {popNode, success := stack.Popif success == false {break}values = append(values, popNode.KV)currentNode = popNode.Right}}

重构code： #L175

子流程个数预设分配为果树路由为数的一半，如果此果树是最大限度的，则为数个数不够为合理。并且也不是将所有路由都漂移设备到子流程再次才能互联进行驱动器，只要很难左孩，才可从子流程中都先取出新表格达方式驱动器。

如果果树不是最大限度的，那么也就是说须要的子流程三维空间可能不够大，但是这个子流程运用作了切片，如果子流程三维空间太少，亦会启动时引入的。

重构步骤如下动示意图右图：

动示意图制作公司不易~

可以看见，须要多少子流程三维空间，与二叉果树的高度有关。

▌ WAL

WAL 的形态躯判别如下：

type Wal struct {f *os.Filepath stringlock sync.Locker}

WAL 须要具备两种能力：

1，流程反向，并能驱动器 WAL 文档的主旨，直至为文件系统表格（二叉先行后顺序果树）。

2，流程重启后，写出新入、移除操纵文件系统表格时，操纵要写出新入到 WAL 文档中都。

参考资料code：

举例来时说来宣讲来龙去脉的 WAL 解决缺陷步骤。

举例来时说是写出新入 WAL 文档的简既有code：

// 就有会话func (w *Wal) Write(value kv.Value) {data, _ := json.Marshal(value)err := binary.Write(w.f, binary.LittleEndian, int64(len(data)))err = binary.Write(w.f, binary.LittleEndian, data)}

可以看见，先行写出新入一个 8 元组，如此一来将 Key/Value 资料流写出新入。

为了并能在流程反向，合理从 WAL 文档直至资料，那么必然须要对 WAL 文档做好合理的连接紧紧，以再次并能合理驱动器每一个表格达方式操纵。

因此，每一个被写出新入 WAL 的表格达方式，都须要就有其尺寸，其尺寸运用作 int64 种类坚称，int64 分之二 8 个元组。

WAL 文档直至步骤

在上一开首中都，写出新入 WAL 文档的一个表格达方式，由表格达方式资料及其尺寸都是由。那么 WAL 的文档形态可以这样视作：

因此，在运用作 WAL 文档直至资料时，首先行驱动器文档末尾的 8 个元组，已确定第一个表格达方式的元组为数 n，然后将 8 ~ (8+n)仅限于中都的二进位资料存储到文件系统中都，然后通过 json.Unmarshal将二进位资料所谓资料流为 kv.Value种类。

接着，驱动器 (8+n) ~ (8+n)+8右方的 8 个元组，以再次已确定下一个表格达方式的资料尺寸，这样无关紧要把整个 WAL 文档驱动器天内。

一般 WAL 文档不亦会很大，因此在流程反向，资料直至步骤，可以将 WAL 文档全部存储到文件系统中都，然后逐个驱动器和所谓资料流，定位操纵是 Set 还是 Delete，然后加载二叉先行后顺序果树的 Set 或 Deleted 分析方例，将表格达方式都添加到路由中都。

参考资料code如下：

code右方：

▌ SSTable 与 SSTable Tree

SSTable 涉及的code不够为多，可以根据完好 SSTable 文档、从文档解析 SSTable和搜索 Key三部份互联进行划分。

来龙去脉所述出新的所有 SSTable code文档表格列出新如下：

SSTable 形态

SSTable 的形态躯判别如下：

// SSTable 表格，传输在FAT文档中都type SSTable struct {// 文档嵌套f *os.FilefilePath string// 配置文件tableMetaInfo MetaInfo// 文档的浓密目录表格列出新sparseIndex map[string]Position// 先行后顺序后的 key 表格列出新sortIndex []stringlock sync.Locker}

sortIndex 中都的表格达方式是一组的，并且表格达方式文件系统右方相连，再次于 CPU CPU，降低浏览稳定性，还可以运用作布隆容器，迟速已确定该 SSTable 中都是否是假定此 Key。

当已确定该 SSTable 再次，再次从 sparseIndex 中都浏览此表格达方式的目录，从而可以在文档中都整合。

其中都配置文件和浓密目录的形态躯判别如下：

type MetaInfo struct {// 版本号version int64// 资料区外算起目录dataStart int64// 资料区外尺寸dataLen int64// 浓密目录区外算起目录indexStart int64// 浓密目录区外尺寸indexLen int64} // Position 表格达方式整合，传输在浓密目录区外中都，坚称一个表格达方式的算起右方和尺寸type Position struct {// 算起目录Start int64// 尺寸Len int64// Key 仍未被移除Deleted bool}

可以看见，一个 SSTable 形态躯除了须要指向FAT文档外，还须要在文件系统中都CPU一些进去，不过完全不尽相同开发者的作例不一样。就举例来时说来龙去脉的作例，在一开始时，再次一般而言了这种模式，须要在文件系统中都CPU Keys 表格列出新，然后运用作字典CPU表格达方式整合。

// 文档的浓密目录表格列出新sparseIndex map[string]Position// 先行后顺序后的 key 表格列出新sortIndex []string

但显然，只存留 sparseIndex map[string]Position也可以进行时所有浏览操纵，sortIndex []string不是需要的。

SSTable 文档形态

SSTable 的文档，总称资料区外，浓密目录区外，配置文件/文档目录，三个部份。传输的主旨与开发者判别的资料形态有关。如示意图例右图：

资料区外是 资料流后的 Value 形态躯表格列出新，而浓密目录区外是资料流后的 Position 表格列出新。不过两个区外域的资料流根本原因不一样。

浓密目录区外，是 map[string]Position种类资料流为二进位传输的，那么我们可以驱动器文档时，可以必要将浓密目录区外整个所谓资料流为 map[string]Position。

资料区外，是一个个 kv.Value资料流后外加的，因此是不必将整个资料区外所谓资料流为 []kv.Value，根本无例通过 Position将资料区外的每一个 block 逐步驱动器，然后所谓资料流为 kv.Value。

SSTable Tree 形态和主要职责 SSTable 文档

为了有组织大量的 SSTable 文档，我们还须要一个形态躯，以具体来说形态，去主要职责所有的FAT文档。

我们须要判别一个 TableTree 形态躯，其判别如下：

// TableTree 果树type TableTree struct {levels []*tableNode // 这部份是一个链表格操作符// 用作避免互联进行或JPEG、移除 SSTable 时频发争执lock *sync.RWMutex}

// 链表格，坚称每一层的 SSTabletype tableNode struct {index inttable *SSTablenext *tableNode}

为了方再次对 SSTable 互联进行分层和标示出新依序，须要颁布 SSTable 文档的命名规定。

如下文档右图：

├── 0.0.db├── 1.0.db├── 2.0.db├── 3.0.db├── 3.1.db├── 3.2.db

SSTable 文档由 {level}.{index}.db都是由，第一个小数代表者格文档所在的 SSTable 层，第二个小数，坚称在该层中都的目录。

其中都，目录越大，坚称其文档越最初。

SSTable 文档步骤

当从文件系统表格转既有为 SSTable 时，每个被转既有的 SSTable ，都是到 Level 0 的之前所面。

每一层的 SSTable 运用作一个链表格互联进行主要职责：

type tableNode struct {index inttable *SSTablenext *tableNode}

因此，在 SSTable 时，沿着往下浏览，放于链表格的之前所面。

链表格路由的code部份请出新处意如下：

for node != nil {if node.next == nil {newNode.index = node.index + 1node.next = newNodebreak} else {node = node.next}} 从文件系统表格转既有为 SSTable 时，亦会涉及不够为多的操纵，念过者群请求参考资料code： 驱动器 SSTable 文档

当流程反向，须要驱动器资料库中都所有的 SSTable 文档到 TableTree 中都，接着存储每一个 SSTable 的浓密目录区外和配置文件。

来龙去脉的 LSM Tree 处理步骤步骤如示意图右图：

来龙去脉的 LSM Tree 存储这些文档，合计费时 19.4259983s 。

存储步骤的code在:

举例来时说来龙去脉时说一下大概的存储步骤。

首先行驱动器资料库中都的所有 .db文档：

infos, err := ioutil.ReadDir(dir)if err != nil {log.Println("Failed to read the database file")panic(err)}for _, info := range infos {// 如果是 SSTable 文档if path.Ext(info.Name) == ".db" {tree.loadDbFile(path.Join(dir, info.Name))}}

然后创建者一个 SSTable 某类，存储文档的配置文件和浓密目录区外：

// 存储文档嵌套的同时，存储表格的配置文件table.loadMetaInfo// 存储浓密目录区外table.loadSparseIndex

之前所根据 .db的文档名称，到 TableTree 中都指定的右方：

SSTable 文档最初设

当一层的 SSTable 文档太多时，或者文档太大时，须要将该层的 SSTable 文档，最初设紧紧，作用作一个最初的、很难重复表格达方式的 SSTable，放于最初的一层中都。

因此，来龙去脉的作例是在流程重启后，运用作一个最初的加载，定期检查文件系统表格是否是须要被转既有为 SSTable、是否是须要JPEG SSTable 层。定期检查时， 从 Level 0 开始，定期检查两个情况下阈最大值，第一个是 SSTable 为数，另一个是该层 SSTable 的文档总个数。

SSTable 文档最初设阈最大值，在流程重启的时候，须要新设。

lsm.Start(config.Config{DataDir: 在在E:重大项目lsm资料检测资料库在在,Level0Size: 1, // 第0层所有 SSTable 文档个数之和的阈最大值PartSize: 4, // 每一层 SSTable 为数阈最大值Threshold: 500, // 文件系统表格表格达方式阈最大值CheckInterval: 3, // JPEG整整时间延迟})

每一层的 SSTable 文档个数之和，是根据第 0 层作用作的，例如，当你新设第 0 层为 1MB 时，第 1 层则为 10MB，第 2 层则为 100 MB，运用作者只须要新设第 0 层的文档总个数阈最大值才可。

举例来时说来时说明了 SSTable 文档最初设步骤。

JPEG最初设的完备code请求参考资料：

举例来时说是初始的文档果树：

首先行创建者一个二叉先行后顺序果树某类：

memoryTree := WildsortTree.Tree{}

然后在 Level 0 中都，从目录之比的 SSTable 开始，驱动器文档资料区外中都的每一个 block，所谓资料流后，互联进行操纵或移除操纵。

for k, position := range table.sparseIndex {if position.Deleted == false {value, err := kv.Decode(newSlice[position.Start:(position.Start + position.Len)])if err != nil {log.Fatal(err)}memoryTree.Set(k, value.Value)} else {memoryTree.Delete(k)}}

将 Level 0 的所有 SSTable 存储到二叉先行后顺序而亦会，即最初设所有表格达方式。

然后将二叉先行后顺序果树转既有为 SSTable，到 Level 1 中都。

接着，移除 Level 0 的所有 SSTable 文档。

出新处，由于来龙去脉的JPEG手段亦会将文档存储到文件系统中都，运用作切片传输文档资料，因此可能亦会再次出新现容量大过大的有误。

这是一个最大有一点追捧的之外。

SSTable 浏览步骤 完备的code请求参考资料：

当须要浏览一个表格达方式时，首先行在文件系统表格中都浏览，浏览将近时，须要在 TableTree 中都，逐个浏览 SSTable。

// 重构每一层的 SSTablefor _, node := range tree.levels {// 校对 SSTable 表格列出新tables := make([]*SSTable, 0)for node != nil {tables = append(tables, node.table)node = node.next}// 浏览的时候要从之前所一个 SSTable 开始浏览for i := len(tables) - 1; i>= 0; i；还有 {value, searchResult := tables[i].Search(key)// 未认出新，则浏览下一个 SSTable 表格if searchResult == kv.None {continue} else { // 如果认出新或已被移除，则调回结果return value, searchResult}}}

在 SSTable 也就是说上浏览时，运用作了二分浏览例：

// 表格达方式整合var position Position = Position{Start: -1,}l := 0r := len(table.sortIndex) - 1

// 二分浏览例，浏览 key 是否是假定for l <= r {mid := int((l + r) / 2)if table.sortIndex[mid] == key {// 获先取表格达方式整合position = table.sparseIndex[key]// 如果表格达方式已被移除，则调回if position.Deleted {return kv.Value{}, kv.Deleted}break} else if table.sortIndex[mid] < key {l = mid + 1} else if table.sortIndex[mid]> key {r = mid - 1}}

if position.Start == -1 {return kv.Value{}, kv.None}

关于 LSM Tree 目录的编写出新，就到这中都天内了，举例来时说明白来龙去脉的目录稳定性和运用作分析方例。

▌ 直观的运用作检测

请出新处意code右方：

首先行下载依赖于包：

go get -u github.com/whuanle/lsm@v1.0.0

然后运用作 lsm.Start初始既有目录，如此一来增删查改 Key，请出新处意code如下：

package main

import ("fmt""github.com/whuanle/lsm""github.com/whuanle/lsm/config")

type TestValue struct {A int64B int64C int64D string}

func main {lsm.Start(config.Config{DataDir: 在在E:重大项目lsm资料检测资料库在在,Level0Size: 1,PartSize: 4,Threshold: 500,CheckInterval: 3, // JPEG整整时间延迟})// 64 个元组testV := TestValue{A: 1,B: 1,C: 3,D: "00000000000000000000000000000000000000",}

lsm.Set("aaa", testV)

value, success := lsm.Get[TestValue]("aaa")if success {fmt.Println(value)}

lsm.Delete("aaa")}

testV 是 64 元组，而 kv.Value 完好了 testV 的最大值，kv.Value 元组个数为 131。

文档JPEG检测

我们可以写出新一个从 26 个字母中都先取任意 6 字母都是由 Key，到目录中都，理应都观察文档JPEG最初设，和飞行速度等。

完全不尽相同气既有具体来说的表格达方式为数：

1 2 3 4 5 6 26 676 17,576 456,976 11,881,376 308,915,776

作用作的检测文档表格列出新：

文档JPEG最初设动示意图步骤的如下(左右20秒)：

检测

举例来时说是一些不严谨的检测结果。

新设重启目录时的配置：

lsm.Start(config.Config{DataDir: 在在E:重大项目lsm资料检测资料库在在,Level0Size: 10, // 0 层 SSTable 文档个数PartSize: 4, // 四边文档为数Threshold: 3000, // 文件系统表格阈最大值CheckInterval: 3, // JPEG整整时间延迟})

lsm.Start(config.Config{DataDir: 在在E:重大项目lsm资料检测资料库在在,Level0Size: 100,PartSize: 4,Threshold: 20000,CheckInterval: 3,})

资料：

func insert {

// 64 个元组testV := TestValue{A: 1,B: 1,C: 3,D: "00000000000000000000000000000000000000",}

count := 0start := time.Nowkey := []byte{'a', 'a', 'a', 'a', 'a', 'a'}lsm.Set(string(key), testV)for a := 0; a < 1; a++ {for b := 0; b < 1; b++ {for c := 0; c < 26; c++ {for d := 0; d < 26; d++ {for e := 0; e < 26; e++ {for f := 0; f < 26; f++ {key[0] = 'a' + byte(a)key[1] = 'a' + byte(b)key[2] = 'a' + byte(c)key[3] = 'a' + byte(d)key[4] = 'a' + byte(e)key[5] = 'a' + byte(f)lsm.Set(string(key), testV)count++}}}}}}elapse := time.Since(start)fmt.Println("进行时，资料量：", count, ",耗损整整：", elapse)}

两次检测，作用作的 SSTable 总文档个数都是左右 82MB。

两次检测耗损的整整：

进行时，资料量：456976 ,耗损整整：1m43.4541747s

进行时，资料量：456976 ,耗损整整：1m42.7098146s

因此，每个表格达方式 131 个元组，这个目录 100s 可以 左右 45w 条资料，即每秒 4500 条资料。

如果将 kv.Value 的最大值不够为大，检测在 3231 元组时， 456976 条资料，文档左右 1.5GB，耗损整整 2m10.8385817s，即每秒 3500条。

较大最大值的 kv.Value，code请出新处意：

存储检测

举例来时说是每个表格达方式 3231 元组时， 45 万条资料后的 SSTable 文档表格列出新，流程反向，我们须要存储这些文档。

2022/05/21 21:59:30 Loading wal.log...2022/05/21 21:59:32 Loaded wal.log,Consumption of time : 1.8237905s2022/05/21 21:59:32 Loading database...2022/05/21 21:59:32 The SSTable list are being loaded2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/1.0.db2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/1.0.db ,Consumption of time : 92.9994ms2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/1.1.db2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/1.1.db ,Consumption of time : 65.9812ms2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/2.0.db2022/05/21 21:59:32 Loading the E:重大项目lsm资料检测资料库/2.0.db ,Consumption of time : 331.6327ms2022/05/21 21:59:32 The SSTable list are being loaded,consumption of time : 490.6133ms

可以看见，除 WAL 存储不够为费时（因为要逐个文件系统中都），SSTable 文档的存储还是不够为迟的。

浏览检测

如果表格达方式都在文件系统中都时，即使有 45 万条资料，浏览飞行速度也是极为迟的，例如浏览 aaaaaa(Key之比)和 aazzzz(Key较大)的资料，费时都大大降低。

举例来时说运用作下面表格达方式 3kb 的目录文档互联进行检测。

浏览code：

start := time.Nowelapse := time.Since(start)v, _ := lsm.Get[TestValue]("aaaaaa") // 或者 aazzzzfmt.Println("浏览进行时，耗损整整：", elapse)fmt.Println(v)

如果在 SSTable 中都浏览，因为 aaaaaa是首先行被写出新入的，因此必定亦会在一个大的 SSTable 文档的结尾处，须要耗损的整整不够为多。

SSTable 文档表格列出新：

├── 1.0.db 116MB├── 2.0.db 643MB├── 2.1.db 707MB

左右 1.5GB

aaaaaa在 2.0db 中都，浏览时亦会以 1.0.db、2.1.db、2.0.db的依序存储。

浏览飞行速度检测：

2022/05/22 08:25:43 Get aaaaaa浏览 aaaaaa 进行时，耗损整整：19.4338ms

2022/05/22 08:25:43 Get aazzzz浏览 aazzzz 进行时，耗损整整：0s

关于来龙去脉的 LSM Tree 目录，就介绍到这中都，参考资料的解决缺陷code，请求参考资料 Github 堆放。

开发者最有价最大值医学专家（MVP）

开发者最有价最大值医学专家是开发者公司获颁第三方核心技术专业人士的一个全球大奖。29年来，多国的核心技术的社区外领导者，因其在线上和路中的核心技术的社区外中都共享专业知识和经验而授予此大奖。

MVP是经过严密物色的医学专家制作公司团队，他们代表者格着核心技术最纯熟且最具与生俱来的人，是对的社区外投放极大的热情并乐于助人的医学专家。MVP致力于通过发表演说、论坛问答、创建者网站、所写出新博文、共享影片、开源重大项目、有组织亦开会等手段来帮助他人，并较大程度地帮助开发者核心技术的社区外用户运用作 Microsoft 核心技术。

不够多详情请求受保护官方：

m/zh-cn

谢谢你念过完了本文～相信你一定有一些回忆、本质、缺陷自已表格达。欢迎在华盛顿邮报区外畅所欲言，渴望惊醒你的“声音”哦！

同时，喜欢的主旨也不要忘记转发给你的人，谢谢你的支持！

追捧开发者中都国MSDN

。

广州看白癜风哪个医院好
成都妇科医院哪家看的好
天津白癜风专科医院哪个好
深圳妇科医院专家预约挂号
吉林男科医院哪个比较好
亚健康症状
一直咳嗽怎么办用什么方法止咳
眼睛视疲劳用什么眼药水
女性生理安全期
喉咙痛的最快解决方法