diff options
Diffstat (limited to 'storage/xtradb/include/dict0dict.ic')
| -rw-r--r-- | storage/xtradb/include/dict0dict.ic | 399 |
1 files changed, 210 insertions, 189 deletions
diff --git a/storage/xtradb/include/dict0dict.ic b/storage/xtradb/include/dict0dict.ic index 687e5f9fb13..aada3096261 100644 --- a/storage/xtradb/include/dict0dict.ic +++ b/storage/xtradb/include/dict0dict.ic @@ -16,24 +16,26 @@ Place, Suite 330, Boston, MA 02111-1307 USA *****************************************************************************/ -/********************************************************************** +/******************************************************************//** +@file include/dict0dict.ic Data dictionary system Created 1/8/1996 Heikki Tuuri ***********************************************************************/ +#include "data0type.h" +#ifndef UNIV_HOTBACKUP #include "dict0load.h" #include "rem0types.h" -#include "data0type.h" -/************************************************************************* +/*********************************************************************//** Gets the column data type. */ UNIV_INLINE void dict_col_copy_type( /*===============*/ - const dict_col_t* col, /* in: column */ - dtype_t* type) /* out: data type */ + const dict_col_t* col, /*!< in: column */ + dtype_t* type) /*!< out: data type */ { ut_ad(col && type); @@ -43,17 +45,18 @@ dict_col_copy_type( type->mbminlen = col->mbminlen; type->mbmaxlen = col->mbmaxlen; } +#endif /* !UNIV_HOTBACKUP */ #ifdef UNIV_DEBUG -/************************************************************************* -Assert that a column and a data type match. */ +/*********************************************************************//** +Assert that a column and a data type match. +@return TRUE */ UNIV_INLINE ibool dict_col_type_assert_equal( /*=======================*/ - /* out: TRUE */ - const dict_col_t* col, /* in: column */ - const dtype_t* type) /* in: data type */ + const dict_col_t* col, /*!< in: column */ + const dtype_t* type) /*!< in: data type */ { ut_ad(col); ut_ad(type); @@ -61,83 +64,89 @@ dict_col_type_assert_equal( ut_ad(col->mtype == type->mtype); ut_ad(col->prtype == type->prtype); ut_ad(col->len == type->len); +# ifndef UNIV_HOTBACKUP ut_ad(col->mbminlen == type->mbminlen); ut_ad(col->mbmaxlen == type->mbmaxlen); +# endif /* !UNIV_HOTBACKUP */ return(TRUE); } #endif /* UNIV_DEBUG */ -/*************************************************************************** -Returns the minimum size of the column. */ +#ifndef UNIV_HOTBACKUP +/***********************************************************************//** +Returns the minimum size of the column. +@return minimum size */ UNIV_INLINE ulint dict_col_get_min_size( /*==================*/ - /* out: minimum size */ - const dict_col_t* col) /* in: column */ + const dict_col_t* col) /*!< in: column */ { return(dtype_get_min_size_low(col->mtype, col->prtype, col->len, col->mbminlen, col->mbmaxlen)); } -/*************************************************************************** -Returns the maximum size of the column. */ +/***********************************************************************//** +Returns the maximum size of the column. +@return maximum size */ UNIV_INLINE ulint dict_col_get_max_size( /*==================*/ - /* out: maximum size */ - const dict_col_t* col) /* in: column */ + const dict_col_t* col) /*!< in: column */ { return(dtype_get_max_size_low(col->mtype, col->len)); } -/*************************************************************************** -Returns the size of a fixed size column, 0 if not a fixed size column. */ +#endif /* !UNIV_HOTBACKUP */ +/***********************************************************************//** +Returns the size of a fixed size column, 0 if not a fixed size column. +@return fixed size, or 0 */ UNIV_INLINE ulint dict_col_get_fixed_size( /*====================*/ - /* out: fixed size, or 0 */ - const dict_col_t* col) /* in: column */ + const dict_col_t* col, /*!< in: column */ + ulint comp) /*!< in: nonzero=ROW_FORMAT=COMPACT */ { return(dtype_get_fixed_size_low(col->mtype, col->prtype, col->len, - col->mbminlen, col->mbmaxlen)); + col->mbminlen, col->mbmaxlen, comp)); } -/*************************************************************************** +/***********************************************************************//** Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a column. -For fixed length types it is the fixed length of the type, otherwise 0. */ +For fixed length types it is the fixed length of the type, otherwise 0. +@return SQL null storage size in ROW_FORMAT=REDUNDANT */ UNIV_INLINE ulint dict_col_get_sql_null_size( /*=======================*/ - /* out: SQL null storage size - in ROW_FORMAT=REDUNDANT */ - const dict_col_t* col) /* in: column */ + const dict_col_t* col, /*!< in: column */ + ulint comp) /*!< in: nonzero=ROW_FORMAT=COMPACT */ { - return(dict_col_get_fixed_size(col)); + return(dict_col_get_fixed_size(col, comp)); } -/************************************************************************* -Gets the column number. */ +/*********************************************************************//** +Gets the column number. +@return col->ind, table column position (starting from 0) */ UNIV_INLINE ulint dict_col_get_no( /*============*/ - const dict_col_t* col) + const dict_col_t* col) /*!< in: column */ { ut_ad(col); return(col->ind); } -/************************************************************************* +/*********************************************************************//** Gets the column position in the clustered index. */ UNIV_INLINE ulint dict_col_get_clust_pos( /*===================*/ - const dict_col_t* col, /* in: table column */ - const dict_index_t* clust_index) /* in: clustered index */ + const dict_col_t* col, /*!< in: table column */ + const dict_index_t* clust_index) /*!< in: clustered index */ { ulint i; @@ -156,15 +165,16 @@ dict_col_get_clust_pos( return(ULINT_UNDEFINED); } +#ifndef UNIV_HOTBACKUP #ifdef UNIV_DEBUG -/************************************************************************ -Gets the first index on the table (the clustered index). */ +/********************************************************************//** +Gets the first index on the table (the clustered index). +@return index, NULL if none exists */ UNIV_INLINE dict_index_t* dict_table_get_first_index( /*=======================*/ - /* out: index, NULL if none exists */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); @@ -172,14 +182,14 @@ dict_table_get_first_index( return(UT_LIST_GET_FIRST(((dict_table_t*) table)->indexes)); } -/************************************************************************ -Gets the next index on the table. */ +/********************************************************************//** +Gets the next index on the table. +@return index, NULL if none left */ UNIV_INLINE dict_index_t* dict_table_get_next_index( /*======================*/ - /* out: index, NULL if none left */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -187,31 +197,30 @@ dict_table_get_next_index( return(UT_LIST_GET_NEXT(indexes, (dict_index_t*) index)); } #endif /* UNIV_DEBUG */ +#endif /* !UNIV_HOTBACKUP */ -/************************************************************************ -Check whether the index is the clustered index. */ +/********************************************************************//** +Check whether the index is the clustered index. +@return nonzero for clustered index, zero for other indexes */ UNIV_INLINE ulint dict_index_is_clust( /*================*/ - /* out: nonzero for clustered index, - zero for other indexes */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); return(UNIV_UNLIKELY(index->type & DICT_CLUSTERED)); } -/************************************************************************ -Check whether the index is unique. */ +/********************************************************************//** +Check whether the index is unique. +@return nonzero for unique index, zero for other indexes */ UNIV_INLINE ulint dict_index_is_unique( /*=================*/ - /* out: nonzero for unique index, - zero for other indexes */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -219,15 +228,14 @@ dict_index_is_unique( return(UNIV_UNLIKELY(index->type & DICT_UNIQUE)); } -/************************************************************************ -Check whether the index is the insert buffer tree. */ +/********************************************************************//** +Check whether the index is the insert buffer tree. +@return nonzero for insert buffer, zero for other indexes */ UNIV_INLINE ulint dict_index_is_ibuf( /*===============*/ - /* out: nonzero for insert buffer, - zero for other indexes */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -235,17 +243,34 @@ dict_index_is_ibuf( return(UNIV_UNLIKELY(index->type & DICT_IBUF)); } -/************************************************************************ +/********************************************************************//** +Check whether the index is a secondary index or the insert buffer tree. +@return nonzero for insert buffer, zero for other indexes */ +UNIV_INLINE +ulint +dict_index_is_sec_or_ibuf( +/*======================*/ + const dict_index_t* index) /*!< in: index */ +{ + ulint type; + + ut_ad(index); + ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); + + type = index->type; + + return(UNIV_LIKELY(!(type & DICT_CLUSTERED) || (type & DICT_IBUF))); +} + +/********************************************************************//** Gets the number of user-defined columns in a table in the dictionary -cache. */ +cache. +@return number of user-defined (e.g., not ROW_ID) columns of a table */ UNIV_INLINE ulint dict_table_get_n_user_cols( /*=======================*/ - /* out: number of user-defined - (e.g., not ROW_ID) - columns of a table */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); @@ -253,15 +278,14 @@ dict_table_get_n_user_cols( return(table->n_cols - DATA_N_SYS_COLS); } -/************************************************************************ -Gets the number of system columns in a table in the dictionary cache. */ +/********************************************************************//** +Gets the number of system columns in a table in the dictionary cache. +@return number of system (e.g., ROW_ID) columns of a table */ UNIV_INLINE ulint dict_table_get_n_sys_cols( /*======================*/ - /* out: number of system (e.g., - ROW_ID) columns of a table */ - const dict_table_t* table __attribute__((unused))) /* in: table */ + const dict_table_t* table __attribute__((unused))) /*!< in: table */ { ut_ad(table); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); @@ -270,15 +294,15 @@ dict_table_get_n_sys_cols( return(DATA_N_SYS_COLS); } -/************************************************************************ +/********************************************************************//** Gets the number of all columns (also system) in a table in the dictionary -cache. */ +cache. +@return number of columns of a table */ UNIV_INLINE ulint dict_table_get_n_cols( /*==================*/ - /* out: number of columns of a table */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); @@ -287,15 +311,15 @@ dict_table_get_n_cols( } #ifdef UNIV_DEBUG -/************************************************************************ -Gets the nth column of a table. */ +/********************************************************************//** +Gets the nth column of a table. +@return pointer to column object */ UNIV_INLINE dict_col_t* dict_table_get_nth_col( /*===================*/ - /* out: pointer to column object */ - const dict_table_t* table, /* in: table */ - ulint pos) /* in: position of column */ + const dict_table_t* table, /*!< in: table */ + ulint pos) /*!< in: position of column */ { ut_ad(table); ut_ad(pos < table->n_def); @@ -304,15 +328,15 @@ dict_table_get_nth_col( return((dict_col_t*) (table->cols) + pos); } -/************************************************************************ -Gets the given system column of a table. */ +/********************************************************************//** +Gets the given system column of a table. +@return pointer to column object */ UNIV_INLINE dict_col_t* dict_table_get_sys_col( /*===================*/ - /* out: pointer to column object */ - const dict_table_t* table, /* in: table */ - ulint sys) /* in: DATA_ROW_ID, ... */ + const dict_table_t* table, /*!< in: table */ + ulint sys) /*!< in: DATA_ROW_ID, ... */ { dict_col_t* col; @@ -329,15 +353,15 @@ dict_table_get_sys_col( } #endif /* UNIV_DEBUG */ -/************************************************************************ -Gets the given system column number of a table. */ +/********************************************************************//** +Gets the given system column number of a table. +@return column number */ UNIV_INLINE ulint dict_table_get_sys_col_no( /*======================*/ - /* out: column number */ - const dict_table_t* table, /* in: table */ - ulint sys) /* in: DATA_ROW_ID, ... */ + const dict_table_t* table, /*!< in: table */ + ulint sys) /*!< in: DATA_ROW_ID, ... */ { ut_ad(table); ut_ad(sys < DATA_N_SYS_COLS); @@ -346,15 +370,14 @@ dict_table_get_sys_col_no( return(table->n_cols - DATA_N_SYS_COLS + sys); } -/************************************************************************ -Check whether the table uses the compact page format. */ +/********************************************************************//** +Check whether the table uses the compact page format. +@return TRUE if table uses the compact page format */ UNIV_INLINE ibool dict_table_is_comp( /*===============*/ - /* out: TRUE if table uses the - compact page format */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); @@ -365,28 +388,28 @@ dict_table_is_comp( return(UNIV_LIKELY(table->flags & DICT_TF_COMPACT)); } -/************************************************************************ -Determine the file format of a table. */ +/********************************************************************//** +Determine the file format of a table. +@return file format version */ UNIV_INLINE ulint dict_table_get_format( /*==================*/ - /* out: file format version */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); return((table->flags & DICT_TF_FORMAT_MASK) >> DICT_TF_FORMAT_SHIFT); } -/************************************************************************ +/********************************************************************//** Determine the file format of a table. */ UNIV_INLINE void dict_table_set_format( /*==================*/ - dict_table_t* table, /* in/out: table */ - ulint format) /* in: file format version */ + dict_table_t* table, /*!< in/out: table */ + ulint format) /*!< in: file format version */ { ut_ad(table); @@ -394,15 +417,14 @@ dict_table_set_format( | (format << DICT_TF_FORMAT_SHIFT); } -/************************************************************************ -Extract the compressed page size from table flags. */ +/********************************************************************//** +Extract the compressed page size from table flags. +@return compressed page size, or 0 if not compressed */ UNIV_INLINE ulint dict_table_flags_to_zip_size( /*=========================*/ - /* out: compressed page size, - or 0 if not compressed */ - ulint flags) /* in: flags */ + ulint flags) /*!< in: flags */ { ulint zip_size = flags & DICT_TF_ZSSIZE_MASK; @@ -416,30 +438,29 @@ dict_table_flags_to_zip_size( return(zip_size); } -/************************************************************************ -Check whether the table uses the compressed compact page format. */ +/********************************************************************//** +Check whether the table uses the compressed compact page format. +@return compressed page size, or 0 if not compressed */ UNIV_INLINE ulint dict_table_zip_size( /*================*/ - /* out: compressed page size, - or 0 if not compressed */ - const dict_table_t* table) /* in: table */ + const dict_table_t* table) /*!< in: table */ { ut_ad(table); return(dict_table_flags_to_zip_size(table->flags)); } -/************************************************************************ +/********************************************************************//** Gets the number of fields in the internal representation of an index, -including fields added by the dictionary system. */ +including fields added by the dictionary system. +@return number of fields */ UNIV_INLINE ulint dict_index_get_n_fields( /*====================*/ - /* out: number of fields */ - const dict_index_t* index) /* in: an internal + const dict_index_t* index) /*!< in: an internal representation of index (in the dictionary cache) */ { @@ -449,17 +470,17 @@ dict_index_get_n_fields( return(index->n_fields); } -/************************************************************************ +/********************************************************************//** Gets the number of fields in the internal representation of an index that uniquely determine the position of an index entry in the index, if we do not take multiversioning into account: in the B-tree use the value -returned by dict_index_get_n_unique_in_tree. */ +returned by dict_index_get_n_unique_in_tree. +@return number of fields */ UNIV_INLINE ulint dict_index_get_n_unique( /*====================*/ - /* out: number of fields */ - const dict_index_t* index) /* in: an internal representation + const dict_index_t* index) /*!< in: an internal representation of index (in the dictionary cache) */ { ut_ad(index); @@ -469,16 +490,16 @@ dict_index_get_n_unique( return(index->n_uniq); } -/************************************************************************ +/********************************************************************//** Gets the number of fields in the internal representation of an index which uniquely determine the position of an index entry in the index, if -we also take multiversioning into account. */ +we also take multiversioning into account. +@return number of fields */ UNIV_INLINE ulint dict_index_get_n_unique_in_tree( /*============================*/ - /* out: number of fields */ - const dict_index_t* index) /* in: an internal representation + const dict_index_t* index) /*!< in: an internal representation of index (in the dictionary cache) */ { ut_ad(index); @@ -493,32 +514,32 @@ dict_index_get_n_unique_in_tree( return(dict_index_get_n_fields(index)); } -/************************************************************************ +/********************************************************************//** Gets the number of user-defined ordering fields in the index. In the internal representation of clustered indexes we add the row id to the ordering fields to make a clustered index unique, but this function returns the number of -fields the user defined in the index as ordering fields. */ +fields the user defined in the index as ordering fields. +@return number of fields */ UNIV_INLINE ulint dict_index_get_n_ordering_defined_by_user( /*======================================*/ - /* out: number of fields */ - const dict_index_t* index) /* in: an internal representation + const dict_index_t* index) /*!< in: an internal representation of index (in the dictionary cache) */ { return(index->n_user_defined_cols); } #ifdef UNIV_DEBUG -/************************************************************************ -Gets the nth field of an index. */ +/********************************************************************//** +Gets the nth field of an index. +@return pointer to field object */ UNIV_INLINE dict_field_t* dict_index_get_nth_field( /*=====================*/ - /* out: pointer to field object */ - const dict_index_t* index, /* in: index */ - ulint pos) /* in: position of field */ + const dict_index_t* index, /*!< in: index */ + ulint pos) /*!< in: position of field */ { ut_ad(index); ut_ad(pos < index->n_def); @@ -528,16 +549,15 @@ dict_index_get_nth_field( } #endif /* UNIV_DEBUG */ -/************************************************************************ -Returns the position of a system column in an index. */ +/********************************************************************//** +Returns the position of a system column in an index. +@return position, ULINT_UNDEFINED if not contained */ UNIV_INLINE ulint dict_index_get_sys_col_pos( /*=======================*/ - /* out: position, - ULINT_UNDEFINED if not contained */ - const dict_index_t* index, /* in: index */ - ulint type) /* in: DATA_ROW_ID, ... */ + const dict_index_t* index, /*!< in: index */ + ulint type) /*!< in: DATA_ROW_ID, ... */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -554,53 +574,55 @@ dict_index_get_sys_col_pos( index, dict_table_get_sys_col_no(index->table, type))); } -/************************************************************************* -Gets the field column. */ +/*********************************************************************//** +Gets the field column. +@return field->col, pointer to the table column */ UNIV_INLINE const dict_col_t* dict_field_get_col( /*===============*/ - const dict_field_t* field) + const dict_field_t* field) /*!< in: index field */ { ut_ad(field); return(field->col); } -/************************************************************************ -Gets pointer to the nth column in an index. */ +/********************************************************************//** +Gets pointer to the nth column in an index. +@return column */ UNIV_INLINE const dict_col_t* dict_index_get_nth_col( /*===================*/ - /* out: column */ - const dict_index_t* index, /* in: index */ - ulint pos) /* in: position of the field */ + const dict_index_t* index, /*!< in: index */ + ulint pos) /*!< in: position of the field */ { return(dict_field_get_col(dict_index_get_nth_field(index, pos))); } -/************************************************************************ -Gets the column number the nth field in an index. */ +/********************************************************************//** +Gets the column number the nth field in an index. +@return column number */ UNIV_INLINE ulint dict_index_get_nth_col_no( /*======================*/ - /* out: column number */ - const dict_index_t* index, /* in: index */ - ulint pos) /* in: position of the field */ + const dict_index_t* index, /*!< in: index */ + ulint pos) /*!< in: position of the field */ { return(dict_col_get_no(dict_index_get_nth_col(index, pos))); } -/************************************************************************ -Returns the minimum data size of an index record. */ +#ifndef UNIV_HOTBACKUP +/********************************************************************//** +Returns the minimum data size of an index record. +@return minimum data size in bytes */ UNIV_INLINE ulint dict_index_get_min_size( /*====================*/ - /* out: minimum data size in bytes */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ulint n = dict_index_get_n_fields(index); ulint size = 0; @@ -613,14 +635,14 @@ dict_index_get_min_size( return(size); } -/************************************************************************* -Gets the space id of the root of the index tree. */ +/*********************************************************************//** +Gets the space id of the root of the index tree. +@return space id */ UNIV_INLINE ulint dict_index_get_space( /*=================*/ - /* out: space id */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -628,14 +650,14 @@ dict_index_get_space( return(index->space); } -/************************************************************************* +/*********************************************************************//** Sets the space id of the root of the index tree. */ UNIV_INLINE void dict_index_set_space( /*=================*/ - dict_index_t* index, /* in/out: index */ - ulint space) /* in: space id */ + dict_index_t* index, /*!< in/out: index */ + ulint space) /*!< in: space id */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -643,14 +665,14 @@ dict_index_set_space( index->space = space; } -/************************************************************************* -Gets the page number of the root of the index tree. */ +/*********************************************************************//** +Gets the page number of the root of the index tree. +@return page number */ UNIV_INLINE ulint dict_index_get_page( /*================*/ - /* out: page number */ - const dict_index_t* index) /* in: index */ + const dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -658,14 +680,14 @@ dict_index_get_page( return(index->page); } -/************************************************************************* +/*********************************************************************//** Sets the page number of the root of index tree. */ UNIV_INLINE void dict_index_set_page( /*================*/ - dict_index_t* index, /* in/out: index */ - ulint page) /* in: page number */ + dict_index_t* index, /*!< in/out: index */ + ulint page) /*!< in: page number */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -673,14 +695,14 @@ dict_index_set_page( index->page = page; } -/************************************************************************* -Gets the read-write lock of the index tree. */ +/*********************************************************************//** +Gets the read-write lock of the index tree. +@return read-write lock */ UNIV_INLINE rw_lock_t* dict_index_get_lock( /*================*/ - /* out: read-write lock */ - dict_index_t* index) /* in: index */ + dict_index_t* index) /*!< in: index */ { ut_ad(index); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -688,28 +710,27 @@ dict_index_get_lock( return(&(index->lock)); } -/************************************************************************ +/********************************************************************//** Returns free space reserved for future updates of records. This is relevant only in the case of many consecutive inserts, as updates -which make the records bigger might fragment the index. */ +which make the records bigger might fragment the index. +@return number of free bytes on page, reserved for updates */ UNIV_INLINE ulint dict_index_get_space_reserve(void) /*==============================*/ - /* out: number of free bytes on page, - reserved for updates */ { return(UNIV_PAGE_SIZE / 16); } -/************************************************************************** -Checks if a table is in the dictionary cache. */ +/**********************************************************************//** +Checks if a table is in the dictionary cache. +@return table, NULL if not found */ UNIV_INLINE dict_table_t* dict_table_check_if_in_cache_low( /*=============================*/ - /* out: table, NULL if not found */ - const char* table_name) /* in: table name */ + const char* table_name) /*!< in: table name */ { dict_table_t* table; ulint table_fold; @@ -733,15 +754,15 @@ dict_table_check_if_in_cache_low( return(table); } -/************************************************************************** +/**********************************************************************//** Gets a table; loads it to the dictionary cache if necessary. A low-level -function. */ +function. +@return table, NULL if not found */ UNIV_INLINE dict_table_t* dict_table_get_low( /*===============*/ - /* out: table, NULL if not found */ - const char* table_name) /* in: table name */ + const char* table_name) /*!< in: table name */ { dict_table_t* table; @@ -759,14 +780,14 @@ dict_table_get_low( return(table); } -/************************************************************************** -Returns a table object based on table id. */ +/**********************************************************************//** +Returns a table object based on table id. +@return table, NULL if does not exist */ UNIV_INLINE dict_table_t* dict_table_get_on_id_low( /*=====================*/ - /* out: table, NULL if does not exist */ - dulint table_id) /* in: table id */ + dulint table_id) /*!< in: table id */ { dict_table_t* table; ulint fold; @@ -795,4 +816,4 @@ dict_table_get_on_id_low( return(table); } - +#endif /* !UNIV_HOTBACKUP */ |