#include "mtr0types.h"
#include "page0types.h"
#include "buf0types.h"
#include "dict0types.h"
#include "srv0srv.h"
#include "trx0types.h"
#include "mem0mem.h"
#include "page0zip.ic"

Include dependency graph for page0zip.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEFAULT_COMPRESSION_LEVEL 6
#define	PAGE_ZIP_MATCH(ptr, page_zip)

Functions
UNIV_INLINE ulint	page_zip_get_size (const page_zip_des_t *page_zip))
UNIV_INLINE void	page_zip_set_size (page_zip_des_t *page_zip, ulint size)
UNIV_INLINE ibool	page_zip_rec_needs_ext (ulint rec_size, ulint comp, ulint n_fields, ulint zip_size))
UNIV_INTERN ulint	page_zip_empty_size (ulint n_fields, ulint zip_size))
UNIV_INLINE void	page_zip_des_init (page_zip_des_t *page_zip)
UNIV_INTERN void	page_zip_set_alloc (void stream, mem_heap_t heap)
UNIV_INTERN ibool	page_zip_compress (page_zip_des_t page_zip, const page_t page, dict_index_t index, ulint level, mtr_t mtr)))
UNIV_INTERN ibool	page_zip_decompress (page_zip_des_t page_zip, page_t page, ibool all)))
UNIV_INLINE ibool	page_zip_simple_validate (const page_zip_des_t *page_zip)
UNIV_INLINE lint	page_zip_max_ins_size (const page_zip_des_t *page_zip, ibool is_clust))
UNIV_INLINE ibool	page_zip_available (const page_zip_des_t *page_zip, ibool is_clust, ulint length, ulint create))
UNIV_INLINE void	page_zip_write_header (page_zip_des_t page_zip, const byte str, ulint length, mtr_t *mtr)))
UNIV_INTERN void	page_zip_write_rec (page_zip_des_t page_zip, const byte rec, dict_index_t index, const ulint offsets, ulint create))
UNIV_INTERN byte *	page_zip_parse_write_blob_ptr (byte ptr, byte end_ptr, page_t page, page_zip_des_t page_zip)
UNIV_INTERN void	page_zip_write_blob_ptr (page_zip_des_t page_zip, const byte rec, dict_index_t index, const ulint offsets, ulint n, mtr_t *mtr)))
UNIV_INTERN byte *	page_zip_parse_write_node_ptr (byte ptr, byte end_ptr, page_t page, page_zip_des_t page_zip)
UNIV_INTERN void	page_zip_write_node_ptr (page_zip_des_t page_zip, byte rec, ulint size, ulint ptr, mtr_t *mtr)))
UNIV_INTERN void	page_zip_write_trx_id_and_roll_ptr (page_zip_des_t page_zip, byte rec, const ulint *offsets, ulint trx_id_col, trx_id_t trx_id, roll_ptr_t roll_ptr))
UNIV_INTERN void	page_zip_rec_set_deleted (page_zip_des_t page_zip, const byte rec, ulint flag))
UNIV_INTERN void	page_zip_rec_set_owned (page_zip_des_t page_zip, const byte rec, ulint flag))
UNIV_INTERN void	page_zip_dir_insert (page_zip_des_t page_zip, const byte prev_rec, const byte free_rec, byte rec)
UNIV_INTERN void	page_zip_dir_delete (page_zip_des_t page_zip, byte rec, const dict_index_t index, const ulint offsets, const byte *free)))
UNIV_INTERN void	page_zip_dir_add_slot (page_zip_des_t *page_zip, ulint is_clustered))
UNIV_INTERN byte *	page_zip_parse_write_header (byte ptr, byte end_ptr, page_t page, page_zip_des_t page_zip)
UNIV_INTERN ibool	page_zip_reorganize (buf_block_t block, dict_index_t index, mtr_t *mtr))
UNIV_INTERN void	page_zip_copy_recs (page_zip_des_t page_zip, page_t page, const page_zip_des_t src_zip, const page_t src, dict_index_t index, mtr_t mtr))
UNIV_INTERN byte *	page_zip_parse_compress (byte ptr, byte end_ptr, page_t page, page_zip_des_t page_zip)))
UNIV_INTERN ulint	page_zip_calc_checksum (const void *data, ulint size, srv_checksum_algorithm_t algo))
UNIV_INTERN ibool	page_zip_verify_checksum (const void *data, ulint size)
UNIV_INLINE void	page_zip_compress_write_log_no_data (ulint level, const page_t page, dict_index_t index, mtr_t *mtr)
UNIV_INLINE byte *	page_zip_parse_compress_no_data (byte ptr, byte end_ptr, page_t page, page_zip_des_t page_zip, dict_index_t *index)))
UNIV_INLINE void	page_zip_reset_stat_per_index ()

Variables
uint	page_zip_level
my_bool	page_zip_log_pages

Detailed Description

Compressed page interface

Created June 2005 by Marko Makela

Macro Definition Documentation

#define PAGE_ZIP_MATCH	(	ptr,
		page_zip
	)

Value:

(((page_zip)->m_external                                        \
          && (page_align(ptr) + UNIV_PAGE_SIZE == (page_zip)->data))    \
          || buf_frame_get_page_zip(ptr) == (page_zip))

Check if a pointer to an uncompressed page matches a compressed page.

When we IMPORT a tablespace the blocks and accompanying frames are allocted from outside the buffer pool.

Parameters

ptr	pointer to an uncompressed page frame
page_zip	compressed page descriptor

Returns: TRUE if ptr and page_zip refer to the same block

Function Documentation

UNIV_INLINE ibool page_zip_available	(	const page_zip_des_t *	page_zip,
		ibool	is_clust,
		ulint	length,
		ulint	create
	)

Determine if enough space is available in the modification log.

Returns: TRUE if page_zip_write_rec() will succeed

Determine if enough space is available in the modification log.

Returns: TRUE if enough space is available

Parameters

page_zip	in: compressed page
is_clust	in: TRUE if clustered index
length	in: combined size of the record
create	in: nonzero=add the record to the heap

UNIV_INTERN ulint page_zip_calc_checksum	(	const void *	data,
		ulint	size,
		srv_checksum_algorithm_t	algo
	)

Calculate the compressed page checksum.

Returns: page checksum

Parameters

data	in: compressed page
size	in: size of compressed page
algo	in: algorithm to use

UNIV_INTERN ibool page_zip_compress	(	page_zip_des_t *	page_zip,
		const page_t *	page,
		dict_index_t *	index,
		ulint	level,
		mtr_t *	mtr
	)

Compress a page.

Returns: TRUE on success, FALSE on failure; page_zip will be left intact on failure.

Parameters

page_zip	in: size; out: data, n_blobs, m_start, m_end, m_nonempty
page	in: uncompressed page
index	in: index of the B-tree node
level	in: compression level
mtr	in: mini-transaction, or NULL

UNIV_INLINE void page_zip_compress_write_log_no_data	(	ulint	level,
		const page_t *	page,
		dict_index_t *	index,
		mtr_t *	mtr
	)

Write a log record of compressing an index page without the data on the page. in: mtr

Write a log record of compressing an index page without the data on the page.

Parameters

level	in: compression level
page	in: page that is compressed
index	in: index
mtr	in: mtr

UNIV_INTERN void page_zip_copy_recs	(	page_zip_des_t *	page_zip,
		page_t *	page,
		const page_zip_des_t *	src_zip,
		const page_t *	src,
		dict_index_t *	index,
		mtr_t *	mtr
	)

Copy the records of a page byte for byte. Do not copy the page header or trailer, except those B-tree header fields that are directly related to the storage of records. Also copy PAGE_MAX_TRX_ID. NOTE: The caller must update the lock table and the adaptive hash index.

Parameters

page_zip	out: copy of src_zip (n_blobs, m_start, m_end, m_nonempty, data[0..size-1])
page	out: copy of src
src_zip	in: compressed page
src	in: page
index	in: index of the B-tree
mtr	in: mini-transaction

UNIV_INTERN ibool page_zip_decompress	(	page_zip_des_t *	page_zip,
		page_t *	page,
		ibool	all
	)

Decompress a page. This function should tolerate errors on the compressed page. Instead of letting assertions fail, it will return FALSE if an inconsistency is detected.

Returns: TRUE on success, FALSE on failure

Parameters

page_zip	in: data, ssize; out: m_start, m_end, m_nonempty, n_blobs
page	out: uncompressed page, may be trashed
all	in: TRUE=decompress the whole page; FALSE=verify but do not copy some page header fields that should not change after page creation

UNIV_INLINE void page_zip_des_init ( page_zip_des_t * page_zip )

Initialize a compressed page descriptor. in/out: compressed page descriptor

Initialize a compressed page descriptor.

Parameters

page_zip in/out: compressed page descriptor

UNIV_INTERN void page_zip_dir_add_slot	(	page_zip_des_t *	page_zip,
		ulint	is_clustered
	)

Add a slot to the dense page directory.

Parameters

page_zip	in/out: compressed page
is_clustered	in: nonzero for clustered index, zero for others

UNIV_INTERN void page_zip_dir_delete	(	page_zip_des_t *	page_zip,
		byte *	rec,
		const dict_index_t *	index,
		const ulint *	offsets,
		const byte *	free
	)

Shift the dense page directory and the array of BLOB pointers when a record is deleted.

Parameters

page_zip	in/out: compressed page
rec	in: deleted record
index	in: index of rec
offsets	in: rec_get_offsets(rec)
free	in: previous start of the free list

UNIV_INTERN void page_zip_dir_insert	(	page_zip_des_t *	page_zip,
		const byte *	prev_rec,
		const byte *	free_rec,
		byte *	rec
	)

Insert a record to the dense page directory. in: record to insert

Parameters

page_zip	in/out: compressed page
prev_rec	in: record after which to insert
free_rec	in: record from which rec was allocated, or NULL

UNIV_INTERN ulint page_zip_empty_size	(	ulint	n_fields,
		ulint	zip_size
	)

Determine the guaranteed free space on an empty page.

Returns: minimum payload size on the page

Parameters

n_fields	in: number of columns in the index
zip_size	in: compressed page size in bytes

UNIV_INLINE ulint page_zip_get_size ( const page_zip_des_t * page_zip )

Determine the size of a compressed page in bytes.

Returns: size in bytes

Parameters

page_zip in: compressed page

UNIV_INLINE lint page_zip_max_ins_size	(	const page_zip_des_t *	page_zip,
		ibool	is_clust
	)

Determine how big record can be inserted without recompressing the page.

Returns: a positive number indicating the maximum size of a record whose insertion is guaranteed to succeed, or zero or negative

Parameters

page_zip	in: compressed page
is_clust	in: TRUE if clustered index

UNIV_INTERN byte* page_zip_parse_compress	(	byte *	ptr,
		byte *	end_ptr,
		page_t *	page,
		page_zip_des_t *	page_zip
	)

Parses a log record of compressing an index page.

Returns: end of log record or NULL

Parameters

ptr	in: buffer
end_ptr	in: buffer end
page	out: uncompressed page
page_zip	out: compressed page

UNIV_INLINE byte* page_zip_parse_compress_no_data	(	byte *	ptr,
		byte *	end_ptr,
		page_t *	page,
		page_zip_des_t *	page_zip,
		dict_index_t *	index
	)

Parses a log record of compressing an index page without the data.

Returns: end of log record or NULL

Parameters

ptr	in: buffer
end_ptr	in: buffer end
page	in: uncompressed page
page_zip	out: compressed page
index	in: index

UNIV_INTERN byte* page_zip_parse_write_blob_ptr	(	byte *	ptr,
		byte *	end_ptr,
		page_t *	page,
		page_zip_des_t *	page_zip
	)

Parses a log record of writing a BLOB pointer of a record.

Returns: end of log record or NULL in/out: compressed page

Parameters

ptr	in: redo log buffer
end_ptr	in: redo log buffer end
page	in/out: uncompressed page

UNIV_INTERN byte* page_zip_parse_write_header	(	byte *	ptr,
		byte *	end_ptr,
		page_t *	page,
		page_zip_des_t *	page_zip
	)

Parses a log record of writing to the header of a page.

Returns: end of log record or NULL in/out: compressed page

Parameters

ptr	in: redo log buffer
end_ptr	in: redo log buffer end
page	in/out: uncompressed page

UNIV_INTERN byte* page_zip_parse_write_node_ptr	(	byte *	ptr,
		byte *	end_ptr,
		page_t *	page,
		page_zip_des_t *	page_zip
	)

Parses a log record of writing the node pointer of a record.

Returns: end of log record or NULL in/out: compressed page

Parameters

ptr	in: redo log buffer
end_ptr	in: redo log buffer end
page	in/out: uncompressed page

UNIV_INLINE ibool page_zip_rec_needs_ext	(	ulint	rec_size,
		ulint	comp,
		ulint	n_fields,
		ulint	zip_size
	)

Determine if a record is so big that it needs to be stored externally.

Returns: FALSE if the entire record can be stored locally on the page

Parameters

rec_size	in: length of the record in bytes
comp	in: nonzero=compact format
n_fields	in: number of fields in the record; ignored if zip_size == 0
zip_size	in: compressed page size in bytes, or 0

UNIV_INTERN void page_zip_rec_set_deleted	(	page_zip_des_t *	page_zip,
		const byte *	rec,
		ulint	flag
	)

Write the "deleted" flag of a record on a compressed page. The flag must already have been written on the uncompressed page.

Parameters

page_zip	in/out: compressed page
rec	in: record on the uncompressed page
flag	in: the deleted flag (nonzero=TRUE)

UNIV_INTERN void page_zip_rec_set_owned	(	page_zip_des_t *	page_zip,
		const byte *	rec,
		ulint	flag
	)

Write the "owned" flag of a record on a compressed page. The n_owned field must already have been written on the uncompressed page.

Parameters

page_zip	in/out: compressed page
rec	in: record on the uncompressed page
flag	in: the owned flag (nonzero=TRUE)

UNIV_INTERN ibool page_zip_reorganize	(	buf_block_t *	block,
		dict_index_t *	index,
		mtr_t *	mtr
	)

Reorganize and compress a page. This is a low-level operation for compressed pages, to be used when page_zip_compress() fails. On success, a redo log entry MLOG_ZIP_PAGE_COMPRESS will be written. The function btr_page_reorganize() should be preferred whenever possible. IMPORTANT: if page_zip_reorganize() is invoked on a leaf page of a non-clustered index, the caller must update the insert buffer free bits in the same mini-transaction in such a way that the modification will be redo-logged.

Returns: TRUE on success, FALSE on failure; page_zip will be left intact on failure, but page will be overwritten.

Parameters

block	in/out: page with compressed page; on the compressed page, in: size; out: data, n_blobs, m_start, m_end, m_nonempty
index	in: index of the B-tree node
mtr	in: mini-transaction

UNIV_INLINE void page_zip_reset_stat_per_index ( )

Reset the counters used for filling INFORMATION_SCHEMA.innodb_cmp_per_index.

UNIV_INTERN void page_zip_set_alloc	(	void *	stream,
		mem_heap_t *	heap
	)

Configure the zlib allocator to use the given memory heap. in: memory heap to use

Parameters

stream in/out: zlib stream

UNIV_INLINE void page_zip_set_size	(	page_zip_des_t *	page_zip,
		ulint	size
	)

Set the size of a compressed page in bytes. in: size in bytes

Set the size of a compressed page in bytes.

Parameters

page_zip	in/out: compressed page
size	in: size in bytes

UNIV_INLINE ibool page_zip_simple_validate ( const page_zip_des_t * page_zip )

Validate a compressed page descriptor.

Returns: TRUE if ok in: compressed page descriptor

Validate a compressed page descriptor.

Returns: TRUE if ok

Parameters

page_zip in: compressed page descriptor

UNIV_INTERN ibool page_zip_verify_checksum	(	const void *	data,
		ulint	size
	)

Verify a compressed page's checksum.

Returns: TRUE if the stored checksum is valid according to the value of innodb_checksum_algorithm in: size of compressed page

Parameters

data	in: compressed page

UNIV_INTERN void page_zip_write_blob_ptr	(	page_zip_des_t *	page_zip,
		const byte *	rec,
		dict_index_t *	index,
		const ulint *	offsets,
		ulint	n,
		mtr_t *	mtr
	)

Write a BLOB pointer of a record on the leaf page of a clustered index. The information must already have been updated on the uncompressed page.

Parameters

page_zip	in/out: compressed page
rec	in/out: record whose data is being written
index	in: index of the page
offsets	in: rec_get_offsets(rec, index)
n	in: column index
mtr	in: mini-transaction handle, or NULL if no logging is needed

UNIV_INLINE void page_zip_write_header	(	page_zip_des_t *	page_zip,
		const byte *	str,
		ulint	length,
		mtr_t *	mtr
	)

Write data to the uncompressed header portion of a page. The data must already have been written to the uncompressed page.

Write data to the uncompressed header portion of a page. The data must already have been written to the uncompressed page. However, the data portion of the uncompressed page may differ from the compressed page when a record is being inserted in page_cur_insert_rec_low().

Write data to the uncompressed header portion of a page. The data must already have been written to the uncompressed page. However, the data portion of the uncompressed page may differ from the compressed page when a record is being inserted in page_cur_insert_rec_zip().

Parameters

page_zip	in/out: compressed page
str	in: address on the uncompressed page
length	in: length of the data
mtr	in: mini-transaction, or NULL

UNIV_INTERN void page_zip_write_node_ptr	(	page_zip_des_t *	page_zip,
		byte *	rec,
		ulint	size,
		ulint	ptr,
		mtr_t *	mtr
	)

Write the node pointer of a record on a non-leaf compressed page.

Parameters

page_zip	in/out: compressed page
rec	in/out: record
size	in: data size of rec
ptr	in: node pointer
mtr	in: mini-transaction, or NULL

UNIV_INTERN void page_zip_write_rec	(	page_zip_des_t *	page_zip,
		const byte *	rec,
		dict_index_t *	index,
		const ulint *	offsets,
		ulint	create
	)

Write an entire record on the compressed page. The data must already have been written to the uncompressed page.

Parameters

page_zip	in/out: compressed page
rec	in: record being written
index	in: the index the record belongs to
offsets	in: rec_get_offsets(rec, index)
create	in: nonzero=insert, zero=update

UNIV_INTERN void page_zip_write_trx_id_and_roll_ptr	(	page_zip_des_t *	page_zip,
		byte *	rec,
		const ulint *	offsets,
		ulint	trx_id_col,
		trx_id_t	trx_id,
		roll_ptr_t	roll_ptr
	)

Write the trx_id and roll_ptr of a record on a B-tree leaf node page.

Parameters

page_zip	in/out: compressed page
rec	in/out: record
offsets	in: rec_get_offsets(rec, index)
trx_id_col	in: column number of TRX_ID in rec
trx_id	in: transaction identifier
roll_ptr	in: roll_ptr

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

Function Documentation