Drizzle originally inherited the FRM file from MySQL (which inherited it from UNIREG). The FRM file stores metadata about a table; what columns it has, what type those columns are, what indexes, any default values, comments etc are all stored in the FRM. In the days of MyISAM, this worked relatively well. The row data was stored in table.MYD, indexes on top of it in table.MYI and information about the format of the row was
\nin table.FRM. Since MyISAM itself wasn’t crash safe, it didn’t really matter if creating\/deleting the FRM file along with the table was either.<\/p>\n
As more sophisticated engines were introduced (e.g. InnoDB) that had their own data dictionary, there started to be more of a problem. There were now two places storing information about a table: the FRM file and the data dictionary specific to the engine. Even if the data dictionary of the storage engine was crash safe, the FRM file was not plugged into that, so you could end up in a situation where the storage engine
\nrecovered from a crash okay, but the FRM was incorrect for what the engine recovered to. This would always require manual intervention to find out what went wrong and then fix it (in some rather unusual ways).<\/p>\n
When the MySQL Cluster (NDB) engine was introduced, a new set of problems arose. Now the MySQL server was connecting to an existing database, where tables could be created on other nodes connected to the cluster. You now not only had the problems of crash recovery, but the problems of keeping the FRM files in sync across many nodes, requiring
\nall sorts of interesting solutions that, for the most part, do work.<\/p>\n
The “obvious” solution to some of these problems would be for an engine to write out an FRM file itself. This is much easier said than done. The file format was never created to be read and written by multiple pieces of software, the code that did the reading and writing inside the server was not reusable elsewhere and the only documentation (that
\nwasn’t a decent chunk of the MySQL source tree) is the rather incomplete definition in the MySQL Internals wiki (http:\/\/forge.mysql.com\/wiki\/MySQL_Internals_File_Formats) – not nearly enough to write a correct FRM file as the specifics are very, very odd.<\/p>\n
Our goals for reworking the metadata system in Drizzle were: to allow engines to own their own metadata (removing any opportunity to have inconsistencies between the engine and the ‘FRM’) and for engines without their own data dictionary, to replace the FRM file format with something simple and well documented.<\/p>\n
One option was to use SQL as the standard storage format, but it is rather non-trivial and expensive to parse – especially if we were to use it as the preferred way of talking table definitions with storage engines. We had been looking at the protobuf library
\n(http:\/\/code.google.com\/p\/protobuf\/) ever since its first release and it has a number of very nice characteristics: a description language of a data structure that is then used to generate APIs for reading and writing it in a number of programming languages and a standard (documented) way to serialize the data structure.<\/p>\n
After a bit of discussion, we arrived at a good outline for the table definition proto. The current one can always be found in the Drizzle source tree at drizzled\/message\/table.proto. The current format is very close to final (i.e. one that we’ll suppport upgrades from).<\/p>\n
The process of modifying the Drizzle code base so that it would write (and read) a file format different to the FRM isn’t worth going too much into here although there were some interesting hurdles to overcome. An interesting one was the FRM file contains a binary image of the default row for the table (which is in the row format that the server uses); we now store the default value for each column in the proto and generate the default row when we read the proto. Another interesting one was removing and refactoring “pack_flag” – the details of which should only be extracted from Jay or Stewart with a liberal application of fine ale.<\/p>\n
The end result is that we now have storage engines that are completely responsible for their own metadata. One example is the ARCHIVE engine. In the CREATE TABLE code path, the ARCHIVE storage engine gets the table definition in an object that represents the table proto. It can examine the parameters it needs to and then either store the proto directly, or convert it into its own format. Since ARCHIVE is simple, it just stores
\nthe table proto in a serialised form (using a standard function provided by the protobuf library) and stores it in the .ARZ data file for the table. This instantly makes the ARCHIVE storage engine crash safe for CREATE and DROP table as there is only 1 file on disk, so no two files to get out of sync.<\/p>\n
If an engine does not have its own data dictionary, it can still use the default implementation which just stores the serialised table proto in a file on disk.<\/p>\n
We can also now use this interface to move INFORMATION_SCHEMA into its own storage engine. This means we can remove a lot of special case code throughout the server for INFORMATION_SCHEMA and instead just have a INFORMATION_SCHEMA storage engine that says it has the following tables in the INFORMATION_SCHEMA database. Because the table definition is now in a documented format with a standard API, this becomes a relatively trivial exercise.<\/p>\n
What we’re all looking forward to is when the InnoDB data dictionary is linked into the new interface and we can have a truly crash safe database server.<\/p>\n
Another wonderful side effect is since we now have a standard data structure for representing a table definition, we can integrate this with the replication system. In the “near” future, we can represent a CREATE TABLE in the replication stream as a table proto and not the raw SQL. If you were wanting to apply the replication stream to a different database server, you then only have to write a table proto to SQL
\nconverter. If the target database system doesn’t do SQL at all, you could generate API calls to create the table.<\/p>\n
So we now have a rather flexible system in place, with the code implementing it being increasingly simple and possible to be “obviously correct”.<\/p>\n
Things that easily fall out of this work that people have written about: Some more info: Drizzle originally inherited the FRM file from MySQL (which inherited it from UNIREG). The FRM file stores metadata about a table; what columns it has, what type those columns are, what indexes, any default values, comments etc are all stored … Continue reading
\n– CREATE TABLE LIKE with ENGINE clause
\n http:\/\/krow.livejournal.com\/671235.html<\/a>
\n– table_raw_reader – looking at the raw representation of table metadata
\n http:\/\/www.flamingspork.com\/blog\/2009\/10\/01\/table_raw_reader-reading-the-table-proto-from-disk-and-examining-everything\/<\/a>
\n– Table discovery
\n http:\/\/www.flamingspork.com\/blog\/2009\/07\/29\/table-discovery-for-drizzle-take-2-now-merged\/<\/a><\/p>\n
\n http:\/\/krow.livejournal.com\/642329.html<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"