mariadb/storage/innobase/include/dict0pagecompress.ic

/*****************************************************************************

Copyright (C) 2013 SkySQL Ab. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

*****************************************************************************/

/******************************************************************//**
@file include/dict0pagecompress.ic
Inline implementation for helper functions for extracting/storing
page compression and atomic writes information to dictionary.

Created 11/12/2013 Jan Lindström jan.lindstrom@skysql.com
***********************************************************************/

/********************************************************************//**
Verify that dictionary flags match tablespace flags
@return	true if flags match, false if not */
UNIV_INLINE
ibool
dict_tf_verify_flags(
/*=================*/
	ulint	table_flags,	/*!< in: dict_table_t::flags */
	ulint   fsp_flags)      /*!< in: fil_space_t::flags  */
{
	ulint   table_unused = DICT_TF_GET_UNUSED(table_flags);
	ulint   compact = DICT_TF_GET_COMPACT(table_flags);
	ulint   ssize = DICT_TF_GET_ZIP_SSIZE(table_flags);
	ulint	atomic_blobs = DICT_TF_HAS_ATOMIC_BLOBS(table_flags);
	ulint   data_dir = DICT_TF_HAS_DATA_DIR(table_flags);
        ulint   page_compression = DICT_TF_GET_PAGE_COMPRESSION(table_flags);
	ulint   page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(table_flags);
	ulint   atomic_writes = DICT_TF_GET_ATOMIC_WRITES(table_flags);
	ulint   page_encryption = DICT_TF_GET_PAGE_ENCRYPTION(table_flags);
	ulint   page_encryption_key = DICT_TF_GET_PAGE_ENCRYPTION_KEY(table_flags);
	ulint	post_antelope = FSP_FLAGS_GET_POST_ANTELOPE(fsp_flags);
	ulint	zip_ssize = FSP_FLAGS_GET_ZIP_SSIZE(fsp_flags);
	ulint	fsp_atomic_blobs = FSP_FLAGS_HAS_ATOMIC_BLOBS(fsp_flags);
	ulint	page_ssize = FSP_FLAGS_GET_PAGE_SSIZE(fsp_flags);
	ulint	fsp_unused = FSP_FLAGS_GET_UNUSED(fsp_flags);
        ulint   fsp_page_compression = FSP_FLAGS_GET_PAGE_COMPRESSION(fsp_flags);
	ulint   fsp_page_compression_level = FSP_FLAGS_GET_PAGE_COMPRESSION_LEVEL(fsp_flags);
	ulint   fsp_atomic_writes = FSP_FLAGS_GET_ATOMIC_WRITES(fsp_flags);
        ulint   fsp_page_encryption = FSP_FLAGS_GET_PAGE_ENCRYPTION(fsp_flags);
        ulint   fsp_page_encryption_key = FSP_FLAGS_GET_PAGE_ENCRYPTION_KEY(fsp_flags);


	DBUG_EXECUTE_IF("dict_tf_verify_flags_failure",
			return(ULINT_UNDEFINED););

	ut_a(!table_unused);
	ut_a(!fsp_unused);
	ut_a(page_ssize == 0 || page_ssize != 0); /* silence compiler */
	ut_a(compact == 0 || compact == 1); /* silence compiler */
	ut_a(data_dir == 0 || data_dir == 1); /* silence compiler */
	ut_a(post_antelope == 0 || post_antelope == 1); /* silence compiler */

	if (ssize != zip_ssize) {
		fprintf(stderr,
			"InnoDB: Error: table flags has zip_ssize %ld"
			" in the data dictionary\n"
			"InnoDB: but the flags in file has zip_ssize %ld\n",
			ssize, zip_ssize);
		return (FALSE);
	}
	if (atomic_blobs != fsp_atomic_blobs) {
		fprintf(stderr,
			"InnoDB: Error: table flags has atomic_blobs %ld"
			" in the data dictionary\n"
			"InnoDB: but the flags in file has atomic_blobs %ld\n",
			atomic_blobs, fsp_atomic_blobs);

		return (FALSE);
	}
	if (page_compression != fsp_page_compression) {
		fprintf(stderr,
			"InnoDB: Error: table flags has page_compression %ld"
			" in the data dictionary\n"
			"InnoDB: but the flags in file ahas page_compression %ld\n",
			page_compression, fsp_page_compression);

		return (FALSE);
	}
	if (page_compression_level != fsp_page_compression_level) {
		fprintf(stderr,
			"InnoDB: Error: table flags has page_compression_level %ld"
			" in the data dictionary\n"
			"InnoDB: but the flags in file has page_compression_level %ld\n",
			page_compression_level, fsp_page_compression_level);

		return (FALSE);
	}

	if (atomic_writes != fsp_atomic_writes) {
		fprintf(stderr,
			"InnoDB: Error: table flags has atomic writes %ld"
			" in the data dictionary\n"
			"InnoDB: but the flags in file has atomic_writes %ld\n",
			atomic_writes, fsp_atomic_writes);

		return (FALSE);
	}

        if (page_encryption != fsp_page_encryption) {
                fprintf(stderr,
                        "InnoDB: Error: table flags has page_encryption %ld"
                        " in the data dictionary\n"
                        "InnoDB: but the flags in file has page_encryption %ld\n",
                        page_encryption, fsp_page_encryption);

                return (FALSE);
        }

        if (page_encryption_key != fsp_page_encryption_key) {
                fprintf(stderr,
                        "InnoDB: Error: table flags has page_encryption_key %ld"
                        " in the data dictionary\n"
                        "InnoDB: but the flags in file has page_encryption_key %ld\n",
                        page_encryption_key, fsp_page_encryption_key);

                return (FALSE);
        }


	return(TRUE);
}

/********************************************************************//**
Extract the page compression level from dict_table_t::flags.
These flags are in memory, so assert that they are valid.
@return	page compression level, or 0 if not compressed */
UNIV_INLINE
ulint
dict_tf_get_page_compression_level(
/*===============================*/
	ulint	flags)	/*!< in: flags */
{
        ulint page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(flags);

	ut_ad(page_compression_level <= 9);

	return(page_compression_level);
}

/********************************************************************//**
Check whether the table uses the page compression page format.
@return	page compression level, or 0 if not compressed */
UNIV_INLINE
ulint
dict_table_page_compression_level(
/*==============================*/
	const dict_table_t*	table)	/*!< in: table */
{
	ut_ad(table);
	ut_ad(dict_tf_get_page_compression(table->flags));

	return(dict_tf_get_page_compression_level(table->flags));
}

/********************************************************************//**
Check whether the table uses the page compression page format.
@return	true if page compressed, false if not */
UNIV_INLINE
ibool
dict_tf_get_page_compression(
/*=========================*/
	ulint	flags)	/*!< in: flags */
{
	return(DICT_TF_GET_PAGE_COMPRESSION(flags));
}

/********************************************************************//**
Check whether the table uses the page compression page format.
@return	true if page compressed, false if not */
UNIV_INLINE
ibool
dict_table_is_page_compressed(
/*==========================*/
	const dict_table_t* table)	/*!< in: table */
{
	return (dict_tf_get_page_compression(table->flags));
}

/********************************************************************//**
Extract the atomic writes flag from table flags.
@return	enumerated value of atomic writes  */
UNIV_INLINE
atomic_writes_t
dict_tf_get_atomic_writes(
/*======================*/
	ulint	flags)			/*!< in: flags */
{
	return((atomic_writes_t)DICT_TF_GET_ATOMIC_WRITES(flags));
}

/********************************************************************//**
Check whether the table uses the atomic writes.
@return	enumerated value of atomic writes */
UNIV_INLINE
atomic_writes_t
dict_table_get_atomic_writes(
/*=========================*/
	const dict_table_t* table)	/*!< in: table */
{
	return ((atomic_writes_t)dict_tf_get_atomic_writes(table->flags));
}