数据库内核月报－ 2018/03 - MySQL · 源码分析 · 原子DDL的实现过程 - 《数据库内核月报》

众所周知，MySQL8.0之前的版本DDL是非原子的。也就是说对于复合的DDL，比如DROP TABLE t1, t2;执行过程中如果遇到server crash，有可能出现表t1被DROP掉了，但是t2没有被DROP掉的情况。即便是一条DDL，比如CREATE TABLE t1(a int);也可能在server crash的情况下导致建表不完整，有可能在建表失败的情况下遗留.frm或者.ibd文件。

上面情况出现的主要原因就是MySQL不支持原子的DDL。从图1可以看出，MySQL8.0以前，metadata在Server layer是存储在MyISAM引擎的系统表里，对于事务型引擎Innodb则自己存储一份metadata。这也导致MySQL存在如下一些弊端：

metadata由于存储在Server layer以及存储引擎（这里特指Innodb)，两份系统表很容易造成数据的不一致。
两份系统表存储的信息有所不同，访问Server layer以及存储引擎需要使用不同API，这种设计导致了不能很好的统一对系统metadata的访问。另外两份API，也同时增加了代码的维护量。
由于Server layer的metadata存储在非事务引擎（MyISAM)里，所以在进行crash recovery的时候就不能维持原子性。
DDL的非原子性使得Replication处理异常情况变得更加复杂。比如DROP TABLE t1, t2; 如果DROP t1成功，但是DROP t2失败，Replication就无法保证主备一致性了。

图1： MySQL Data Dictionary before MySQL8.0

MySQL8.0为了解决上面的缺陷，引入了事务型DDL。首先我们看一下MySQL8.0 metadata存储的架构变化：

图2: MySQL Data Dictionary in MySQL8.0

图2我们可以看到，Server layer(后面简称SL）以及Storage Engine（后面简称SE）使用同一份data dictionary(后面简称DD）用来存储metadata。SL和SE将各自需要的metadata存入DD中。由于DD使用Innodb作为存储引擎，所以crash recovery的时候，DD可以安全的进行事务回滚。

下面我们介绍一下MySQL8.0为了实现原子DDL，在源码层面引入的一些重要数据结构：


1. class Dictionary_client
2. /*
3. 这个类提供了SL以及SE统一访问DD的接口。每一个THD都有一个访问DD的Dictionary_client类型的成员。 如果需要操作DD，直接调用相关接口函数即可。
4. 这个类成员函数的主要方法是去访问一个多session共享的cache来操作DD存储的各种对象。和其他cache一样，如果在访问过程中，在这个cache里没有找到对应的对象，那么后台会自动读取DD中的相关metadata，进而构建相应的数据表。
5. */
6. {
7. public:

9. /*
10. 这个类是用来辅助Dictionary_client自动释放获取的DD对象。该类会自动跟踪当前Dictionary_client获取的每个DD对象。当Dictionary_client对象生命期结束的时候，该对象会自动释放当前session获取的DD对象。
11. 这个类对象可以进行嵌套，Dictionary_client中的m_current_releaser成员变量始终会指向嵌套堆栈最顶层的一个Auto_releaser对象。如果当前的Auto_releaser对象结束了生命期，它会释放掉自己记录的位于共享cache中的DD对象，同时把m_current_releaser指向上一个老的Auto_releaser对象。
12. */
13. class Auto_releaser
14. {
15. friend class Dictionary_client;

17. private:
18. Dictionary_client *m_client; // 用来指向当前的Dictionary_client对象
19. Object_registry m_release_registry; // 用来记录从共享cache中获取的DD对象，以便自动释放
20. Auto_releaser *m_prev; // 用来形成列表，以方便当前实例生命期结束的时候，将Dictionary_client对象中的Auto_releaser重新指向之前创建的实例。

22. /**
23. 注册一个DD对象
24. */
25. template <typename T>
26. void auto_release(Cache_element<T> *element)
27. {
28. // Catch situations where we do not use a non-default releaser.
29. DBUG_ASSERT(m_prev != NULL);
30. m_release_registry.put(element);
31. }

33. /**
34. 当一个Auto_releaser对象结束生命期的时候，有的DD对象并不能结束生命期，该函数用来把一个DD对象转移给上一个Auto_releaser对象。
35. */
36. template <typename T>
37. void transfer_release(const T* object);

39. /**
40. 移除一个DD对象
41. */
42. template <typename T>
43. Auto_releaser *remove(Cache_element<T> *element);

45. // Create a new empty auto releaser. Used only by the Dictionary_client.
46. Auto_releaser();

48. public:
49. /**
50. Create a new auto releaser and link it into the dictionary client
51. as the current releaser.

53. @param  client  Dictionary client for which to install this auto
54. releaser.
55. */
56. explicit Auto_releaser(Dictionary_client *client);

58. // Release all objects registered and restore previous releaser.
59. ~Auto_releaser();

61. // Debug dump to stderr.
62. template <typename T>
63. void dump() const;
64. };

66. private:
67. std::vector<Entity_object*> m_uncached_objects; // Objects to be deleted.
68. Object_registry m_registry_committed;   // Registry of committed objects.
69. Object_registry m_registry_uncommitted; // Registry of uncommitted objects.
70. Object_registry m_registry_dropped;     // Registry of dropped objects.
71. THD *m_thd;                             // Thread context, needed for cache misses.
72. Auto_releaser m_default_releaser;       // Default auto releaser.
73. Auto_releaser *m_current_releaser;      // Current auto releaser.

75. ...
76. }

79. /**
80. 该类定义了共享的DD对象缓存，该类取代了8.0之前的table_cache。数据库对象会根据对象类型从不同的map中获取对象。所有对DD对象的访问都需要经过该缓存。
81. */
82. class Shared_dictionary_cache
83. {
84. private:
85. // 设置一些缓存的最大容量，目前看来都是硬编码
86. static const size_t collation_capacity= 256;
87. static const size_t column_statistics_capacity= 32;
88. static const size_t charset_capacity= 64;
89. static const size_t event_capacity= 256;
90. static const size_t spatial_reference_system_capacity= 256;
91. /**
92. Maximum number of DD resource group objects to be kept in
93. cache. We use value of 32 which is a fairly reasonable upper limit
94. of resource group configurations that may be in use.
95. */
96. static const size_t resource_group_capacity= 32;

98. /* 下面是各种不同类型DD对象缓存map */
99. Shared_multi_map<Abstract_table> m_abstract_table_map;
100. Shared_multi_map<Charset>        m_charset_map;
101. Shared_multi_map<Collation>      m_collation_map;
102. Shared_multi_map<Column_statistics> m_column_stat_map;
103. Shared_multi_map<Event>          m_event_map;
104. Shared_multi_map<Resource_group> m_resource_group_map;
105. Shared_multi_map<Routine>        m_routine_map;
106. Shared_multi_map<Schema>         m_schema_map;
107. Shared_multi_map<Spatial_reference_system> m_spatial_reference_system_map;
108. Shared_multi_map<Tablespace>     m_tablespace_map;

110. template <typename T> struct Type_selector { }; // Dummy type to use for
111. // selecting map instance.

113. /**
114. Overloaded functions to use for selecting map instance based
115. on a key type. Const and non-const variants.
116. */
117. Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>)
118. { return &m_abstract_table_map; }
119. Shared_multi_map<Charset>        *m_map(Type_selector<Charset>)
120. { return &m_charset_map; }
121. Shared_multi_map<Collation>      *m_map(Type_selector<Collation>)
122. { return &m_collation_map; }
123. Shared_multi_map<Column_statistics> *m_map(Type_selector<Column_statistics>)
124. { return &m_column_stat_map; }
125. Shared_multi_map<Event>        *m_map(Type_selector<Event>)
126. { return &m_event_map; }
127. Shared_multi_map<Resource_group> *m_map(Type_selector<Resource_group>)
128. { return &m_resource_group_map; }
129. Shared_multi_map<Spatial_reference_system> m_spatial_reference_system_map;
130. Shared_multi_map<Tablespace>     m_tablespace_map;

132. template <typename T> struct Type_selector { }; // Dummy type to use for
133. // selecting map instance.

135. /**
136. Overloaded functions to use for selecting map instance based
137. on a key type. Const and non-const variants.
138. */
139. Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>)
140. { return &m_abstract_table_map; }
141. Shared_multi_map<Charset>        *m_map(Type_selector<Charset>)
142. { return &m_charset_map; }
143. Shared_multi_map<Collation>      *m_map(Type_selector<Collation>)
144. { return &m_collation_map; }
145. Shared_multi_map<Column_statistics> *m_map(Type_selector<Column_statistics>)
146. { return &m_column_stat_map; }
147. Shared_multi_map<Event>        *m_map(Type_selector<Event>)
148. { return &m_event_map; }
149. Shared_multi_map<Resource_group> *m_map(Type_selector<Resource_group>)
150. { return &m_resource_group_map; }
151. Shared_multi_map<Routine>        *m_map(Type_selector<Routine>)
152. { return &m_routine_map; }
153. Shared_multi_map<Schema>         *m_map(Type_selector<Schema>)
154. { return &m_schema_map; }
155. Shared_multi_map<Spatial_reference_system> *
156. m_map(Type_selector<Spatial_reference_system>)
157. { return &m_spatial_reference_system_map; }
158. Shared_multi_map<Tablespace>     *m_map(Type_selector<Tablespace>)
159. { return &m_tablespace_map; }

162. const Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>) const
163. { return &m_abstract_table_map; }
164. const Shared_multi_map<Charset>        *m_map(Type_selector<Charset>) const
165. { return &m_charset_map; }
166. const Shared_multi_map<Collation>      *m_map(Type_selector<Collation>) const
167. { return &m_collation_map; }
168. const Shared_multi_map<Column_statistics> *
169. m_map(Type_selector<Column_statistics>) const
170. { return &m_column_stat_map; }
171. const Shared_multi_map<Schema>         *m_map(Type_selector<Schema>) const
172. { return &m_schema_map; }
173. const Shared_multi_map<Spatial_reference_system> *
174. m_map(Type_selector<Spatial_reference_system>) const
175. { return &m_spatial_reference_system_map; }
176. const Shared_multi_map<Tablespace>     *m_map(Type_selector<Tablespace>) const
177. { return &m_tablespace_map; }
178. const Shared_multi_map<Resource_group> *m_map(
179. { return &m_abstract_table_map; }
180. const Shared_multi_map<Charset>        *m_map(Type_selector<Charset>) const
181. { return &m_charset_map; }
182. const Shared_multi_map<Collation>      *m_map(Type_selector<Collation>) const
183. { return &m_collation_map; }
184. const Shared_multi_map<Column_statistics> *
185. m_map(Type_selector<Column_statistics>) const
186. { return &m_column_stat_map; }
187. const Shared_multi_map<Schema>         *m_map(Type_selector<Schema>) const
188. { return &m_schema_map; }
189. const Shared_multi_map<Spatial_reference_system> *
190. m_map(Type_selector<Spatial_reference_system>) const
191. { return &m_spatial_reference_system_map; }
192. const Shared_multi_map<Tablespace>     *m_map(Type_selector<Tablespace>) const
193. { return &m_tablespace_map; }
194. const Shared_multi_map<Resource_group> *m_map(
195. Type_selector<Resource_group>) const
196. { return &m_resource_group_map; }

198. /**
199. 根据DD对象类型获取对应的map对象。
200. */
201. template <typename T>
202. Shared_multi_map<T> *m_map()
203. { return m_map(Type_selector<T>()); }

205. template <typename T>
206. const Shared_multi_map<T> *m_map() const
207. { return m_map(Type_selector<T>()); }

209. Shared_dictionary_cache()
210. { }

212. public:
213. static Shared_dictionary_cache *instance();

215. // Set capacity of the shared maps.
216. static void init();

218. // Shutdown the shared maps.
219. static void shutdown();

221. // Reset the shared cache. Optionally keep the core DD table meta data.
222. static void reset(bool keep_dd_entities);
223. // Reset the table and tablespace partitions.
224. static bool reset_tables_and_tablespaces(THD *thd);

226. /**
227. 根据DD类型及名称来验证对象是否在缓存中。
228. */
229. template <typename K, typename T>
230. bool available(const K &key)
231. { return m_map<T>()->available(key); }

233. /**
234. 该函数用来输出调试信息。
235. */
236. template <typename T>
237. void dump() const
238. {
239. #ifndef DBUG_OFF
240. fprintf(stderr, "================================\n");
241. fprintf(stderr, "Shared dictionary cache\n");
242. m_map<T>()->dump();
243. fprintf(stderr, "================================\n");
244. #endif
245. }
246. };

248. } // namespace cache

251. /**
252. 这个类抽象了对DD对象的metadata进行存储的方法。它是一个静态类。对于新创建的对象（表，索引，表空间等）都会通过该类进行一个clone， clone之后该类会将该对象的metadata存储到对应的系统表中。另外，它也提供接口用来从系统表中获取metadata并生成调用需要的DD对象。

254. 该类同时也提供了一个缓存，每次调用存储新对象的时候，它会自动将一个对象clone缓存起来。该类成员函数中core_xxx都是负责操作缓存。
255. */
256. class Storage_adapter
257. {
258. friend class dd_cache_unittest::CacheStorageTest;

260. private:

262. /**
263. Use an id not starting at 1 to make it easy to recognize ids generated
264. before objects are stored persistently.
265. */
266. static const Object_id FIRST_OID= 10001;

269. /**
270. 为新的对象产生一个ID标识。
271. */
272. template <typename T>
273. Object_id next_oid();

276. /**
277. 根据对象名称从缓存中返回一个对象的clone。
278. */
279. template <typename K, typename T>
280. void core_get(const K &key, const T **object);

283. Object_registry m_core_registry;   // Object registry storing core DD objects.
284. mysql_mutex_t m_lock;              // Single mutex to protect the registry.
285. static bool s_use_fake_storage;    // Whether to use the core registry to
286. // simulate the storage engine.

288. Storage_adapter()
289. { mysql_mutex_init(PSI_NOT_INSTRUMENTED, &m_lock, MY_MUTEX_INIT_FAST); }
290. ~Storage_adapter()
291. {
292. mysql_mutex_lock(&m_lock);
293. m_core_registry.erase_all();
294. mysql_mutex_unlock(&m_lock);
295. mysql_mutex_destroy(&m_lock);
296. }

299. public:

301. /* 这里可以获取到单例。 */
302. static Storage_adapter *instance();

304. /**
305. 根据对象类型返回缓存区中所有对象的数量。
306. */
307. template <typename T>
308. size_t core_size();

310. /**
311. 获取对象ID标识
312. */
313. template <typename T>
314. Object_id core_get_id(const typename T::Name_key &key);

316. /**
317. 该函数可以根据对象类型及名称获取对象。如果该对象已经被缓存，那么调用core_get获取clone对象。否则会根据对象类型到对应的metadata数据表中查找并构造一个对象。
318. */
319. template <typename K, typename T>
320. static bool get(THD *thd,
321. const K &key,
322. enum_tx_isolation isolation,
323. bool bypass_core_registry,
324. const T **object);
325. /**
326. 缓存中清除一个对象.
327. */
328. template <typename T>
329. void core_drop(THD *thd, const T *object);

332. /**
333. 从对象所对应的各个metadata数据表中清除相关数据.
334. */
335. template <typename T>
336. static bool drop(THD *thd, const T *object);
337. /**
338. 缓冲区中添加一个DD对象
339. */
340. template <typename T>
341. void core_store(THD *thd, T *object);

343. /**
344. 该函数会根据DD对象类型，将metadata存入相关的系统表中。后面的建表语句中会对该函数进行详细的解释。
345. */
346. template <typename T>
347. static bool store(THD *thd, T *object);

349. /**
350. 同步缓存中的DD对象。
351. */
352. template <typename T>
353. bool core_sync(THD *thd, const typename T::Name_key &key, const T *object);

355. /**
356. Remove and delete all elements and objects from core storage.
357. */
358. void erase_all();
359. /**
360. 备份缓存中的对象。
361. */
362. void dump();
363. };

365. } // namespace cache
366. } // namespace dd

接下来我们以CREATE TABLE为例从源码上简单看一下MYSQL8.0是如何实现原子DDL的。

CREATE TABLE实现的流程图如下：

这里我们看一下CREATE TABLE过程中新增加的几个比较重要的函数（这里主要看Innodb存储引擎）：


1. /*
2. 该函数将会为Innodb存储引擎创建它自己需要的系统列。实际上就是把原来Innodb自己的系统表统一到DD中。
3. */
4. int
5. ha_innobase::get_extra_columns_and_keys(
6. const HA_CREATE_INFO*,
7. const List<Create_field>*,
8. const KEY*,
9. uint,
10. dd::Table*  dd_table)
11. {
12. DBUG_ENTER("ha_innobase::get_extra_columns_and_keys");
13. THD*      thd     = ha_thd();
14. dd::Index*    primary     = nullptr;
15. bool      has_fulltext    = false;
16. const dd::Index*  fts_doc_id_index  = nullptr;

18. /* 检查各个定义的索引是否合法。*/
19. for (dd::Index* i : *dd_table->indexes()) {
20. /* The name "PRIMARY" is reserved for the PRIMARY KEY */
21. ut_ad((i->type() == dd::Index::IT_PRIMARY)
22. == !my_strcasecmp(system_charset_info, i->name().c_str(),
23. primary_key_name));

25. if (!my_strcasecmp(system_charset_info,
26. i->name().c_str(), FTS_DOC_ID_INDEX_NAME)) {
27. ut_ad(!fts_doc_id_index);
28. ut_ad(i->type() != dd::Index::IT_PRIMARY);
29. fts_doc_id_index = i;
30. }

32. /* 验证索引算法是否有效 */
33. switch (i->algorithm()) {
34. ...
35. }

37. /* 验证并处理全文索引 */
38. if (has_fulltext) {
39. ...
40. }

42. /* 如果当前没有定义主键，Innodb将自动增加DB_ROW_ID作为主键。 */
43. if (primary == nullptr) {
44. dd::Column* db_row_id = dd_add_hidden_column(
45. dd_table, "DB_ROW_ID", DATA_ROW_ID_LEN,
46. dd::enum_column_types::INT24);

48. if (db_row_id == nullptr) {
49. DBUG_RETURN(ER_WRONG_COLUMN_NAME);
50. }

52. primary = dd_set_hidden_unique_index(
53. dd_table->add_first_index(),
54. primary_key_name,
55. db_row_id);
56. }

58. /* 为二级索引增加主键列 */
59. std::vector<const dd::Index_element*,
60. ut_allocator<const dd::Index_element*>> pk_elements;

62. for (dd::Index* index : *dd_table->indexes()) {
63. if (index == primary) {
64. continue;
65. }
66. pk_elements.clear();
67. for (const dd::Index_element* e : primary->elements()) {
68. if (e->is_prefix() ||
69. std::search_n(index->elements().begin(),
70. index->elements().end(), 1, e,
71. [](const dd::Index_element* ie,
72. const dd::Index_element* e) {
73. return(&ie->column()
74. == &e->column());
75. }) == index->elements().end()) {
76. pk_elements.push_back(e);
77. }
78. }

80. for (const dd::Index_element* e : pk_elements) {
81. auto ie = index->add_element(
82. const_cast<dd::Column*>(&e->column()));
83. ie->set_hidden(true);
84. ie->set_order(e->order());
85. }
86. }

88. /* 增加系统列 DB_TRX_ID, DB_ROLL_PTR. */
89. dd::Column* db_trx_id = dd_add_hidden_column(
90. dd_table, "DB_TRX_ID", DATA_TRX_ID_LEN,
91. dd::enum_column_types::INT24);
92. if (db_trx_id == nullptr) {
93. DBUG_RETURN(ER_WRONG_COLUMN_NAME);
94. }

96. dd::Column* db_roll_ptr = dd_add_hidden_column(
97. dd_table, "DB_ROLL_PTR", DATA_ROLL_PTR_LEN,
98. dd::enum_column_types::LONGLONG);
99. if (db_roll_ptr == nullptr) {
100. DBUG_RETURN(ER_WRONG_COLUMN_NAME);
101. }

103. dd_add_hidden_element(primary, db_trx_id);
104. dd_add_hidden_element(primary, db_roll_ptr);

106. /* Add all non-virtual columns to the clustered index,
107. unless they already part of the PRIMARY KEY. */

109. for (const dd::Column* c : const_cast<const dd::Table*>(dd_table)->columns()) {
110. if (c->is_hidden() || c->is_virtual()) {
111. continue;
112. }

114. if (std::search_n(primary->elements().begin(),
115. primary->elements().end(), 1,
116. c, [](const dd::Index_element* e,
117. const dd::Column* c)
118. {
119. return(!e->is_prefix()
120. && &e->column() == c);
121. })
122. == primary->elements().end()) {
123. dd_add_hidden_element(primary, c);
124. }
125. }

127. DBUG_RETURN(0);
128. }

131. template <typename T>
132. Dictionary_client::store(T* object)
133. {
134. ...

136. /* 调用下面函数完成存储 */
137. if (Storage_adapter::store(m_thd, object))
138. return true;
139. ...
140. }

143. /* 该函数负责将DD对象写入对应的系统表中。 */
144. template <typename T>
145. bool Storage_adapter::store(THD *thd, T *object)
146. {
147. // 如果是测试或者未到真正需要建表的阶段，只存入缓存，不进行持久化存储。
148. if (s_use_fake_storage ||
149. bootstrap::DD_bootstrap_ctx::instance().get_stage() <
150. bootstrap::Stage::CREATED_TABLES)
151. {
152. instance()->core_store(thd, object);
153. return false;
154. }

156. // 这里会验证DD对象的有效性
157. if (object->impl()->validate())
158. {
159. DBUG_ASSERT(thd->is_system_thread() || thd->killed || thd->is_error());
160. return true;
161. }

163. // 切换上下文，包括更新系统表的时候关闭binlog、修改auto_increament_increament增量、设置一些相关变量等与修改DD相关的上下文。
164. Update_dictionary_tables_ctx ctx(thd);
165. ctx.otx.register_tables<T>();
166. DEBUG_SYNC(thd, "before_storing_dd_object");

168. // object->impl()->store 这里会将DD对象存入相关的系统表。具体比如表，列， 表空间是如何持久化到系统表中的，由于篇幅有限，我们将在以后的月报中继续剖析。
169. if (ctx.otx.open_tables() || object->impl()->store(&ctx.otx))
170. {
171. DBUG_ASSERT(thd->is_system_thread() || thd->killed || thd->is_error());
172. return true;
173. }
174. // Do not create SDIs for tablespaces and tables while creating
175. // dictionary entry during upgrade.
176. if (bootstrap::DD_bootstrap_ctx::instance().get_stage() >
177. bootstrap::Stage::CREATED_TABLES &&
178. dd::upgrade_57::allow_sdi_creation() &&
179. sdi::store(thd, object))
180. return true;

182. return false;
183. }

综上篇章简要的描述了MySQL8.0实现原子DDL的背景以及一些重点的数据结构，并对CREATE TABLE过程，以及创建过程中用到的几个重要函数进行了分析。但是原子DDL的实现是一个非常大的工程，本篇月报由于篇幅问题，只是挖了冰山一角。以后的月报会继续对原子DDL的实现进行分析，希望大家持续关注。

原文：http://mysql.taobao.org/monthly/2018/03/02/