diff options
Diffstat (limited to 'storage/innobase/include/rem0rec.h')
| -rw-r--r-- | storage/innobase/include/rem0rec.h | 354 |
1 files changed, 244 insertions, 110 deletions
diff --git a/storage/innobase/include/rem0rec.h b/storage/innobase/include/rem0rec.h index c6c70bb5f09..2a84aee7a6f 100644 --- a/storage/innobase/include/rem0rec.h +++ b/storage/innobase/include/rem0rec.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1994, 2011, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1994, 2012, Oracle and/or its affiliates. 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 @@ -66,6 +66,15 @@ The status is stored in the low-order bits. */ /* Length of a B-tree node pointer, in bytes */ #define REC_NODE_PTR_SIZE 4 +/** SQL null flag in a 1-byte offset of ROW_FORMAT=REDUNDANT records */ +#define REC_1BYTE_SQL_NULL_MASK 0x80UL +/** SQL null flag in a 2-byte offset of ROW_FORMAT=REDUNDANT records */ +#define REC_2BYTE_SQL_NULL_MASK 0x8000UL + +/** In a 2-byte offset of ROW_FORMAT=REDUNDANT records, the second most +significant bit denotes that the tail of a field is stored off-page. */ +#define REC_2BYTE_EXTERN_MASK 0x4000UL + #ifdef UNIV_DEBUG /* Length of the rec_get_offsets() header */ # define REC_OFFS_HEADER_SIZE 4 @@ -88,7 +97,8 @@ const rec_t* rec_get_next_ptr_const( /*===================*/ const rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to get the pointer of the next chained record on the same page. @@ -98,7 +108,8 @@ rec_t* rec_get_next_ptr( /*=============*/ rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to get the offset of the next chained record on the same page. @@ -108,7 +119,8 @@ ulint rec_get_next_offs( /*==============*/ const rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the next record offset field of an old-style record. */ @@ -117,7 +129,8 @@ void rec_set_next_offs_old( /*==================*/ rec_t* rec, /*!< in: old-style physical record */ - ulint next); /*!< in: offset of the next record */ + ulint next) /*!< in: offset of the next record */ + __attribute__((nonnull)); /******************************************************//** The following function is used to set the next record offset field of a new-style record. */ @@ -126,7 +139,8 @@ void rec_set_next_offs_new( /*==================*/ rec_t* rec, /*!< in/out: new-style physical record */ - ulint next); /*!< in: offset of the next record */ + ulint next) /*!< in: offset of the next record */ + __attribute__((nonnull)); /******************************************************//** The following function is used to get the number of fields in an old-style record. @@ -135,7 +149,8 @@ UNIV_INLINE ulint rec_get_n_fields_old( /*=================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to get the number of fields in a record. @@ -145,7 +160,8 @@ ulint rec_get_n_fields( /*=============*/ const rec_t* rec, /*!< in: physical record */ - const dict_index_t* index); /*!< in: record descriptor */ + const dict_index_t* index) /*!< in: record descriptor */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to get the number of records owned by the previous directory record. @@ -154,7 +170,8 @@ UNIV_INLINE ulint rec_get_n_owned_old( /*================*/ - const rec_t* rec); /*!< in: old-style physical record */ + const rec_t* rec) /*!< in: old-style physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the number of owned records. */ UNIV_INLINE @@ -162,7 +179,8 @@ void rec_set_n_owned_old( /*================*/ rec_t* rec, /*!< in: old-style physical record */ - ulint n_owned); /*!< in: the number of owned */ + ulint n_owned) /*!< in: the number of owned */ + __attribute__((nonnull)); /******************************************************//** The following function is used to get the number of records owned by the previous directory record. @@ -171,7 +189,8 @@ UNIV_INLINE ulint rec_get_n_owned_new( /*================*/ - const rec_t* rec); /*!< in: new-style physical record */ + const rec_t* rec) /*!< in: new-style physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the number of owned records. */ UNIV_INLINE @@ -180,7 +199,8 @@ rec_set_n_owned_new( /*================*/ rec_t* rec, /*!< in/out: new-style physical record */ page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */ - ulint n_owned);/*!< in: the number of owned */ + ulint n_owned)/*!< in: the number of owned */ + __attribute__((nonnull(1))); /******************************************************//** The following function is used to retrieve the info bits of a record. @@ -190,7 +210,8 @@ ulint rec_get_info_bits( /*==============*/ const rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the info bits of a record. */ UNIV_INLINE @@ -198,7 +219,8 @@ void rec_set_info_bits_old( /*==================*/ rec_t* rec, /*!< in: old-style physical record */ - ulint bits); /*!< in: info bits */ + ulint bits) /*!< in: info bits */ + __attribute__((nonnull)); /******************************************************//** The following function is used to set the info bits of a record. */ UNIV_INLINE @@ -206,7 +228,8 @@ void rec_set_info_bits_new( /*==================*/ rec_t* rec, /*!< in/out: new-style physical record */ - ulint bits); /*!< in: info bits */ + ulint bits) /*!< in: info bits */ + __attribute__((nonnull)); /******************************************************//** The following function retrieves the status bits of a new-style record. @return status bits */ @@ -214,7 +237,8 @@ UNIV_INLINE ulint rec_get_status( /*===========*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the status bits of a new-style record. */ @@ -223,7 +247,8 @@ void rec_set_status( /*===========*/ rec_t* rec, /*!< in/out: physical record */ - ulint bits); /*!< in: info bits */ + ulint bits) /*!< in: info bits */ + __attribute__((nonnull)); /******************************************************//** The following function is used to retrieve the info and status @@ -234,7 +259,8 @@ ulint rec_get_info_and_status_bits( /*=========================*/ const rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the info and status bits of a record. (Only compact records have status bits.) */ @@ -243,7 +269,8 @@ void rec_set_info_and_status_bits( /*=========================*/ rec_t* rec, /*!< in/out: compact physical record */ - ulint bits); /*!< in: info bits */ + ulint bits) /*!< in: info bits */ + __attribute__((nonnull)); /******************************************************//** The following function tells if record is delete marked. @@ -253,7 +280,8 @@ ulint rec_get_deleted_flag( /*=================*/ const rec_t* rec, /*!< in: physical record */ - ulint comp); /*!< in: nonzero=compact page format */ + ulint comp) /*!< in: nonzero=compact page format */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the deleted bit. */ UNIV_INLINE @@ -261,7 +289,8 @@ void rec_set_deleted_flag_old( /*=====================*/ rec_t* rec, /*!< in: old-style physical record */ - ulint flag); /*!< in: nonzero if delete marked */ + ulint flag) /*!< in: nonzero if delete marked */ + __attribute__((nonnull)); /******************************************************//** The following function is used to set the deleted bit. */ UNIV_INLINE @@ -270,7 +299,8 @@ rec_set_deleted_flag_new( /*=====================*/ rec_t* rec, /*!< in/out: new-style physical record */ page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */ - ulint flag); /*!< in: nonzero if delete marked */ + ulint flag) /*!< in: nonzero if delete marked */ + __attribute__((nonnull(1))); /******************************************************//** The following function tells if a new-style record is a node pointer. @return TRUE if node pointer */ @@ -278,7 +308,8 @@ UNIV_INLINE ibool rec_get_node_ptr_flag( /*==================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to get the order number of an old-style record in the heap of the index page. @@ -287,7 +318,8 @@ UNIV_INLINE ulint rec_get_heap_no_old( /*================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the heap number field in an old-style record. */ @@ -296,7 +328,8 @@ void rec_set_heap_no_old( /*================*/ rec_t* rec, /*!< in: physical record */ - ulint heap_no);/*!< in: the heap number */ + ulint heap_no)/*!< in: the heap number */ + __attribute__((nonnull)); /******************************************************//** The following function is used to get the order number of a new-style record in the heap of the index page. @@ -305,7 +338,8 @@ UNIV_INLINE ulint rec_get_heap_no_new( /*================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** The following function is used to set the heap number field in a new-style record. */ @@ -314,7 +348,8 @@ void rec_set_heap_no_new( /*================*/ rec_t* rec, /*!< in/out: physical record */ - ulint heap_no);/*!< in: the heap number */ + ulint heap_no)/*!< in: the heap number */ + __attribute__((nonnull)); /******************************************************//** The following function is used to test whether the data offsets in the record are stored in one-byte or two-byte format. @@ -323,7 +358,57 @@ UNIV_INLINE ibool rec_get_1byte_offs_flag( /*====================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); + +/******************************************************//** +The following function is used to set the 1-byte offsets flag. */ +UNIV_INLINE +void +rec_set_1byte_offs_flag( +/*====================*/ + rec_t* rec, /*!< in: physical record */ + ibool flag) /*!< in: TRUE if 1byte form */ + __attribute__((nonnull)); + +/******************************************************//** +Returns the offset of nth field end if the record is stored in the 1-byte +offsets form. If the field is SQL null, the flag is ORed in the returned +value. +@return offset of the start of the field, SQL null flag ORed */ +UNIV_INLINE +ulint +rec_1_get_field_end_info( +/*=====================*/ + const rec_t* rec, /*!< in: record */ + ulint n) /*!< in: field index */ + __attribute__((nonnull, pure, warn_unused_result)); + +/******************************************************//** +Returns the offset of nth field end if the record is stored in the 2-byte +offsets form. If the field is SQL null, the flag is ORed in the returned +value. +@return offset of the start of the field, SQL null flag and extern +storage flag ORed */ +UNIV_INLINE +ulint +rec_2_get_field_end_info( +/*=====================*/ + const rec_t* rec, /*!< in: record */ + ulint n) /*!< in: field index */ + __attribute__((nonnull, pure, warn_unused_result)); + +/******************************************************//** +Returns nonzero if the field is stored off-page. +@retval 0 if the field is stored in-page +@retval REC_2BYTE_EXTERN_MASK if the field is stored externally */ +UNIV_INLINE +ulint +rec_2_is_field_extern( +/*==================*/ + const rec_t* rec, /*!< in: record */ + ulint n) /*!< in: field index */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Determine how many of the first n columns in a compact @@ -333,9 +418,10 @@ UNIV_INTERN ulint rec_get_n_extern_new( /*=================*/ - const rec_t* rec, /*!< in: compact physical record */ - dict_index_t* index, /*!< in: record descriptor */ - ulint n); /*!< in: number of columns to scan */ + const rec_t* rec, /*!< in: compact physical record */ + const dict_index_t* index, /*!< in: record descriptor */ + ulint n) /*!< in: number of columns to scan */ + __attribute__((nonnull, warn_unused_result)); /******************************************************//** The following function determines the offsets to each field @@ -356,30 +442,13 @@ rec_get_offsets_func( (ULINT_UNDEFINED if all fields) */ mem_heap_t** heap, /*!< in/out: memory heap */ const char* file, /*!< in: file name where called */ - ulint line); /*!< in: line number where called */ + ulint line) /*!< in: line number where called */ + __attribute__((nonnull(1,2,5,6),warn_unused_result)); #define rec_get_offsets(rec,index,offsets,n,heap) \ rec_get_offsets_func(rec,index,offsets,n,heap,__FILE__,__LINE__) /******************************************************//** -Determine the offset to each field in a leaf-page record -in ROW_FORMAT=COMPACT. This is a special case of -rec_init_offsets() and rec_get_offsets_func(). */ -UNIV_INTERN -void -rec_init_offsets_comp_ordinary( -/*===========================*/ - const rec_t* rec, /*!< in: physical record in - ROW_FORMAT=COMPACT */ - ulint extra, /*!< in: number of bytes to reserve - between the record header and - the data payload - (usually REC_N_NEW_EXTRA_BYTES) */ - const dict_index_t* index, /*!< in: record descriptor */ - ulint* offsets);/*!< in/out: array of offsets; - in: n=rec_offs_n_fields(offsets) */ - -/******************************************************//** The following function determines the offsets to each field in the record. It can reuse a previously allocated array. */ UNIV_INTERN @@ -393,9 +462,10 @@ rec_get_offsets_reverse( const dict_index_t* index, /*!< in: record descriptor */ ulint node_ptr,/*!< in: nonzero=node pointer, 0=leaf node */ - ulint* offsets);/*!< in/out: array consisting of + ulint* offsets)/*!< in/out: array consisting of offsets[0] allocated elements */ - + __attribute__((nonnull)); +#ifdef UNIV_DEBUG /************************************************************//** Validates offsets returned by rec_get_offsets(). @return TRUE if valid */ @@ -405,9 +475,9 @@ rec_offs_validate( /*==============*/ const rec_t* rec, /*!< in: record or NULL */ const dict_index_t* index, /*!< in: record descriptor or NULL */ - const ulint* offsets);/*!< in: array returned by + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ -#ifdef UNIV_DEBUG + __attribute__((nonnull(3), warn_unused_result)); /************************************************************//** Updates debug data in offsets, in order to avoid bogus rec_offs_validate() failures. */ @@ -417,8 +487,9 @@ rec_offs_make_valid( /*================*/ const rec_t* rec, /*!< in: record */ const dict_index_t* index, /*!< in: record descriptor */ - ulint* offsets);/*!< in: array returned by + ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull)); #else # define rec_offs_make_valid(rec, index, offsets) ((void) 0) #endif /* UNIV_DEBUG */ @@ -433,8 +504,9 @@ rec_get_nth_field_offs_old( /*=======================*/ const rec_t* rec, /*!< in: record */ ulint n, /*!< in: index of the field */ - ulint* len); /*!< out: length of the field; UNIV_SQL_NULL + ulint* len) /*!< out: length of the field; UNIV_SQL_NULL if SQL null */ + __attribute__((nonnull)); #define rec_get_nth_field_old(rec, n, len) \ ((rec) + rec_get_nth_field_offs_old(rec, n, len)) /************************************************************//** @@ -447,7 +519,8 @@ ulint rec_get_nth_field_size( /*===================*/ const rec_t* rec, /*!< in: record */ - ulint n); /*!< in: index of the field */ + ulint n) /*!< in: index of the field */ + __attribute__((nonnull, pure, warn_unused_result)); /************************************************************//** The following function is used to get an offset to the nth data field in a record. @@ -458,8 +531,9 @@ rec_get_nth_field_offs( /*===================*/ const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ ulint n, /*!< in: index of the field */ - ulint* len); /*!< out: length of the field; UNIV_SQL_NULL + ulint* len) /*!< out: length of the field; UNIV_SQL_NULL if SQL null */ + __attribute__((nonnull)); #define rec_get_nth_field(rec, offsets, n, len) \ ((rec) + rec_get_nth_field_offs(offsets, n, len)) /******************************************************//** @@ -470,7 +544,8 @@ UNIV_INLINE ulint rec_offs_comp( /*==========*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Determine if the offsets are for a record containing externally stored columns. @@ -479,8 +554,8 @@ UNIV_INLINE ulint rec_offs_any_extern( /*================*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ -#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Determine if the offsets are for a record containing null BLOB pointers. @return first field containing a null BLOB pointer, or NULL if none found */ @@ -490,8 +565,7 @@ rec_offs_any_null_extern( /*=====================*/ const rec_t* rec, /*!< in: record */ const ulint* offsets) /*!< in: rec_get_offsets(rec) */ - __attribute__((nonnull, warn_unused_result)); -#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Returns nonzero if the extern bit is set in nth field of rec. @return nonzero if externally stored */ @@ -500,7 +574,8 @@ ulint rec_offs_nth_extern( /*================*/ const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ - ulint n); /*!< in: nth field */ + ulint n) /*!< in: nth field */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Returns nonzero if the SQL NULL bit is set in nth field of rec. @return nonzero if SQL NULL */ @@ -509,7 +584,8 @@ ulint rec_offs_nth_sql_null( /*==================*/ const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ - ulint n); /*!< in: nth field */ + ulint n) /*!< in: nth field */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Gets the physical size of a field. @return length of field */ @@ -518,7 +594,8 @@ ulint rec_offs_nth_size( /*==============*/ const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ - ulint n); /*!< in: nth field */ + ulint n) /*!< in: nth field */ + __attribute__((nonnull, pure, warn_unused_result)); /******************************************************//** Returns the number of extern bits set in a record. @@ -527,7 +604,8 @@ UNIV_INLINE ulint rec_offs_n_extern( /*==============*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /***********************************************************//** This is used to modify the value of an already existing field in a record. The previous value must have exactly the same size as the new value. If len @@ -542,11 +620,12 @@ rec_set_nth_field( const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ ulint n, /*!< in: index number of the field */ const void* data, /*!< in: pointer to the data if not SQL null */ - ulint len); /*!< in: length of the data or UNIV_SQL_NULL. + ulint len) /*!< in: length of the data or UNIV_SQL_NULL. If not SQL null, must have the same length as the previous value. If SQL null, previous value must be SQL null. */ + __attribute__((nonnull(1,2))); /**********************************************************//** The following function returns the data size of an old-style physical record, that is the sum of field lengths. SQL null fields @@ -557,7 +636,8 @@ UNIV_INLINE ulint rec_get_data_size_old( /*==================*/ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** The following function returns the number of allocated elements for an array of offsets. @@ -566,7 +646,8 @@ UNIV_INLINE ulint rec_offs_get_n_alloc( /*=================*/ - const ulint* offsets);/*!< in: array for rec_get_offsets() */ + const ulint* offsets)/*!< in: array for rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** The following function sets the number of allocated elements for an array of offsets. */ @@ -576,7 +657,8 @@ rec_offs_set_n_alloc( /*=================*/ ulint* offsets, /*!< out: array for rec_get_offsets(), must be allocated */ - ulint n_alloc); /*!< in: number of elements */ + ulint n_alloc) /*!< in: number of elements */ + __attribute__((nonnull)); #define rec_offs_init(offsets) \ rec_offs_set_n_alloc(offsets, (sizeof offsets) / sizeof *offsets) /**********************************************************//** @@ -586,7 +668,8 @@ UNIV_INLINE ulint rec_offs_n_fields( /*==============*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** The following function returns the data size of a physical record, that is the sum of field lengths. SQL null fields @@ -597,7 +680,8 @@ UNIV_INLINE ulint rec_offs_data_size( /*===============*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** Returns the total size of record minus data size of record. The value returned by the function is the distance from record @@ -607,7 +691,8 @@ UNIV_INLINE ulint rec_offs_extra_size( /*================*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** Returns the total size of a physical record. @return size */ @@ -615,7 +700,8 @@ UNIV_INLINE ulint rec_offs_size( /*==========*/ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); #ifdef UNIV_DEBUG /**********************************************************//** Returns a pointer to the start of the record. @@ -625,7 +711,8 @@ byte* rec_get_start( /*==========*/ const rec_t* rec, /*!< in: pointer to record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); /**********************************************************//** Returns a pointer to the end of the record. @return pointer to end */ @@ -634,7 +721,8 @@ byte* rec_get_end( /*========*/ const rec_t* rec, /*!< in: pointer to record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull, pure, warn_unused_result)); #else /* UNIV_DEBUG */ # define rec_get_start(rec, offsets) ((rec) - rec_offs_extra_size(offsets)) # define rec_get_end(rec, offsets) ((rec) + rec_offs_data_size(offsets)) @@ -648,8 +736,48 @@ rec_copy( /*=====*/ void* buf, /*!< in: buffer */ const rec_t* rec, /*!< in: physical record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull)); #ifndef UNIV_HOTBACKUP +/**********************************************************//** +Determines the size of a data tuple prefix in a temporary file. +@return total size */ +UNIV_INTERN +ulint +rec_get_converted_size_temp( +/*========================*/ + const dict_index_t* index, /*!< in: record descriptor */ + const dfield_t* fields, /*!< in: array of data fields */ + ulint n_fields,/*!< in: number of data fields */ + ulint* extra) /*!< out: extra size */ + __attribute__((warn_unused_result, nonnull)); + +/******************************************************//** +Determine the offset to each field in temporary file. +@see rec_convert_dtuple_to_temp() */ +UNIV_INTERN +void +rec_init_offsets_temp( +/*==================*/ + const rec_t* rec, /*!< in: temporary file record */ + const dict_index_t* index, /*!< in: record descriptor */ + ulint* offsets)/*!< in/out: array of offsets; + in: n=rec_offs_n_fields(offsets) */ + __attribute__((nonnull)); + +/*********************************************************//** +Builds a temporary file record out of a data tuple. +@see rec_init_offsets_temp() */ +UNIV_INTERN +void +rec_convert_dtuple_to_temp( +/*=======================*/ + rec_t* rec, /*!< out: record */ + const dict_index_t* index, /*!< in: record descriptor */ + const dfield_t* fields, /*!< in: array of data fields */ + ulint n_fields) /*!< in: number of fields */ + __attribute__((nonnull)); + /**************************************************************//** Copies the first n fields of a physical record to a new physical record in a buffer. @@ -665,7 +793,8 @@ rec_copy_prefix_to_buf( 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)); /************************************************************//** Folds a prefix of a physical record to a ulint. @return the folded value */ @@ -681,24 +810,9 @@ rec_fold( ulint n_bytes, /*!< in: number of bytes to fold in an incomplete last field */ index_id_t tree_id) /*!< in: index tree id */ - __attribute__((pure)); + __attribute__((nonnull, pure, warn_unused_result)); #endif /* !UNIV_HOTBACKUP */ /*********************************************************//** -Builds a ROW_FORMAT=COMPACT record out of a data tuple. */ -UNIV_INTERN -void -rec_convert_dtuple_to_rec_comp( -/*===========================*/ - rec_t* rec, /*!< in: origin of record */ - ulint extra, /*!< in: number of bytes to - reserve between the record - header and the data payload - (normally REC_N_NEW_EXTRA_BYTES) */ - const dict_index_t* index, /*!< in: record descriptor */ - ulint status, /*!< in: status bits of the record */ - const dfield_t* fields, /*!< in: array of data fields */ - ulint n_fields);/*!< in: number of data fields */ -/*********************************************************//** Builds a physical record out of a data tuple and stores it into the given buffer. @return pointer to the origin of physical record */ @@ -710,8 +824,9 @@ rec_convert_dtuple_to_rec( physical record */ const dict_index_t* index, /*!< in: record descriptor */ const dtuple_t* dtuple, /*!< in: data tuple */ - ulint n_ext); /*!< in: number of + ulint n_ext) /*!< in: number of externally stored columns */ + __attribute__((nonnull, warn_unused_result)); /**********************************************************//** Returns the extra size of an old-style physical record if we know its data size and number of fields. @@ -723,7 +838,7 @@ rec_get_converted_extra_size( ulint data_size, /*!< in: data size */ ulint n_fields, /*!< in: number of fields */ ulint n_ext) /*!< in: number of externally stored columns */ - __attribute__((const)); + __attribute__((const)); /**********************************************************//** Determines the size of a data tuple prefix in ROW_FORMAT=COMPACT. @return total size */ @@ -731,13 +846,11 @@ UNIV_INTERN ulint rec_get_converted_size_comp_prefix( /*===============================*/ - const dict_index_t* index, /*!< in: record descriptor; - dict_table_is_comp() is - assumed to hold, even if - it does not */ + const dict_index_t* index, /*!< in: record descriptor */ const dfield_t* fields, /*!< in: array of data fields */ ulint n_fields,/*!< in: number of data fields */ - ulint* extra); /*!< out: extra size */ + ulint* extra) /*!< out: extra size */ + __attribute__((warn_unused_result, nonnull(1,2))); /**********************************************************//** Determines the size of a data tuple in ROW_FORMAT=COMPACT. @return total size */ @@ -752,7 +865,8 @@ rec_get_converted_size_comp( ulint status, /*!< in: status bits of the record */ const dfield_t* fields, /*!< in: array of data fields */ ulint n_fields,/*!< in: number of data fields */ - ulint* extra); /*!< out: extra size */ + ulint* extra) /*!< out: extra size */ + __attribute__((nonnull(1,3))); /**********************************************************//** The following function returns the size of a data tuple when converted to a physical record. @@ -763,7 +877,8 @@ rec_get_converted_size( /*===================*/ dict_index_t* index, /*!< in: record descriptor */ const dtuple_t* dtuple, /*!< in: data tuple */ - ulint n_ext); /*!< in: number of externally stored columns */ + ulint n_ext) /*!< in: number of externally stored columns */ + __attribute__((warn_unused_result, nonnull)); #ifndef UNIV_HOTBACKUP /**************************************************************//** Copies the first n fields of a physical record to a data tuple. @@ -777,7 +892,8 @@ rec_copy_prefix_to_dtuple( const dict_index_t* index, /*!< in: record descriptor */ ulint n_fields, /*!< in: number of fields to copy */ - mem_heap_t* heap); /*!< in: memory heap */ + mem_heap_t* heap) /*!< in: memory heap */ + __attribute__((nonnull)); #endif /* !UNIV_HOTBACKUP */ /***************************************************************//** Validates the consistency of a physical record. @@ -787,7 +903,8 @@ ibool rec_validate( /*=========*/ const rec_t* rec, /*!< in: physical record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull)); /***************************************************************//** Prints an old-style physical record. */ UNIV_INTERN @@ -795,7 +912,8 @@ void rec_print_old( /*==========*/ FILE* file, /*!< in: file where to print */ - const rec_t* rec); /*!< in: physical record */ + const rec_t* rec) /*!< in: physical record */ + __attribute__((nonnull)); #ifndef UNIV_HOTBACKUP /***************************************************************//** Prints a physical record in ROW_FORMAT=COMPACT. Ignores the @@ -806,7 +924,8 @@ rec_print_comp( /*===========*/ FILE* file, /*!< in: file where to print */ const rec_t* rec, /*!< in: physical record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull)); /***************************************************************//** Prints a physical record. */ UNIV_INTERN @@ -815,7 +934,8 @@ rec_print_new( /*==========*/ FILE* file, /*!< in: file where to print */ const rec_t* rec, /*!< in: physical record */ - const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ + __attribute__((nonnull)); /***************************************************************//** Prints a physical record. */ UNIV_INTERN @@ -824,7 +944,21 @@ rec_print( /*======*/ FILE* file, /*!< in: file where to print */ const rec_t* rec, /*!< in: physical record */ - const dict_index_t* index); /*!< in: record descriptor */ + const dict_index_t* index) /*!< in: record descriptor */ + __attribute__((nonnull)); + +# ifdef UNIV_DEBUG +/************************************************************//** +Reads the DB_TRX_ID of a clustered index record. +@return the value of DB_TRX_ID */ +UNIV_INTERN +trx_id_t +rec_get_trx_id( +/*===========*/ + const rec_t* rec, /*!< in: record */ + const dict_index_t* index) /*!< in: clustered index */ + __attribute__((nonnull, warn_unused_result)); +# endif /* UNIV_DEBUG */ #endif /* UNIV_HOTBACKUP */ /* Maximum lengths for the data in a physical record if the offsets |