CryptDB代码分析3-元数据管理结构

发表于 分类于

本文是CryptDB代码分析的第三篇。在CryptDB中，需要对加密过程进行记录：比如某个表的原始名字和加密以后的名字，表中有多少列，每列用了什么样的加密算法。这些信息被记录在mysql-proxy端的embedded MySQL中。CryptDB使用了元数据管理的模块处理这些信息，相关代码主要位于main/dbobject.hh以及main/schema.cc。

层次化的结构

在介绍元数据相关的类层次之前，我们首先考虑什么样的元信息需要被记录。我们创建一个数据库，需要在元信息里面记录新添加了这个数据库db。我们进一步在这个数据库里面建立一个表student，使用的语句是CREATE TABLE student (id integer)，这样的话，元信息里面就需要记录新加入的表student，并且需要知道这个表包含一个整数列id。由于要对数据做加密，这个整数列会被多种不同的洋葱加密，元信息里面也要包含这些内容。由于洋葱有很多的层次，那么每个洋葱处于哪一层也要被记录下来，这样才可以完成正确的加解密流程。
由此可以看到，元信息需要记录是一个层次化的结构，最上层的是db(数据库)，依次往下走，分别是table(表)，field(列)，onion(洋葱)，以及layer(洋葱层次)。CryptDB用了一组相关的数据结构来表示这个信息，分别是DatabaseMeta，TableMeta，FieldMeta，OnionMeta，Enclayer，下面依次介绍。

DatabaseMeta

当我们使用语句CREATE DATABASE db创建一个数据库db的时候，CryptDB会生成一个DatabaseMeta结构来表示这个新的数据库，并把这个信息序列化以后写入到embedded MySQL中。该类的结构如下：

可以看到DatabaseMeta继承了模板类MappedDBMeta，而MappedDBMeta又继承了DBMeta类，下面分别介绍。

1）MappedDBMeta

MappedDBMeta是一个类模板，实例化以后被DatabaseMeta等一系列的类继承，其内部包含了std::map类型的成员，用于保存元数据的层次化关系。举例来说，一个数据库db下面，会建立很多的表，如**table1,table2,table3…**，这样的话可以通过一个如下的map来保存这种关系：

1
std::map<KeyType, std::unique_ptr<ChildType> > children;

在CryptDB中，下层结构被称为child，上层和下层是包含关系，比如一个DatabaseMeta中就包含多个TableMeta。对于DatabaseMeta来说，map中的KeyType是IdentityMetaKey，是对表名字如table1的封装，而ChildType则是TableMeta，代表了一个表的元数据。所有继承了MappedDBMeta的元数据管理相关的类，都是通过map结构用Key-Value的方式来保存这种层次关系的。此外，MappedDBMeta还实现了继承自DBMeta的一些和child操作相关的函数，如：

1
2
3
4
5
6
7
8
9
10

std::vector<DBMeta *>
fetchChildren(const std::unique_ptr<Connect> &e_conn);

bool
applyToChildren(std::function<bool(const DBMeta &)>);

AbstractMetaKey const &
getKey(const DBMeta &child);

分别用于获取children，对每个child执行一个函数操作，以及通过child来获得child对应的key。

2）DBMeta：

DBMeta类继承了DBOjbect和NormalAlloc，其中提供功能的是DBObject，其作用是给给元数据相关的类记录一个id。本文介绍的所有元数据相关的类，都从DBObject中得到了id这个成员。此外，DBMeta类还定义了MappedDBMeta中用于对child做处理的纯虚函数。这样，各种常见的元数据相关的类都可以通过DBMeta的指针来保存，并执行相应的操作对内部保存在Map中的children进行处理。

除此之外，其中还定义了纯虚函数：serialize，各个下层的类实现这个函数，对自身的结构做序列化，并存储在数据库中。

最后，DBMeta中还定义了函数doFetchChildren，该函数会执行SQL语句，从数据库中读取序列化后的元数据管理类，做反序列化操作，然后以vector的形式返回结果。

3）DatabaseMeta：

有了上面的基础，就可以介绍DataBaseMeta了。DatabaseMeta代表了一个新的数据库，其通过继承模板类，用TableMeta和IdentityMetaKey来实例化模板参数来以Key-Value的形式保存数据库和表的关系。并且实现了继承自DBMeta的serialize函数来实现序列化，定义了deserialize函数实现反序列化，主要代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class DatabaseMeta : public MappedDBMeta<TableMeta, IdentityMetaKey> {

static std::unique_ptr<DatabaseMeta>
        deserialize(unsigned int id, const std::string &serial);        
std::string serialize(const DBObject &parent) const;
}

std::unique_ptr<DatabaseMeta>
DatabaseMeta::deserialize(unsigned int id, const std::string &serial) {
    assert(id != 0);

    return std::unique_ptr<DatabaseMeta>(new DatabaseMeta(id));
}

std::string
DatabaseMeta::serialize(const DBObject &parent) const{
    const std::string &serial =
        "Serialize to associate database name with DatabaseMeta";

    return serial;
}

可以看到，对于database来说，序列化只要写固定的一个字符串下去就可以，而反序列化的时候，这个字符串也没有用到，而是直接使用DatabaseMeta对应的id来做反序列化。

TableMeta

和DatabaseMeta类似，TableMeta保存了一个table的信息。上图给出了TableMeta的继承关系。Table中包含了很多的列，每个列都有自己的名字，所以其用于实例化模板的类型分别是FieldMeta和IdentityMetaKey。前者代表了表中的一个列，后者则是列名的封装。TableMeta的主要定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class TableMeta : public MappedDBMeta<FieldMeta, IdentityMetaKey>,
                  public UniqueCounter {
    static std::unique_ptr<TableMeta>
        deserialize(unsigned int id, const std::string &serial);
    std::string serialize(const DBObject &parent) const;
    std::string getAnonTableName() const;
    std::vector<FieldMeta *> orderedFieldMetas() const;
private:
    const std::string anon_table_name;
    uint64_t counter;
    //from UniqueCounter
    uint64_t &getCounter_() {return counter;}
}

首先看其成员anno_table_name。在CryptDB中，每个明文的表名都被替换成了密文的表名。其中明文的表名被封装成了IdentityMetaKey，存储在DatabaseMeta内部的Map中作为key，加密替换以后的表名则存储在TableMeta中的成员anon_table_name中。这样，在通过明文的表名做Key，找到对应的TableMeta类型的value时，可以从其类成员anno_table_name得到加密的表名。明文和密文的对应关系就是这样存储的。

和DatabaseMeta不同的是，TableMeta还继承了UniqueCounter类，并拥有一个uint64t类型的成员counter。这个类的功能是，给counter值增加1,以及返回当前的counter值。这种增加counter的功能是为了底层的child类型能够被排序而设计的。一个表下有好几个列，这些列都是有顺序的。比如对于语句CREATE TABLE student( id integer, name value)，id列和name列的元信息表示都是FieldMeta，但是id在前，name在后。这种顺序就是通过counter来记录。在使用CREATE TABLE语句来建表时，会建立TableMeta结构，这个过程中，由于TableMeta通过Key-Value的形式保存了表中的各个列，所以在创建过程中要在map中添加项目，也就需要创建FieldMeta结构。创建每个FieldMeta前，都获取自增的counter传递到FieldMeta中，这样一个TableMeta下的FieldMeta就可以根据这个counter值进行排序了。

最后来看看TableMeta的序列化和反序列化函数：

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

std::unique_ptr<TableMeta>
TableMeta::deserialize(unsigned int id, const std::string &serial) {
    assert(id != 0); 
    const auto vec = unserialize_string(serial);
    //five items to be deserialized
    assert(5 == vec.size());
    const std::string anon_table_name = vec[0];
    const bool hasSensitive = string_to_bool(vec[1]);
    const bool has_salt = string_to_bool(vec[2]);
    const std::string salt_name = vec[3];
    const unsigned int counter = atoi(vec[4].c_str());
    return std::unique_ptr<TableMeta>
        (new TableMeta(id, anon_table_name, hasSensitive, has_salt,
                       salt_name, counter));
}

std::string 
TableMeta::serialize(const DBObject &parent) const{
    const std::string &serial =
        serialize_string(getAnonTableName()) +
        serialize_string(bool_to_string(hasSensitive)) +
        serialize_string(bool_to_string(has_salt)) +
        serialize_string(salt_name) +
        serialize_string(std::to_string(counter));
    return serial;
}

可以看到，TableMeta中的序列化和反序列化会对TableMeta中的几个成员进行了处理，进行了类成员和字符串的相互转换。

FieldMeta

FieldMeta和TableMeta类似，也继承了UniqueCounter，因为一个Field内部包含了多个洋葱加密模型，每个洋葱代表了加密表中的一个列，这些洋葱当然也是有顺序的。FieldMeta的继承结构如下：

FieldMeta的主要定义是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class FieldMeta : public MappedDBMeta<OnionMeta, OnionMetaKey>,
                  public UniqueCounter {
public:
static std::unique_ptr<FieldMeta>
        deserialize(unsigned int id, const std::string &serial);
        std::string serialize(const DBObject &parent) const;
	std::vector<std::pair<const OnionMetaKey *, OnionMeta *>>
        orderedOnionMetas() const;
        OnionMeta *getOnionMeta(onion o) const;
private:
	const std::string fname;
        const std::string salt_name;
        const onionlayout onion_layout;
        const bool has_salt;
}

对于FieldMeta，首先需要关注的是成员salt_name。对于一个Field来说，其除了被多层洋葱加密以外，还有一列随机数IV，在内部被称为salt。这个salt列有自己的名字，被保存在FieldMeta中。另一个需要关注的成员是onionlayout，是一个map结构，key是洋葱类型，value是一个vector，表示洋葱的各个层次。其示例代码如下：

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
//洋葱类型
typedef enum onion {
    oDET,
    oOPE,
    oAGG,
} onion;
//洋葱层次
enum class SECLEVEL {
    OPE,
    DET,
    SEARCH,
    HOM,
    RND,
};
//常见的onionlayout
onionlayout NUM_ONION_LAYOUT = {
    {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                  SECLEVEL::RND})},
    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPE, SECLEVEL::RND})},
    {oAGG, std::vector<SECLEVEL>({SECLEVEL::HOM})}
};

onionlayout STR_ONION_LAYOUT = {
    {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                  SECLEVEL::RND})},
    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPEFOREIGN, SECLEVEL::OPE, SECLEVEL::RND})},
    {oSWP, std::vector<SECLEVEL>({SECLEVEL::SEARCH})}
};

可以看到，洋葱以及洋葱的层次全都通过自行定义枚举类型来实现。上面给出了针对整数类型和字符串类型的onionlayout。最后我们给出FieldMeta的序列化和反序列化函数：

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

std::string FieldMeta::serialize(const DBObject &parent) const {
    const std::string &serialized_salt_name =
        true == this->has_salt ? serialize_string(getSaltName())
                               : serialize_string("");
    std::string sql_type_string = std::to_string((int)sql_type);
    const std::string serial =
        serialize_string(fname) +
        serialize_string(bool_to_string(has_salt)) +
        serialized_salt_name +
        serialize_string(TypeText<onionlayout>::toText(onion_layout)) +
        serialize_string(TypeText<SECURITY_RATING>::toText(sec_rating)) +
        serialize_string(std::to_string(uniq_count)) +
        serialize_string(std::to_string(counter)) +
        serialize_string(bool_to_string(has_default)) +
        serialize_string(default_value) +
        serialize_string(sql_type_string);//added by shaoyiwen
   return serial;
}

std::unique_ptr<FieldMeta>
FieldMeta::deserialize(unsigned int id, const std::string &serial) {
    assert(id != 0);
    const auto vec = unserialize_string(serial);
    assert(10 == vec.size());//We add one item,so there are ten items now

    const std::string fname = vec[0];
    const bool has_salt = string_to_bool(vec[1]);
    const std::string salt_name = vec[2];
    const onionlayout onion_layout = TypeText<onionlayout>::toType(vec[3]);
    const SECURITY_RATING sec_rating =
        TypeText<SECURITY_RATING>::toType(vec[4]);
    const unsigned int uniq_count = atoi(vec[5].c_str());
    const unsigned int counter = atoi(vec[6].c_str());
    const bool has_default = string_to_bool(vec[7]);
    const std::string default_value = vec[8];

    enum  enum_field_types sql_type = ((enum  enum_field_types)atoi(vec[9].c_str()));//new field added


    return std::unique_ptr<FieldMeta>
        (new FieldMeta(id, fname, has_salt, salt_name, onion_layout,
                       sec_rating, uniq_count, counter, has_default,
                       default_value,sql_type));
}


可以看到，序列化和反序列化的函数和TableMeta是类似的，就是一些相关的成员转化成字符串，以及从字符串转换回各个成员的过程。

OnionMeta

和前面的TableMeta，FieldMeta以及DatabaseMeta不同，OnionMeta没有继承MappedDBMeta类型，而是直接继承了DBMeta。其继承结构如下：

由于没有继承MappedDBMeta，所以其不会通过Key-Value的形式来保存children。对于OnionMeta来说，其下一层的类型是Enclayer，这种加密层的数据是直接通过std::vector来保存的。其主要的实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class OnionMeta : public DBMeta {
static std::unique_ptr<OnionMeta>
        deserialize(unsigned int id, const std::string &serial);
	//from DBMeta
	std::string serialize(const DBObject &parent) const;

	//from DBMeta
        std::vector<DBMeta *>
        fetchChildren(const std::unique_ptr<Connect> &e_conn);        
        bool applyToChildren(std::function<bool(const DBMeta &)>) const;
	UIntMetaKey const &getKey(const DBMeta &child) const;

	std::string getAnonOnionName() const;
	SECLEVEL getSecLevel() const;
private:
	std::vector<std::unique_ptr<EncLayer> > layers;
	const std::string onionname;
	const unsigned long uniq_count;
};

OnionMeta代表了一个洋葱。在CryptDB中，一个洋葱有很多的层次，每个层次代表一次加密，原始列的数据被这个洋葱中的多个层次依次进行加密。加密以后的列有列名，通过这里的onionname成员来记录。uniq_count成员则是用于onionmeta的排序，之前已经做过介绍。layers成员是通过vector类型来对加密层次进行记录。序列化和反序列化的函数和前面的类似，这里不再给出。

EncLayers

最后就是加密层了。加密层是整个元数据相关类的最底层，其继承结构如下：

首先来看LeafDBmeta类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class LeafDBMeta : public DBMeta {
public:
    //from DBMeta
    std::vector<DBMeta *>
        fetchChildren(const std::unique_ptr<Connect> &e_conn) {
        return std::vector<DBMeta *>();
    }
    //from DBMeta
    bool applyToChildren(std::function<bool(const DBMeta &)>
        fn) const {
        return true;
    }
    //from DBMeta
    AbstractMetaKey const &getKey(const DBMeta &child) const {
        assert(false);
    }
};

可以看到，LeafDBMeta的作用是继承DBMeta，并实现其中三个函数。fetchChildren返回空的vector，applyToChildren也是什么也不做。这是因为对于EncLayers来说，已经没有更下一层的类，没有children的概念，当然就应该这么做实现。所以这里通过LeafDBMeta把这些性质都放到一起，作为EncLayer以及其下层类的共同特征。

然后来看EncLayers：

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

class EncLayer : public LeafDBMeta {
public:
    virtual SECLEVEL level() const = 0;
    virtual std::string name() const = 0;

    // returns a rewritten create field to include in rewritten query
    virtual Create_field *
        newCreateField(const Create_field &cf,
                       const std::string &anonname = "") const = 0;
                       
    virtual Item *decryptUDF(Item * const col, Item * const ivcol = NULL)
        const {
        thrower() << "decryptUDF not supported";
    }
                       
    virtual Item *encrypt(const Item &ptext, uint64_t IV) const = 0;
    virtual Item *decrypt(const Item &ctext, uint64_t IV) const = 0;
    //
    virtual std::string doSerialize() const = 0;
    std::string serialize(const DBObject &parent) const {
        return serial_pack(this->level(), this->name(),
                           this->doSerialize());
    }
};

EncLayer代表了一个加密层次的抽象，所以其首先应该有加密和解密函数，用于对数据做加解密。在这个层次，数据的加解密的对象是Item，这是一个MySQL的parser中定义的类型，代表了解析以后的SQL语句的语法树中的一个节点。加解密函数都有另一个参数IV，是用于构造随机性的随机数。对于具体的一种加密算法，其继承EncLayer以后，只要实现相关的函数就可以。

每个加密层有自己的名字，有自己层次对应的枚举值，对于具体的加密类，还有自己本身特定的数据结构。这三类信息都需要在序列化的时候被保存，这就是EncLayers的serialize函数的实现。对于反序列化函数，则依然在底层的类(DET_str，OPE_int等)中通过static函数的形式给出。

newCreateField函数是为了处理数据类型的变化：数据经过加密算法的处理，其数据类型和数据长度会发生变化，加密层的newCreateField要能够返回加密以后的数据类型。这种类型的信息封装在Create_field类里面了，这也是MySQL的parser中定义的类，具体细节不在此展开。

decryptUDF函数用于洋葱层次的调整。举例来说，当一个查询需要使用where xx=xx的条件时，需要使用洋葱层次DET，而如果此时洋葱的实际层次是RND，则需要在MySQL端执行解密函数，剥掉RND层。这个操作通过UDF来完成，而decryptUDF就是用来生成这个UDF语句的。

以RND_str为例

对于具体的加密算法层，只要继承EncLayer并实现上面介绍的几个函数就可以了，这里以RND_str作为例子。

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class RND_str : public EncLayer {
public:
    RND_str(const Create_field &cf, const std::string &seed_key);

    // serialize and deserialize
    std::string doSerialize() const {return rawkey;}
    RND_str(unsigned int id, const std::string &serial);

    SECLEVEL level() const {return SECLEVEL::RND;}
    std::string name() const {return "RND_str";}
    Create_field * newCreateField(const Create_field &cf,
                                  const std::string &anonname = "")
        const;
    Item * encrypt(const Item &ptext, uint64_t IV) const;
    Item * decrypt(const Item &ctext, uint64_t IV) const;
    Item * decryptUDF(Item * const col, Item * const ivcol) const;

private:
    const std::string rawkey;
    static const int key_bytes = 16;
    static const bool do_pad   = true;
    const std::unique_ptr<const AES_KEY> enckey;
    const std::unique_ptr<const AES_KEY> deckey;

};

Create_field *
RND_str::newCreateField(const Create_field &cf,
                        const std::string &anonname) const {
    const auto typelen = AESTypeAndLength(cf, do_pad);
    return arrayCreateFieldHelper(cf, typelen.second, typelen.first,
                                  anonname, &my_charset_bin);
}

Item *
RND_str::encrypt(const Item &ptext, uint64_t IV) const {
    const std::string &enc =
        encrypt_AES_CBC(ItemToString(ptext), enckey.get(),
                        BytesFromInt(IV, SALT_LEN_BYTES), do_pad);
    return new (current_thd->mem_root) Item_string(make_thd_string(enc),
                                                   enc.length(),
                                                   &my_charset_bin);
}

Item *
RND_str::decrypt(const Item &ctext, uint64_t IV) const {
    const std::string &dec =
        decrypt_AES_CBC(ItemToString(ctext), deckey.get(),
                        BytesFromInt(IV, SALT_LEN_BYTES), do_pad);
    return new (current_thd->mem_root) Item_string(make_thd_string(dec),
                                                   dec.length(),
                                                   &my_charset_bin);
}

static udf_func u_decRNDString = {
    LEXSTRING("cryptdb_decrypt_text_sem"),
    STRING_RESULT,
    UDFTYPE_FUNCTION,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    0L,
};

Item *
RND_str::decryptUDF(Item * const col, Item * const ivcol) const {
    List<Item> l;
    l.push_back(col);
    l.push_back(get_key_item(rawkey));
    l.push_back(ivcol);
    return new (current_thd->mem_root) Item_func_udf_str(&u_decRNDString,
                                                         l);
}

上面的例子给出了一个实际的RND_str加密层的实现。其他层的实现是类似的：本文基于修改版的CryptDB，采用类似的方法添加了新的加密层ASHE。

上面的代码也是对MySQL parser中的类型进行操作，这里先忽略这个细节，直接关注每个函数的功能：

  • 初始化的时候，对AES算法进行初始化
  • encrypt与decrypt函数使用AES算法对Item类型进行加解密，加解密都要求先把Item类型转化成普通的string类型，然后对string进行加解密处理，处理完成以后又重新转化成Item类型
  • decryptUDF在这里返回了一个UDF，名字是cryptdb_decrypt_text_sem，通过调用这个UDF来实现RND层次的洋葱解密
  • newCreateField函数对string长度做了padding的处理，要求string长度是AES的blcok大小的整数倍。举例来说一个**CREATE TABLE student(name varchar(20))**，在block大小是16的情况下，20会被这个函数被扩展成32。这种数据类型和长度的信息都记录在了Create_field类结构中

元数据存储格式

最后介绍元数据在数据库中的存储格式。首先看本地的数据库中用于记录元数据的表的定义：

1
2
3
4
5
6
7
8
9
CREATE TABLE `MetaData` (
  `serial_object` varbinary(500) NOT NULL,
  `serial_key` varbinary(500) NOT NULL,
  `parent_id` bigint(20) NOT NULL,
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`),
  UNIQUE KEY `id` (`id`)
)

在上面的层次结构中，一部分对象通过Key-Value的形式被记录，还有最后一层的EncLayers，虽然是以数组的形式存储，但是每一层也有自己的枚举的名字，也可以看成Key-Value。这样，就可以用seria_key和serial_object两个列来记录这个Key-Value。每个元数据管理对象有自己继承自DBObject的id，这个id存储在表中的id这列。parent_id表示的是当前的类上层的类的id。下面给出一个例子：

假设我们执行了以下两个语句：

1
2
CREATE DATABASE db;
CREATE TABLE student(id integer);

并且我们对于整数列id只使用一个DET洋葱进行加密。那么，初始化有三个洋葱层：DETJOIN DET RND。那么语句执行完以后的数据库中表内容如下：

serial_object serial_key parent_id id
Serialize to associate database name with DatabaseMeta 2_db 0 1
16_table_IAUMLMEJLL4_TRUE4_ TRUE20_tableSalt_JXOLNITEJN1 _1 7_student 1 2
2_id4_TRUE18_cdb_saltYHRATVO WOU18_CURRENT_NUM_LAYOU T9_SENSITIVE1_01_35_FALSE0_ 1_3 2_id 2 3
13_CATSNIAGMMoEq1_07_ DETJOIN 3_oEq 3 4
67 DETJOIN DETJOIN_int 16_???19_ MYSQL_TYPE_LONGLONG1_0 20_18446744073709551615 1_0 4 5
67 DET DET_int 16_???19_MYSQL_TYP E_LONGLONG1_020_184467 44073709551615 1_1 4 6
67 RND RND_int 16_???19_MYSQL_TYP E_LONGLONG1_020_1844674 4073709551615 1_2 4 7

从表中可以看出，建立db数据库的时候，写入了第一行记录。id是1，parent_id是0。建立student表的时候，db有了第一个child，于是插入一条新记录：id是2，parent_id是1。对于表来说，有一个field是id，所以有第三条记录，parent_id是2，表示这是studnet表的field。对于field id来说，包含了一个洋葱DET，这个洋葱有三个层次。所以有后面几行数据。而serial_boject以及serial_key则是之前介绍的序列化函数处理的结果(对于不可显示字符采用???替换)。通过这个例子，我们可以发现，通过serial_object和serial_key可以保存元数据管理类，这些字符串是通过serialize函数来编码生成的。通过id和parent_id，可以保存这些类之间的层次关系。

小结

本文介绍了CryptDB中元数据管理相关的类的设计。由于需要保存database，table，field，onion，layer这样的层次关系，分别设计了DatabaseMeta，TableMeta，FieldMeta，OnionMeta，Enclayer类。Enclayer之上，上下层的关系通过继承MappedDBMeta，使用map结构进行保存，EncLayer则直接通过vector保存在OnionMeta中。每个类都有自己的序列化和反序列函数，需要把类自身以及类之间的关系编码写入到MySQL，本文通过一个例子来说明了这种编码方式。

参考文献

https://github.com/yiwenshao/Practical-Cryptdb