众所周知，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存在如下一些弊端：
图2我们可以看到，Server layer(后面简称SL）以及Storage Engine（后面简称SE） 使用同一份data dictionary(后面简称DD）用来存储metadata。SL和SE将各自需要的metadata存入DD中。由于DD使用Innodb作为存储引擎，所以crash recovery的时候，DD可以安全的进行事务回滚。
class Dictionary_client/*
这个类提供了SL以及SE统一访问DD的接口。每一个THD都有一个访问DD的Dictionary_client类型的成员。 如果需要操作DD，直接调用相关接口函数即可。
这个类成员函数的主要方法是去访问一个多session共享的cache来操作DD存储的各种对象。和其他cache一样，如果在访问过程中，在这个cache里没有找到对应的对象，那么后台会自动读取DD中的相关metadata，进而构建相应的数据表。
*/{public:/*
这个类是用来辅助Dictionary_client自动释放获取的DD对象。该类会自动跟踪当前Dictionary_client获取的每个DD对象。当Dictionary_client对象生命期结束的时候，该对象会自动释放当前session获取的DD对象。
这个类对象可以进行嵌套，Dictionary_client中的m_current_releaser成员变量始终会指向嵌套堆栈最顶层的一个Auto_releaser对象。如果当前的Auto_releaser对象结束了生命期，它会释放掉自己记录的位于共享cache中的DD对象，同时把m_current_releaser指向上一个老的Auto_releaser对象。
*/class Auto_releaser
{ friend class Dictionary_client; private:
Dictionary_client *m_client; // 用来指向当前的Dictionary_client对象
Object_registry m_release_registry; // 用来记录从共享cache中获取的DD对象，以便自动释放
Auto_releaser *m_prev; // 用来形成列表，以方便当前实例生命期结束的时候，将Dictionary_client对象中的Auto_releaser重新指向之前创建的实例。
/**
注册一个DD对象
*/
template <typename T> void auto_release(Cache_element<T> *element)
{ // Catch situations where we do not use a non-default releaser.
DBUG_ASSERT(m_prev != NULL);
m_release_registry.put(element);
} /**
当一个Auto_releaser对象结束生命期的时候，有的DD对象并不能结束生命期，该函数用来把一个DD对象转移给上一个Auto_releaser对象。
*/
template <typename T> void transfer_release(const T* object); /**
移除一个DD对象
*/
template <typename T>
Auto_releaser *remove(Cache_element<T> *element); // Create a new empty auto releaser. Used only by the Dictionary_client.
Auto_releaser(); public: /**
Create a new auto releaser and link it into the dictionary client
as the current releaser.
@param client Dictionary client for which to install this auto
releaser.
*/
explicit Auto_releaser(Dictionary_client *client); // Release all objects registered and restore previous releaser.
~Auto_releaser(); // Debug dump to stderr.
template <typename T> void dump() const;
};private: std::vector<Entity_object*> m_uncached_objects; // Objects to be deleted.
Object_registry m_registry_committed; // Registry of committed objects.
Object_registry m_registry_uncommitted; // Registry of uncommitted objects.
Object_registry m_registry_dropped; // Registry of dropped objects.
THD *m_thd; // Thread context, needed for cache misses.
Auto_releaser m_default_releaser; // Default auto releaser.
Auto_releaser *m_current_releaser; // Current auto releaser....
}/**
该类定义了共享的DD对象缓存，该类取代了8.0之前的table_cache。数据库对象会根据对象类型从不同的map中获取对象。所有对DD对象的访问都需要经过该缓存。
*/class Shared_dictionary_cache
{private: // 设置一些缓存的最大容量，目前看来都是硬编码
static const size_t collation_capacity= 256; static const size_t column_statistics_capacity= 32; static const size_t charset_capacity= 64; static const size_t event_capacity= 256; static const size_t spatial_reference_system_capacity= 256; /**
Maximum number of DD resource group objects to be kept in
cache. We use value of 32 which is a fairly reasonable upper limit
of resource group configurations that may be in use.
*/
static const size_t resource_group_capacity= 32; /* 下面是各种不同类型DD对象缓存map */
Shared_multi_map<Abstract_table> m_abstract_table_map;
Shared_multi_map<Charset> m_charset_map;
Shared_multi_map<Collation> m_collation_map;
Shared_multi_map<Column_statistics> m_column_stat_map;
Shared_multi_map<Event> m_event_map;
Shared_multi_map<Resource_group> m_resource_group_map;
Shared_multi_map<Routine> m_routine_map;
Shared_multi_map<Schema> m_schema_map;
Shared_multi_map<Spatial_reference_system> m_spatial_reference_system_map;
Shared_multi_map<Tablespace> m_tablespace_map; template <typename T> struct Type_selector { }; // Dummy type to use for
// selecting map instance.
/**
Overloaded functions to use for selecting map instance based
on a key type. Const and non-const variants.
*/
Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>)
{ return &m_abstract_table_map; }
Shared_multi_map<Charset> *m_map(Type_selector<Charset>)
{ return &m_charset_map; }
Shared_multi_map<Collation> *m_map(Type_selector<Collation>)
{ return &m_collation_map; }
Shared_multi_map<Column_statistics> *m_map(Type_selector<Column_statistics>)
{ return &m_column_stat_map; }
Shared_multi_map<Event> *m_map(Type_selector<Event>)
{ return &m_event_map; }
Shared_multi_map<Resource_group> *m_map(Type_selector<Resource_group>)
{ return &m_resource_group_map; }
Shared_multi_map<Spatial_reference_system> m_spatial_reference_system_map;
Shared_multi_map<Tablespace> m_tablespace_map; template <typename T> struct Type_selector { }; // Dummy type to use for
// selecting map instance.
/**
Overloaded functions to use for selecting map instance based
on a key type. Const and non-const variants.
*/
Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>)
{ return &m_abstract_table_map; }
Shared_multi_map<Charset> *m_map(Type_selector<Charset>)
{ return &m_charset_map; }
Shared_multi_map<Collation> *m_map(Type_selector<Collation>)
{ return &m_collation_map; }
Shared_multi_map<Column_statistics> *m_map(Type_selector<Column_statistics>)
{ return &m_column_stat_map; }
Shared_multi_map<Event> *m_map(Type_selector<Event>)
{ return &m_event_map; }
Shared_multi_map<Resource_group> *m_map(Type_selector<Resource_group>)
{ return &m_resource_group_map; }
Shared_multi_map<Routine> *m_map(Type_selector<Routine>)
{ return &m_routine_map; }
Shared_multi_map<Schema> *m_map(Type_selector<Schema>)
{ return &m_schema_map; }
Shared_multi_map<Spatial_reference_system> *
m_map(Type_selector<Spatial_reference_system>)
{ return &m_spatial_reference_system_map; }
Shared_multi_map<Tablespace> *m_map(Type_selector<Tablespace>)
{ return &m_tablespace_map; } const Shared_multi_map<Abstract_table> *m_map(Type_selector<Abstract_table>) const
{ return &m_abstract_table_map; } const Shared_multi_map<Charset> *m_map(Type_selector<Charset>) const
{ return &m_charset_map; } const Shared_multi_map<Collation> *m_map(Type_selector<Collation>) const
{ return &m_collation_map; } const Shared_multi_map<Column_statistics> *
m_map(Type_selector<Column_statistics>) const
{ return &m_column_stat_map; } const Shared_multi_map<Schema> *m_map(Type_selector<Schema>) const
{ return &m_schema_map; } const Shared_multi_map<Spatial_reference_system> *
m_map(Type_selector<Spatial_reference_system>) const
{ return &m_spatial_reference_system_map; } const Shared_multi_map<Tablespace> *m_map(Type_selector<Tablespace>) const
{ return &m_tablespace_map; } const Shared_multi_map<Resource_group> *m_map(
{ return &m_abstract_table_map; } const Shared_multi_map<Charset> *m_map(Type_selector<Charset>) const
{ return &m_charset_map; } const Shared_multi_map<Collation> *m_map(Type_selector<Collation>) const
{ return &m_collation_map; } const Shared_multi_map<Column_statistics> *
m_map(Type_selector<Column_statistics>) const
{ return &m_column_stat_map; } const Shared_multi_map<Schema> *m_map(Type_selector<Schema>) const
{ return &m_schema_map; } const Shared_multi_map<Spatial_reference_system> *
m_map(Type_selector<Spatial_reference_system>) const
{ return &m_spatial_reference_system_map; } const Shared_multi_map<Tablespace> *m_map(Type_selector<Tablespace>) const
{ return &m_tablespace_map; } const Shared_multi_map<Resource_group> *m_map(
Type_selector<Resource_group>) const
{ return &m_resource_group_map; } /**
根据DD对象类型获取对应的map对象。
*/
template <typename T>
Shared_multi_map<T> *m_map()
{ return m_map(Type_selector<T>()); } template <typename T> const Shared_multi_map<T> *m_map() const
{ return m_map(Type_selector<T>()); }
Shared_dictionary_cache()
{ }public: static Shared_dictionary_cache *instance(); // Set capacity of the shared maps.
static void init(); // Shutdown the shared maps.
static void shutdown(); // Reset the shared cache. Optionally keep the core DD table meta data.
static void reset(bool keep_dd_entities); // Reset the table and tablespace partitions.
static bool reset_tables_and_tablespaces(THD *thd); /**
根据DD类型及名称来验证对象是否在缓存中。
*/
template <typename K, typename T> bool available(const K &key)
{ return m_map<T>()->available(key); } /**
该函数用来输出调试信息。
*/
template <typename T> void dump() const
{#ifndef DBUG_OFF
fprintf(stderr, "================================\n"); fprintf(stderr, "Shared dictionary cache\n");
m_map<T>()->dump(); fprintf(stderr, "================================\n");#endif
}
};
} // namespace cache/**
这个类抽象了对DD对象的metadata进行存储的方法。它是一个静态类。对于新创建的对象（表，索引，表空间等）都会通过该类进行一个clone， clone之后该类会将该对象的metadata存储到对应的系统表中。另外，它也提供接口用来从系统表中获取metadata并生成调用需要的DD对象。
该类同时也提供了一个缓存，每次调用存储新对象的时候，它会自动将一个对象clone缓存起来。该类成员函数中core_xxx都是负责操作缓存。
*/class Storage_adapter
{friend class dd_cache_unittest::CacheStorageTest;private: /**
Use an id not starting at 1 to make it easy to recognize ids generated
before objects are stored persistently.
*/
static const Object_id FIRST_OID= 10001; /**
为新的对象产生一个ID标识。
*/
template <typename T> Object_id next_oid(); /**
根据对象名称从缓存中返回一个对象的clone。
*/
template <typename K, typename T> void core_get(const K &key, const T **object);
Object_registry m_core_registry; // Object registry storing core DD objects.
mysql_mutex_t m_lock; // Single mutex to protect the registry.
static bool s_use_fake_storage; // Whether to use the core registry to
// simulate the storage engine.
Storage_adapter()
{ mysql_mutex_init(PSI_NOT_INSTRUMENTED, &m_lock, MY_MUTEX_INIT_FAST); }
~Storage_adapter()
{
mysql_mutex_lock(&m_lock);
m_core_registry.erase_all();
mysql_mutex_unlock(&m_lock);
mysql_mutex_destroy(&m_lock);
}public: /* 这里可以获取到单例。 */
static Storage_adapter *instance(); /**
根据对象类型返回缓存区中所有对象的数量。
*/
template <typename T> size_t core_size(); /**
获取对象ID标识
*/
template <typename T> Object_id core_get_id(const typename T::Name_key &key); /**
该函数可以根据对象类型及名称获取对象。如果该对象已经被缓存，那么调用core_get获取clone对象。否则会根据对象类型到对应的metadata数据表中查找并构造一个对象。
*/
template <typename K, typename T> static bool get(THD *thd, const K &key,
enum_tx_isolation isolation, bool bypass_core_registry, const T **object); /**
缓存中清除一个对象.
*/
template <typename T> void core_drop(THD *thd, const T *object); /**
从对象所对应的各个metadata数据表中清除相关数据.
*/
template <typename T> static bool drop(THD *thd, const T *object); /**
缓冲区中添加一个DD对象
*/
template <typename T> void core_store(THD *thd, T *object); /**
该函数会根据DD对象类型，将metadata存入相关的系统表中。后面的建表语句中会对该函数进行详细的解释。
*/
template <typename T> static bool store(THD *thd, T *object); /**
同步缓存中的DD对象。
*/
template <typename T> bool core_sync(THD *thd, const typename T::Name_key &key, const T *object); /**
Remove and delete all elements and objects from core storage.
*/
void erase_all(); /**
备份缓存中的对象。
*/
void dump();
};
} // namespace cache} // namespace dd
综上篇章简要的描述了MySQL8.0实现原子DDL的背景以及一些重点的数据结构，并对CREATE TABLE过程，以及创建过程中用到的几个重要函数进行了分析。但是原子DDL的实现是一个非常大的工程，本篇月报由于篇幅问题，只是挖了冰山一角。以后的月报会继续对原子DDL的实现进行分析，希望大家持续关注。
发起投票
技术讨论
加好友
发消息
2019-8-29 9:56:01 |
赞(
操作
