LevelDB的数据插入首先会存储在内存表memdb内部，当数据量达到一定的大小之后才会被持久化到文件中。本文就内存数据表的结构及其操作相关源码进行分析。

1.memdb结构

memdb的定义如下, 该db内部有三个主要的数据结构：1).byte[]kvData 用于存储用户插入的key-value数据; 2).[]int 类型的nodeData 用于对kv数据建立一个调表格式的索引; 3).preNode，这是辅助nodeData的数据查询以及插入使用的，后续进行详细介绍。

type DB struct {
    cmp comparer.BasicComparer //key的比较器
    rnd *rand.Rand             //随机数生成器，产生随机的调表层高

    mu     sync.RWMutex
    kvData []byte //存储key value的序列化数据
    // Node data:
    // [0]         : KV offset
    // [1]         : Key length
    // [2]         : Value length
    // [3]         : Height
    // [3..height] : Next nodes
    nodeData  []int //存储key value的索引信息
    prevNode  [tMaxHeight]int
    maxHeight int
    n         int //键值对的数量
    kvSize    int
}

kvData 和nodeData的数据结构如下,其中kvData的实现比较简单，就是用一个byte类型的数组将key-value 对一个个存储下来。nodeData通过一个int数组实现了一个随机的调表。如下如所示对于nodeData我们可以将其视为n个node所组成，每个node表示了一个kv对的索引。
如图所示每个node包含了kv对的索引信息和调表信息，其中kvOffset指向了具体kv的起始位置，keyLen和valueLen分别用于key和value的读取。

memdb data structure.png

除此之外每个node中还包含了该node所有层级的指针，Height表示当前node的所有层高，后面的h1 ~ h(Height)的位置表示该层该节点的后继节点的指针。如下图所示是论文skip-list的配图，memdb中的node的h1到h(Height)就如图中的垂直方向的指针结构。

skip-list.png

2.memdb关键操作

memdb中的所有操作都是通过nodeData进行，也就是说memdb中涉及的插入、查找、删除等都通过调表的数据结构去实现。

2.1 查找函数findGE

findGE用于调表中数据的检索，即检索大于等于key的相关信息，这里有一点值得关注的是preNode的数据结构，该结构就是图skip-list的search path数据，存储了新key的搜索路径，如图插入的17号节点，那么其查询会从最高层进行查询，查询之后，preNode中比17号节点height高的preNode[i]中保存了比17大的后继节点，比17号小的或者等于的记录了17号节点对应层级的前置节点，这为后续的插入提供了层级上节点插入的辅助。

func (p *DB) findGE(key []byte, prev bool) (int, bool) {
    node := 0
    h := p.maxHeight - 1
    for {
        next := p.nodeData[node+nNext+h] //+h 表示从Node节点高度为h的层次开始查找
        cmp := 1
        if next != 0 {
            o := p.nodeData[next]
            cmp = p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key)
        }
        if cmp < 0 {
            // Keep searching in this list
            node = next
            //当前的kvData中key比目标key小，继续向前查找
        } else {
            //cmp >= 0, 表示当前值大于等于目标key，则目标key要么替代该位置，要么得插入在当前key的后面
            if prev {
                p.prevNode[h] = node
            } else if cmp == 0 {
                return next, true //恰好找到相同的key
            }
            if h == 0 {
                return next, cmp == 0
            }
            h-- // 按层级查找
        }
    }
}

2.2 插入函数Put

func (p *DB) Put(key []byte, value []byte) error {
    p.mu.Lock()
    defer p.mu.Unlock() //mem的数据操作直接通过互斥锁进行并发控制

    if node, exact := p.findGE(key, true); exact { // key == node key
        kvOffset := len(p.kvData)
        p.kvData = append(p.kvData, key...)
        p.kvData = append(p.kvData, value...)
        p.nodeData[node] = kvOffset
        m := p.nodeData[node+nVal]
        p.nodeData[node+nVal] = len(value)
        p.kvSize += len(value) - m
        return nil
    }

    //插入新key

    h := p.randHeight()
    if h > p.maxHeight {
        for i := p.maxHeight; i < h; i++ {
            p.prevNode[i] = 0 //prevNode链接各个层级的node的第一个node
            //如果maxHight增加，则新增的preNode的节点指向最底层的数据
        }
        p.maxHeight = h
    }

    kvOffset := len(p.kvData)
    p.kvData = append(p.kvData, key...) //存储key value数据
    p.kvData = append(p.kvData, value...)
    // Node 构建node节点
    node := len(p.nodeData)
    p.nodeData = append(p.nodeData, kvOffset, len(key), len(value), h) //插入索引node信息
    for i, n := range p.prevNode[:h] {                                 //p.prevNode的每个元素当前所的node 的key应该 <= newkey
        m := n + nNext + i
        p.nodeData = append(p.nodeData, p.nodeData[m]) //添加一个新的node节点，保证nodeData始终有足够的节点数存储层级索引
        //preNode记录所查找节点的所有前置节点位置
        //1.将newNode节点的前置节点的该层指向的位置复制给newNode的第h层
        //2.将newNode节点的前置节点的指向改为指向newNode
        p.nodeData[m] = node
    }

    p.kvSize += len(key) + len(value)
    p.n++
    return nil
}

memdb的其他相关操作也是类似地借助skip-list进行的。