List:Commits« Previous MessageNext Message »
From:marko.makela Date:March 29 2012 12:30pm
Subject:bzr push into mysql-trunk branch (marko.makela:3876 to 3878)
View as plain text  
 3878 Marko Mäkelä	2012-03-29
      Fix attributes on function prototypes.

    modified:
      storage/innobase/include/dict0dict.h
 3877 Marko Mäkelä	2012-03-29
      Re-enable innodb-index-online.test on Valgrind.
      This should have been done when fixing Bug#13875241.

    modified:
      mysql-test/suite/innodb/t/innodb-index-online.test
 3876 Andrei Elkin	2012-03-29
      omitted opt file to a test for bug12995174 is added.

    added:
      mysql-test/suite/rpl/t/rpl_parallel_change_master-slave.opt
=== modified file 'mysql-test/suite/innodb/t/innodb-index-online.test'
--- a/mysql-test/suite/innodb/t/innodb-index-online.test	revid:andrei.elkin@stripped9114802-ffi5jek42g37seg7
+++ b/mysql-test/suite/innodb/t/innodb-index-online.test	revid:marko.makela@stripped120329122927-0utcgxgnh1c24z3m
@@ -1,7 +1,5 @@
 --source include/have_innodb.inc
 --source include/have_debug_sync.inc
-# Temporarily prohibit Valgrind runs until Bug#13875241 is resolved
---source include/not_valgrind.inc
 
 call mtr.add_suppression("InnoDB: Warning: Small buffer pool size");
 # These will be triggered by INSERT INTO t1 VALUES(6,3,1);

=== modified file 'storage/innobase/include/dict0dict.h'
--- a/storage/innobase/include/dict0dict.h	revid:andrei.elkin@strippedeg7
+++ b/storage/innobase/include/dict0dict.h	revid:marko.makela@stripped
@@ -51,7 +51,8 @@ UNIV_INTERN
 void
 dict_casedn_str(
 /*============*/
-	char*	a);	/*!< in/out: string to put in lower case */
+	char*	a)	/*!< in/out: string to put in lower case */
+	__attribute__((nonnull));
 /********************************************************************//**
 Get the database name length in a table name.
 @return	database name length */
@@ -59,17 +60,19 @@ UNIV_INTERN
 ulint
 dict_get_db_name_len(
 /*=================*/
-	const char*	name);	/*!< in: table name in the form
+	const char*	name)	/*!< in: table name in the form
 				dbname '/' tablename */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Return the end of table name where we have removed dbname and '/'.
 @return	table name */
-
+UNIV_INTERN
 const char*
 dict_remove_db_name(
 /*================*/
-	const char*	name);	/*!< in: table name in the form
+	const char*	name)	/*!< in: table name in the form
 				dbname '/' tablename */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Returns a table object based on table id.
 @return	table, NULL if does not exist */
@@ -118,7 +121,8 @@ UNIV_INLINE
 ulint
 dict_col_get_mbminlen(
 /*==================*/
-	const dict_col_t*	col);	/*!< in: column */
+	const dict_col_t*	col)	/*!< in: column */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Gets the maximum number of bytes per character.
 @return maximum multi-byte char size, in bytes */
@@ -126,7 +130,8 @@ UNIV_INLINE
 ulint
 dict_col_get_mbmaxlen(
 /*==================*/
-	const dict_col_t*	col);	/*!< in: column */
+	const dict_col_t*	col)	/*!< in: column */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Sets the minimum and maximum number of bytes per character. */
 UNIV_INLINE
@@ -136,8 +141,9 @@ dict_col_set_mbminmaxlen(
 	dict_col_t*	col,		/*!< in/out: column */
 	ulint		mbminlen,	/*!< in: minimum multi-byte
 					character size, in bytes */
-	ulint		mbmaxlen);	/*!< in: minimum multi-byte
+	ulint		mbmaxlen)	/*!< in: minimum multi-byte
 					character size, in bytes */
+	__attribute__((nonnull));
 /*********************************************************************//**
 Gets the column data type. */
 UNIV_INLINE
@@ -145,7 +151,8 @@ void
 dict_col_copy_type(
 /*===============*/
 	const dict_col_t*	col,	/*!< in: column */
-	dtype_t*		type);	/*!< out: data type */
+	dtype_t*		type)	/*!< out: data type */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Determine bytes of column prefix to be stored in the undo log. Please
 note if the table format is UNIV_FORMAT_A (< UNIV_FORMAT_B), no prefix
@@ -156,9 +163,9 @@ ulint
 dict_max_field_len_store_undo(
 /*==========================*/
 	dict_table_t*		table,	/*!< in: table */
-	const dict_col_t*	col);	/*!< in: column which index prefix
+	const dict_col_t*	col)	/*!< in: column which index prefix
 					is based on */
-
+	__attribute__((nonnull, warn_unused_result));
 #endif /* !UNIV_HOTBACKUP */
 #ifdef UNIV_DEBUG
 /*********************************************************************//**
@@ -169,7 +176,8 @@ ibool
 dict_col_type_assert_equal(
 /*=======================*/
 	const dict_col_t*	col,	/*!< in: column */
-	const dtype_t*		type);	/*!< in: data type */
+	const dtype_t*		type)	/*!< in: data type */
+	__attribute__((nonnull, warn_unused_result));
 #endif /* UNIV_DEBUG */
 #ifndef UNIV_HOTBACKUP
 /***********************************************************************//**
@@ -179,7 +187,8 @@ UNIV_INLINE
 ulint
 dict_col_get_min_size(
 /*==================*/
-	const dict_col_t*	col);	/*!< in: column */
+	const dict_col_t*	col)	/*!< in: column */
+	__attribute__((nonnull, warn_unused_result));
 /***********************************************************************//**
 Returns the maximum size of the column.
 @return	maximum size */
@@ -187,7 +196,8 @@ UNIV_INLINE
 ulint
 dict_col_get_max_size(
 /*==================*/
-	const dict_col_t*	col);	/*!< in: column */
+	const dict_col_t*	col)	/*!< in: column */
+	__attribute__((nonnull, warn_unused_result));
 /***********************************************************************//**
 Returns the size of a fixed size column, 0 if not a fixed size column.
 @return	fixed size, or 0 */
@@ -196,7 +206,8 @@ ulint
 dict_col_get_fixed_size(
 /*====================*/
 	const dict_col_t*	col,	/*!< in: column */
-	ulint			comp);	/*!< in: nonzero=ROW_FORMAT=COMPACT  */
+	ulint			comp)	/*!< in: nonzero=ROW_FORMAT=COMPACT  */
+	__attribute__((nonnull, warn_unused_result));
 /***********************************************************************//**
 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.
@@ -206,8 +217,8 @@ ulint
 dict_col_get_sql_null_size(
 /*=======================*/
 	const dict_col_t*	col,	/*!< in: column */
-	ulint			comp);	/*!< in: nonzero=ROW_FORMAT=COMPACT  */
-
+	ulint			comp)	/*!< in: nonzero=ROW_FORMAT=COMPACT  */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Gets the column number.
 @return	col->ind, table column position (starting from 0) */
@@ -215,7 +226,8 @@ UNIV_INLINE
 ulint
 dict_col_get_no(
 /*============*/
-	const dict_col_t*	col);	/*!< in: column */
+	const dict_col_t*	col)	/*!< in: column */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Gets the column position in the clustered index. */
 UNIV_INLINE
@@ -223,7 +235,8 @@ 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_index_t*	clust_index)	/*!< in: clustered index */
+	__attribute__((nonnull, warn_unused_result));
 /****************************************************************//**
 If the given column name is reserved for InnoDB system columns, return
 TRUE.
@@ -232,14 +245,16 @@ UNIV_INTERN
 ibool
 dict_col_name_is_reserved(
 /*======================*/
-	const char*	name);	/*!< in: column name */
+	const char*	name)	/*!< in: column name */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Acquire the autoinc lock. */
 UNIV_INTERN
 void
 dict_table_autoinc_lock(
 /*====================*/
-	dict_table_t*	table);	/*!< in/out: table */
+	dict_table_t*	table)	/*!< in/out: table */
+	__attribute__((nonnull));
 /********************************************************************//**
 Unconditionally set the autoinc counter. */
 UNIV_INTERN
@@ -247,7 +262,8 @@ void
 dict_table_autoinc_initialize(
 /*==========================*/
 	dict_table_t*	table,	/*!< in/out: table */
-	ib_uint64_t	value);	/*!< in: next value to assign to a row */
+	ib_uint64_t	value)	/*!< in: next value to assign to a row */
+	__attribute__((nonnull));
 /********************************************************************//**
 Reads the next autoinc value (== autoinc counter value), 0 if not yet
 initialized.
@@ -256,7 +272,8 @@ UNIV_INTERN
 ib_uint64_t
 dict_table_autoinc_read(
 /*====================*/
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Updates the autoinc counter if the value supplied is greater than the
 current value. */
@@ -266,14 +283,16 @@ dict_table_autoinc_update_if_greater(
 /*=================================*/
 
 	dict_table_t*	table,	/*!< in/out: table */
-	ib_uint64_t	value);	/*!< in: value which was assigned to a row */
+	ib_uint64_t	value)	/*!< in: value which was assigned to a row */
+	__attribute__((nonnull));
 /********************************************************************//**
 Release the autoinc lock. */
 UNIV_INTERN
 void
 dict_table_autoinc_unlock(
 /*======================*/
-	dict_table_t*	table);	/*!< in/out: table */
+	dict_table_t*	table)	/*!< in/out: table */
+	__attribute__((nonnull));
 #endif /* !UNIV_HOTBACKUP */
 /**********************************************************************//**
 Adds system columns to a table object. */
@@ -282,7 +301,8 @@ void
 dict_table_add_system_columns(
 /*==========================*/
 	dict_table_t*	table,	/*!< in/out: table */
-	mem_heap_t*	heap);	/*!< in: temporary heap */
+	mem_heap_t*	heap)	/*!< in: temporary heap */
+	__attribute__((nonnull));
 #ifndef UNIV_HOTBACKUP
 /**********************************************************************//**
 Adds a table object to the dictionary cache. */
@@ -292,14 +312,16 @@ dict_table_add_to_cache(
 /*====================*/
 	dict_table_t*	table,		/*!< in: table */
 	ibool		can_be_evicted,	/*!< in: TRUE if can be evicted*/
-	mem_heap_t*	heap);		/*!< in: temporary heap */
+	mem_heap_t*	heap)		/*!< in: temporary heap */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Removes a table object from the dictionary cache. */
 UNIV_INTERN
 void
 dict_table_remove_from_cache(
 /*=========================*/
-	dict_table_t*	table);	/*!< in, own: table */
+	dict_table_t*	table)	/*!< in, own: table */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Renames a table object.
 @return	TRUE if success */
@@ -309,9 +331,11 @@ dict_table_rename_in_cache(
 /*=======================*/
 	dict_table_t*	table,		/*!< in/out: table */
 	const char*	new_name,	/*!< in: new name */
-	ibool		rename_also_foreigns);/*!< in: in ALTER TABLE we want
+	ibool		rename_also_foreigns)
+					/*!< in: in ALTER TABLE we want
 					to preserve the original table name
 					in constraints which reference it */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Removes an index from the dictionary cache. */
 UNIV_INTERN
@@ -319,7 +343,8 @@ void
 dict_index_remove_from_cache(
 /*=========================*/
 	dict_table_t*	table,	/*!< in/out: table */
-	dict_index_t*	index);	/*!< in, own: index */
+	dict_index_t*	index)	/*!< in, own: index */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Change the id of a table object in the dictionary cache. This is used in
 DISCARD TABLESPACE. */
@@ -328,7 +353,8 @@ void
 dict_table_change_id_in_cache(
 /*==========================*/
 	dict_table_t*	table,	/*!< in/out: table object already in cache */
-	table_id_t	new_id);/*!< in: new id to set */
+	table_id_t	new_id)	/*!< in: new id to set */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Adds a foreign key constraint object to the dictionary cache. May free
 the object if there already is an object with the same identifier in.
@@ -340,8 +366,9 @@ ulint
 dict_foreign_add_to_cache(
 /*======================*/
 	dict_foreign_t*	foreign,	/*!< in, own: foreign key constraint */
-	ibool		check_charsets);/*!< in: TRUE=check charset
+	ibool		check_charsets)	/*!< in: TRUE=check charset
 					compatibility */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Check if the index is referenced by a foreign key, if TRUE return the
 matching instance NULL otherwise.
@@ -352,7 +379,8 @@ dict_foreign_t*
 dict_table_get_referenced_constraint(
 /*=================================*/
 	dict_table_t*	table,	/*!< in: InnoDB table */
-	dict_index_t*	index);	/*!< in: InnoDB index */
+	dict_index_t*	index)	/*!< in: InnoDB index */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Checks if a table is referenced by foreign keys.
 @return	TRUE if table is referenced by a foreign key */
@@ -360,7 +388,8 @@ UNIV_INTERN
 ibool
 dict_table_is_referenced_by_foreign_key(
 /*====================================*/
-	const dict_table_t*	table);	/*!< in: InnoDB table */
+	const dict_table_t*	table)	/*!< in: InnoDB table */
+	__attribute__((nonnull, warn_unused_result));
 #if 1 /* TODO: enable this in WL#6049 (MDL for FK lookups) */
 /**********************************************************************//**
 Replace the index passed in with another equivalent index in the
@@ -396,7 +425,8 @@ dict_foreign_t*
 dict_table_get_foreign_constraint(
 /*==============================*/
 	dict_table_t*	table,	/*!< in: InnoDB table */
-	dict_index_t*	index);	/*!< in: InnoDB index */
+	dict_index_t*	index)	/*!< in: InnoDB index */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Scans a table create SQL string and adds to the data dictionary
 the foreign key constraints declared in the string. This function
@@ -422,9 +452,10 @@ dict_create_foreign_constraints(
 	const char*	name,		/*!< in: table full name in the
 					normalized form
 					database_name/table_name */
-	ibool		reject_fks);	/*!< in: if TRUE, fail with error
+	ibool		reject_fks)	/*!< in: if TRUE, fail with error
 					code DB_CANNOT_ADD_CONSTRAINT if
 					any foreign keys are found. */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Parses the CONSTRAINT id's to be dropped in an ALTER TABLE statement.
 @return DB_SUCCESS or DB_CANNOT_DROP_CONSTRAINT if syntax error or the
@@ -439,8 +470,9 @@ dict_foreign_parse_drop_constraints(
 	dict_table_t*	table,			/*!< in: table */
 	ulint*		n,			/*!< out: number of constraints
 						to drop */
-	const char***	constraints_to_drop);	/*!< out: id's of the
+	const char***	constraints_to_drop)	/*!< out: id's of the
 						constraints to drop */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Returns a table object and increments its open handle count.
 NOTE! This is a high-level function to be used mainly from outside the
@@ -512,7 +544,8 @@ dict_table_get_index_by_max_id(
 	dict_table_t*	table,	/*!< in: table */
 	const char*	name,	/*!< in: the index name to find */
 	const char**	columns,/*!< in: array of column names */
-	ulint		n_cols);/*!< in: number of columns */
+	ulint		n_cols)	/*!< in: number of columns */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Returns a column's name.
 @return column name. NOTE: not guaranteed to stay valid if table is
@@ -522,29 +555,32 @@ const char*
 dict_table_get_col_name(
 /*====================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			col_nr);/*!< in: column number */
-
+	ulint			col_nr)	/*!< in: column number */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Prints a table definition. */
 UNIV_INTERN
 void
 dict_table_print(
 /*=============*/
-	dict_table_t*	table);	/*!< in: table */
+	dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Prints a table data. */
 UNIV_INTERN
 void
 dict_table_print_low(
 /*=================*/
-	dict_table_t*	table);	/*!< in: table */
+	dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Prints a table data when we know the table name. */
 UNIV_INTERN
 void
 dict_table_print_by_name(
 /*=====================*/
-	const char*	name);	/*!< in: table name */
+	const char*	name)	/*!< in: table name */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Outputs info on foreign keys of a table. */
 UNIV_INTERN
@@ -557,7 +593,8 @@ dict_print_info_on_foreign_keys(
 				of SHOW TABLE STATUS */
 	FILE*		file,	/*!< in: file where to print */
 	trx_t*		trx,	/*!< in: transaction */
-	dict_table_t*	table);	/*!< in: table */
+	dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Outputs info on a foreign key of a table in a format suitable for
 CREATE TABLE. */
@@ -568,7 +605,8 @@ dict_print_info_on_foreign_key_in_create
 	FILE*		file,		/*!< in: file where to print */
 	trx_t*		trx,		/*!< in: transaction */
 	dict_foreign_t*	foreign,	/*!< in: foreign key constraint */
-	ibool		add_newline);	/*!< in: whether to add a newline */
+	ibool		add_newline)	/*!< in: whether to add a newline */
+	__attribute__((nonnull(1,3)));
 /********************************************************************//**
 Displays the names of the index and the table. */
 UNIV_INTERN
@@ -577,7 +615,8 @@ dict_index_name_print(
 /*==================*/
 	FILE*			file,	/*!< in: output stream */
 	trx_t*			trx,	/*!< in: transaction */
-	const dict_index_t*	index);	/*!< in: index to print */
+	const dict_index_t*	index)	/*!< in: index to print */
+	__attribute__((nonnull(1,3)));
 #ifdef UNIV_DEBUG
 /********************************************************************//**
 Gets the first index on the table (the clustered index).
@@ -586,7 +625,8 @@ UNIV_INLINE
 dict_index_t*
 dict_table_get_first_index(
 /*=======================*/
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Gets the next index on the table.
 @return	index, NULL if none left */
@@ -594,7 +634,8 @@ UNIV_INLINE
 dict_index_t*
 dict_table_get_next_index(
 /*======================*/
-	const dict_index_t*	index);	/*!< in: index */
+	const dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 #else /* UNIV_DEBUG */
 # define dict_table_get_first_index(table) UT_LIST_GET_FIRST((table)->indexes)
 # define dict_table_get_next_index(index) UT_LIST_GET_NEXT(indexes, index)
@@ -654,13 +695,14 @@ dict_index_is_sec_or_ibuf(
 /************************************************************************
 Gets the all the FTS indexes for the table. NOTE: must not be called for
 tables which do not have an FTS-index. */
-
+UNIV_INTERN
 ulint
 dict_table_get_all_fts_indexes(
 /*===========================*/
 				/* out: number of indexes collected */
 	dict_table_t*	table,	/* in: table */
-	ib_vector_t*	indexes);/* out: vector for collecting FTS indexes */
+	ib_vector_t*	indexes)/* out: vector for collecting FTS indexes */
+	__attribute__((nonnull));
 /********************************************************************//**
 Gets the number of user-defined columns in a table in the dictionary
 cache.
@@ -699,7 +741,8 @@ dict_col_t*
 dict_table_get_nth_col(
 /*===================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			pos);	/*!< in: position of column */
+	ulint			pos)	/*!< in: position of column */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Gets the given system column of a table.
 @return	pointer to column object */
@@ -708,7 +751,8 @@ dict_col_t*
 dict_table_get_sys_col(
 /*===================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			sys);	/*!< in: DATA_ROW_ID, ... */
+	ulint			sys)	/*!< in: DATA_ROW_ID, ... */
+	__attribute__((nonnull, warn_unused_result));
 #else /* UNIV_DEBUG */
 #define dict_table_get_nth_col(table, pos) \
 ((table)->cols + (pos))
@@ -723,7 +767,8 @@ ulint
 dict_table_get_sys_col_no(
 /*======================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			sys);	/*!< in: DATA_ROW_ID, ... */
+	ulint			sys)	/*!< in: DATA_ROW_ID, ... */
+	__attribute__((nonnull, warn_unused_result));
 #ifndef UNIV_HOTBACKUP
 /********************************************************************//**
 Returns the minimum data size of an index record.
@@ -732,7 +777,8 @@ UNIV_INLINE
 ulint
 dict_index_get_min_size(
 /*====================*/
-	const dict_index_t*	index);	/*!< in: index */
+	const dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 #endif /* !UNIV_HOTBACKUP */
 /********************************************************************//**
 Check whether the table uses the compact page format.
@@ -741,7 +787,8 @@ UNIV_INLINE
 ibool
 dict_table_is_comp(
 /*===============*/
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Determine the file format of a table.
 @return	file format version */
@@ -749,7 +796,8 @@ UNIV_INLINE
 ulint
 dict_table_get_format(
 /*==================*/
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Determine the file format from a dict_table_t::flags.
 @return	file format version */
@@ -757,7 +805,8 @@ UNIV_INLINE
 ulint
 dict_tf_get_format(
 /*===============*/
-	ulint		flags);		/*!< in: dict_table_t::flags */
+	ulint		flags)		/*!< in: dict_table_t::flags */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Set the various values in a dict_table_t::flags pointer. */
 UNIV_INLINE
@@ -766,7 +815,8 @@ dict_tf_set(
 /*========*/
 	ulint*		flags,		/*!< in/out: table */
 	rec_format_t	format,		/*!< in: file format */
-	ulint		zip_ssize);	/*!< in: zip shift size */
+	ulint		zip_ssize)	/*!< in: zip shift size */
+	__attribute__((nonnull));
 /********************************************************************//**
 Convert a 32 bit integer table flags to the 32 bit integer that is
 written into the tablespace header at the offset FSP_SPACE_FLAGS and is
@@ -800,7 +850,8 @@ UNIV_INLINE
 ulint
 dict_table_zip_size(
 /*================*/
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 #ifndef UNIV_HOTBACKUP
 /*********************************************************************//**
 Obtain exclusive locks on all index trees of the table. This is to prevent
@@ -810,14 +861,16 @@ UNIV_INLINE
 void
 dict_table_x_lock_indexes(
 /*======================*/
-	dict_table_t*	table);	/*!< in: table */
+	dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /*********************************************************************//**
 Release the exclusive locks on all index tree. */
 UNIV_INLINE
 void
 dict_table_x_unlock_indexes(
 /*========================*/
-	dict_table_t*	table);	/*!< in: table */
+	dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /********************************************************************//**
 Checks if a column is in the ordering columns of the clustered index of a
 table. Column prefixes are treated like whole columns.
@@ -827,7 +880,8 @@ ibool
 dict_table_col_in_clustered_key(
 /*============================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			n);	/*!< in: column number */
+	ulint			n)	/*!< in: column number */
+	__attribute__((nonnull, warn_unused_result));
 /*******************************************************************//**
 Check if the table has an FTS index.
 @return TRUE if table has an FTS index */
@@ -835,7 +889,8 @@ UNIV_INLINE
 ibool
 dict_table_has_fts_index(
 /*=====================*/
-	dict_table_t*   table);		/*!< in: table */
+	dict_table_t*   table)		/*!< in: table */
+	__attribute__((nonnull, warn_unused_result));
 /*******************************************************************//**
 Copies types of columns contained in table to tuple and sets all
 fields of the tuple to the SQL NULL value.  This function should
@@ -845,18 +900,20 @@ void
 dict_table_copy_types(
 /*==================*/
 	dtuple_t*		tuple,	/*!< in/out: data tuple */
-	const dict_table_t*	table);	/*!< in: table */
+	const dict_table_t*	table)	/*!< in: table */
+	__attribute__((nonnull));
 /********************************************************************
 Wait until all the background threads of the given table have exited, i.e.,
 bg_threads == 0. Note: bg_threads_mutex must be reserved when
 calling this. */
-
+UNIV_INTERN
 void
 dict_table_wait_for_bg_threads_to_exit(
 /*===================================*/
 	dict_table_t*	table,	/* in: table */
-	ulint		delay);	/* in: time in microseconds to wait between
+	ulint		delay)	/* in: time in microseconds to wait between
 				checks of bg_threads. */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Looks for an index with the given id. NOTE that we do not reserve
 the dictionary mutex: this function is for emergency purposes like
@@ -866,7 +923,8 @@ UNIV_INTERN
 dict_index_t*
 dict_index_find_on_id_low(
 /*======================*/
-	index_id_t	id);	/*!< in: index id */
+	index_id_t	id)	/*!< in: index id */
+	__attribute__((warn_unused_result));
 /**********************************************************************//**
 Make room in the table cache by evicting an unused table. The unused table
 should not be part of FK relationship and currently not used in any user
@@ -889,9 +947,10 @@ dict_index_add_to_cache(
 	dict_index_t*	index,	/*!< in, own: index; NOTE! The index memory
 				object is freed in this function! */
 	ulint		page_no,/*!< in: root page number of the index */
-	ibool		strict);/*!< in: TRUE=refuse to create the index
+	ibool		strict)	/*!< in: TRUE=refuse to create the index
 				if records could be too big to fit in
 				an B-tree page */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Removes an index from the dictionary cache. */
 UNIV_INTERN
@@ -899,7 +958,8 @@ void
 dict_index_remove_from_cache(
 /*=========================*/
 	dict_table_t*	table,	/*!< in/out: table */
-	dict_index_t*	index);	/*!< in, own: index */
+	dict_index_t*	index)	/*!< in, own: index */
+	__attribute__((nonnull));
 #endif /* !UNIV_HOTBACKUP */
 /********************************************************************//**
 Gets the number of fields in the internal representation of an index,
@@ -909,9 +969,10 @@ UNIV_INLINE
 ulint
 dict_index_get_n_fields(
 /*====================*/
-	const dict_index_t*	index);	/*!< in: an internal
+	const dict_index_t*	index)	/*!< in: an internal
 					representation of index (in
 					the dictionary cache) */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 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
@@ -922,8 +983,9 @@ UNIV_INLINE
 ulint
 dict_index_get_n_unique(
 /*====================*/
-	const dict_index_t*	index);	/*!< in: an internal representation
+	const dict_index_t*	index)	/*!< in: an internal representation
 					of index (in the dictionary cache) */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 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
@@ -933,8 +995,9 @@ UNIV_INLINE
 ulint
 dict_index_get_n_unique_in_tree(
 /*============================*/
-	const dict_index_t*	index);	/*!< in: an internal representation
+	const dict_index_t*	index)	/*!< in: an internal representation
 					of index (in the dictionary cache) */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Gets the number of user-defined ordering fields in the index. In the internal
 representation we add the row id to the ordering fields to make all indexes
@@ -945,8 +1008,9 @@ UNIV_INLINE
 ulint
 dict_index_get_n_ordering_defined_by_user(
 /*======================================*/
-	const dict_index_t*	index);	/*!< in: an internal representation
+	const dict_index_t*	index)	/*!< in: an internal representation
 					of index (in the dictionary cache) */
+	__attribute__((nonnull, warn_unused_result));
 #ifdef UNIV_DEBUG
 /********************************************************************//**
 Gets the nth field of an index.
@@ -956,7 +1020,8 @@ dict_field_t*
 dict_index_get_nth_field(
 /*=====================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			pos);	/*!< in: position of field */
+	ulint			pos)	/*!< in: position of field */
+	__attribute__((nonnull, warn_unused_result));
 #else /* UNIV_DEBUG */
 # define dict_index_get_nth_field(index, pos) ((index)->fields + (pos))
 #endif /* UNIV_DEBUG */
@@ -968,7 +1033,8 @@ const dict_col_t*
 dict_index_get_nth_col(
 /*===================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			pos);	/*!< in: position of the field */
+	ulint			pos)	/*!< in: position of the field */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Gets the column number of the nth field in an index.
 @return	column number */
@@ -977,7 +1043,8 @@ ulint
 dict_index_get_nth_col_no(
 /*======================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			pos);	/*!< in: position of the field */
+	ulint			pos)	/*!< in: position of the field */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Looks for column n in an index.
 @return position in internal representation of the index;
@@ -987,7 +1054,8 @@ ulint
 dict_index_get_nth_col_pos(
 /*=======================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			n);	/*!< in: column number */
+	ulint			n)	/*!< in: column number */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Looks for column n in an index.
 @return position in internal representation of the index;
@@ -998,8 +1066,9 @@ dict_index_get_nth_col_or_prefix_pos(
 /*=================================*/
 	const dict_index_t*	index,		/*!< in: index */
 	ulint			n,		/*!< in: column number */
-	ibool			inc_prefix);	/*!< in: TRUE=consider
+	ibool			inc_prefix)	/*!< in: TRUE=consider
 						column prefixes too */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Returns TRUE if the index contains a column or a prefix of that column.
 @return	TRUE if contains the column or its prefix */
@@ -1008,7 +1077,8 @@ ibool
 dict_index_contains_col_or_prefix(
 /*==============================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			n);	/*!< in: column number */
+	ulint			n)	/*!< in: column number */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Looks for a matching field in an index. The column has to be the same. The
 column in index must be complete, or must contain a prefix longer than the
@@ -1022,7 +1092,8 @@ dict_index_get_nth_field_pos(
 /*=========================*/
 	const dict_index_t*	index,	/*!< in: index from which to search */
 	const dict_index_t*	index2,	/*!< in: index */
-	ulint			n);	/*!< in: field number in index2 */
+	ulint			n)	/*!< in: field number in index2 */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Looks for column n position in the clustered index.
 @return	position in internal representation of the clustered index */
@@ -1031,7 +1102,8 @@ ulint
 dict_table_get_nth_col_pos(
 /*=======================*/
 	const dict_table_t*	table,	/*!< in: table */
-	ulint			n);	/*!< in: column number */
+	ulint			n)	/*!< in: column number */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Returns the position of a system column in an index.
 @return	position, ULINT_UNDEFINED if not contained */
@@ -1040,7 +1112,8 @@ ulint
 dict_index_get_sys_col_pos(
 /*=======================*/
 	const dict_index_t*	index,	/*!< in: index */
-	ulint			type);	/*!< in: DATA_ROW_ID, ... */
+	ulint			type)	/*!< in: DATA_ROW_ID, ... */
+	__attribute__((nonnull, warn_unused_result));
 /*******************************************************************//**
 Adds a column to index. */
 UNIV_INTERN
@@ -1050,7 +1123,8 @@ dict_index_add_col(
 	dict_index_t*		index,		/*!< in/out: index */
 	const dict_table_t*	table,		/*!< in: table */
 	dict_col_t*		col,		/*!< in: column */
-	ulint			prefix_len);	/*!< in: column prefix length */
+	ulint			prefix_len)	/*!< in: column prefix length */
+	__attribute__((nonnull));
 #ifndef UNIV_HOTBACKUP
 /*******************************************************************//**
 Copies types of fields contained in index to tuple. */
@@ -1060,8 +1134,9 @@ dict_index_copy_types(
 /*==================*/
 	dtuple_t*		tuple,		/*!< in/out: data tuple */
 	const dict_index_t*	index,		/*!< in: index */
-	ulint			n_fields);	/*!< in: number of
+	ulint			n_fields)	/*!< in: number of
 						field types to copy */
+	__attribute__((nonnull));
 #endif /* !UNIV_HOTBACKUP */
 /*********************************************************************//**
 Gets the field column.
@@ -1070,7 +1145,8 @@ UNIV_INLINE
 const dict_col_t*
 dict_field_get_col(
 /*===============*/
-	const dict_field_t*	field);	/*!< in: index field */
+	const dict_field_t*	field)	/*!< in: index field */
+	__attribute__((nonnull, warn_unused_result));
 #ifndef UNIV_HOTBACKUP
 /**********************************************************************//**
 Returns an index object if it is found in the dictionary cache.
@@ -1080,7 +1156,8 @@ UNIV_INTERN
 dict_index_t*
 dict_index_get_if_in_cache_low(
 /*===========================*/
-	index_id_t	index_id);	/*!< in: index id */
+	index_id_t	index_id)	/*!< in: index id */
+	__attribute__((warn_unused_result));
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /**********************************************************************//**
 Returns an index object if it is found in the dictionary cache.
@@ -1089,7 +1166,8 @@ UNIV_INTERN
 dict_index_t*
 dict_index_get_if_in_cache(
 /*=======================*/
-	index_id_t	index_id);	/*!< in: index id */
+	index_id_t	index_id)	/*!< in: index id */
+	__attribute__((warn_unused_result));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 #ifdef UNIV_DEBUG
 /**********************************************************************//**
@@ -1101,7 +1179,8 @@ ibool
 dict_index_check_search_tuple(
 /*==========================*/
 	const dict_index_t*	index,	/*!< in: index tree */
-	const dtuple_t*		tuple);	/*!< in: tuple used in a search */
+	const dtuple_t*		tuple)	/*!< in: tuple used in a search */
+	__attribute__((nonnull, warn_unused_result));
 /** Whether and when to allow temporary index names */
 enum check_name {
 	/** Require all indexes to be complete. */
@@ -1137,8 +1216,9 @@ dict_index_build_node_ptr(
 					pointer */
 	mem_heap_t*		heap,	/*!< in: memory heap where pointer
 					created */
-	ulint			level);	/*!< in: level of rec in tree:
+	ulint			level)	/*!< in: level of rec in tree:
 					0 means leaf level */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Copies an initial segment of a physical record, long enough to specify an
 index entry uniquely.
@@ -1153,7 +1233,8 @@ dict_index_copy_rec_order_prefix(
 	ulint*			n_fields,/*!< out: number of fields copied */
 	byte**			buf,	/*!< in/out: memory buffer for the
 					copied prefix, or NULL */
-	ulint*			buf_size);/*!< in/out: buffer size */
+	ulint*			buf_size)/*!< in/out: buffer size */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Builds a typed data tuple out of a physical record.
 @return	own: data tuple */
@@ -1164,7 +1245,8 @@ dict_index_build_data_tuple(
 	dict_index_t*	index,	/*!< in: index */
 	rec_t*		rec,	/*!< in: record for which to build data tuple */
 	ulint		n_fields,/*!< in: number of data fields */
-	mem_heap_t*	heap);	/*!< in: memory heap where tuple created */
+	mem_heap_t*	heap)	/*!< in: memory heap where tuple created */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Gets the space id of the root of the index tree.
 @return	space id */
@@ -1172,7 +1254,8 @@ UNIV_INLINE
 ulint
 dict_index_get_space(
 /*=================*/
-	const dict_index_t*	index);	/*!< in: index */
+	const dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Sets the space id of the root of the index tree. */
 UNIV_INLINE
@@ -1180,7 +1263,8 @@ void
 dict_index_set_space(
 /*=================*/
 	dict_index_t*	index,	/*!< in/out: index */
-	ulint		space);	/*!< in: space id */
+	ulint		space)	/*!< in: space id */
+	__attribute__((nonnull));
 /*********************************************************************//**
 Gets the page number of the root of the index tree.
 @return	page number */
@@ -1188,7 +1272,8 @@ UNIV_INLINE
 ulint
 dict_index_get_page(
 /*================*/
-	const dict_index_t*	tree);	/*!< in: index */
+	const dict_index_t*	tree)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Gets the read-write lock of the index tree.
 @return	read-write lock */
@@ -1196,7 +1281,8 @@ UNIV_INLINE
 rw_lock_t*
 dict_index_get_lock(
 /*================*/
-	dict_index_t*	index);	/*!< in: index */
+	dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Returns free space reserved for future updates of records. This is
 relevant only in the case of many consecutive inserts, as updates
@@ -1237,7 +1323,6 @@ dict_index_is_online_ddl(
 /*=====================*/
 	const dict_index_t*	index)	/*!< in: index */
 	__attribute__((nonnull, warn_unused_result));
-
 /*********************************************************************//**
 Logs an operation to a secondary index that is being created. */
 UNIV_INTERN
@@ -1268,7 +1353,8 @@ UNIV_INTERN
 ulint
 dict_index_calc_min_rec_len(
 /*========================*/
-	const dict_index_t*	index);	/*!< in: index */
+	const dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull, warn_unused_result));
 /********************************************************************//**
 Reserves the dictionary system mutex for MySQL. */
 UNIV_INTERN
@@ -1290,8 +1376,9 @@ void
 dict_table_stats_lock(
 /*==================*/
 	const dict_table_t*	table,		/*!< in: table */
-	ulint			latch_mode);	/*!< in: RW_S_LATCH or
+	ulint			latch_mode)	/*!< in: RW_S_LATCH or
 						RW_X_LATCH */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Unlock the latch that has been locked by dict_table_stats_lock() */
 UNIV_INTERN
@@ -1299,8 +1386,9 @@ void
 dict_table_stats_unlock(
 /*====================*/
 	const dict_table_t*	table,		/*!< in: table */
-	ulint			latch_mode);	/*!< in: RW_S_LATCH or
+	ulint			latch_mode)	/*!< in: RW_S_LATCH or
 						RW_X_LATCH */
+	__attribute__((nonnull));
 /********************************************************************//**
 Checks if the database name in two table names is the same.
 @return	TRUE if same db name */
@@ -1310,8 +1398,9 @@ dict_tables_have_same_db(
 /*=====================*/
 	const char*	name1,	/*!< in: table name in the form
 				dbname '/' tablename */
-	const char*	name2);	/*!< in: table name in the form
+	const char*	name2)	/*!< in: table name in the form
 				dbname '/' tablename */
+	__attribute__((nonnull, warn_unused_result));
 /*********************************************************************//**
 Removes an index from the cache */
 UNIV_INTERN
@@ -1319,7 +1408,8 @@ void
 dict_index_remove_from_cache(
 /*=========================*/
 	dict_table_t*	table,	/*!< in/out: table */
-	dict_index_t*	index);	/*!< in, own: index */
+	dict_index_t*	index)	/*!< in, own: index */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Get index by name
 @return	index, NULL if does not exist */
@@ -1328,7 +1418,8 @@ dict_index_t*
 dict_table_get_index_on_name(
 /*=========================*/
 	dict_table_t*	table,	/*!< in: table */
-	const char*	name);	/*!< in: name of the index to find */
+	const char*	name)	/*!< in: name of the index to find */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 In case there is more than one index with the same name return the index
 with the min(id).
@@ -1338,7 +1429,8 @@ dict_index_t*
 dict_table_get_index_on_name_and_min_id(
 /*====================================*/
 	dict_table_t*	table,	/*!< in: table */
-	const char*	name);	/*!< in: name of the index to find */
+	const char*	name)	/*!< in: name of the index to find */
+	__attribute__((nonnull, warn_unused_result));
 /***************************************************************
 Check whether a column exists in an FTS index. */
 UNIV_INLINE
@@ -1348,28 +1440,32 @@ dict_table_is_fts_column(
 				/* out: ULINT_UNDEFINED if no match else
 				the offset within the vector */
 	ib_vector_t*	indexes,/* in: vector containing only FTS indexes */
-	ulint		col_no);/* in: col number to search for */
+	ulint		col_no)	/* in: col number to search for */
+	__attribute__((nonnull, warn_unused_result));
 /**********************************************************************//**
 Move a table to the non LRU end of the LRU list. */
 UNIV_INTERN
 void
 dict_table_move_from_lru_to_non_lru(
 /*================================*/
-	dict_table_t*	table);	/*!< in: table to move from LRU to non-LRU */
+	dict_table_t*	table)	/*!< in: table to move from LRU to non-LRU */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Move a table to the LRU list from the non-LRU list. */
 UNIV_INTERN
 void
 dict_table_move_from_non_lru_to_lru(
 /*================================*/
-	dict_table_t*	table);	/*!< in: table to move from non-LRU to LRU */
+	dict_table_t*	table)	/*!< in: table to move from non-LRU to LRU */
+	__attribute__((nonnull));
 /**********************************************************************//**
 Move to the most recently used segment of the LRU list. */
 UNIV_INTERN
 void
 dict_move_to_mru(
 /*=============*/
-	dict_table_t*	table);	/*!< in: table to move to MRU */
+	dict_table_t*	table)	/*!< in: table to move to MRU */
+	__attribute__((nonnull));
 /* Buffers for storing detailed information about the latest foreign key
 and unique key errors */
 extern FILE*	dict_foreign_err_file;
@@ -1476,7 +1572,8 @@ dict_table_schema_check(
 						message if != DB_SUCCESS and
 						!= DB_TABLE_NOT_FOUND is
 						returned */
-	size_t			errstr_sz);	/*!< in: errstr size */
+	size_t			errstr_sz)	/*!< in: errstr size */
+	__attribute__((nonnull, warn_unused_result));
 /* @} */
 
 /**********************************************************************//**
@@ -1525,7 +1622,8 @@ void
 dict_set_corrupted_index_cache_only(
 /*================================*/
 	dict_index_t*	index,		/*!< in/out: index */
-	dict_table_t*	table);		/*!< in/out: table */
+	dict_table_t*	table)		/*!< in/out: table */
+	__attribute__((nonnull));
 
 /**********************************************************************//**
 Flags a table with specified space_id corrupted in the table dictionary

No bundle (reason: useless for push emails).
Thread
bzr push into mysql-trunk branch (marko.makela:3876 to 3878) marko.makela29 Mar