Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/mtr/mtr0log.c File Reference

#include "mtr0log.h"
#include "buf0buf.h"
#include "dict0boot.h"
#include "log0recv.h"
#include "page0page.h"

Include dependency graph for mtr0log.c:

Go to the source code of this file.

Functions
void	mlog_catenate_string (mtr_t *mtr, const byte *str, ulint len)
void	mlog_write_initial_log_record (byte *ptr, byte type, mtr_t *mtr)
byte *	mlog_parse_initial_log_record (byte *ptr, byte *end_ptr, byte *type, ulint *space, ulint *page_no)
byte *	mlog_parse_nbytes (ulint type, byte *ptr, byte *end_ptr, byte *page)
void	mlog_write_ulint (byte *ptr, ulint val, byte type, mtr_t *mtr)
void	mlog_write_dulint (byte *ptr, dulint val, mtr_t *mtr)
void	mlog_write_string (byte *ptr, const byte *str, ulint len, mtr_t *mtr)
byte *	mlog_parse_string (byte *ptr, byte *end_ptr, byte *page)
byte *	mlog_open_and_write_index (mtr_t *mtr, byte *rec, dict_index_t *index, byte type, ulint size)
byte *	mlog_parse_index (byte *ptr, byte *end_ptr, ibool comp, dict_index_t **index)

---

Function Documentation

void mlog_catenate_string	(	mtr_t *	mtr,
		const byte *	str,
		ulint	len
	)

Definition at line 24 of file mtr0log.c.

References dyn_push_string(), mtr_struct::log, mtr_get_log_mode(), and MTR_LOG_NONE.

Referenced by fil_op_write_log(), mlog_write_string(), page_cur_insert_rec_write_log(), row_upd_index_write_log(), and trx_undof_page_add_undo_rec_log().

                                     : mtr */
        const byte*     str,    /* in: string to write */
        ulint           len)    /* in: string length */
{
        dyn_array_t*    mlog;

        if (mtr_get_log_mode(mtr) == MTR_LOG_NONE) {

                return;
        }

        mlog = &(mtr->log);

        dyn_push_string(mlog, str, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

byte* mlog_open_and_write_index	(	mtr_t *	mtr,
		byte *	rec,
		dict_index_t *	index,
		byte	type,
		ulint	size
	)

Definition at line 395 of file mtr0log.c.

References DATA_BLOB, DATA_NOT_NULL, dict_col_get_type(), dict_field_get_col(), dict_index_get_n_fields(), dict_index_get_n_unique_in_tree(), dict_index_get_nth_field(), dict_table_is_comp(), dtype_get_len(), dtype_get_mtype(), dtype_get_prtype(), DYN_ARRAY_DATA_SIZE, index(), mach_write_to_2(), mlog_close(), mlog_open(), mlog_write_initial_log_record_fast(), n, NULL, page_rec_is_comp(), ut_a, and ut_ad.

Referenced by btr_cur_del_mark_set_clust_rec_log(), btr_cur_update_in_place_log(), btr_page_reorganize_low(), page_copy_rec_list_to_created_page_write_log(), page_cur_delete_rec_write_log(), page_cur_insert_rec_write_log(), and page_delete_rec_list_write_log().

                                      : buffer, NULL if log mode
                                MTR_LOG_NONE */
        mtr_t*          mtr,    /* in: mtr */
        byte*           rec,    /* in: index record or page */
        dict_index_t*   index,  /* in: record descriptor */
        byte            type,   /* in: log item type */
        ulint           size)   /* in: requested buffer size in bytes
                                (if 0, calls mlog_close() and returns NULL) */
{
        byte*           log_ptr;
        const byte*     log_start;
        const byte*     log_end;

        ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));

        if (!page_rec_is_comp(rec)) {
                log_start = log_ptr = mlog_open(mtr, 11 + size);
                if (!log_ptr) {
                        return(NULL); /* logging is disabled */
                }
                log_ptr = mlog_write_initial_log_record_fast(rec, type,
                                log_ptr, mtr);
                log_end = log_ptr + 11 + size;
        } else {
                ulint   i;
                ulint   n       = dict_index_get_n_fields(index);
                /* total size needed */
                ulint   total   = 11 + size + (n + 2) * 2;
                ulint   alloc   = total;
                /* allocate at most DYN_ARRAY_DATA_SIZE at a time */
                if (alloc > DYN_ARRAY_DATA_SIZE) {
                        alloc = DYN_ARRAY_DATA_SIZE;
                }
                log_start = log_ptr = mlog_open(mtr, alloc);
                if (!log_ptr) {
                        return(NULL); /* logging is disabled */
                }
                log_end = log_ptr + alloc;
                log_ptr = mlog_write_initial_log_record_fast(rec, type,
                                log_ptr, mtr);
                mach_write_to_2(log_ptr, n);
                log_ptr += 2;
                mach_write_to_2(log_ptr,
                                dict_index_get_n_unique_in_tree(index));
                log_ptr += 2;
                for (i = 0; i < n; i++) {
                        dict_field_t*   field;
                        dtype_t*        type;
                        ulint           len;
                        field = dict_index_get_nth_field(index, i);
                        type = dict_col_get_type(dict_field_get_col(field));
                        len = field->fixed_len;
                        ut_ad(len < 0x7fff);
                        if (len == 0 && (dtype_get_len(type) > 255
                                || dtype_get_mtype(type) == DATA_BLOB)) {
                                /* variable-length field
                                with maximum length > 255 */
                                len = 0x7fff;
                        }
                        if (dtype_get_prtype(type) & DATA_NOT_NULL) {
                                len |= 0x8000;
                        }
                        if (log_ptr + 2 > log_end) {
                                mlog_close(mtr, log_ptr);
                                ut_a(total > (ulint) (log_ptr - log_start));
                                total -= log_ptr - log_start;
                                alloc = total;
                                if (alloc > DYN_ARRAY_DATA_SIZE) {
                                        alloc = DYN_ARRAY_DATA_SIZE;
                                }
                                log_start = log_ptr = mlog_open(mtr, alloc);
                                if (!log_ptr) {
                                        return(NULL); /* logging is disabled */
                                }
                                log_end = log_ptr + alloc;
                        }
                        mach_write_to_2(log_ptr, len);
                        log_ptr += 2;
                }
        }
        if (size == 0) {
                mlog_close(mtr, log_ptr);
                log_ptr = NULL;
        } else if (log_ptr + size > log_end) {
                mlog_close(mtr, log_ptr);
                log_ptr = mlog_open(mtr, size);
        }
        return(log_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

byte* mlog_parse_index	(	byte *	ptr,
		byte *	end_ptr,
		ibool	comp,
		dict_index_t **	index
	)

Definition at line 491 of file mtr0log.c.

References dict_index_struct::cached, DATA_BINARY, DATA_FIXBINARY, DATA_NOT_NULL, DICT_CLUSTERED, DICT_HDR_SPACE, dict_index_add_col(), dict_mem_index_create(), dict_mem_table_add_col(), dict_mem_table_create(), dict_table_get_nth_col(), DICT_TF_COMPACT, FALSE, index(), mach_read_from_2(), n, dict_index_struct::n_uniq, NULL, dict_index_struct::table, TRUE, dict_index_struct::type, and ut_ad.

Referenced by recv_parse_or_apply_log_rec_body().

                                      : parsed record end,
                                NULL if not a complete record */
        byte*           ptr,    /* in: buffer */
        byte*           end_ptr,/* in: buffer end */
                                /* out: new value of log_ptr */
        ibool           comp,   /* in: TRUE=compact record format */
        dict_index_t**  index)  /* out, own: dummy index */
{
        ulint           i, n, n_uniq;
        dict_table_t*   table;
        dict_index_t*   ind;

        ut_ad(comp == FALSE || comp == TRUE);

        if (comp) {
                if (end_ptr < ptr + 4) {
                        return(NULL);
                }
                n = mach_read_from_2(ptr);
                ptr += 2;
                n_uniq = mach_read_from_2(ptr);
                ut_ad(n_uniq <= n);
                if (end_ptr < ptr + (n + 1) * 2) {
                        return(NULL);
                }
        } else {
                n = n_uniq = 1;
        }
        table = dict_mem_table_create("LOG_DUMMY", DICT_HDR_SPACE, n,
                comp ? DICT_TF_COMPACT : 0);
        ind = dict_mem_index_create("LOG_DUMMY", "LOG_DUMMY",
                                DICT_HDR_SPACE, 0, n);
        ind->table = table;
        ind->n_uniq = n_uniq;
        if (n_uniq != n) {
                ind->type = DICT_CLUSTERED;
        }
        /* avoid ut_ad(index->cached) in dict_index_get_n_unique_in_tree */
        ind->cached = TRUE;
        if (comp) {
                for (i = 0; i < n; i++) {
                        ulint   len = mach_read_from_2(ptr += 2);
                        /* The high-order bit of len is the NOT NULL flag;
                        the rest is 0 or 0x7fff for variable-length fields,
                        and 1..0x7ffe for fixed-length fields. */
                        dict_mem_table_add_col(table, "DUMMY",
                                        ((len + 1) & 0x7fff) <= 1
                                                ? DATA_BINARY
                                                : DATA_FIXBINARY,
                                        len & 0x8000 ? DATA_NOT_NULL : 0,
                                        len & 0x7fff, 0);
                        dict_index_add_col(ind,
                                dict_table_get_nth_col(table, i), 0);
                }
                ptr += 2;
        }
        *index = ind;
        return(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

byte* mlog_parse_initial_log_record	(	byte *	ptr,
		byte *	end_ptr,
		byte *	type,
		ulint *	space,
		ulint *	page_no
	)

Definition at line 83 of file mtr0log.c.

References mach_parse_compressed(), MLOG_BIGGEST_TYPE, MLOG_SINGLE_REC_FLAG, NULL, and ut_ad.

Referenced by recv_parse_log_rec().

                              : parsed record end, NULL if not a complete
                        record */
        byte*   ptr,    /* in: buffer */
        byte*   end_ptr,/* in: buffer end */
        byte*   type,   /* out: log record type: MLOG_1BYTE, ... */
        ulint*  space,  /* out: space id */
        ulint*  page_no)/* out: page number */
{
        if (end_ptr < ptr + 1) {

                return(NULL);
        }

        *type = (byte)((ulint)*ptr & ~MLOG_SINGLE_REC_FLAG);
        ut_ad(*type <= MLOG_BIGGEST_TYPE);

        ptr++;

        if (end_ptr < ptr + 2) {

                return(NULL);
        }

        ptr = mach_parse_compressed(ptr, end_ptr, space);

        if (ptr == NULL) {

                return(NULL);
        }

        ptr = mach_parse_compressed(ptr, end_ptr, page_no);

        return(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

byte* mlog_parse_nbytes	(	ulint	type,
		byte *	ptr,
		byte *	end_ptr,
		byte *	page
	)

Definition at line 124 of file mtr0log.c.

References recv_sys_struct::found_corrupt_log, mach_dulint_parse_compressed(), mach_parse_compressed(), mach_read_from_2(), mach_write_to_1(), mach_write_to_2(), mach_write_to_4(), mach_write_to_8(), MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES, MLOG_8BYTES, NULL, offset, recv_sys, TRUE, UNIV_PAGE_SIZE, and ut_a.

Referenced by recv_parse_or_apply_log_rec_body().

                              : parsed record end, NULL if not a complete
                        record or a corrupt record */
        ulint   type,   /* in: log record type: MLOG_1BYTE, ... */
        byte*   ptr,    /* in: buffer */
        byte*   end_ptr,/* in: buffer end */
        byte*   page)   /* in: page where to apply the log record, or NULL */
{
        ulint   offset;
        ulint   val;
        dulint  dval;

        ut_a(type <= MLOG_8BYTES);

        if (end_ptr < ptr + 2) {

                return(NULL);
        }

        offset = mach_read_from_2(ptr);
        ptr += 2;

        if (offset >= UNIV_PAGE_SIZE) {
                recv_sys->found_corrupt_log = TRUE;

                return(NULL);
        }

        if (type == MLOG_8BYTES) {
                ptr = mach_dulint_parse_compressed(ptr, end_ptr, &dval);

                if (ptr == NULL) {

                        return(NULL);
                }

                if (page) {
                        mach_write_to_8(page + offset, dval);
                }

                return(ptr);
        }

        ptr = mach_parse_compressed(ptr, end_ptr, &val);

        if (ptr == NULL) {

                return(NULL);
        }

        if (type == MLOG_1BYTE) {
                if (val > 0xFFUL) {
                        recv_sys->found_corrupt_log = TRUE;

                        return(NULL);
                }
        } else if (type == MLOG_2BYTES) {
                if (val > 0xFFFFUL) {
                        recv_sys->found_corrupt_log = TRUE;

                        return(NULL);
                }
        } else {
                if (type != MLOG_4BYTES) {
                        recv_sys->found_corrupt_log = TRUE;

                        return(NULL);
                }
        }

        if (page) {
                if (type == MLOG_1BYTE) {
                        mach_write_to_1(page + offset, val);
                } else if (type == MLOG_2BYTES) {
                        mach_write_to_2(page + offset, val);
                } else {
                        ut_a(type == MLOG_4BYTES);
                        mach_write_to_4(page + offset, val);
                }
        }

        return(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

byte* mlog_parse_string	(	byte *	ptr,
		byte *	end_ptr,
		byte *	page
	)

Definition at line 348 of file mtr0log.c.

References recv_sys_struct::found_corrupt_log, mach_read_from_2(), NULL, offset, recv_sys, TRUE, UNIV_PAGE_SIZE, ut_a, and ut_memcpy().

Referenced by recv_parse_or_apply_log_rec_body().

                              : parsed record end, NULL if not a complete
                        record */
        byte*   ptr,    /* in: buffer */
        byte*   end_ptr,/* in: buffer end */
        byte*   page)   /* in: page where to apply the log record, or NULL */
{
        ulint   offset;
        ulint   len;

        if (end_ptr < ptr + 4) {

                return(NULL);
        }

        offset = mach_read_from_2(ptr);
        ptr += 2;

        if (offset >= UNIV_PAGE_SIZE) {
                recv_sys->found_corrupt_log = TRUE;

                return(NULL);
        }

        len = mach_read_from_2(ptr);
        ptr += 2;

        ut_a(len + offset < UNIV_PAGE_SIZE);

        if (end_ptr < ptr + len) {

                return(NULL);
        }

        if (page) {
                ut_memcpy(page + offset, ptr, len);
        }

        return(ptr + len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mlog_write_dulint	(	byte *	ptr,
		dulint	val,
		mtr_t *	mtr
	)

Definition at line 261 of file mtr0log.c.

References buf_frame_align(), buf_pool, buf_pool_struct::high_end, mach_dulint_write_compressed(), mach_write_to_2(), mach_write_to_8(), MLOG_8BYTES, mlog_close(), mlog_open(), mlog_write_initial_log_record_fast(), NULL, ut_ad, and ut_error.

Referenced by dict_hdr_create(), dict_hdr_flush_row_id(), dict_hdr_get_new_id(), fseg_alloc_free_extent(), fseg_alloc_free_page_low(), fseg_create_general(), fseg_fill_free_list(), fsp_alloc_seg_inode_page(), fsp_free_seg_inode(), fsp_header_init(), trx_purge_add_update_undo_to_history(), trx_sys_flush_max_trx_id(), trx_sysf_create(), and trx_undo_mark_as_dict_operation().

                             : pointer where to write */
        dulint  val,    /* in: value to write */
        mtr_t*  mtr)    /* in: mini-transaction handle */
{
        byte*   log_ptr;

        if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
                fprintf(stderr,
        "InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
                ut_error;
        }

        ut_ad(ptr && mtr);

        mach_write_to_8(ptr, val);

        log_ptr = mlog_open(mtr, 11 + 2 + 9);

        /* If no logging is requested, we may return now */
        if (log_ptr == NULL) {

                return;
        }

        log_ptr = mlog_write_initial_log_record_fast(ptr, MLOG_8BYTES,
                                                        log_ptr, mtr);

        mach_write_to_2(log_ptr, ptr - buf_frame_align(ptr));
        log_ptr += 2;

        log_ptr += mach_dulint_write_compressed(log_ptr, val);

        mlog_close(mtr, log_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mlog_write_initial_log_record	(	byte *	ptr,
		byte	type,
		mtr_t *	mtr
	)

Definition at line 48 of file mtr0log.c.

References buf_pool, buf_pool_struct::high_end, MLOG_8BYTES, MLOG_BIGGEST_TYPE, mlog_close(), mlog_open(), mlog_write_initial_log_record_fast(), NULL, ut_ad, and ut_error.

Referenced by btr_set_min_rec_mark_log(), fsp_init_file_page(), ibuf_bitmap_page_init(), page_create_write_log(), trx_undo_discard_latest_log(), trx_undo_erase_page_end(), trx_undo_header_create_log(), trx_undo_insert_header_reuse_log(), and trx_undo_page_init_log().

                             : pointer to (inside) a buffer frame holding the
                        file page where modification is made */
        byte    type,   /* in: log item type: MLOG_1BYTE, ... */
        mtr_t*  mtr)    /* in: mini-transaction handle */
{
        byte*   log_ptr;

        ut_ad(type <= MLOG_BIGGEST_TYPE);
        ut_ad(type > MLOG_8BYTES);

        if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
                fprintf(stderr,
        "InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
                ut_error;
        }

        log_ptr = mlog_open(mtr, 11);

        /* If no logging is requested, we may return now */
        if (log_ptr == NULL) {

                return;
        }

        log_ptr = mlog_write_initial_log_record_fast(ptr, type, log_ptr, mtr);

        mlog_close(mtr, log_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mlog_write_string	(	byte *	ptr,
		const byte *	str,
		ulint	len,
		mtr_t *	mtr
	)

Definition at line 303 of file mtr0log.c.

References buf_frame_align(), buf_pool, buf_pool_struct::high_end, mach_write_to_2(), mlog_catenate_string(), mlog_close(), mlog_open(), mlog_write_initial_log_record_fast(), MLOG_WRITE_STRING, NULL, UNIV_PAGE_SIZE, ut_a, ut_ad, ut_error, and ut_memcpy().

Referenced by btr_store_big_rec_extern_fields(), trx_sys_update_mysql_binlog_offset(), and trx_undo_write_xid().

                                     : pointer where to write */
        const byte*     str,    /* in: string to write */
        ulint           len,    /* in: string length */
        mtr_t*          mtr)    /* in: mini-transaction handle */
{
        byte*   log_ptr;

        if (UNIV_UNLIKELY(ptr < buf_pool->frame_zero)
                || UNIV_UNLIKELY(ptr >= buf_pool->high_end)) {
                fprintf(stderr,
        "InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
                ut_error;
        }
        ut_ad(ptr && mtr);
        ut_a(len < UNIV_PAGE_SIZE);

        ut_memcpy(ptr, str, len);

        log_ptr = mlog_open(mtr, 30);

        /* If no logging is requested, we may return now */
        if (log_ptr == NULL) {

                return;
        }

        log_ptr = mlog_write_initial_log_record_fast(ptr, MLOG_WRITE_STRING,
                                                                log_ptr, mtr);
        mach_write_to_2(log_ptr, ptr - buf_frame_align(ptr));
        log_ptr += 2;

        mach_write_to_2(log_ptr, len);
        log_ptr += 2;

        mlog_close(mtr, log_ptr);

        mlog_catenate_string(mtr, str, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mlog_write_ulint	(	byte *	ptr,
		ulint	val,
		byte	type,
		mtr_t *	mtr
	)

Definition at line 214 of file mtr0log.c.

References buf_frame_align(), buf_pool, buf_pool_struct::high_end, mach_write_compressed(), mach_write_to_1(), mach_write_to_2(), mach_write_to_4(), MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES, mlog_close(), mlog_open(), mlog_write_initial_log_record_fast(), NULL, ut_ad, and ut_error.

Referenced by btr_cur_set_ownership_of_extern_field(), btr_free_externally_stored_field(), btr_node_ptr_set_child_page_no(), btr_store_big_rec_extern_fields(), dict_hdr_create(), flst_add_to_empty(), flst_cut_end(), flst_insert_after(), flst_insert_before(), flst_remove(), flst_truncate_end(), fseg_create_general(), fseg_free_extent(), fseg_free_page_low(), fseg_mark_page_used(), fseg_set_nth_frag_page_no(), fsp_alloc_free_page(), fsp_alloc_seg_inode_page(), fsp_fill_free_list(), fsp_free_page(), fsp_free_seg_inode(), fsp_header_inc_size(), fsp_header_init(), fsp_try_extend_data_file(), fsp_try_extend_data_file_with_pages(), ibuf_add_free_page(), ibuf_bitmap_page_set_bits(), page_rec_write_index_page_no(), rec_set_nth_field_extern_bit_new(), rec_set_nth_field_extern_bit_old(), trx_purge_add_update_undo_to_history(), trx_purge_free_segment(), trx_rseg_header_create(), trx_sys_create_doublewrite_buf(), trx_sys_mark_upgraded_to_multiple_tablespaces(), trx_sys_update_mysql_binlog_offset(), trx_sysf_create(), trx_undo_empty_header_page(), trx_undo_free_page(), trx_undo_header_add_space_for_xid(), trx_undo_mark_as_dict_operation(), trx_undo_seg_create(), trx_undo_set_state_at_finish(), trx_undo_set_state_at_prepare(), trx_undo_write_xid(), xdes_init(), xdes_set_bit(), and xdes_set_state().

                             : pointer where to write */
        ulint   val,    /* in: value to write */
        byte    type,   /* in: MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES */
        mtr_t*  mtr)    /* in: mini-transaction handle */
{
        byte*   log_ptr;

        if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
                fprintf(stderr,
        "InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
                ut_error;
        }

        if (type == MLOG_1BYTE) {
                mach_write_to_1(ptr, val);
        } else if (type == MLOG_2BYTES) {
                mach_write_to_2(ptr, val);
        } else {
                ut_ad(type == MLOG_4BYTES);
                mach_write_to_4(ptr, val);
        }

        log_ptr = mlog_open(mtr, 11 + 2 + 5);

        /* If no logging is requested, we may return now */
        if (log_ptr == NULL) {

                return;
        }

        log_ptr = mlog_write_initial_log_record_fast(ptr, type, log_ptr, mtr);

        mach_write_to_2(log_ptr, ptr - buf_frame_align(ptr));
        log_ptr += 2;

        log_ptr += mach_write_compressed(log_ptr, val);

        mlog_close(mtr, log_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.